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))