Spaces:
Sleeping
Sleeping
| # cargamos el modelo de huggingsound | |
| import re | |
| import unidecode | |
| #from huggingsound import SpeechRecognitionModel | |
| #from models.model import * | |
| def sim_jac(s1, s2): | |
| bigrams_s1 = [] | |
| bigrams_s2 = [] | |
| for i in range(len(s1) - 1): | |
| bigrams_s1.append(s1[i:i+2]) | |
| for i in range(len(s2) - 1): | |
| bigrams_s2.append(s2[i:i+2]) | |
| c_common = 0 | |
| for i in bigrams_s1: | |
| if bigrams_s2.count(i) > 0: | |
| c_common += 1 | |
| return c_common / ((len(s1) - 1) + (len(s2) - 1) - c_common) | |
| def encontrar_palabras(transcript,cjto_palabras): | |
| ''' | |
| Toma un string (en minúsculas) y un conjunto de palabras. Busca el primer match | |
| de cjto_palabras en transcript y particiona el string en: | |
| 1. El slice de la cadena antes del primer match (antes_palabra) | |
| 2. La cadena del primer match (coincidencia de cjto_palabras) | |
| 3. El slice de la cadena después del match (despues_palabra) | |
| ''' | |
| inicio,final=list(re.finditer(r'|'.join(cjto_palabras),transcript))[0].span() | |
| antes_palabra=transcript[:inicio].strip() | |
| despues_palabra=transcript[final:].strip() | |
| palabra=transcript[inicio:final] | |
| return antes_palabra,palabra,despues_palabra | |
| def agregar_adentro(codigo, transcipcion): | |
| codigo2 = main(transcipcion) | |
| return codigo[:-1] + codigo2 | |
| import numpy as np | |
| def main(instruccion): | |
| global bloque | |
| plantillas = [ | |
| crear_funcion, | |
| crear_condicional, | |
| crear_condicional, | |
| asignar_variable, | |
| crear_variable, | |
| crear_llamada, | |
| crear_for, | |
| fin_de_bloque, | |
| crear_comentario, | |
| crear_regresa | |
| ] | |
| comandos = [set(['definir', 'funcion', 'parametros']), | |
| set(['mientras']), | |
| set(['si']), # si se cumple / mientras se cumpla | |
| set(['asignar', 'con']), | |
| set(['definir', 'variable']), | |
| set(['ejecuta', 'argumentos']), | |
| set(['para', 'rango']), | |
| set(['terminar','bloque']), | |
| set(['comentario']), | |
| set(['regresa']) | |
| ] | |
| J = [] | |
| for comando in comandos: | |
| J.append(len(set(instruccion.strip().split(' ')).intersection(comando)) / len(set(instruccion.strip().split(' ')).union(comando))) | |
| # print(J,np.argmax(J)) | |
| pos_func=np.argmax(J) | |
| # print(pos_func) | |
| return plantillas[pos_func](instruccion) | |
| #------------------------------------------------ | |
| #from models.plantillas_codigo import * | |
| import re | |
| def crear_funcion(instruccion): | |
| """ | |
| Crea el template de la estructura de una función | |
| Parametros | |
| ---------- | |
| instrucion: str | |
| La intruccion de voz en texto. | |
| Regresa | |
| --------- | |
| output: str | |
| Codigo generado | |
| recomendacion: str | |
| Una sugerencia o fallo | |
| """ | |
| global indentacion | |
| global recomendacion | |
| global bloque | |
| bloque='funcion' | |
| # guarda los avisos o recomendaciones que el programa te hace | |
| recomendacion = '' | |
| # guarda la línea de código | |
| output = '' | |
| # pivote que ayuda a definir el nombre de una función | |
| before_keyword, keyword, after_keyword = instruccion.partition('nombre') | |
| # verifica que haya o esté escrita la frase "nombre" | |
| if len(after_keyword) == 0: | |
| recomendacion = f'¡No me dijiste el nombre de la función!' | |
| # de otro modo, si tiene nombre la función | |
| else: | |
| # obtenemos el nombre de la función por el usuario | |
| name_func = after_keyword.split(' ')[1] | |
| # verificamos si no desea poner parametros | |
| if instruccion.strip().split(' ')[-1] == name_func: | |
| parametros = '' | |
| # de otro modo, si desea una función con parámetros | |
| else: | |
| before_keyword, keyword, after_keyword = instruccion.partition('parametros') | |
| # verifica que si exista el nombre de los parámetros | |
| if len(after_keyword) == 0: | |
| parametros = '' | |
| recomendacion = f'¡No me dijiste el nombre de los parámetros!' | |
| # escribe como parámetros todo lo que está después de "parámetros" | |
| else: | |
| candidatos = [] | |
| cadena_separada = after_keyword.strip().split(' ') | |
| for palabra in cadena_separada: | |
| try: | |
| candidatos.append(diccionario_fonetico[palabra]) | |
| except: | |
| continue | |
| if len(candidatos) == 0: | |
| parametros = after_keyword.split(' ')[1:] | |
| parametros = ', '.join(parametros) | |
| else: | |
| parametros = ', '.join(candidatos) | |
| # indenta aunque marque que detecte que no le dije parámetros | |
| if not recomendacion or recomendacion == '¡No me dijiste el nombre de los parámetros!': | |
| indentacion += 1 | |
| # concatenación del nombre y parámetros de la función | |
| output = f'<span style="color: #008000; font-weight: bold">def</span> <span style="color: #0066bb; font-weight: bold">{name_func}</span>({parametros}):<br>' + ' ' * indentacion + '|' | |
| return output | |
| import re | |
| def encontrar_palabras(transcript,cjto_palabras): | |
| """ | |
| Toma un string (en minúsculos) y un conjunto de palabras. Busca el primer match | |
| de cjto_palabras en transcript y particiona el string | |
| Parametros | |
| ---------- | |
| transcript: str | |
| La intruccion de voz en texto ya en minúsculas. | |
| cjto_palabras: list(str) | |
| Lista de strings donde se comienza a dividir el transcript original | |
| Regresa | |
| --------- | |
| output: list(str) | |
| [antes_palabra,palabra,despues_palabra] | |
| antes_palabra: string que está antes de la palabra de interés (de cjto_palabras) | |
| palabra: string que da la palabra clave donde dividimos | |
| despues_palabra: string que está después de la palabra | |
| Ejemplo | |
| -------- | |
| encontrar_palabras('variable india producto variable alfa',['producto','suma','menos','entre']) | |
| >> ['variable india','producto',' variable alfa] | |
| """ | |
| inicio,final=list(re.finditer(r'|'.join(cjto_palabras),transcript))[0].span() | |
| antes_palabra=transcript[:inicio].strip() | |
| despues_palabra=transcript[final:].strip() | |
| palabra=transcript[inicio:final] | |
| return antes_palabra,palabra,despues_palabra | |
| def crear_condicional(transcript): | |
| ''' | |
| Toma el transcript de un enunciado condicional y regresa su traducción a código en Python | |
| Parametros | |
| ---------- | |
| transcript: str | |
| La intruccion de voz en texto ya en minúsculas. | |
| Regresa | |
| --------- | |
| output: str | |
| Cadena con el código en python, tiene una línea al final y un pipe | |
| que representa el prompt donde se seguirá escribiendo | |
| Ejemplo | |
| -------- | |
| crear_condicional('mientras variable india sea menor igual a numero seis') | |
| >> while (i<=6): | |
| >> | | |
| ''' | |
| global indentacion | |
| global bloque | |
| keyword_mapeo={'mientras':'while','si':'if','contrario':'else'} | |
| antes_keyword,keyword,desp_keyword=encontrar_palabras(transcript,keyword_mapeo.keys()) | |
| cadena=keyword_mapeo[keyword] | |
| bloque = keyword | |
| if cadena=='else': | |
| indentacion=indentacion+1 | |
| return 'else:'+'\n' +'\t'* indentacion+'|' | |
| # Primera división | |
| condicional_mapeo={'menor estricto':'<','menor o igual':'<=','igual':'==','diferente':'!=' | |
| ,'mayor estricto':'>','mayor o igual':'>='} | |
| cjto_condicional=condicional_mapeo.keys() | |
| antes_condicional,palabra_condicional,despues_condicional=encontrar_palabras(transcript,cjto_condicional) | |
| # Buscar antes en la lista de variables | |
| a_var,var,d_var=encontrar_palabras(antes_condicional,['variable']) | |
| nombre_var=d_var.split(' ')[0] | |
| if diccionario_fonetico.get(nombre_var,False): | |
| nombre_var=diccionario_fonetico[nombre_var] | |
| cadena+=' '+nombre_var+' ' +condicional_mapeo[palabra_condicional] | |
| # Buscar en despues_condicional el número | |
| valor=despues_condicional.split(' ')[-1] | |
| if dict_numeros.get(valor,False): | |
| valor=str(dict_numeros[valor]) | |
| indentacion+=1 | |
| #t = f'<span style="text-indent:{20 * indentacion}px";> <span>' | |
| return f'<span style="color: #008000; font-weight: bold">{keyword_mapeo[keyword]} </span> {nombre_var} {condicional_mapeo[palabra_condicional]} {valor}:'+'<br>' +' '* indentacion+'|' | |
| def crear_cadena(transcript): | |
| """ | |
| Toma el transcript de un enunciado que contiene una cadena y regresa el código en Python. | |
| Para usarse cuando ya se sabe que transcript sólo es los límites de la cadena | |
| Parametros | |
| ---------- | |
| transcript: str | |
| La intruccion de voz en texto ya en minúsculas. | |
| Regresa | |
| --------- | |
| output: list(str) | |
| antes_palabra:parte del transcript que va antes de las comillas | |
| palabra: Cadena con el código en python de las comillas y lo que está adentro | |
| despues_palabra:parte del transcript que va antes de las comillas | |
| Ejemplo | |
| -------- | |
| crear_cadena('ejecuta print con argumentos variable India producto cadena guion cadena')[1] | |
| >> ['ejecuta print con argumentos variable India producto','"guion"',''] | |
| """ | |
| try: | |
| inicio,final=list(re.finditer(r"cadena (.+) cadena",transcript))[0].span() | |
| except: | |
| return '' | |
| antes_palabra=transcript[:inicio].strip() | |
| despues_palabra=transcript[final:].strip() | |
| palabra=list(re.finditer(r"cadena (.+) cadena",transcript))[0].group(1) | |
| return antes_palabra,f'"{palabra}"',despues_palabra | |
| def crear_var_existente(transcript): | |
| """ | |
| Toma el transcript de un enunciado que contiene la mención de una variable | |
| y devuelve dicha variable | |
| Parametros | |
| ---------- | |
| transcript: str | |
| La intruccion de voz en texto ya en minúsculas. | |
| Regresa | |
| --------- | |
| output: str | |
| palabra: Cadena con el código en python del nombre de la variable | |
| Ejemplo | |
| -------- | |
| crear_var_existente('ejecuta print con argumentos variable india producto cadena guión cadena') | |
| >> i | |
| """ | |
| try: | |
| antes_var,var,desp_var=encontrar_palabras(transcript,['variable']) | |
| except: | |
| return '' | |
| nombre_var=desp_var.split(' ')[0] | |
| if diccionario_fonetico.get(nombre_var,False): | |
| nombre_var=diccionario_fonetico[nombre_var] | |
| return nombre_var | |
| # TODO: Hay que ver: | |
| # Si es otra operación hay que llamar la función recursivamente en cada pedazo | |
| # 1. si es cadena | |
| # 2. si es otra operación. Para esto, hay que regresar error o algo así cuando no se encuentre | |
| def crear_operacion(transcript): | |
| ''' | |
| Toma el transcript de una operación binaria y la traduce a código de Python. | |
| Para traducir las variables que se usan en la operación binaria busca | |
| si son cadenas o sólo menciones de variables usando las funciones | |
| crear_cadena y crear_var_existente | |
| Parametros | |
| ---------- | |
| transcript: str | |
| La intruccion de voz en texto ya en minúsculas. | |
| Regresa | |
| --------- | |
| output: str | |
| Cadena con el código en python | |
| Ejemplo | |
| -------- | |
| crear_operacion('variable India producto cadena guión cadena') | |
| >> i*'-' | |
| ''' | |
| global dict_operaciones | |
| try: | |
| antes_op,op,desp_op=encontrar_palabras(transcript,dict_operaciones.keys()) | |
| except: | |
| return '' | |
| # Buscamos la información en la cadena detrás del operador | |
| cadena_izq=crear_var_existente(antes_op) | |
| try: | |
| cadena_izq+=f'{crear_cadena(antes_op)[1]}' | |
| except: | |
| cadena_izq+='' | |
| if len(cadena_izq)==0: | |
| nombre_var=antes_op.split(' ')[-1] | |
| if dict_numeros.get(nombre_var,False): | |
| nombre_var=dict_numeros[nombre_var] | |
| cadena_izq+=str(nombre_var) | |
| # Buscamos la información en la cadena después del operador | |
| cadena_der=crear_var_existente(desp_op) | |
| try: | |
| cadena_der+=f'{crear_cadena(desp_op)[1]}' | |
| except: | |
| cadena_der+='' | |
| if len(cadena_der)==0: | |
| nombre_var=desp_op.split(' ')[0] | |
| if dict_numeros.get(nombre_var,False): | |
| nombre_var=dict_numeros[nombre_var] | |
| if diccionario_fonetico.get(nombre_var,False): | |
| nombre_var=diccionario_fonetico[nombre_var] | |
| cadena_der+=str(nombre_var) | |
| return f'{cadena_izq} {dict_operaciones[op]} {cadena_der}' | |
| def crear_llamada(transcript): | |
| """ | |
| Toma el transcript de la llamada de una función y la convierte en código de Python | |
| Hace uso de las funciones que detectan operaciones, variables y comillas | |
| ,para cada argumento de la función | |
| Parametros | |
| ---------- | |
| transcript: str | |
| La intruccion de voz en texto ya en minúsculas. | |
| Regresa | |
| --------- | |
| output: str | |
| Cadena con el código en python | |
| Ejemplo | |
| -------- | |
| crear_llamada(ejecuta print con argumentos variable India producto cadena guión cadena | |
| coma cadena hola cadena') | |
| >> print(i*'-','hola') | |
| """ | |
| global bloque | |
| global indentacion | |
| bloque='llamada' | |
| try: | |
| antes_ej,ej,desp_ej=encontrar_palabras(transcript,['ejecuta']) | |
| except: | |
| return '' | |
| funcion_nombre=desp_ej.split(' ')[0] | |
| # Aquí tal vez valdría la pena tener un registro de las funciones previamente definidas para | |
| # poder buscar en un directorio con Jaccard y no aproximar | |
| antes_arg,keyword,desp_arg=encontrar_palabras(desp_ej,['argumentos','parametros']) | |
| argumentos=desp_arg.split('coma') | |
| lista_cadenas=[] | |
| for arg in argumentos: | |
| arg=arg.strip() | |
| cadena_arg='' | |
| # print('arg',arg) | |
| # Caso cuando es operacion | |
| cadena_op=crear_operacion(arg) | |
| cadena_var=crear_var_existente(arg) | |
| cadena_cadena=crear_cadena(arg) | |
| if len(cadena_op)!=0: | |
| lista_cadenas.append(cadena_op) | |
| elif len(cadena_var)!=0: | |
| lista_cadenas.append(cadena_var) | |
| elif len(cadena_cadena)!=0: | |
| lista_cadenas.append(cadena_cadena[1]) | |
| else: | |
| nombre_var=arg | |
| if dict_numeros.get(nombre_var,False): | |
| nombre_var=str(dict_numeros[nombre_var]) | |
| lista_cadenas.append(nombre_var) | |
| # Caso cuando es variable | |
| cadena_final=','.join(lista_cadenas) | |
| cadena=f'{funcion_nombre}({cadena_final})<br>'+' '*indentacion+'|' | |
| return cadena | |
| def crear_regresa(transcript): | |
| antes_reg,reg,desp_reg=encontrar_palabras(transcript,['regresa']) | |
| arg=desp_reg.strip() | |
| cadena_arg='' | |
| # Si es llamada | |
| cadena_llamada=crear_llamada(arg) | |
| # Caso cuando es operacion | |
| cadena_op=crear_operacion(arg) | |
| cadena_var=crear_var_existente(arg) | |
| cadena_cadena=crear_cadena(arg) | |
| cadena_final='' | |
| if len(cadena_llamada)!=0: | |
| cadena_final+=cadena_llamada[:-2] | |
| elif len(cadena_op)!=0: | |
| cadena_final+=cadena_op | |
| elif len(cadena_var)!=0: | |
| cadena_final+=cadena_var | |
| elif len(cadena_cadena)!=0: | |
| cadena_final+=cadena_cadena[1] | |
| else: | |
| nombre_var=arg | |
| if dict_numeros.get(nombre_var,False): | |
| nombre_var=str(dict_numeros[nombre_var]) | |
| cadena_final+=nombre_var | |
| global indentacion | |
| indentacion-=1 | |
| return f'<span style="color: #AA22FF; font-weight: bold">return</span> {cadena_final}<br>'+' '*indentacion+'|' | |
| def crear_variable(instruccion): | |
| """ | |
| Estructura: | |
| definir variable con nombre [nombre_variable] igual a /*objeto_basico* valor/ | |
| Parametros | |
| ---------- | |
| instrucion: str | |
| La intruccion de voz en texto. | |
| Regresa | |
| --------- | |
| output: str | |
| Codigo generado | |
| recomendacion: str | |
| Una sugerencia o fallo | |
| Testing | |
| ------- | |
| >>> definir variable con nombre india igual a numero uno | |
| >>> definir variable con nombre i igual a numero 1 (int) | |
| >>> definir variable con nombre i igual a flotante tres punto cinco (float) | |
| >>> definir variable con nombre i igual a cadena hola (string) | |
| >>> definir variable con nombre i igual a lista/dic (string) | |
| """ | |
| global indentacion | |
| global bloque | |
| bloque='variable' | |
| # pivote que ayuda a definir el nombre de la variable | |
| before_keyword, keyword, after_keyword = instruccion.partition('nombre') | |
| after_keyword_list = after_keyword.strip().split(' ') | |
| # [india igual a numero uno] | |
| name_variable = after_keyword_list[0] | |
| # Como sabemos que despues del nombre va seguido de "igual a" | |
| tipo_dato = after_keyword_list[3] | |
| #print(after_keyword_list[4:]) -> lista | |
| valor = tipos_datos[tipo_dato](after_keyword_list[4:]) | |
| # Verificamos si es una palabra fonetica | |
| if diccionario_fonetico.get(name_variable,False): | |
| name_variable=diccionario_fonetico[name_variable] | |
| codigo_generado = f'{name_variable} = {valor}<br>'+ ' ' * indentacion + '|' | |
| return codigo_generado | |
| def asignar_variable(instruccion): | |
| """ | |
| Asigna una variable (eg. indio = indio + 1) | |
| Parametros | |
| ---------- | |
| instrucion: str | |
| La intruccion de voz en texto. | |
| Regresa | |
| --------- | |
| output: str | |
| Codigo generado (indio = indio + 1) | |
| Testing | |
| -------- | |
| >>>'asignar variable india con india suma uno', | |
| >>>'asignar variable contador con contador menos uno', | |
| >>>'asignar variable contador con alfa', | |
| >>>'asignar variable india con india', | |
| """ | |
| global bloque | |
| bloque = "asignar" | |
| before_keyword, keyword, after_keyword = instruccion.partition('variable') | |
| after_keyword_list = after_keyword.strip().split(' ') | |
| name_variable = after_keyword_list[0] | |
| start = after_keyword_list.index('con') + 1 | |
| operacion = after_keyword_list[start:] | |
| if len(operacion) != 1: | |
| operacion_str = crear_operacion(keyword + ' ' + ' '.join(operacion)) | |
| else: | |
| operacion_str = operacion[0] | |
| # Verificamos si es una palabra fonetica para lado derecho de la | |
| # asignacion | |
| if diccionario_fonetico.get(operacion_str,False): | |
| operacion_str=diccionario_fonetico[operacion_str] | |
| # Verificamos si es una palabra fonetica | |
| if diccionario_fonetico.get(name_variable,False): | |
| name_variable=diccionario_fonetico[name_variable] | |
| codigo_generado = f'{name_variable} = {operacion_str}<br>'+ ' ' * indentacion + '|' | |
| return codigo_generado | |
| def crear_for(instruccion): | |
| """ | |
| Crea el template de la estructura de un ciclo for. | |
| Parámetros | |
| ---------- | |
| instrucción: str | |
| La intrucción de voz en texto. | |
| Regresa | |
| --------- | |
| output: str | |
| Estructura del ciclo for | |
| recomendacion: str | |
| Una sugerencia o error | |
| """ | |
| global bloque | |
| global indentacion | |
| global recomendacion | |
| bloque='for' | |
| vocabulario_basico = ['iteracion', 'rango'] | |
| # verificamos si la frase cumple los requisitos | |
| instruccion_tokens = instruccion.strip().split(' ') | |
| for i in vocabulario_basico: | |
| try: | |
| instruccion_tokens.index(i) | |
| except: | |
| recomendacion = 'Parece que quieres una iteración pero no reconozco tus comandos, inténtalo de nuevo' | |
| return f'', recomendacion | |
| # guarda los avisos o recomendaciones que el programa te hace | |
| recomendacion = '' | |
| # guarda la línea de código | |
| output = '' | |
| # pivote que ayuda a definir el rango e iterador | |
| before_keyword, keyword, after_keyword = instruccion.partition('iteracion') | |
| if after_keyword.strip().split(' ')[1] in diccionario_fonetico: | |
| iterador = diccionario_fonetico[after_keyword.strip().split(' ')[1]] | |
| else: | |
| iterador = after_keyword.strip().split(' ')[1] | |
| before_keyword, keyword, after_keyword = instruccion.partition('rango') | |
| limites = [] | |
| for i, item in enumerate(after_keyword.strip().split(' ')): | |
| try: | |
| limites.append(dict_numeros[item]) | |
| except: | |
| continue | |
| if len(limites) == 0: | |
| for i, item in enumerate(after_keyword.strip().split(' ')): | |
| try: | |
| limites.append(diccionario_fonetico[item]) | |
| except: | |
| continue | |
| indentacion += 1 | |
| if len(limites) == 0: | |
| return f'' | |
| elif len(limites) == 1: | |
| return f'<span style="color: #008000; font-weight: bold">for</span> {iterador} in <span style="color: #0066bb; font-weight: bold">range</span>({limites[-1]}):<br>' + ' ' * indentacion + '|' | |
| elif len(limites) == 2: | |
| return f'<span style="color: #008000; font-weight: bold">for</span> {iterador} in <span style="color: #0066bb; font-weight: bold">range</span>({limites[0]}, {limites[1]}):<br>' + ' ' * indentacion + '|' | |
| elif len(limites) >= 2: | |
| recomendacion = 'Me dictaste más de un número en el rango pero tomé los dos primeros' | |
| return f'<span style="color: #008000; font-weight: bold">for</span> {iterador} in <span style="color: #0066bb; font-weight: bold">range</span>({limites[0]}, {limites[1]}):<br>' + ' ' * indentacion + '|' | |
| def crear_comentario(instruccion): | |
| """ | |
| Agrega el comentario de la intrucción en una línea de código | |
| Parámetros | |
| ---------- | |
| instrucción: str | |
| La intrucción de voz en texto. | |
| Regresa | |
| --------- | |
| output: str | |
| Comentario | |
| """ | |
| global bloque | |
| global indentacion | |
| # guarda los avisos o recomendaciones que el programa te hace | |
| recomendacion = '' | |
| bloque = 'comentario' | |
| # guarda la línea de código | |
| output = '' | |
| before_keyword, keyword, after_keyword = instruccion.partition('comentario') | |
| return '<span style="color: #888888">' + '# ' + after_keyword + '</span>' + '<br>' + ' ' * indentacion + '|' | |
| def fin_de_bloque(transcripcion): | |
| global indentacion | |
| global bloque | |
| bloque='fin' | |
| indentacion=indentacion-1 | |
| return '|' | |
| #------------------------------------ | |
| #from models.variables_globales import * | |
| def numero(text): | |
| """Convierte un texto de numero en numero entero (int) | |
| Parametros | |
| ---------- | |
| text: list | |
| Serie de valores | |
| Regresa | |
| --------- | |
| dict_numeros: int | |
| El número correspondiente | |
| """ | |
| global dict_numeros | |
| # Como sabemos que siempre sera el primer elemento el valor despues | |
| # de número (eg. cuatro or veintecinco) | |
| numero_str = text[0] | |
| return dict_numeros[numero_str] | |
| def flotante(text): | |
| """Convierte un texto de numero en numero floatante (float) | |
| Parametros | |
| ---------- | |
| text: list | |
| Serie de valores | |
| Regresa | |
| --------- | |
| dict_numeros: float | |
| El número correspondiente en floatante (eg 3.4) | |
| """ | |
| global dict_numeros | |
| text = " ".join(text) | |
| before_keyword, keyword, after_keyword = text.partition('punto') | |
| print(before_keyword) | |
| print(after_keyword) | |
| # Obtenemos los dos numeros antes y despues del punto | |
| before_num = before_keyword.strip().split(' ')[0] | |
| after_num = after_keyword.strip().split(' ')[0] | |
| # Hacemos el mapeo uno -> 1 | |
| num1_int = dict_numeros[before_num] | |
| num2_int = dict_numeros[after_num] | |
| return float(str(num1_int) + '.' + str(num2_int)) | |
| def cadena(text): | |
| """Convierte un texto de numero en string (str) | |
| Parametros | |
| ---------- | |
| text: list | |
| Serie de valores | |
| Regresa | |
| --------- | |
| string: str | |
| Una cadena con el contenido del texto | |
| """ | |
| numero_str = text[:] | |
| return ' '.join(text) | |
| def lista(text): | |
| """Convierte un texto de numero en string (str) | |
| Parametros | |
| ---------- | |
| text: list | |
| Serie de valores | |
| Regresa | |
| --------- | |
| lista: list | |
| Una lista vacia | |
| """ | |
| return [] | |
| diccionario_fonetico={'andrea':'a', | |
| 'bravo':'b', | |
| 'carlos':'c', | |
| 'delta':'d', | |
| 'eduardo':'e', | |
| 'fernando':'f', | |
| 'garcia':'g', | |
| 'hotel':'h', | |
| 'india':'i', | |
| 'julieta':'j', | |
| 'kilo':'k', | |
| 'lima':'l', | |
| 'miguel':'m', | |
| 'noviembre':'n', | |
| 'oscar':'o', | |
| 'papa':'p', | |
| 'queretaro':'q', | |
| 'romero':'', | |
| 'sierra':'s', | |
| 'tango':'t', | |
| 'uniforme':'u', | |
| 'victor':'v', | |
| 'wafle':'w', | |
| 'equis':'x', | |
| 'yarda':'y', | |
| 'llarda':'y', | |
| 'espacio':' '} | |
| # Separa en operadores comunes | |
| # si esto se lematiza puedes agarrar todas las frases de la forma suma, sumar, etc. | |
| dict_operaciones={ | |
| 'producto':'*','mas':'+','menos':'-','concatena':'+','entre':'/','modulo':'%' | |
| } | |
| dict_numeros = { | |
| 'cero':0, | |
| 'uno': 1, | |
| 'dos': 2, | |
| 'tres': 3, | |
| 'cuatro':4, | |
| 'cinco': 5, | |
| 'seis': 6, | |
| 'siete': 7, | |
| 'ocho': 8, | |
| 'nueve': 9, | |
| 'diez': 10, | |
| 'once': 11, | |
| 'doce': 12, | |
| 'trece': 13, | |
| 'catorce': 14, | |
| 'quince': 15, | |
| 'dieciseis': 16, | |
| 'diecisiete': 17, | |
| 'dieciocho': 18, | |
| 'diecinueve': 19, | |
| 'veinte': 20, | |
| 'treinta': 30, | |
| 'cuarenta': 40, | |
| 'cicuenta': 50, | |
| } | |
| # Diccionario de funciones | |
| tipos_datos ={ | |
| 'natural': numero, | |
| 'flotante': flotante, | |
| 'cadena': cadena, | |
| 'lista': lista, | |
| } | |
| #-------------------------- | |
| from transformers import pipeline | |
| import gradio as gr | |
| # creación del modelo | |
| # model = SpeechRecognitionModel("patrickvonplaten/wav2vec2-large-xlsr-53-spanish-with-lm") | |
| p = pipeline("automatic-speech-recognition", "patrickvonplaten/wav2vec2-large-xlsr-53-spanish-with-lm") | |
| tabla=''' | |
| <style type="text/css"> | |
| .tg {border-collapse:collapse;border-spacing:0;} | |
| .tg td{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px; | |
| overflow:hidden;padding:10px 5px;word-break:normal;} | |
| .tg th{border-color:black;border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px; | |
| font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;} | |
| .tg .tg-r31x{color:#ffffff;text-align:center;vertical-align:top} | |
| .tg .tg-urxo{border-color:#ffffff;color:#ffffff;text-align:center;vertical-align:top} | |
| .tg .tg-iejp{border-color:#ffffff;color:#ffffff;font-weight:bold;text-align:center;vertical-align:top} | |
| </style> | |
| <table class="tg"> | |
| <thead> | |
| <tr> | |
| <th class="tg-iejp">Fonético</th> | |
| <th class="tg-r31x">andrea</th> | |
| <th class="tg-r31x">bravo</th> | |
| <th class="tg-r31x">carlos</th> | |
| <th class="tg-r31x">delta</th> | |
| <th class="tg-r31x">eduardo</th> | |
| <th class="tg-r31x">fernando</th> | |
| <th class="tg-r31x">garcia</th> | |
| <th class="tg-r31x">hotel</th> | |
| <th class="tg-r31x">india</th> | |
| <th class="tg-r31x">julieta</th> | |
| <th class="tg-r31x">kilo</th> | |
| <th class="tg-r31x">lima</th> | |
| <th class="tg-r31x">miguel</th> | |
| <th class="tg-r31x">noviembre</th> | |
| </tr> | |
| </thead> | |
| <tbody> | |
| <tr> | |
| <td class="tg-iejp">Letra</td> | |
| <td class="tg-r31x">a</td> | |
| <td class="tg-r31x">b</td> | |
| <td class="tg-r31x">c</td> | |
| <td class="tg-r31x">d</td> | |
| <td class="tg-r31x">e</td> | |
| <td class="tg-r31x">f</td> | |
| <td class="tg-r31x">g</td> | |
| <td class="tg-r31x">h</td> | |
| <td class="tg-r31x">i</td> | |
| <td class="tg-r31x">j</td> | |
| <td class="tg-r31x">k</td> | |
| <td class="tg-r31x">l</td> | |
| <td class="tg-r31x">m</td> | |
| <td class="tg-r31x">n</td> | |
| </tr> | |
| <tr> | |
| <td class="tg-urxo"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| </tr> | |
| <tr> | |
| <td class="tg-iejp">Fonético</td> | |
| <td class="tg-r31x">oscar</td> | |
| <td class="tg-r31x">papa</td> | |
| <td class="tg-r31x">queretaro</td> | |
| <td class="tg-r31x">romero</td> | |
| <td class="tg-r31x">sierra</td> | |
| <td class="tg-r31x">tango</td> | |
| <td class="tg-r31x">uniforme</td> | |
| <td class="tg-r31x">victor</td> | |
| <td class="tg-r31x">waffle</td> | |
| <td class="tg-r31x">equis</td> | |
| <td class="tg-r31x">yarda</td> | |
| <td class="tg-r31x">zapato</td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| </tr> | |
| <tr> | |
| <td class="tg-iejp">Letra</td> | |
| <td class="tg-r31x">o</td> | |
| <td class="tg-r31x">p</td> | |
| <td class="tg-r31x">q</td> | |
| <td class="tg-r31x">r</td> | |
| <td class="tg-r31x">s</td> | |
| <td class="tg-r31x">t</td> | |
| <td class="tg-r31x">u</td> | |
| <td class="tg-r31x">v</td> | |
| <td class="tg-r31x">w</td> | |
| <td class="tg-r31x">x</td> | |
| <td class="tg-r31x">y</td> | |
| <td class="tg-r31x">z</td> | |
| <td class="tg-r31x"></td> | |
| <td class="tg-r31x"></td> | |
| </tr> | |
| </tbody> | |
| </table> | |
| ''' | |
| # Variables globales | |
| bloque = '' # Define el contexto (si es función, condicional, ciclo, etc.) | |
| codigo = None # Guarda el código hasta el momento | |
| indentacion = 0 # Nivel de indentación | |
| linea_codigo = 0 # Esto para dar seguimiento al eliminado de una linea | |
| recomendacion = "" | |
| # fin_de_bloque=False | |
| import gradio as gr | |
| def transcribe(audio, Español, Codigo_Python): | |
| global bloque | |
| global codigo | |
| global indentacion | |
| #transcriptions_es = model.transcribe([audio])[0] | |
| transcriptions_es = p(audio)['text'] | |
| # quitamos el acento de la transcripcion | |
| frase = unidecode.unidecode(transcriptions_es).lower() | |
| # print(frase) | |
| if not bloque: | |
| # Significa que es la primera vez | |
| codigo = main(frase) | |
| else: | |
| codigo = agregar_adentro(codigo, frase) | |
| return codigo, frase | |
| inputs = gr.inputs.Audio(label="Dar click para grabar tu voz", type="filepath", source="microphone") | |
| output1 = gr.outputs.Textbox(label="Asi se ve tu código") | |
| output2 = gr.outputs.Textbox(label="Lo que entendió la caracola fue:") | |
| title = "Caracola App" | |
| description = '<p style="color:white">Aplicación que ayuda a programar a traves de tu voz.\nSe usa el siguiente diccionario fonético para capturar las variables de una letra.</p>'+tabla+'<br> <h3 style="color:white"> Instrucciones </h3> <p style="color:white"> Selecciona uno de los ejemplos y da click en enviar para convertir comandos de voz en código! </p>' | |
| # ,'mientras variable alpha es menor igual a numero dos' | |
| # ,'Definir variable con nombre india igual a numero uno' | |
| input2 = gr.inputs.Textbox(lines=0, placeholder="Aqui aparece el texto en español de los ejemplos") | |
| input3 = gr.inputs.Textbox(lines=0, placeholder="Aqui aparece el codigo en python de los ejemplos") | |
| output_html = gr.outputs.HTML(label='Asi se ve tu código:') | |
| examples = [ | |
| ['./wav/comentario.wav','agregar comentario mi primer función', '# mi primer funcion'], | |
| ['./wav/funcion.wav','definir función con nombre mágica y parámetros noviembre', 'def magica(n):'], | |
| ['./wav/definira.wav','definir variable con nombre andrea igual a natural cero', 'a=0'], | |
| ['./wav/definirb.wav','definir variable con nombre bravo igual a natural uno', 'b = 1'], | |
| ['./wav/iteracion.wav','ejecuta iteracion para india en un rango noviembre', 'for i in range(n)'], | |
| ['./wav/asignar_c_b.wav','asignar variable carlos con bravo', 'c=b'], | |
| ['./wav/andreabravo.wav','asignar variable bravo con andrea mas bravo', 'b = a + b'], | |
| ['./wav/asignar_a_c.wav','asignar variable andrea con carlos', 'a=c'], | |
| ['./wav/terminar_bloque.wav','terminar bloque',''], | |
| ['./wav/comentario2.wav','agregar comentario fin de ciclo', '# fin de ciclo'], | |
| ['./wav/regresa.wav','regresa variable andrea', 'return a'], | |
| ['./wav/llamada.wav', 'ejecuta mágica con argumentos diez', 'magica(10)'] | |
| ] | |
| article = "<a style='color:#eb9f59;' href = 'https://github.com/gandres-dev/Hackaton-Common-Voice'> Repositorio de la app" | |
| demo = gr.Interface(fn=transcribe, inputs=[inputs, input2, input3], outputs=[output_html,output2], | |
| examples=examples, | |
| title=title, description=description, article=article, | |
| allow_flagging="never", theme="darkpeach", | |
| ) | |
| demo.launch() |