Subindo arquivos21

app.py

@@ -52,6 +52,24 @@ def verificar_tipo(var_name, valor, tipos_variaveis, linha):
             return f"# Atenção: Possível atribuição de valor real à variável inteira '{var_name}' na linha: {linha}"
     return None
 
+def identificar_variaveis_entrada(portugol_code):
+    lines = portugol_code.splitlines()
+    variaveis_entrada = []
+    tipos_variaveis = {}
+    
+    for line in lines:
+        line = line.strip()
+        if ":" in line and not line.upper().startswith("CASO"):
+            var_name, var_type = line.split(":", 1)
+            var_name = var_name.strip().lower()  # Convertendo para minúsculas
+            var_type = var_type.strip().upper()
+            tipos_variaveis[var_name] = var_type
+        elif line.upper().startswith("LEIA"):
+            var_name = line.split("(")[1].split(")")[0].strip().lower()  # Convertendo para minúsculas
+            variaveis_entrada.append((var_name, tipos_variaveis.get(var_name, "STRING")))
+    
+    return variaveis_entrada
+
 def traduzir_para_python(portugol_code):
     portugol_code = preprocessar_codigos(portugol_code)
     lines = portugol_code.splitlines()
@@ -89,13 +107,13 @@ def traduzir_para_python(portugol_code):
             if var_name in tipos_variaveis:
                 tipo = tipos_variaveis[var_name]
                 if tipo == "INTEIRO":
-                    codigo_python.append(f"{var_name} = int(input('Digite um valor para {var_name}: '))")
+                    codigo_python.append(f"{var_name} = int(input_values['{var_name.lower()}'])")
                 elif tipo == "REAL":
-                    codigo_python.append(f"{var_name} = float(input('Digite um valor para {var_name}: '))")
+                    codigo_python.append(f"{var_name} = float(input_values['{var_name.lower()}'])")
                 else:
-                    codigo_python.append(f"{var_name} = input('Digite um valor para {var_name}: ')")
+                    codigo_python.append(f"{var_name} = input_values['{var_name.lower()}']")
             else:
-                codigo_python.append(f"{var_name} = input('Digite um valor para {var_name}: ')")
+                codigo_python.append(f"{var_name} = input_values['{var_name.lower()}']")
 
         elif line.upper().startswith("SE"):
             condicao = line[2:].split("THEN")[0].strip()
@@ -186,50 +204,103 @@ def traduzir_para_python(portugol_code):
 
     return "\n".join(codigo_python), avisos
 
