def test_annotate_video(self, mock_create_stub):
# Mock gRPC layer
grpc_stub = mock.Mock()
mock_create_stub.return_value = grpc_stub
client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
# Mock request
input_uri = 'inputUri1707300727'
features = []
# Mock response
expected_response = {}
expected_response = video_intelligence_pb2.AnnotateVideoResponse(
**expected_response)
operation = operations_pb2.Operation(
name='operations/test_annotate_video', done=True)
operation.response.Pack(expected_response)
grpc_stub.AnnotateVideo.return_value = operation
response = client.annotate_video(input_uri, features)
self.assertEqual(expected_response, response.result())
grpc_stub.AnnotateVideo.assert_called_once()
args, kwargs = grpc_stub.AnnotateVideo.call_args
self.assertEqual(len(args), 2)
self.assertEqual(len(kwargs), 1)
self.assertIn('metadata', kwargs)
actual_request = args[0]
expected_request = video_intelligence_pb2.AnnotateVideoRequest(
input_uri=input_uri, features=features)
self.assertEqual(expected_request, actual_request)
def analyze_faces(path):
# [START construct_request]
""" Detects faces given a GCS path. """
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.FACE_DETECTION]
operation = video_client.annotate_video(path, features)
# [END construct_request]
print('\nProcessing video for face annotations:')
# [START check_operation]
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(20)
print('\nFinished processing.')
# [END check_operation]
# [START parse_response]
# first result is retrieved because a single video was processed
face_annotations = (
operation.result().annotation_results[0].face_annotations)
for face_id, face in enumerate(face_annotations):
print('Thumbnail size: {}'.format(len(face.thumbnail)))
for segment_id, segment in enumerate(face.segments):
start_time = (segment.segment.start_time_offset.seconds +
segment.segment.start_time_offset.nanos / 1e9)
end_time = (segment.segment.end_time_offset.seconds +
segment.segment.end_time_offset.nanos / 1e9)
positions = '{}s to {}s'.format(start_time, end_time)
print('\tSegment {}: {}'.format(segment_id, positions))
def test_annotate_video(self):
# Setup Expected Response
expected_response = {}
expected_response = video_intelligence_pb2.AnnotateVideoResponse(
**expected_response)
operation = operations_pb2.Operation(
name="operations/test_annotate_video", done=True)
operation.response.Pack(expected_response)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch("google.api_core.grpc_helpers.create_channel")
with patch as create_channel:
create_channel.return_value = channel
client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
# Setup Request
input_uri = "gs://demomaker/cat.mp4"
features_element = enums.Feature.LABEL_DETECTION
features = [features_element]
response = client.annotate_video(input_uri=input_uri,
features=features)
result = response.result()
assert expected_response == result
assert len(channel.requests) == 1
expected_request = video_intelligence_pb2.AnnotateVideoRequest(
input_uri=input_uri, features=features)
actual_request = channel.requests[0][1]
assert expected_request == actual_request
def analyze_shots(path):
""" Detects camera shot changes. """
# [START construct_request]
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.SHOT_CHANGE_DETECTION]
operation = video_client.annotate_video(path, features)
# [END construct_request]
print('\nProcessing video for shot change annotations:')
# [START check_operation]
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(20)
print('\nFinished processing.')
# [END check_operation]
# [START parse_response]
shots = operation.result().annotation_results[0].shot_annotations
for i, shot in enumerate(shots):
start_time = (shot.start_time_offset.seconds +
shot.start_time_offset.nanos / 1e9)
end_time = (shot.end_time_offset.seconds +
shot.end_time_offset.nanos / 1e9)
print('\tShot {}: {} to {}'.format(i, start_time, end_time))
def analyze_explicit_content(path):
""" Detects explicit content from the GCS path to a video. """
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.EXPLICIT_CONTENT_DETECTION]
operation = video_client.annotate_video(path, features)
print('\nProcessing video for explicit content annotations:')
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(15)
print('\nFinished processing.')
# first result is retrieved because a single video was processed
explicit_annotation = (
operation.result().annotation_results[0].explicit_annotation)
likely_string = ("Unknown", "Very unlikely", "Unlikely", "Possible",
"Likely", "Very likely")
for frame in explicit_annotation.frames:
frame_time = frame.time_offset.seconds + frame.time_offset.nanos / 1e9
print('Time: {}s'.format(frame_time))
print('\tpornography: {}'.format(
likely_string[frame.pornography_likelihood]))
def analyze_faces(path):
""" Detects faces given a GCS path. """
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.FACE_DETECTION]
config = types.FaceDetectionConfig(include_bounding_boxes=True)
context = types.VideoContext(face_detection_config=config)
operation = video_client.annotate_video(path,
features,
video_context=context)
print('\nProcessing video for face annotations:')
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(15)
print('\nFinished processing.')
# first result is retrieved because a single video was processed
face_annotations = (
operation.result().annotation_results[0].face_annotations)
for face_id, face in enumerate(face_annotations):
print('Face {}'.format(face_id))
print('Thumbnail size: {}'.format(len(face.thumbnail)))
for segment_id, segment in enumerate(face.segments):
start_time = (segment.segment.start_time_offset.seconds +
segment.segment.start_time_offset.nanos / 1e9)
end_time = (segment.segment.end_time_offset.seconds +
segment.segment.end_time_offset.nanos / 1e9)
positions = '{}s to {}s'.format(start_time, end_time)
print('\tSegment {}: {}'.format(segment_id, positions))
# There are typically many frames for each face,
# here we print information on only the first frame.
frame = face.frames[0]
time_offset = (frame.time_offset.seconds +
frame.time_offset.nanos / 1e9)
box = frame.normalized_bounding_boxes[0]
print('First frame time offset: {}s'.format(time_offset))
print('First frame normalized bounding box:')
print('\tleft: {}'.format(box.left))
print('\ttop: {}'.format(box.top))
print('\tright: {}'.format(box.right))
print('\tbottom: {}'.format(box.bottom))
print('\n')
def test_annotate_video_exception(self):
# Setup Response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name='operations/test_annotate_video_exception', done=True)
operation.error.CopyFrom(error)
# Mock the API response
channel = ChannelStub(responses=[operation])
client = videointelligence_v1beta2.VideoIntelligenceServiceClient(
channel=channel)
response = client.annotate_video()
exception = response.exception()
assert exception.errors[0] == error
def test_annotate_video_exception(self, mock_create_stub):
# Mock gRPC layer
grpc_stub = mock.Mock()
mock_create_stub.return_value = grpc_stub
client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
# Mock request
input_uri = 'inputUri1707300727'
features = []
# Mock exception response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name='operations/test_annotate_video_exception', done=True)
operation.error.CopyFrom(error)
grpc_stub.AnnotateVideo.return_value = operation
response = client.annotate_video(input_uri, features)
self.assertEqual(error, response.exception())
def run_quickstart():
# [START videointelligence_quickstart]
import sys
import time
from google.cloud import videointelligence_v1beta2
from google.cloud.videointelligence_v1beta2 import enums
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.LABEL_DETECTION]
operation = video_client.annotate_video('gs://demomaker/cat.mp4', features)
print('\nProcessing video for label annotations:')
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(15)
print('\nFinished processing.')
# first result is retrieved because a single video was processed
results = operation.result().annotation_results[0]
for i, segment_label in enumerate(results.segment_label_annotations):
print('Video label description: {}'.format(
segment_label.entity.description))
for category_entity in segment_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
for i, segment in enumerate(segment_label.segments):
start_time = (segment.segment.start_time_offset.seconds +
segment.segment.start_time_offset.nanos / 1e9)
end_time = (segment.segment.end_time_offset.seconds +
segment.segment.end_time_offset.nanos / 1e9)
positions = '{}s to {}s'.format(start_time, end_time)
confidence = segment.confidence
print('\tSegment {}: {}'.format(i, positions))
print('\tConfidence: {}'.format(confidence))
print('\n')
def test_annotate_video(self):
# Setup Expected Response
expected_response = {}
expected_response = video_intelligence_pb2.AnnotateVideoResponse(
**expected_response)
operation = operations_pb2.Operation(
name='operations/test_annotate_video', done=True)
operation.response.Pack(expected_response)
# Mock the API response
channel = ChannelStub(responses=[operation])
client = videointelligence_v1beta2.VideoIntelligenceServiceClient(
channel=channel)
response = client.annotate_video()
result = response.result()
assert expected_response == result
assert len(channel.requests) == 1
expected_request = video_intelligence_pb2.AnnotateVideoRequest()
actual_request = channel.requests[0][1]
assert expected_request == actual_request
def test_annotate_video_exception(self):
# Setup Response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name="operations/test_annotate_video_exception", done=True)
operation.error.CopyFrom(error)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch("google.api_core.grpc_helpers.create_channel")
with patch as create_channel:
create_channel.return_value = channel
client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
# Setup Request
features_element = enums.Feature.LABEL_DETECTION
features = [features_element]
input_uri = "gs://cloud-samples-data/video/cat.mp4"
response = client.annotate_video(features, input_uri=input_uri)
exception = response.exception()
assert exception.errors[0] == error
def analyze_labels(path):
""" Detects labels given a GCS path. """
# [START construct_request]
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.LABEL_DETECTION]
operation = video_client.annotate_video(path, features)
# [END construct_request]
print('\nProcessing video for label annotations:')
# [START check_operation]
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(20)
print('\nFinished processing.')
# [END check_operation]
# [START parse_response]
results = operation.result().annotation_results[0]
for i, segment_label in enumerate(results.segment_label_annotations):
print('Video label description: {}'.format(
segment_label.entity.description))
for category_entity in segment_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
for i, segment in enumerate(segment_label.segments):
start_time = (segment.segment.start_time_offset.seconds +
segment.segment.start_time_offset.nanos / 1e9)
end_time = (segment.segment.end_time_offset.seconds +
segment.segment.end_time_offset.nanos / 1e9)
positions = '{}s to {}s'.format(start_time, end_time)
confidence = segment.confidence
print('\tSegment {}: {}'.format(i, positions))
print('\tConfidence: {}'.format(confidence))
print('\n')
def analyze_shots(path):
""" Detects camera shot changes. """
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.SHOT_CHANGE_DETECTION]
operation = video_client.annotate_video(path, features)
print('\nProcessing video for shot change annotations:')
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(15)
print('\nFinished processing.')
# first result is retrieved because a single video was processed
shots = operation.result().annotation_results[0].shot_annotations
for i, shot in enumerate(shots):
start_time = (shot.start_time_offset.seconds +
shot.start_time_offset.nanos / 1e9)
end_time = (shot.end_time_offset.seconds +
shot.end_time_offset.nanos / 1e9)
print('\tShot {}: {} to {}'.format(i, start_time, end_time))
def test_annotate_video_exception(self):
# Setup Response
error = status_pb2.Status()
operation = operations_pb2.Operation(
name='operations/test_annotate_video_exception', done=True)
operation.error.CopyFrom(error)
# Mock the API response
channel = ChannelStub(responses=[operation])
patch = mock.patch('google.api_core.grpc_helpers.create_channel')
with patch as create_channel:
create_channel.return_value = channel
client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
# Setup Request
input_uri = 'gs://demomaker/cat.mp4'
features_element = enums.Feature.LABEL_DETECTION
features = [features_element]
response = client.annotate_video(input_uri=input_uri,
features=features)
exception = response.exception()
assert exception.errors[0] == error
def analyze_labels(path):
""" Detects labels given a GCS path. """
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.LABEL_DETECTION]
config = types.LabelDetectionConfig(
label_detection_mode=enums.LabelDetectionMode.SHOT_AND_FRAME_MODE)
context = types.VideoContext(label_detection_config=config)
operation = video_client.annotate_video(path,
features,
video_context=context)
print('\nProcessing video for label annotations:')
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(15)
print('\nFinished processing.')
# first result is retrieved because a single video was processed
results = operation.result().annotation_results[0]
# Process video/segment level label annotations
for i, segment_label in enumerate(results.segment_label_annotations):
print('Video label description: {}'.format(
segment_label.entity.description))
for category_entity in segment_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
for i, segment in enumerate(segment_label.segments):
start_time = (segment.segment.start_time_offset.seconds +
segment.segment.start_time_offset.nanos / 1e9)
end_time = (segment.segment.end_time_offset.seconds +
segment.segment.end_time_offset.nanos / 1e9)
positions = '{}s to {}s'.format(start_time, end_time)
confidence = segment.confidence
print('\tSegment {}: {}'.format(i, positions))
print('\tConfidence: {}'.format(confidence))
print('\n')
# Process shot level label annotations
for i, shot_label in enumerate(results.shot_label_annotations):
print('Shot label description: {}'.format(
shot_label.entity.description))
for category_entity in shot_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
for i, shot in enumerate(shot_label.segments):
start_time = (shot.segment.start_time_offset.seconds +
shot.segment.start_time_offset.nanos / 1e9)
end_time = (shot.segment.end_time_offset.seconds +
shot.segment.end_time_offset.nanos / 1e9)
positions = '{}s to {}s'.format(start_time, end_time)
confidence = shot.confidence
print('\tSegment {}: {}'.format(i, positions))
print('\tConfidence: {}'.format(confidence))
print('\n')
# Process frame level label annotations
for i, frame_label in enumerate(results.frame_label_annotations):
print('Frame label description: {}'.format(
frame_label.entity.description))
for category_entity in frame_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
# Each frame_label_annotation has many frames,
# here we print information only about the first frame.
frame = frame_label.frames[0]
time_offset = (frame.time_offset.seconds +
frame.time_offset.nanos / 1e9)
print('\tFirst frame time offset: {}s'.format(time_offset))
print('\tFirst frame confidence: {}'.format(frame.confidence))
print('\n')
def analyze_labels_file(path):
""" Detects labels given a file path. """
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.LABEL_DETECTION]
with io.open(path, "rb") as movie:
content_base64 = base64.b64encode(movie.read())
operation = video_client.annotate_video('',
features,
input_content=content_base64)
print('\nProcessing video for label annotations:')
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(15)
print('\nFinished processing.')
# first result is retrieved because a single video was processed
results = operation.result().annotation_results[0]
# Process video/segment level label annotations
for i, segment_label in enumerate(results.segment_label_annotations):
print('Video label description: {}'.format(
segment_label.entity.description))
for category_entity in segment_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
for i, segment in enumerate(segment_label.segments):
start_time = (segment.segment.start_time_offset.seconds +
segment.segment.start_time_offset.nanos / 1e9)
end_time = (segment.segment.end_time_offset.seconds +
segment.segment.end_time_offset.nanos / 1e9)
positions = '{}s to {}s'.format(start_time, end_time)
confidence = segment.confidence
print('\tSegment {}: {}'.format(i, positions))
print('\tConfidence: {}'.format(confidence))
print('\n')
# Process shot level label annotations
for i, shot_label in enumerate(results.shot_label_annotations):
print('Shot label description: {}'.format(
shot_label.entity.description))
for category_entity in shot_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
for i, shot in enumerate(shot_label.segments):
start_time = (shot.segment.start_time_offset.seconds +
shot.segment.start_time_offset.nanos / 1e9)
end_time = (shot.segment.end_time_offset.seconds +
shot.segment.end_time_offset.nanos / 1e9)
positions = '{}s to {}s'.format(start_time, end_time)
confidence = shot.confidence
print('\tSegment {}: {}'.format(i, positions))
print('\tConfidence: {}'.format(confidence))
print('\n')
# Process frame level label annotations
for i, frame_label in enumerate(results.frame_label_annotations):
print('Frame label description: {}'.format(
frame_label.entity.description))
for category_entity in frame_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
# Each frame_label_annotation has many frames,
# here we print information only about the first frame.
frame = frame_label.frames[0]
time_offset = frame.time_offset.seconds + frame.time_offset.nanos / 1e9
print('\tFirst frame time offset: {}s'.format(time_offset))
print('\tFirst frame confidence: {}'.format(frame.confidence))
print('\n')
import sys
import time
import os
from google.cloud import videointelligence_v1beta2
from google.cloud.videointelligence_v1beta2 import enums
video_client = videointelligence_v1beta2.VideoIntelligenceServiceClient()
features = [enums.Feature.LABEL_DETECTION]
operation = video_client.annotate_video('gs://demomaker/volleyball.mp4',
features)
print('\nProcessing video for label annotations:')
while not operation.done():
sys.stdout.write('.')
sys.stdout.flush()
time.sleep(15)
print('\nFinished processing.')
# first result is retrieved because a single video was processed
results = operation.result().annotation_results[0]
for i, segment_label in enumerate(results.segment_label_annotations):
print('Video label description: {}'.format(
segment_label.entity.description))
for category_entity in segment_label.category_entities:
print('\tLabel category description: {}'.format(
category_entity.description))
