Small batch file annotation online

  import 
  
 com.google.cloud.vision.v1. AnnotateFileRequest 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. AnnotateImageResponse 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. BatchAnnotateFilesRequest 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. BatchAnnotateFilesResponse 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. Block 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. Feature 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. ImageAnnotatorClient 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. InputConfig 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. Page 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. Paragraph 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. Symbol 
 
 ; 
 import 
  
 com.google.cloud.vision.v1. Word 
 
 ; 
 import 
  
 com.google.protobuf. ByteString 
 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.nio.file.Files 
 ; 
 import 
  
 java.nio.file.Path 
 ; 
 import 
  
 java.nio.file.Paths 
 ; 
 public 
  
 class 
 BatchAnnotateFiles 
  
 { 
  
 public 
  
 static 
  
 void 
  
 batchAnnotateFiles 
 () 
  
 throws 
  
 IOException 
  
 { 
  
 String 
  
 filePath 
  
 = 
  
 "path/to/your/file.pdf" 
 ; 
  
 batchAnnotateFiles 
 ( 
 filePath 
 ); 
  
 } 
  
 public 
  
 static 
  
 void 
  
 batchAnnotateFiles 
 ( 
 String 
  
 filePath 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
 // Initialize client that will be used to send requests. This client only needs to be created 
  
 // once, and can be reused for multiple requests. After completing all of your requests, call 
  
 // the "close" method on the client to safely clean up any remaining background resources. 
  
 try 
  
 ( 
  ImageAnnotatorClient 
 
  
 imageAnnotatorClient 
  
 = 
  
  ImageAnnotatorClient 
 
 . 
 create 
 ()) 
  
 { 
  
 // You can send multiple files to be annotated, this sample demonstrates how to do this with 
  
 // one file. If you want to use multiple files, you have to create a `AnnotateImageRequest` 
  
 // object for each file that you want annotated. 
  
 // First read the files contents 
  
 Path 
  
 path 
  
 = 
  
 Paths 
 . 
 get 
 ( 
 filePath 
 ); 
  
 byte 
 [] 
  
 data 
  
 = 
  
 Files 
 . 
 readAllBytes 
 ( 
 path 
 ); 
  
  ByteString 
 
  
 content 
  
 = 
  
  ByteString 
 
 . 
  copyFrom 
 
 ( 
 data 
 ); 
  
 // Specify the input config with the file's contents and its type. 
  
 // Supported mime_type: application/pdf, image/tiff, image/gif 
  
 // https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#inputconfig 
  
  InputConfig 
 
  
 inputConfig 
  
 = 
  
  InputConfig 
 
 . 
 newBuilder 
 (). 
  setMimeType 
 
 ( 
 "application/pdf" 
 ). 
 setContent 
 ( 
 content 
 ). 
 build 
 (); 
  
 // Set the type of annotation you want to perform on the file 
  
 // https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#google.cloud.vision.v1.Feature.Type 
  
  Feature 
 
  
 feature 
  
 = 
  
  Feature 
 
 . 
 newBuilder 
 (). 
 setType 
 ( 
  Feature 
 
 . 
 Type 
 . 
 DOCUMENT_TEXT_DETECTION 
 ). 
 build 
 (); 
  
 // Build the request object for that one file. Note: for additional file you have to create 
  
 // additional `AnnotateFileRequest` objects and store them in a list to be used below. 
  
 // Since we are sending a file of type `application/pdf`, we can use the `pages` field to 
  
 // specify which pages to process. The service can process up to 5 pages per document file. 
  
 // https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#google.cloud.vision.v1.AnnotateFileRequest 
  
  AnnotateFileRequest 
 
  
 fileRequest 
  
 = 
  
  AnnotateFileRequest 
 
 . 
 newBuilder 
 () 
  
 . 
 setInputConfig 
 ( 
 inputConfig 
 ) 
  
 . 
 addFeatures 
 ( 
 feature 
 ) 
  
 . 
 addPages 
 ( 
 1 
 ) 
  
 // Process the first page 
  
 . 
 addPages 
 ( 
 2 
 ) 
  
 // Process the second page 
  
 . 
 addPages 
 ( 
 - 
 1 
 ) 
  
 // Process the last page 
  
 . 
 build 
 (); 
  
 // Add each `AnnotateFileRequest` object to the batch request. 
  
  BatchAnnotateFilesRequest 
 
  
 request 
  
 = 
  
  BatchAnnotateFilesRequest 
 
 . 
 newBuilder 
 (). 
 addRequests 
 ( 
 fileRequest 
 ). 
 build 
 (); 
  
 // Make the synchronous batch request. 
  
  BatchAnnotateFilesResponse 
 
  
 response 
  
 = 
  
 imageAnnotatorClient 
 . 
 batchAnnotateFiles 
 ( 
 request 
 ); 
  
 // Process the results, just get the first result, since only one file was sent in this 
  
 // sample. 
  
 for 
  
 ( 
  AnnotateImageResponse 
 
  
 imageResponse 
  
 : 
  
 response 
 . 
  getResponsesList 
 
 (). 
 get 
 ( 
 0 
 ). 
 getResponsesList 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 format 
 ( 
 "Full text: %s%n" 
 , 
  
 imageResponse 
 . 
 getFullTextAnnotation 
 (). 
 getText 
 ()); 
  
 for 
  
 ( 
  Page 
 
  
 page 
  
 : 
  
 imageResponse 
 . 
 getFullTextAnnotation 
 (). 
 getPagesList 
 ()) 
  
 { 
  
 for 
  
 ( 
  Block 
 
  
 block 
  
 : 
  
 page 
 . 
 getBlocksList 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 format 
 ( 
 "%nBlock confidence: %s%n" 
 , 
  
 block 
 . 
 getConfidence 
 ()); 
  
 for 
  
 ( 
  Paragraph 
 
  
 par 
  
 : 
  
 block 
 . 
 getParagraphsList 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 format 
 ( 
 "\tParagraph confidence: %s%n" 
 , 
  
 par 
 . 
 getConfidence 
 ()); 
  
 for 
  
 ( 
  Word 
 
  
 word 
  
 : 
  
 par 
 . 
 getWordsList 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 format 
 ( 
 "\t\tWord confidence: %s%n" 
 , 
  
 word 
 . 
 getConfidence 
 ()); 
  
 for 
  
 ( 
  Symbol 
 
  
 symbol 
  
 : 
  
 word 
 . 
 getSymbolsList 
 ()) 
  
 { 
  
 System 
 . 
 out 
 . 
 format 
 ( 
  
 "\t\t\tSymbol: %s, (confidence: %s)%n" 
 , 
  
 symbol 
 . 
 getText 
 (), 
  
 symbol 
 . 
 getConfidence 
 ()); 
  
 } 
  
 } 
  
 } 
  
 } 
  
 } 
  
 } 
  
 } 
  
 } 
 } 
 

  /** 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
 // const fileName = 'path/to/your/file.pdf'; 
 // Imports the Google Cloud client libraries 
 const 
  
 { 
 ImageAnnotatorClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/vision 
' 
 ). 
 v1 
 ; 
 const 
  
 fs 
  
 = 
  
 require 
 ( 
 'fs' 
 ). 
 promises 
 ; 
 // Instantiates a client 
 const 
  
 client 
  
 = 
  
 new 
  
  ImageAnnotatorClient 
 
 (); 
 // You can send multiple files to be annotated, this sample demonstrates how to do this with 
 // one file. If you want to use multiple files, you have to create a request object for each file that you want annotated. 
 async 
  
 function 
  
 batchAnnotateFiles 
 () 
  
 { 
  
 // First Specify the input config with the file's path and its type. 
  
 // Supported mime_type: application/pdf, image/tiff, image/gif 
  
 // https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#inputconfig 
  
 const 
  
 inputConfig 
  
 = 
  
 { 
  
 mimeType 
 : 
  
 'application/pdf' 
 , 
  
 content 
 : 
  
 await 
  
 fs 
 . 
 readFile 
 ( 
 fileName 
 ), 
  
 }; 
  
 // Set the type of annotation you want to perform on the file 
  
 // https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#google.cloud.vision.v1.Feature.Type 
  
 const 
  
 features 
  
 = 
  
 [{ 
 type 
 : 
  
 'DOCUMENT_TEXT_DETECTION' 
 }]; 
  
 // Build the request object for that one file. Note: for additional files you have to create 
  
 // additional file request objects and store them in a list to be used below. 
  
 // Since we are sending a file of type `application/pdf`, we can use the `pages` field to 
  
 // specify which pages to process. The service can process up to 5 pages per document file. 
  
 // https://cloud.google.com/vision/docs/reference/rpc/google.cloud.vision.v1#google.cloud.vision.v1.AnnotateFileRequest 
  
 const 
  
 fileRequest 
  
 = 
  
 { 
  
 inputConfig 
 : 
  
 inputConfig 
 , 
  
 features 
 : 
  
 features 
 , 
  
 // Annotate the first two pages and the last one (max 5 pages) 
  
 // First page starts at 1, and not 0. Last page is -1. 
  
 pages 
 : 
  
 [ 
 1 
 , 
  
 2 
 , 
  
 - 
 1 
 ], 
  
 }; 
  
 // Add each `AnnotateFileRequest` object to the batch request. 
  
 const 
  
 request 
  
 = 
  
 { 
  
 requests 
 : 
  
 [ 
 fileRequest 
 ], 
  
 }; 
  
 // Make the synchronous batch request. 
  
 const 
  
 [ 
 result 
 ] 
  
 = 
  
 await 
  
 client 
 . 
 batchAnnotateFiles 
 ( 
 request 
 ); 
  
 // Process the results, just get the first result, since only one file was sent in this 
  
 // sample. 
  
 const 
  
 responses 
  
 = 
  
  result 
 
 . 
 responses 
 [ 
 0 
 ]. 
 responses 
 ; 
  
 for 
  
 ( 
 const 
  
 response 
  
 of 
  
 responses 
 ) 
  
 { 
  
 console 
 . 
 log 
 ( 
 `Full text: 
 ${ 
 response 
 . 
 fullTextAnnotation 
 . 
 text 
 } 
 ` 
 ); 
  
 for 
  
 ( 
 const 
  
 page 
  
 of 
  
 response 
 . 
 fullTextAnnotation 
 . 
 pages 
 ) 
  
 { 
  
 for 
  
 ( 
 const 
  
 block 
  
 of 
  
 page 
 . 
 blocks 
 ) 
  
 { 
  
 console 
 . 
 log 
 ( 
 `Block confidence: 
 ${ 
 block 
 . 
 confidence 
 } 
 ` 
 ); 
  
 for 
  
 ( 
 const 
  
 paragraph 
  
 of 
  
 block 
 . 
 paragraphs 
 ) 
  
 { 
  
 console 
 . 
 log 
 ( 
 ` Paragraph confidence: 
 ${ 
 paragraph 
 . 
 confidence 
 } 
 ` 
 ); 
  
 for 
  
 ( 
 const 
  
 word 
  
 of 
  
 paragraph 
 . 
 words 
 ) 
  
 { 
  
 const 
  
 symbol_texts 
  
 = 
  
 word 
 . 
 symbols 
 . 
 map 
 ( 
 symbol 
  
 = 
>  
 symbol 
 . 
 text 
 ); 
  
 const 
  
 word_text 
  
 = 
  
 symbol_texts 
 . 
 join 
 ( 
 '' 
 ); 
  
 console 
 . 
 log 
 ( 
  
 `  Word text: 
 ${ 
 word_text 
 } 
 (confidence: 
 ${ 
 word 
 . 
 confidence 
 } 
 )` 
  
 ); 
  
 for 
  
 ( 
 const 
  
 symbol 
  
 of 
  
 word 
 . 
 symbols 
 ) 
  
 { 
  
 console 
 . 
 log 
 ( 
  
 `   Symbol: 
 ${ 
 symbol 
 . 
 text 
 } 
 (confidence: 
 ${ 
 symbol 
 . 
 confidence 
 } 
 )` 
  
 ); 
  
 } 
  
 } 
  
 } 
  
 } 
  
 } 
  
 } 
 } 
 batchAnnotateFiles 
 (); 
 

  from 
  
 google.cloud 
  
 import 
  vision_v1 
 
 def 
  
 sample_batch_annotate_files 
 ( 
 file_path 
 = 
 "path/to/your/document.pdf" 
 ): 
  
 """Perform batch file annotation.""" 
 client 
 = 
  vision_v1 
 
 . 
  ImageAnnotatorClient 
 
 () 
 # Supported mime_type: application/pdf, image/tiff, image/gif 
 mime_type 
 = 
 "application/pdf" 
 with 
 open 
 ( 
 file_path 
 , 
 "rb" 
 ) 
 as 
 f 
 : 
 content 
 = 
 f 
 . 
 read 
 () 
 input_config 
 = 
 { 
 "mime_type" 
 : 
 mime_type 
 , 
 "content" 
 : 
 content 
 } 
 features 
 = 
 [{ 
 "type_" 
 : 
  vision_v1 
 
 . 
  Feature 
 
 . 
 Type 
 . 
 DOCUMENT_TEXT_DETECTION 
 }] 
 # The service can process up to 5 pages per document file. Here we specify 
 # the first, second, and last page of the document to be processed. 
 pages 
 = 
 [ 
 1 
 , 
 2 
 , 
 - 
 1 
 ] 
 requests 
 = 
 [{ 
 "input_config" 
 : 
 input_config 
 , 
 "features" 
 : 
 features 
 , 
 "pages" 
 : 
 pages 
 }] 
 response 
 = 
 client 
 . 
  batch_annotate_files 
 
 ( 
 requests 
 = 
 requests 
 ) 
 for 
 image_response 
 in 
 response 
 . 
 responses 
 [ 
 0 
 ] 
 . 
 responses 
 : 
 print 
 ( 
 f 
 "Full text: 
 { 
 image_response 
 . 
 full_text_annotation 
 . 
 text 
 } 
 " 
 ) 
 for 
 page 
 in 
 image_response 
 . 
 full_text_annotation 
 . 
 pages 
 : 
 for 
 block 
 in 
 page 
 . 
 blocks 
 : 
 print 
 ( 
 f 
 " 
 \n 
 Block confidence: 
 { 
 block 
 . 
 confidence 
 } 
 " 
 ) 
 for 
 par 
 in 
 block 
 . 
 paragraphs 
 : 
 print 
 ( 
 f 
 " 
 \t 
 Paragraph confidence: 
 { 
 par 
 . 
 confidence 
 } 
 " 
 ) 
 for 
 word 
 in 
 par 
 . 
 words 
 : 
 print 
 ( 
 f 
 " 
 \t\t 
 Word confidence: 
 { 
 word 
 . 
 confidence 
 } 
 " 
 ) 
 for 
 symbol 
 in 
 word 
 . 
 symbols 
 : 
 print 
 ( 
 " 
 \t\t\t 
 Symbol: 
 {} 
 , (confidence: 
 {} 
 )" 
 . 
 format 
 ( 
 symbol 
 . 
 text 
 , 
 symbol 
 . 
 confidence 
 ) 
 )