-def interpretador(portugol_code):
-    codigo_python = "# Código Python não gerado devido a um erro"
-    try:
-        codigo_python, avisos = traduzir_para_python(portugol_code)
-        codigo_python = re.sub(r"\bAND\b", "and", codigo_python)
-
-        output = io.StringIO()
-        with contextlib.redirect_stdout(output):
-            exec(codigo_python, globals())
-
-        # INICIALIZE resultado COMO UMA STRING VAZIA
-        resultado = ""
-
-        # DESCOMENTE A LINHA ABAIXO PARA MOSTRAR O CÓDIGO PYTHON GERADO
-        # resultado += f"Código Python Gerado:\n{codigo_python}\n\n"
-
-        if avisos:
-            resultado += "Avisos:\n" + "\n".join(avisos) + "\n\n"
-
-        resultado += f"Saída:\n{output.getvalue().strip()}"
-        return resultado
-    except Exception as e:
-        error_traceback = traceback.format_exc()
-        # VOCÊ PODE OPTAR POR NÃO MOSTRAR O CÓDIGO PYTHON GERADO EM CASO DE ERRO
-        # DESCOMENTANDO A LINHA ABAIXO E COMENTANDO A LINHA SEGUINTE
-        # return f"Erro durante a execução:\n{error_traceback}"
-        return f"Erro durante a execução:\n{error_traceback}\n\nCódigo Python Gerado:\n{codigo_python}"
-
-def interpretar(portugol_code):
-    return interpretador(portugol_code)
+def interpretador(portugol_code, **input_values):
+    codigo_python, avisos = traduzir_para_python(portugol_code)
+    
+    # Adicionando input_values ao escopo de execução
+    locals_dict = {'input_values': input_values}
+    
+    output = io.StringIO()
+    with contextlib.redirect_stdout(output):
+        exec(codigo_python, globals(), locals_dict)
+    
+    resultado = f"Saída:\n{output.getvalue().strip()}"
+    if avisos:
+        resultado = "Avisos:\n" + "\n".join(avisos) + "\n\n" + resultado
+    
+    return resultado
+
+def interpretar(portugol_code, **kwargs):
+    variaveis_entrada = identificar_variaveis_entrada(portugol_code)
+    input_values = {var[0]: kwargs.get(var[0], '') for var in variaveis_entrada}
+    return interpretador(portugol_code, **input_values)
+
+def execute_code(code, *args):
+    variaveis_entrada = identificar_variaveis_entrada(code)
+    input_values = {var[0]: arg for var, arg in zip(variaveis_entrada, args) if arg}
+    return interpretar(code, **input_values)
+
+def criar_interface():
+    with gr.Blocks() as iface:
+        gr.Markdown(description_html)
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                portugol_code = gr.Textbox(lines=20, label="Pseudocódigo")
+                
+                with gr.Column(visible=False) as input_column:
+                    input_boxes = [gr.Textbox(visible=False, label=f"Entrada {i+1}") for i in range(10)]
+                
+                run_button = gr.Button("Executar")
+                exemplo_button = gr.Button("Carregar Exemplo de Fatorial")
+            
+            with gr.Column(scale=1):
+                output = gr.Textbox(label="Saída", lines=20)
+        
+        def update_interface(portugol_code):
+            variaveis_entrada = identificar_variaveis_entrada(portugol_code)
+            return [gr.update(visible=True, label=f"Valor para {var_name} ({var_type})") for var_name, var_type in variaveis_entrada] + \
+                   [gr.update(visible=False) for _ in range(10 - len(variaveis_entrada))]
+        
+        exemplo_code = """VARIAVEIS
+n: INTEIRO
+fat: INTEIRO
+INICIO
+LEIA (n)
+fat = 1
+ENQUANTO n > 1
+    fat = fat * n
+    n = n - 1
+FIM-ENQUANTO
+ESCREVA fat
+FIM"""
+        
+        portugol_code.change(
+            update_interface,
+            inputs=[portugol_code],
+            outputs=input_boxes
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[input_column]
+        )
+        
+        exemplo_button.click(
+            lambda: exemplo_code,
+            outputs=[portugol_code]
+        ).then(
+            update_interface,
+            inputs=[portugol_code],
+            outputs=input_boxes
+        ).then(
+            lambda: gr.update(visible=True),
+            outputs=[input_column]
+        )
+        
+        run_button.click(
+            execute_code,
+            inputs=[portugol_code] + input_boxes,
+            outputs=output
+        )
+    
+    return iface
 
 description_html = """
-<p>Interpretador de pseudocodigo:</p>
+<p>Interpretador de pseudocódigo:</p>
 <p>Ramon Mayor Martins: <a href="https://rmayormartins.github.io/" target="_blank">Website</a> | <a href="https://huggingface.co/rmayormartins" target="_blank">Spaces</a></p>
 <p><a href="https://huggingface.co/spaces/rmayormartins/pseudocodelab/blob/main/Manual_PseudocodeLab.pdf" target="_blank">Clique aqui para visualizar o Manual do PseudocodeLab</a></p>
 """
 
-iface = gr.Interface(
-    fn=interpretar,
-    inputs=gr.Textbox(lines=20, label="Pseudocodigo"),
-    outputs="text",
-    title="PseudocodeLab",
-    description=description_html
-)
+iface = criar_interface()
 
 if __name__ == "__main__":
     iface.launch(debug=True)