Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Uso del flujo de trabajo de Analyze Lending
<a name="async-using-lending"></a>

 Para detectar texto en documentos de préstamos de varias páginas o analizarlos mediante el flujo de trabajo de Analyze Lending, haga lo siguiente:

1. Cree el tema de Amazon SNS y la cola de Amazon SQS.

1. Suscríbase a la cola del tema.

1. Conceda permiso al tema para enviar mensajes a la cola.

1. Empieza a procesar el documento. `StartLendingAnalysis`Operación de llamada.

1. Obtenga el estado de realización a partir de la cola de Amazon SQS. El código de ejemplo rastrea el identificador de trabajo (`JobId`) que devuelve la `Start` operación. El código de ejemplo solo obtiene los resultados de los identificadores de trabajo coincidentes que se leen desde el estado de finalización. Esto es importante si otras aplicaciones utilizan la misma cola y el mismo tema. Para simplificar, el código de ejemplo elimina los trabajos que no coinciden. Considere la posibilidad de añadir los trabajos eliminados a una cola de espera de Amazon SQS para seguir investigando.

   Los resultados de la StartLendingAnalysis operación se pueden enviar a un bucket de Amazon S3 de su elección mediante esta función. OutputConfig Si utiliza esta función, es posible que deba realizar alguna configuración adicional de su rol de usuario y servicio. Para obtener información sobre cómo permitir que Amazon Textract envíe documentos cifrados a su bucket de Amazon S3, consulte[Permisos para la configuración de salida](api-async-roles.md#async-output-config).

1. Obtenga y muestre los resultados del procesamiento llamando a la `GetLendingAnalysis` operación o a la `GetLendingAnalysisSummary` operación.

1. Cuando termine de procesar los documentos, asegúrese de eliminar el tema de Amazon SNS y la cola de Amazon SQS. Si necesita procesar documentos adicionales, puede dejar el tema de Amazon SNS y la cola de Amazon SQS tal como están y reutilizarlos para los demás documentos.

## Realización de un análisis asincrónico de préstamos
<a name="async-using-lending-analysis"></a>

El código de ejemplo de este procedimiento se proporciona para Python y para. AWS CLI Antes de empezar, instale el AWS SDK apropiado. Para obtener más información, consulte [Paso 2: configurar el AWS CLI and AWS SDK](setup-awscli-sdk.md). 

1. Configure el acceso de los usuarios a Amazon Textract y configure el acceso de Amazon Textract a Amazon SNS. Para obtener más información, consulte [ Configuración de Amazon Textract para operaciones asincrónicas. ](https://docs.aws.amazon.com/en_us/textract/latest/dg/api-async-roles.html) Para completar este procedimiento, necesita un archivo de documento de varias páginas en formato PDF. Puede omitir los pasos 3 a 6 de las instrucciones de configuración, ya que el código de ejemplo crea y configura el tema de Amazon SNS y la cola de Amazon SQS. Si está completando el ejemplo de la CLI, no necesita configurar una cola de SQS. 

1. Cargue un archivo de documentos de varias páginas en formato PDF o TIFF a su bucket de Amazon S3 (también puede procesar documentos de una sola página en formato JPEG, PNG, TIFF o PDF). Para obtener instrucciones, consulte [ Carga de objetos a Amazon S3 ](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/UploadingObjectsintoAmazonS3.html) en la guía del usuario de * Amazon Simple Storage Service. * 

1. Utilice el siguiente código de AWS SDK para Python (Boto3) o de la CLI de AWS para analizar el texto de un documento de préstamo de varias páginas. En la función principal: 
   + Sustituya el valor de `roleArn` por el ARN del rol de IAM que guardó [ al dar acceso a Amazon Textract a su tema de Amazon SNS. ](https://docs.aws.amazon.com/en_us/textract/latest/dg/api-async-roles.html#api-async-roles-all-topics)
   + Sustituya los valores de `bucket` y `document` por el nombre del bucket y del archivo del documento que especificó anteriormente en el paso 2 siguiente.
   + Sustituya el valor del parámetro de `type` entrada de la `ProcessDocument` función por el tipo de procesamiento que desee utilizar. Por ejemplo, `ProcessType.DETECTION` utilícelo para detectar texto o `ProcessType.ANALYSIS` para analizarlo.
   + En el ejemplo de Python, sustituya el valor `region_name` de por la región en la que opera su cliente.

    Para ver el próximo código de ejemplo de la CLI de AWS, haga lo siguiente: 
   + Al llamar a la [ StartLendingAnalysis ](https://docs.aws.amazon.com/en_us/textract/latest/dg/API_StartLendingAnalysis.html) operación, sustituya el valor de `bucket-name` por el nombre de su bucket de S3 y `FileName` sustitúyalo por el nombre del archivo que especificó en el paso 2. Especifica la región de tu bucket `region-name` sustituyéndola por el nombre de tu región. Tenga en cuenta que el ejemplo de la CLI no utiliza SQS.
   + Al llamar a la [ GetLendingAnalysis ](https://docs.aws.amazon.com/en_us/textract/latest/dg/API_GetLendingAnalysis.html) operación o a la [ GetLendingAnalysisSummary ](https://docs.aws.amazon.com/en_us/textract/latest/dg/API_GetLendingAnalysisSummary.html) operación, `jobId` sustitúyala por la `jobId` devuelta por [ StartLendingAnalysis](https://docs.aws.amazon.com/en_us/textract/latest/dg/API_StartLendingAnalysis.html). Especifica la región de tu bucket `region-name` sustituyéndola por el nombre de tu región.

1. Ejecuta el código del SDK o la AWS CLI que hayas elegido. 

   La operación podría llevar algún tiempo. Una vez finalizado, se muestra una lista de bloques para el texto detectado o analizado en los siguientes ejemplos:

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

   Para iniciar el análisis del documento de préstamo, utilice el siguiente comando de la CLI. Si desea ver documentos divididos, utilice el `output-config` argumento; de lo contrario, puede eliminarlo: 

   ```
   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 obtener los resultados del análisis del documento de préstamo, utilice el siguiente comando de la CLI. El `max-results` argumento es opcional y, si no desea limitar la cantidad de resultados devueltos, puede eliminarlo:

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

   Para recuperar un resumen de los 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()
   ```

------