As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Usando o fluxo de trabalho Analyze Lending
<a name="async-using-lending"></a>

 Para detectar texto em documentos de empréstimo de várias páginas ou analisá-los usando o fluxo de trabalho Analisar empréstimos, faça o seguinte:

1. Crie o tópico do Amazon SNS e a fila do Amazon SQS.

1. Inscreva na fila o tópico.

1. Dê permissão ao tópico para enviar mensagens para a fila.

1. Comece a processar o documento. `StartLendingAnalysis`Operação de chamada.

1. Obtenha o status de conclusão na fila do Amazon SQS. O código de exemplo rastreia o identificador do trabalho (`JobId`) que é retornado pela `Start` operação. O código de exemplo só obtém os resultados da correspondência de identificadores de trabalho que são lidos no status de conclusão. Isso é importante se outros aplicativos estiverem usando a mesma fila e o mesmo tópico. Para simplificar, o código de exemplo exclui trabalhos que não coincidem. Considere adicionar os trabalhos excluídos a uma fila de e-mails enviados do Amazon SQS para uma investigação mais aprofundada.

   Os resultados da StartLendingAnalysis operação podem ser enviados para um bucket do Amazon S3 de sua escolha usando o OutputConfig recurso. Se você usar esse recurso, talvez precise fazer algumas configurações adicionais de sua função de usuário e serviço. Para obter informações sobre como permitir que o Amazon Textract envie documentos criptografados para seu bucket do Amazon S3, consulte. [Permissões para configuração de saída](api-async-roles.md#async-output-config)

1. Obtenha e exiba os resultados do processamento chamando a `GetLendingAnalysis` operação ou a `GetLendingAnalysisSummary` operação.

1. Quando terminar de processar os documentos, certifique-se de excluir o tópico do Amazon SNS e a fila do Amazon SQS. Se precisar processar documentos adicionais, você pode deixar o tópico do Amazon SNS e a fila do Amazon SQS como estão e reutilizá-los para os outros documentos.

## Executando análise assíncrona de empréstimos
<a name="async-using-lending-analysis"></a>

O código de exemplo para esse procedimento é fornecido para Python e o. AWS CLI Antes de começar, instale o AWS SDK apropriado. Para obter mais informações, consulte [Etapa 2: configurar o AWS CLI and AWS SDKs](setup-awscli-sdk.md). 

1. Configure o acesso do usuário ao Amazon Textract e configure o acesso do Amazon Textract ao Amazon SNS. Para obter mais informações, consulte [ Configuração do Amazon Textract para operações assíncronas. ](https://docs.aws.amazon.com/en_us/textract/latest/dg/api-async-roles.html) Para concluir esse procedimento, você precisa de um arquivo de documento de várias páginas em formato PDF. Você pode pular as etapas 3 a 6 nas instruções de configuração, pois o código de exemplo cria e configura o tópico do Amazon SNS e a fila do Amazon SQS. Ao concluir o exemplo da CLI, você não precisa configurar uma fila SQS. 

1. Faça upload de um arquivo de documento de várias páginas em formato PDF ou TIFF para seu bucket do Amazon S3 (você também pode processar documentos de uma única página nos formatos JPEG, PNG, TIFF ou PDF). Para obter instruções, consulte [ Upload de objetos no Amazon S3 ](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/UploadingObjectsintoAmazonS3.html) no Guia do usuário do * Amazon Simple Storage Service. * 

1. Use o seguinte SDK da AWS para Python (Boto3) ou o código da AWS CLI para analisar o texto em um documento de empréstimo de várias páginas. Na função principal: 
   + Substitua o valor de `roleArn` pelo ARN da função IAM que você salvou em [ Conceder acesso ao Amazon Textract ao seu tópico do Amazon SNS. ](https://docs.aws.amazon.com/en_us/textract/latest/dg/api-async-roles.html#api-async-roles-all-topics)
   + Substitua os valores `document` de `bucket` e pelo nome do arquivo do bucket e do documento que você especificou anteriormente na Etapa 2 anterior.
   + Substitua o valor do parâmetro de `type` entrada da `ProcessDocument` função pelo tipo de processamento que você deseja usar. Por exemplo, use `ProcessType.DETECTION` para detectar texto ou `ProcessType.ANALYSIS` para analisar texto.
   + Para o exemplo do Python, substitua o valor de `region_name` pela região em que seu cliente está operando.

    Para o próximo código de exemplo da AWS CLI, faça o seguinte: 
   + Ao chamar a [ StartLendingAnalysis ](https://docs.aws.amazon.com/en_us/textract/latest/dg/API_StartLendingAnalysis.html) operação, substitua o valor de `bucket-name` pelo nome do seu bucket do S3 e `FileName` substitua pelo nome do arquivo que você especificou na etapa 2. Especifique a região do seu bucket `region-name` substituindo-a pelo nome da sua região. Observe que o exemplo da CLI não usa o SQS.
   + Ao chamar a [ GetLendingAnalysis ](https://docs.aws.amazon.com/en_us/textract/latest/dg/API_GetLendingAnalysis.html) operação ou a [ GetLendingAnalysisSummary ](https://docs.aws.amazon.com/en_us/textract/latest/dg/API_GetLendingAnalysisSummary.html) operação, `jobId` substitua pela `jobId` retornada por [ StartLendingAnalysis](https://docs.aws.amazon.com/en_us/textract/latest/dg/API_StartLendingAnalysis.html). Especifique a região do seu bucket `region-name` substituindo-a pelo nome da sua região.

1. Execute o código para o SDK ou a AWS CLI de sua escolha. 

   A operação pode demorar um pouco para ser concluída. Depois de concluído, uma lista de blocos para texto detectado ou analisado é exibida nos seguintes exemplos:

------
#### [ AWS CLI ]

   Para iniciar a análise do documento de empréstimo, use o seguinte comando CLI. Se você quiser ver documentos divididos, use o `output-config` argumento, caso contrário, você pode removê-lo: 

   ```
   aws textract start-lending-analysis \
   --document-location '{"S3Object":{"Bucket":"S3Bucket","Name":"FileName"}}' \
   --output-config '{"S3Bucket": "S3Bucket",  "S3Prefix": "S3Prefix"}' \
   --kms-key-id '1234abcd-12ab-34cd-56ef-1234567890ab' \
   --region 'region-name'
   ```

   Para obter os resultados da análise do documento de empréstimo, use o seguinte comando CLI. O `max-results` argumento é opcional e, se você não quiser limitar o número de resultados retornados, poderá removê-lo:

   ```
   aws textract get-lending-analysis \
   --job-id 'jobId' \
   --region 'us-west-2' \
   --max-results 30
   ```

   Para recuperar um resumo dos resultados:

   ```
   aws textract get-lending-analysis-summary \
   --job-id 'jobId' \
   --region 'us-west-2'
   ```

------
#### [ Python ]

   ```
   import boto3
   import json
   import sys
   import time
   
   class DocumentProcessor:
   
       def __init__(self, role, bucket, document, region):
           self.roleArn = role
           self.bucket = bucket
           self.document = document
           self.region_name = region
   
           self.textract = boto3.client('textract', region_name=self.region_name)
           self.sqs = boto3.client('sqs')
           self.sns = boto3.client('sns')
   
       def ProcessDocument(self):
           jobFound = False
   
           response = self.textract.start_lending_analysis(
               DocumentLocation={'S3Object': {'Bucket': self.bucket, 'Name': self.document}},
               NotificationChannel={'RoleArn': self.roleArn, 'SNSTopicArn': self.snsTopicArn})
           print('Processing type: Analysis')
   
           print('Start Job Id: ' + response['JobId'])
           dotLine = 0
           while jobFound == False:
               sqsResponse = self.sqs.receive_message(QueueUrl=self.sqsQueueUrl, MessageAttributeNames=['ALL'],
                                                      MaxNumberOfMessages=10)
               if sqsResponse:
                   if 'Messages' not in sqsResponse:
                       if dotLine < 40:
                           print('.', end='')
                           dotLine = dotLine + 1
                       else:
                           print()
                           dotLine = 0
                       sys.stdout.flush()
                       time.sleep(5)
                       continue
   
                   for message in sqsResponse['Messages']:
                       notification = json.loads(message['Body'])
                       textMessage = json.loads(notification['Message'])
                       print(textMessage['JobId'])
                       print(textMessage['Status'])
                       if str(textMessage['JobId']) == response['JobId']:
                           print('Matching Job Found:' + textMessage['JobId'])
                           jobFound = True
                           self.GetResults(textMessage['JobId'])
                           self.GetSummary(textMessage['JobId'])
                           self.sqs.delete_message(QueueUrl=self.sqsQueueUrl,
                                                   ReceiptHandle=message['ReceiptHandle'])
                       else:
                           print("Job didn't match:" +
                                 str(textMessage['JobId']) + ' : ' + str(response['JobId']))
                       # Delete the unknown message. Consider sending to dead letter queue
                       self.sqs.delete_message(QueueUrl=self.sqsQueueUrl,
                                               ReceiptHandle=message['ReceiptHandle'])
   
           print('Done!')
   
       def CreateTopicandQueue(self):
   
           millis = str(int(round(time.time() * 1000)))
   
           # Create SNS topic
           snsTopicName = "AmazonTextractTopic" + millis
   
           topicResponse = self.sns.create_topic(Name=snsTopicName)
           self.snsTopicArn = topicResponse['TopicArn']
   
           # create SQS queue
           sqsQueueName = "AmazonTextractQueue" + millis
           self.sqs.create_queue(QueueName=sqsQueueName)
           self.sqsQueueUrl = self.sqs.get_queue_url(QueueName=sqsQueueName)['QueueUrl']
   
           attribs = self.sqs.get_queue_attributes(QueueUrl=self.sqsQueueUrl,
                                                   AttributeNames=['QueueArn'])['Attributes']
   
           sqsQueueArn = attribs['QueueArn']
   
           # Subscribe SQS queue to SNS topic
           self.sns.subscribe(
               TopicArn=self.snsTopicArn,
               Protocol='sqs',
               Endpoint=sqsQueueArn)
   
           # Authorize SNS to write SQS queue
           policy = """{{
     "Version":"2012-10-17",		 	 	 
     "Statement":[
       {{
         "Sid":"MyPolicy",
         "Effect":"Allow",
         "Principal" : {{"AWS" : "*"}},
         "Action":"sqs:*",
         "Resource": "{}",
         "Condition":{{
           "ArnEquals":{{
             "aws:SourceArn": "{}"
           }}
         }}
       }}
     ]
   }}""".format(sqsQueueArn, self.snsTopicArn)
   
           response = self.sqs.set_queue_attributes(
               QueueUrl=self.sqsQueueUrl,
               Attributes={
                   'Policy': policy
               })
   
       def DeleteTopicandQueue(self):
           self.sqs.delete_queue(QueueUrl=self.sqsQueueUrl)
           self.sns.delete_topic(TopicArn=self.snsTopicArn)
   
       # Display information about a block
       def DisplayExtractInfo(self, response):
           results = response['Results']
           for page in results:
               print("Page Classification: {}".format(page["PageClassification"]["PageType"]))
               print("Page Number: {}".format(page["Page"]))
               for extract in page["Extractions"]:
                   for fields, vals in extract['LendingDocument'].items():
                       for val in vals:
                           print("Document Type: {}".format(val['Type']))
                           detections = val['ValueDetections']
                           for i in detections:
                               print(i['Text'])
                               print('Geometry')
                               print('\tBounding Box: {}'.format(i['Geometry']['BoundingBox']))
                               print('\tPolygon: {}'.format(i['Geometry']['Polygon']))
   
       def GetSummary(self, jobId):
           
           maxResults = 1000
           response = self.textract.get_lending_analysis_summary(JobId=jobId, MaxResults=maxResults)
           doc_groups = response['DocumentGroups']
           print("Summary info:")
           for group in doc_groups:
               print("Document type: " + group['Type'])
               split_docs = group['SplitDocuments']
               for doc in split_docs:
                   print(doc)
                   for idx, page in doc.items():
                       print(str(idx) + " - " + str(page))
   
       def GetResults(self, jobId):
   
           maxResults = 1000
           paginationToken = None
           finished = False
   
           while finished == False:
   
               response = None
               if paginationToken == None:
                   response = self.textract.get_lending_analysis(JobId=jobId,
                                                                 MaxResults=maxResults)
               else:
                   response = self.textract.get_lending_analysis(JobId=jobId,
                                                                 MaxResults=maxResults,
                                                                 NextToken=paginationToken)
   
               print('Detected Document Text')
               print('Pages: {}'.format(response['DocumentMetadata']['Pages']))
   
               self.DisplayExtractInfo(response)
   
               if 'NextToken' in response:
                   paginationToken = response['NextToken']
               else:
                   finished = True
   
   def main():
       roleArn = ''
       bucket = ''
       document = ''
       region_name = ''
   
       analyzer = DocumentProcessor(roleArn, bucket, document, region_name)
       analyzer.CreateTopicandQueue()
       analyzer.ProcessDocument()
       analyzer.DeleteTopicandQueue()
   
   
   if __name__ == "__main__":
       main()
   ```

------