GoogleCloudPlatform
diff --git a/‎videointelligence/samples/analyze/analyze.py‎
Lines changed: 72 additions & 57 deletions b/‎videointelligence/samples/analyze/analyze.py‎
Lines changed: 72 additions & 57 deletions
diff --git a/‎videointelligence/samples/analyze/analyze_test.py‎
Lines changed: 2 additions & 2 deletions b/‎videointelligence/samples/analyze/analyze_test.py‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎videointelligence/samples/analyze/beta_snippets.py‎
Lines changed: 83 additions & 78 deletions b/‎videointelligence/samples/analyze/beta_snippets.py‎
Lines changed: 83 additions & 78 deletions
diff --git a/‎videointelligence/samples/analyze/beta_snippets_test.py‎
Lines changed: 4 additions & 4 deletions b/‎videointelligence/samples/analyze/beta_snippets_test.py‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎videointelligence/samples/analyze/noxfile.py‎
Lines changed: 17 additions & 17 deletions b/‎videointelligence/samples/analyze/noxfile.py‎
Lines changed: 17 additions & 17 deletions
diff --git a/‎videointelligence/samples/analyze/video_detect_faces_beta.py‎
Lines changed: 9 additions & 7 deletions b/‎videointelligence/samples/analyze/video_detect_faces_beta.py‎
Lines changed: 9 additions & 7 deletions
diff --git a/‎videointelligence/samples/analyze/video_detect_faces_gcs_beta.py‎
Lines changed: 9 additions & 7 deletions b/‎videointelligence/samples/analyze/video_detect_faces_gcs_beta.py‎
Lines changed: 9 additions & 7 deletions
diff --git a/‎videointelligence/samples/analyze/video_detect_logo.py‎
Lines changed: 10 additions & 6 deletions b/‎videointelligence/samples/analyze/video_detect_logo.py‎
Lines changed: 10 additions & 6 deletions
diff --git a/‎videointelligence/samples/analyze/video_detect_logo_gcs.py‎
Lines changed: 10 additions & 6 deletions b/‎videointelligence/samples/analyze/video_detect_logo_gcs.py‎
Lines changed: 10 additions & 6 deletions
diff --git a/‎videointelligence/samples/analyze/video_detect_person_beta.py‎
Lines changed: 7 additions & 5 deletions b/‎videointelligence/samples/analyze/video_detect_person_beta.py‎
Lines changed: 7 additions & 5 deletions
@@ -74,15 +74,15 @@ def test_speech_transcription(capsys):
 def test_detect_text_gcs(capsys):
     analyze.video_detect_text_gcs("gs://cloud-samples-data/video/googlework_tiny.mp4")
     out, _ = capsys.readouterr()
-    assert 'Text' in out
+    assert "Text" in out
 
 
 # Flaky timeout
 @pytest.mark.flaky(max_runs=3, min_passes=1)
 def test_detect_text(capsys):
     analyze.video_detect_text("resources/googlework_tiny.mp4")
     out, _ = capsys.readouterr()
-    assert 'Text' in out
+    assert "Text" in out
 
 
 # Flaky timeout
 
@@ -15,13 +15,13 @@
 # limitations under the License.
 
 import os
+from urllib.request import urlopen
 import uuid
 
 import backoff
 from google.api_core.exceptions import Conflict
 from google.cloud import storage
 import pytest
-from six.moves.urllib.request import urlopen
 
 import beta_snippets
 
@@ -55,7 +55,7 @@ def video_path(tmpdir_factory):
 @pytest.fixture(scope="function")
 def bucket():
     # Create a temporaty bucket to store annotation output.
-    bucket_name = f'tmp-{uuid.uuid4().hex}'
+    bucket_name = f"tmp-{uuid.uuid4().hex}"
     storage_client = storage.Client()
     bucket = storage_client.create_bucket(bucket_name)
 
@@ -128,7 +128,7 @@ def test_detect_text(capsys):
     in_file = "./resources/googlework_tiny.mp4"
     beta_snippets.video_detect_text(in_file)
     out, _ = capsys.readouterr()
-    assert 'Text' in out
+    assert "Text" in out
 
 
 # Flaky timeout
@@ -137,7 +137,7 @@ def test_detect_text_gcs(capsys):
     in_file = "gs://python-docs-samples-tests/video/googlework_tiny.mp4"
     beta_snippets.video_detect_text_gcs(in_file)
     out, _ = capsys.readouterr()
