Creacion de la función Translate

Función Translate

Creacion de la función para traduccion de una entrada en ToDoList al idioma seleccionado identificando de forma automática el idioma origen. Se utlizaron las funciones de Amazon Comprehend y Amazon Translate

Se utilizó la herramienta logger.info junto con CloudWathc para analizar los herrores durante la creación de la función realizando todo en un único fichero.

01- Deteccion del lenguaje de entrada del ítem en ToDoLis. Se utilizó la función comprehend.detect_dominant_language.

source_language = comprehend.detect_dominant_language(
            Text=item['text']
        )

Esta función retorna un set de lenguajes detectados en la cadena de texto y un score de cada uno de ellos. Por ejemplo para la cadena "Learn Serverless test 2" la función retorna dos lenguajes posibles: de y en

{'Languages': [{'LanguageCode': 'de', 'Score': 0.15776684880256653}, {'LanguageCode': 'en', 'Score': 0.3843933343887329}], 'ResponseMetadata': {'RequestId': '13a752ad-b96b-41e9-8c63-f784786416a2', 'HTTPStatusCode': 200, 'HTTPHeaders': {'x-amzn-requestid': '13a752ad-b96b-41e9-8c63-f784786416a2', 'content-type': 'application/x-amz-json-1.1', 'content-length': '114', 'date': 'Thu, 20 Jan 2022 23:24:00 GMT'}, 'RetryAttempts': 0}}

02-Traducción Se obtiene el lenguaje de mayor score y se lo coloca en la variable thelangcode para servir de input a la función de translate.translate_text

order_languaje = sorted(
                source_language['Languages'],
                key=lambda k: k['Score'],
                reverse=True)
# Obtengo el primero de la lista ordenada
thelangcode = order_languaje[0]['LanguageCode']

result = translate.translate_text(
                    Text=item['text'],
                    SourceLanguageCode=thelangcode,
                    TargetLanguageCode=target_language
                )

Y se obtiene como resultado la traduccion de la cadena, para el ejemplo el lenguaje destino es fr

{'TranslatedText': 'Apprendre le test Serverless 2', 'SourceLanguageCode': 'en', 'TargetLanguageCode': 'fr', 'ResponseMetadata': {'RequestId': '223d2b36-fbf0-405a-b5f0-88dc9f39d0f5', 'HTTPStatusCode': 200, 'HTTPHeaders': {'x-amzn-requestid': '223d2b36-fbf0-405a-b5f0-88dc9f39d0f5', 'cache-control': 'no-cache', 'content-type': 'application/x-amz-json-1.1', 'content-length': '103', 'date': 'Thu, 20 Jan 2022 23:24:08 GMT'}, 'RetryAttempts': 0}}

Finalizadas las pruebas se movieron las porciones de código al fichero /src/todoList como funciones específicas

def get_comprehend(comprehend=None):
    if not comprehend:
        comprehend = boto3.client(service_name='comprehend')
        # print('Instanciado--------------')
    logger.info(comprehend)
    return comprehend


def get_translate(translate=None):
    if not translate:
        translate = boto3.client(service_name='translate')
        # print('Instanciado--------------')
    logger.info(translate)
    return translate

    
def get_item_languaje(text, comprehend=None):
    comprehend = get_comprehend(comprehend)
    logger.info(comprehend)
    try:
        logger.info("Detect text lang: " + str(text))
        response = comprehend.detect_dominant_language(
                Text=text
        )
    except ClientError as e:
        logger.exception("Couldn't detect languages.")
        print(e.response['Error']['Message'])
    else:
        languages = response['Languages']
        logger.info("Detected %s languages.", len(languages))
        
        # Ordeno la lista de lenguajes por el mejor score
        order_languaje = sorted(
                response['Languages'],
                key=lambda k: k['Score'],
                reverse=True)
        # Obtengo el primero de la lista ordenada
        thelangcode = order_languaje[0]['LanguageCode'] 
        return str(thelangcode)


def translate_text(text, s_lang, t_lang, translate=None):
    logging.info('get translateclient --------------------')
    translate = get_translate(translate)
    logger.info(translate)
    
    try:
        logger.info(translate)
        logger.info("texto: " + text)
        logger.info("Lenguaje entrada: " + str(s_lang))
        logger.info("Lenguaje salida: " + str(t_lang))

        response = translate.translate_text(
                Text=text,
                SourceLanguageCode=s_lang,
                TargetLanguageCode=t_lang
        )
    except ClientError as e:
        logger.exception("No fue posible realizar la traduccion")
        print(e.response['Error']['Message'])
    except ParamValidationError:
        logger.exception("Problemas de parametros")
    else:
        logger.info("traduccion.")
        logger.info(response)
        return str(response['TranslatedText'])


# Traduzco el texto ingresado
# pre requisitos: ID y Lenguaje
def translate_item(key, language, translate=None, dynamodb=None): 
    logging.info('inicio translate --------------------')
    table = get_table(dynamodb)
    logging.info('get table --------------------')
    logging.info(table)
    
    try:
        logging.info('get item --------------------')
        item = table.get_item(
            Key={
                'id': key
            }
        )
        thetext = item['Item']['text']
        logging.info(item)
        logging.info(thetext)
        logging.info('source languaje --------------------')
        source_language = get_item_languaje(
                        thetext
        )
        logging.info(source_language)
    
        translateresult = translate_text(
                thetext,
                source_language,
                language
        )
        logging.info("Translation output: " + str(translateresult))
        
        
        # Creo la esrtuctura de respuesta del tipo todolist
        # temtranslated = {
        #    'id': key,
        #    'text': translateresult,
        #    'checked':item['Item']['checked']
        # }
        item['Item']['text'] = translateresult
        
        response = {
            "statusCode": 200,
            # "body": json.dumps(itemtranslated, cls=decimalencoder.DecimalEncoder)
            "body": json.dumps(item['Item'])
        }
        # logger.info(response)
        logging.info(response)

    except ClientError as e:
        logger.exception("Couldn't translate.")
        print(e.response['Error']['Message'])
    else:
        return response