app.py

# 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>' + '&emsp;' * 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>' +'&emsp;'* 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>'+'&emsp;'*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>'+'&emsp;'*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>'+ '&emsp;' * 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>'+ '&emsp;' * 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>' + '&emsp;' * 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>' + '&emsp;' * 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>' + '&emsp;' * 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>' + '&emsp;' * 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()