def async_detect_document(gcs_source_uri, gcs_destination_uri): # Supported mime_types are: 'application/pdf' and 'image/tiff' mime_type = 'application/pdf' # How many pages should be grouped into each json output file. # With a file of 5 pages batch_size = 2 client = vision.ImageAnnotatorClient() feature = vision.types.Feature( type=vision.enums.Feature.Type.DOCUMENT_TEXT_DETECTION) gcs_source = vision.types.GcsSource(uri=gcs_source_uri) input_config = vision.types.InputConfig(gcs_source=gcs_source, mime_type=mime_type) gcs_destination = vision.types.GcsDestination(uri=gcs_destination_uri) output_config = vision.types.OutputConfig(gcs_destination=gcs_destination, batch_size=batch_size) async_request = vision.types.AsyncAnnotateFileRequest( features=[feature], input_config=input_config, output_config=output_config) client.async_batch_annotate_files(requests=[async_request])
def test_async_batch_annotate_files(self): # Setup Expected Response expected_response = {} expected_response = image_annotator_pb2.AsyncBatchAnnotateFilesResponse( **expected_response) operation = operations_pb2.Operation( name='operations/test_async_batch_annotate_files', done=True) operation.response.Pack(expected_response) # Mock the API response channel = ChannelStub(responses=[operation]) client = vision_v1p2beta1.ImageAnnotatorClient(channel=channel) # Setup Request requests = [] response = client.async_batch_annotate_files(requests) result = response.result() assert expected_response == result assert len(channel.requests) == 1 expected_request = image_annotator_pb2.AsyncBatchAnnotateFilesRequest( requests=requests) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_async_batch_annotate_files(self): # Setup Expected Response expected_response = {} expected_response = image_annotator_pb2.AsyncBatchAnnotateFilesResponse( **expected_response) operation = operations_pb2.Operation( name="operations/test_async_batch_annotate_files", 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 = vision_v1p2beta1.ImageAnnotatorClient() # Setup Request requests = [] response = client.async_batch_annotate_files(requests) result = response.result() assert expected_response == result assert len(channel.requests) == 1 expected_request = image_annotator_pb2.AsyncBatchAnnotateFilesRequest( requests=requests) actual_request = channel.requests[0][1] assert expected_request == actual_request
def _google_pdf_ocr(guid, account, train, thread_storage): if getattr(thread_storage, 'vision_client', None) is None: thread_storage.vision_client = gv.ImageAnnotatorClient() if getattr(thread_storage, 'storage_client', None) is None: thread_storage.storage_client = gs.Client() if getattr(thread_storage, 'logger', None) is None: thread_storage.logger = get_logger('utils.ocr') if _check_duplicate(guid, thread_storage): thread_storage.logger.warning( 'Skipping {} because it has already been OCRd'.format(guid)) return src_uri = _locate_src_file(guid, account, train, thread_storage) gcs_src = gv.types.GcsSource(uri=src_uri) input_config = gv.types.InputConfig(gcs_source=gcs_src, mime_type=GOOGLE_MIME_TYPE) dst_uri = _locate_dst_file(guid) gcs_dst = gv.types.GcsDestination(uri=dst_uri) output_config = gv.types.OutputConfig(gcs_destination=gcs_dst, batch_size=1) feature = gv.types.Feature( type=gv.enums.Feature.Type.DOCUMENT_TEXT_DETECTION) async_request = gv.types.AsyncAnnotateFileRequest( features=[feature], input_config=input_config, output_config=output_config) thread_storage.vision_client.async_batch_annotate_files( requests=[async_request])
def run_google_vision(img_urls_dict): print("Classifying Imgs. w. Google Vision API...") client = vision.ImageAnnotatorClient() image = vision.types.Image() for search_term in img_urls_dict.keys(): img_urls = img_urls_dict[search_term] img_classified_dict = {} img_classified_dict[search_term] = {} for image_uri in img_urls: try: image.source.image_uri = image_uri response = client.label_detection(image=image) img_classified_dict[image_uri] = {} for label in response.label_annotations: img_classified_dict[search_term][image_uri] = {} img_classified_dict[search_term][image_uri][ label.description] = label.score except: pass return img_classified_dict
def test_batch_annotate_images(self): # Setup Expected Response expected_response = {} expected_response = image_annotator_pb2.BatchAnnotateImagesResponse( **expected_response ) # Mock the API response channel = ChannelStub(responses=[expected_response]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = vision_v1p2beta1.ImageAnnotatorClient() # Setup Request requests = [] response = client.batch_annotate_images(requests) assert expected_response == response assert len(channel.requests) == 1 expected_request = image_annotator_pb2.BatchAnnotateImagesRequest( requests=requests ) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_batch_annotate_images_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) client = vision_v1p2beta1.ImageAnnotatorClient(channel=channel) # Setup request requests = [] with pytest.raises(CustomException): client.batch_annotate_images(requests)
def sample_batch_annotate_images(): # Create a client client = vision_v1p2beta1.ImageAnnotatorClient() # Initialize request argument(s) request = vision_v1p2beta1.BatchAnnotateImagesRequest() # Make the request response = client.batch_annotate_images(request=request) # Handle the response print(response)
def test_batch_annotate_images_exception(self): # Mock the API response channel = ChannelStub(responses=[CustomException()]) patch = mock.patch("google.api_core.grpc_helpers.create_channel") with patch as create_channel: create_channel.return_value = channel client = vision_v1p2beta1.ImageAnnotatorClient() # Setup request requests = [] with pytest.raises(CustomException): client.batch_annotate_images(requests)
def async_detect_document(gcs_source_uri, gcs_destination_uri): """Attempt ocr on a single gs:// uri Makes an async call to a gs:// uri to do ocr Args: gcs_source_uri: gs:// uri of file to attempt ocr on gcs_destination_uri: gs:// uri of where to write .json output output-x-to-y.json will be added to the end of this, where x is first page in the json and y is the last page. Up to 100 pages are in each json file Raises: error: catches all Exceptions (should exclude KeyboardInterrupt and other trivial exceptions) """ # adapted from https://github.com/GoogleCloudPlatform/python-docs-samples/ # blob/7405c0011ef6a691444349a91d8d6e90923f636c/vision/cloud-client/ # detect/detect_pdf.py try: # Supported mime_types are: 'application/pdf' and 'image/tiff' mime_type = 'application/pdf' # How many pages should be grouped into each json output file. batch_size = 100 client = vision.ImageAnnotatorClient() feature = vision.types.Feature( type=vision.enums.Feature.Type.DOCUMENT_TEXT_DETECTION) gcs_source = vision.types.GcsSource(uri=gcs_source_uri) input_config = vision.types.InputConfig(gcs_source=gcs_source, mime_type=mime_type) gcs_destination = vision.types.GcsDestination(uri=gcs_destination_uri) output_config = vision.types.OutputConfig( gcs_destination=gcs_destination, batch_size=batch_size) async_request = vision.types.AsyncAnnotateFileRequest( features=[feature], input_config=input_config, output_config=output_config) operation = client.async_batch_annotate_files(requests=[async_request]) # todo(michaelsherman) catch and log the operation ID response = operation.result(timeout=150) return response # intentional, catch everything and pass up the stack for report except Exception as error: raise error
def sample_async_batch_annotate_files(): # Create a client client = vision_v1p2beta1.ImageAnnotatorClient() # Initialize request argument(s) request = vision_v1p2beta1.AsyncBatchAnnotateFilesRequest() # Make the request operation = client.async_batch_annotate_files(request=request) print("Waiting for operation to complete...") response = operation.result() # Handle the response print(response)
def test_async_batch_annotate_files_exception(self): # Setup Response error = status_pb2.Status() operation = operations_pb2.Operation( name='operations/test_async_batch_annotate_files_exception', done=True) operation.error.CopyFrom(error) # Mock the API response channel = ChannelStub(responses=[operation]) client = vision_v1p2beta1.ImageAnnotatorClient(channel=channel) # Setup Request requests = [] response = client.async_batch_annotate_files(requests) exception = response.exception() assert exception.errors[0] == error
def run_google_vision( img_urls_dict: Dict[str, List[str]]) -> Dict[str, Dict[str, Any]]: """ Use the Google vision API to return a set of classification labels for each image collected from Google using the search_and_download function. Each label assigned by Google vision is associated with a score indicating Google's confidence in the fit fo the label for the image. img_urls_dict: dictionary containing image_urls """ log = get_logger("run_google_vision") log.info("Classifying Imgs. w. Google Vision API...") # copy environment variable from configuration to the name where google API expects to find it os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = os.getenv( "COMPSYN_GOOGLE_APPLICATION_CREDENTIALS") client = vision.ImageAnnotatorClient() image = vision.types.Image() for search_term in img_urls_dict.keys(): img_urls = img_urls_dict[search_term] img_classified_dict = {} img_classified_dict[search_term] = {} log.info(f"Classifying {len(img_urls)} images for {search_term}") for image_uri in img_urls: try: image.source.image_uri = image_uri response = client.label_detection(image=image) img_classified_dict[image_uri] = {} for label in response.label_annotations: img_classified_dict[search_term][image_uri] = {} img_classified_dict[search_term][image_uri][ label.description] = label.score except: pass return img_classified_dict
def settings( application_cred_name: str, driver_browser: str, driver_executable_path: str, driver_options: Optional[List[str]] = None, ) -> None: # This client for the Google API needs to be set for the VISION classification # but it is not necessary for the selenium scaper for image downloading os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = application_cred_name client = vision.ImageAnnotatorClient( ) # authentification via environment variable # See here for scraper details: # https://towardsdatascience.com/image-scraping-with-python-a96feda8af2d wd = get_webdriver( driver_browser=driver_browser, driver_executable_path=driver_executable_path, driver_options=driver_options, ) wd.quit()
def test_batch_annotate_images(self): # Setup Expected Response expected_response = {} expected_response = image_annotator_pb2.BatchAnnotateImagesResponse( **expected_response) # Mock the API response channel = ChannelStub(responses=[expected_response]) client = vision_v1p2beta1.ImageAnnotatorClient(channel=channel) # Setup Request requests = [] response = client.batch_annotate_images(requests) assert expected_response == response assert len(channel.requests) == 1 expected_request = image_annotator_pb2.BatchAnnotateImagesRequest( requests=requests) actual_request = channel.requests[0][1] assert expected_request == actual_request
def test_async_batch_annotate_files_exception(self): # Setup Response error = status_pb2.Status() operation = operations_pb2.Operation( name="operations/test_async_batch_annotate_files_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 = vision_v1p2beta1.ImageAnnotatorClient() # Setup Request requests = [] response = client.async_batch_annotate_files(requests) exception = response.exception() assert exception.errors[0] == error
def run_google_vision( img_urls_dict: Dict[str, List[str]]) -> Dict[str, Dict[str, Any]]: """ Use the Google vision API to return a set of classification labels for each image collected from Google using the search_and_download function. Each label assigned by Google vision is associated with a score indicating Google's confidence in the fit fo the label for the image. img_urls_dict: dictionary containing image_urls """ get_logger("run_google_vision").info( "Classifying Imgs. w. Google Vision API...") client = vision.ImageAnnotatorClient() image = vision.types.Image() for search_term in img_urls_dict.keys(): img_urls = img_urls_dict[search_term] img_classified_dict = {} img_classified_dict[search_term] = {} for image_uri in img_urls: try: image.source.image_uri = image_uri response = client.label_detection(image=image) img_classified_dict[image_uri] = {} for label in response.label_annotations: img_classified_dict[search_term][image_uri] = {} img_classified_dict[search_term][image_uri][ label.description] = label.score except: pass return img_classified_dict
def OCRfromPILImage(pilImg): img_data = GetPILImageBytes(pilImg) req_body = { 'image': { 'content': img_data }, 'features': [{ 'type': 'TEXT_DETECTION' }] } try: cred = get_credential() except SSTRAuthException as sstrex: return str(sstrex) client = vision_v1p2beta1.ImageAnnotatorClient(credentials=cred) result = client.annotate_image(req_body) fw = open(str(responselog_path), "w", encoding="utf-8") fw.write(str(result)) fw.close() pilImg.save(imagelog_path) # jsonl = json.loads(res.text) jsonl = result try: if len(jsonl.text_annotations) == 0: return "" ocr = jsonl.text_annotations[0].description ocr = ocr.replace("\n", " ") return ocr except: import traceback traceback.print_exc() #jsonl内容はLogを見ること return "OCR ERROR!!"
import json import rapidjson import os from pprint import pprint from IPython.display import clear_output from IPython.display import Image sns.set(style='whitegrid') from google.cloud import vision_v1p2beta1 as vision from google.protobuf.json_format import MessageToDict from google_images_download import google_images_download #importing the library # In[2]: # on the line below, replace the file directory with the directory for your own credential JSON file os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = 'COMPSYN2-18e251c693df.json' client = vision.ImageAnnotatorClient( ) # authentification via environment variable # In[3]: # PHASE 1: def build_image(input_string): '''builds image object''' if input_string.startswith('http') or input_string.startswith( 'gs:'): # online images image = vision.types.Image() image.source.image_uri = input_string else: # local images with open(input_string, 'rb') as image_file: content = image_file.read()
def async_detect_document(gcs_source_uri, gcs_destination_uri): # Supported mime_types are: 'application/pdf' and 'image/tiff' mime_type = 'application/pdf' # How many pages should be grouped into each json output file. # With a file of 5 pages batch_size = 2 client = vision.ImageAnnotatorClient() feature = vision.types.Feature( type=vision.enums.Feature.Type.DOCUMENT_TEXT_DETECTION) gcs_source = vision.types.GcsSource(uri=gcs_source_uri) input_config = vision.types.InputConfig(gcs_source=gcs_source, mime_type=mime_type) gcs_destination = vision.types.GcsDestination(uri=gcs_destination_uri) output_config = vision.types.OutputConfig(gcs_destination=gcs_destination, batch_size=batch_size) async_request = vision.types.AsyncAnnotateFileRequest( features=[feature], input_config=input_config, output_config=output_config) operation = client.async_batch_annotate_files(requests=[async_request]) print('Waiting for the operation to finish.') operation.result(timeout=90) # Once the request has completed and the output has been # written to GCS, we can list all the output files. storage_client = storage.Client() match = re.match(r'gs://([^/]+)/(.+)', gcs_destination_uri) bucket_name = match.group(1) prefix = match.group(2) bucket = storage_client.get_bucket(bucket_name=bucket_name) # List objects with the given prefix. blob_list = list(bucket.list_blobs(prefix=prefix)) print('Output files:') for blob in blob_list: print(blob.name) # Process the first output file from GCS. # Since we specified batch_size=2, the first response contains # the first two pages of the input file. output = blob_list[0] json_string = output.download_as_string() response = json_format.Parse(json_string, vision.types.AnnotateFileResponse()) # The actual response for the first page of the input file. first_page_response = response.responses[0] annotation = first_page_response.full_text_annotation # Here we print the full text from the first page. # The response contains more information: # annotation/pages/blocks/paragraphs/words/symbols # including confidence scores and bounding boxes print(u'Full text:\n{}'.format(annotation.text))