-    assert 'Text' in out
+    assert "Text" in out
 
 
 # Flaky InvalidArgument
 
@@ -37,28 +37,25 @@
 
 TEST_CONFIG = {
     # You can opt out from the test for specific Python versions.
-    'ignored_versions': ["2.7"],
-
+    "ignored_versions": ["2.7"],
     # Old samples are opted out of enforcing Python type hints
     # All new samples should feature them
-    'enforce_type_hints': False,
-
+    "enforce_type_hints": False,
     # An envvar key for determining the project id to use. Change it
     # to 'BUILD_SPECIFIC_GCLOUD_PROJECT' if you want to opt in using a
     # build specific Cloud project. You can also use your own string
     # to use your own Cloud project.
-    'gcloud_project_env': 'GOOGLE_CLOUD_PROJECT',
+    "gcloud_project_env": "GOOGLE_CLOUD_PROJECT",
     # 'gcloud_project_env': 'BUILD_SPECIFIC_GCLOUD_PROJECT',
-
     # A dictionary you want to inject into your test. Don't put any
     # secrets here. These values will override predefined values.
-    'envs': {},
+    "envs": {},
 }
 
 
 try:
     # Ensure we can import noxfile_config in the project's directory.
-    sys.path.append('.')
+    sys.path.append(".")
     from noxfile_config import TEST_CONFIG_OVERRIDE
 except ImportError as e:
     print("No user noxfile_config found: detail: {}".format(e))
@@ -73,12 +70,12 @@ def get_pytest_env_vars():
     ret = {}
 
     # Override the GCLOUD_PROJECT and the alias.
-    env_key = TEST_CONFIG['gcloud_project_env']
+    env_key = TEST_CONFIG["gcloud_project_env"]
     # This should error out if not set.
-    ret['GOOGLE_CLOUD_PROJECT'] = os.environ[env_key]
+    ret["GOOGLE_CLOUD_PROJECT"] = os.environ[env_key]
 
     # Apply user supplied envs.
-    ret.update(TEST_CONFIG['envs'])
+    ret.update(TEST_CONFIG["envs"])
     return ret
 
 
@@ -87,7 +84,7 @@ def get_pytest_env_vars():
 ALL_VERSIONS = ["2.7", "3.6", "3.7", "3.8"]
 
 # Any default versions that should be ignored.
-IGNORED_VERSIONS = TEST_CONFIG['ignored_versions']
+IGNORED_VERSIONS = TEST_CONFIG["ignored_versions"]
 
 TESTED_VERSIONS = sorted([v for v in ALL_VERSIONS if v not in IGNORED_VERSIONS])
 
@@ -136,7 +133,7 @@ def _determine_local_import_names(start_dir):
 
 @nox.session
 def lint(session):
-    if not TEST_CONFIG['enforce_type_hints']:
+    if not TEST_CONFIG["enforce_type_hints"]:
         session.install("flake8", "flake8-import-order")
     else:
         session.install("flake8", "flake8-import-order", "flake8-annotations")
@@ -145,9 +142,11 @@ def lint(session):
     args = FLAKE8_COMMON_ARGS + [
         "--application-import-names",
         ",".join(local_names),
-        "."
+        ".",
     ]
     session.run("flake8", *args)
+
+
 #
 # Black
 #
@@ -160,6 +159,7 @@ def blacken(session):
 
     session.run("black", *python_files)
 
+
 #
 # Sample Tests
 #
@@ -199,9 +199,9 @@ def py(session):
     if session.python in TESTED_VERSIONS:
         _session_tests(session)
     else:
-        session.skip("SKIPPED: {} tests are disabled for this sample.".format(
-            session.python
-        ))
+        session.skip(
+            "SKIPPED: {} tests are disabled for this sample.".format(session.python)
+        )
 
 
 #
 
@@ -27,16 +27,18 @@ def detect_faces(local_file_path="path/to/your/video-file.mp4"):
         input_content = f.read()
 
     # Configure the request
-    config = videointelligence.types.FaceDetectionConfig(
+    config = videointelligence.FaceDetectionConfig(
         include_bounding_boxes=True, include_attributes=True
     )
-    context = videointelligence.types.VideoContext(face_detection_config=config)
+    context = videointelligence.VideoContext(face_detection_config=config)
 
     # Start the asynchronous request
     operation = client.annotate_video(
-        input_content=input_content,
-        features=[videointelligence.enums.Feature.FACE_DETECTION],
-        video_context=context,
+        request={
+            "features": [videointelligence.Feature.FACE_DETECTION],
+            "input_content": input_content,
+            "video_context": context,
+        }
     )
 
     print("\nProcessing video for face detection annotations.")
@@ -53,9 +55,9 @@ def detect_faces(local_file_path="path/to/your/video-file.mp4"):
             print(
                 "Segment: {}s to {}s".format(
                     track.segment.start_time_offset.seconds
-                    + track.segment.start_time_offset.nanos / 1e9,
+                    + track.segment.start_time_offset.microseconds / 1e6,
                     track.segment.end_time_offset.seconds
-                    + track.segment.end_time_offset.nanos / 1e9,
+                    + track.segment.end_time_offset.microseconds / 1e6,
                 )
             )
 
 
@@ -22,16 +22,18 @@ def detect_faces(gcs_uri="gs://YOUR_BUCKET_ID/path/to/your/video.mp4"):
     client = videointelligence.VideoIntelligenceServiceClient()
 
     # Configure the request
-    config = videointelligence.types.FaceDetectionConfig(
+    config = videointelligence.FaceDetectionConfig(
         include_bounding_boxes=True, include_attributes=True
     )
-    context = videointelligence.types.VideoContext(face_detection_config=config)
+    context = videointelligence.VideoContext(face_detection_config=config)
 
     # Start the asynchronous request
     operation = client.annotate_video(
-        input_uri=gcs_uri,
-        features=[videointelligence.enums.Feature.FACE_DETECTION],
-        video_context=context,
+        request={
+            "features": [videointelligence.Feature.FACE_DETECTION],
+            "input_uri": gcs_uri,
+            "video_context": context,
+        }
     )
 
     print("\nProcessing video for face detection annotations.")
@@ -48,9 +50,9 @@ def detect_faces(gcs_uri="gs://YOUR_BUCKET_ID/path/to/your/video.mp4"):
             print(
                 "Segment: {}s to {}s".format(
                     track.segment.start_time_offset.seconds
-                    + track.segment.start_time_offset.nanos / 1e9,
+                    + track.segment.start_time_offset.microseconds / 1e6,
                     track.segment.end_time_offset.seconds
-                    + track.segment.end_time_offset.nanos / 1e9,
+                    + track.segment.end_time_offset.microseconds / 1e6,
                 )
             )
 
 
@@ -26,9 +26,11 @@ def detect_logo(local_file_path="path/to/your/video.mp4"):
 
     with io.open(local_file_path, "rb") as f:
         input_content = f.read()
-    features = [videointelligence.enums.Feature.LOGO_RECOGNITION]
+    features = [videointelligence.Feature.LOGO_RECOGNITION]
 
-    operation = client.annotate_video(input_content=input_content, features=features)
+    operation = client.annotate_video(
+        request={"features": features, "input_content": input_content}
+    )
 
     print(u"Waiting for operation to complete...")
     response = operation.result()
@@ -53,13 +55,13 @@ def detect_logo(local_file_path="path/to/your/video.mp4"):
             print(
                 u"\n\tStart Time Offset : {}.{}".format(
                     track.segment.start_time_offset.seconds,
-                    track.segment.start_time_offset.nanos,
+                    track.segment.start_time_offset.microseconds * 1000,
                 )
             )
             print(
                 u"\tEnd Time Offset : {}.{}".format(
                     track.segment.end_time_offset.seconds,
-                    track.segment.end_time_offset.nanos,
+                    track.segment.end_time_offset.microseconds * 1000,
                 )
             )
             print(u"\tConfidence : {}".format(track.confidence))
@@ -91,12 +93,14 @@ def detect_logo(local_file_path="path/to/your/video.mp4"):
         for segment in logo_recognition_annotation.segments:
             print(
                 u"\n\tStart Time Offset : {}.{}".format(
-                    segment.start_time_offset.seconds, segment.start_time_offset.nanos,
+                    segment.start_time_offset.seconds,
+                    segment.start_time_offset.microseconds * 1000,
                 )
             )
             print(
                 u"\tEnd Time Offset : {}.{}".format(
-                    segment.end_time_offset.seconds, segment.end_time_offset.nanos,
+                    segment.end_time_offset.seconds,
+                    segment.end_time_offset.microseconds * 1000,
                 )
             )
 
 
@@ -21,9 +21,11 @@ def detect_logo_gcs(input_uri="gs://YOUR_BUCKET_ID/path/to/your/file.mp4"):
 
     client = videointelligence.VideoIntelligenceServiceClient()
 
-    features = [videointelligence.enums.Feature.LOGO_RECOGNITION]
+    features = [videointelligence.Feature.LOGO_RECOGNITION]
 
-    operation = client.annotate_video(input_uri=input_uri, features=features)
+    operation = client.annotate_video(
+        request={"features": features, "input_uri": input_uri}
+    )
 
     print(u"Waiting for operation to complete...")
     response = operation.result()
@@ -49,13 +51,13 @@ def detect_logo_gcs(input_uri="gs://YOUR_BUCKET_ID/path/to/your/file.mp4"):
             print(
                 u"\n\tStart Time Offset : {}.{}".format(
                     track.segment.start_time_offset.seconds,
-                    track.segment.start_time_offset.nanos,
+                    track.segment.start_time_offset.microseconds * 1000,
                 )
             )
             print(
                 u"\tEnd Time Offset : {}.{}".format(
                     track.segment.end_time_offset.seconds,
-                    track.segment.end_time_offset.nanos,
+                    track.segment.end_time_offset.microseconds * 1000,
                 )
             )
             print(u"\tConfidence : {}".format(track.confidence))
@@ -86,12 +88,14 @@ def detect_logo_gcs(input_uri="gs://YOUR_BUCKET_ID/path/to/your/file.mp4"):
         for segment in logo_recognition_annotation.segments:
             print(
                 u"\n\tStart Time Offset : {}.{}".format(
-                    segment.start_time_offset.seconds, segment.start_time_offset.nanos,
+                    segment.start_time_offset.seconds,
+                    segment.start_time_offset.microseconds * 1000,
                 )
             )
             print(
                 u"\tEnd Time Offset : {}.{}".format(
-                    segment.end_time_offset.seconds, segment.end_time_offset.nanos,
+                    segment.end_time_offset.seconds,
+                    segment.end_time_offset.microseconds * 1000,
                 )
             )
 
 
@@ -36,9 +36,11 @@ def detect_person(local_file_path="path/to/your/video-file.mp4"):
 
     # Start the asynchronous request
     operation = client.annotate_video(
-        input_content=input_content,
-        features=[videointelligence.enums.Feature.PERSON_DETECTION],
-        video_context=context,
+        request={
+            "features": [videointelligence.Feature.PERSON_DETECTION],
+            "input_content": input_content,
+            "video_context": context,
+        }
     )
 
     print("\nProcessing video for person detection annotations.")
@@ -55,9 +57,9 @@ def detect_person(local_file_path="path/to/your/video-file.mp4"):
             print(
                 "Segment: {}s to {}s".format(
                     track.segment.start_time_offset.seconds
-                    + track.segment.start_time_offset.nanos / 1e9,
+                    + track.segment.start_time_offset.microseconds / 1e6,
                     track.segment.end_time_offset.seconds
-                    + track.segment.end_time_offset.nanos / 1e9,
+                    + track.segment.end_time_offset.microseconds / 1e6,
                 )
             )
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,11 @@ def detect_logo(local_file_path="path/to/your/video.mp4"):`
`26`	`26`
`27`	`27`	`with io.open(local_file_path, "rb") as f:`
`28`	`28`	`input_content = f.read()`
`29`		`- features = [videointelligence.enums.Feature.LOGO_RECOGNITION]`
	`29`	`+ features = [videointelligence.Feature.LOGO_RECOGNITION]`
`30`	`30`
`31`		`- operation = client.annotate_video(input_content=input_content, features=features)`
	`31`	`+ operation = client.annotate_video(`
	`32`	`+ request={"features": features, "input_content": input_content}`
	`33`	`+ )`
`32`	`34`
`33`	`35`	`print(u"Waiting for operation to complete...")`
`34`	`36`	`response = operation.result()`
`@@ -53,13 +55,13 @@ def detect_logo(local_file_path="path/to/your/video.mp4"):`
`53`	`55`	`print(`
`54`	`56`	`u"\n\tStart Time Offset : {}.{}".format(`
`55`	`57`	`track.segment.start_time_offset.seconds,`
`56`		`- track.segment.start_time_offset.nanos,`
	`58`	`+ track.segment.start_time_offset.microseconds * 1000,`
`57`	`59`	`)`
`58`	`60`	`)`
`59`	`61`	`print(`
`60`	`62`	`u"\tEnd Time Offset : {}.{}".format(`
`61`	`63`	`track.segment.end_time_offset.seconds,`
`62`		`- track.segment.end_time_offset.nanos,`
	`64`	`+ track.segment.end_time_offset.microseconds * 1000,`
`63`	`65`	`)`
`64`	`66`	`)`
`65`	`67`	`print(u"\tConfidence : {}".format(track.confidence))`
`@@ -91,12 +93,14 @@ def detect_logo(local_file_path="path/to/your/video.mp4"):`
`91`	`93`	`for segment in logo_recognition_annotation.segments:`
`92`	`94`	`print(`
`93`	`95`	`u"\n\tStart Time Offset : {}.{}".format(`
`94`		`- segment.start_time_offset.seconds, segment.start_time_offset.nanos,`
	`96`	`+ segment.start_time_offset.seconds,`
	`97`	`+ segment.start_time_offset.microseconds * 1000,`
`95`	`98`	`)`
`96`	`99`	`)`
`97`	`100`	`print(`
`98`	`101`	`u"\tEnd Time Offset : {}.{}".format(`
`99`		`- segment.end_time_offset.seconds, segment.end_time_offset.nanos,`
	`102`	`+ segment.end_time_offset.seconds,`
	`103`	`+ segment.end_time_offset.microseconds * 1000,`
`100`	`104`	`)`
`101`	`105`	`)`
`102`	`106`
Original file line number	Diff line number	Diff line change
`@@ -21,9 +21,11 @@ def detect_logo_gcs(input_uri="gs://YOUR_BUCKET_ID/path/to/your/file.mp4"):`
`21`	`21`
`22`	`22`	`client = videointelligence.VideoIntelligenceServiceClient()`
`23`	`23`
`24`		`- features = [videointelligence.enums.Feature.LOGO_RECOGNITION]`
	`24`	`+ features = [videointelligence.Feature.LOGO_RECOGNITION]`
`25`	`25`
`26`		`- operation = client.annotate_video(input_uri=input_uri, features=features)`
	`26`	`+ operation = client.annotate_video(`
	`27`	`+ request={"features": features, "input_uri": input_uri}`
	`28`	`+ )`
`27`	`29`
`28`	`30`	`print(u"Waiting for operation to complete...")`
`29`	`31`	`response = operation.result()`
`@@ -49,13 +51,13 @@ def detect_logo_gcs(input_uri="gs://YOUR_BUCKET_ID/path/to/your/file.mp4"):`
`49`	`51`	`print(`
`50`	`52`	`u"\n\tStart Time Offset : {}.{}".format(`
`51`	`53`	`track.segment.start_time_offset.seconds,`
`52`		`- track.segment.start_time_offset.nanos,`
	`54`	`+ track.segment.start_time_offset.microseconds * 1000,`
`53`	`55`	`)`
`54`	`56`	`)`
`55`	`57`	`print(`
`56`	`58`	`u"\tEnd Time Offset : {}.{}".format(`
`57`	`59`	`track.segment.end_time_offset.seconds,`
`58`		`- track.segment.end_time_offset.nanos,`
	`60`	`+ track.segment.end_time_offset.microseconds * 1000,`
`59`	`61`	`)`
`60`	`62`	`)`
`61`	`63`	`print(u"\tConfidence : {}".format(track.confidence))`
`@@ -86,12 +88,14 @@ def detect_logo_gcs(input_uri="gs://YOUR_BUCKET_ID/path/to/your/file.mp4"):`
`86`	`88`	`for segment in logo_recognition_annotation.segments:`
`87`	`89`	`print(`
`88`	`90`	`u"\n\tStart Time Offset : {}.{}".format(`
`89`		`- segment.start_time_offset.seconds, segment.start_time_offset.nanos,`
	`91`	`+ segment.start_time_offset.seconds,`
	`92`	`+ segment.start_time_offset.microseconds * 1000,`
`90`	`93`	`)`
`91`	`94`	`)`
`92`	`95`	`print(`
`93`	`96`	`u"\tEnd Time Offset : {}.{}".format(`
`94`		`- segment.end_time_offset.seconds, segment.end_time_offset.nanos,`
	`97`	`+ segment.end_time_offset.seconds,`
	`98`	`+ segment.end_time_offset.microseconds * 1000,`
`95`	`99`	`)`
`96`	`100`	`)`
`97`	`101`