Create App.py

App.py

@@ -0,0 +1,152 @@
+# app.py - Gradio app para rodar DECOMPAI em Hugging Face Spaces
+# Ajuste os nomes de funções locais conforme o seu repositório (ex.: decompai.decompile_text)
+
+import os
+import traceback
+from typing import Optional
+
+import gradio as gr
+
+# Tenta carregar cliente da Hugging Face (para fallback via Inference API)
+hf_token = os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_TOKEN") or None
+INFERENCE_MODEL = "tiiuae/falcon-40b-instruct"  # exemplo: substitua por um modelo apropriado
+
+try:
+    from huggingface_hub import InferenceClient
+    hf_client = InferenceClient(token=hf_token) if hf_token else None
+except Exception:
+    hf_client = None
+
+# Tenta importar função local do repositório (ajuste o caminho/nome conforme seu projeto)
+# Ex.: seu repositório pode expor `decompai.api.decompile_text` ou similar.
+LOCAL_DECOMPILE_FN = None
+try:
+    # tente alguns caminhos comuns — ajuste para o nome real
+    try:
+        # se o pacote for instalado como editable e expuser decompile_text
+        from decompai import decompile_text as _fn  # exemplo
+        LOCAL_DECOMPILE_FN = _fn
+    except Exception:
+        # outro palpite: src.decompai.api.decompile_text
+        try:
+            from src.decompai import decompile_text as _fn2
+            LOCAL_DECOMPILE_FN = _fn2
+        except Exception:
+            LOCAL_DECOMPILE_FN = None
+except Exception:
+    LOCAL_DECOMPILE_FN = None
+
+def run_local_decompile(text: str) -> str:
+    """Chama a função local (se existir). Deve retornar string com resultado."""
+    if not LOCAL_DECOMPILE_FN:
+        raise RuntimeError("Função local decompiladora não encontrada.")
+    return LOCAL_DECOMPILE_FN(text)
+
+def run_hf_inference(prompt: str, model_name: Optional[str] = None) -> str:
+    """Fallback: usa Hugging Face Inference API para gerar uma resposta."""
+    model = model_name or INFERENCE_MODEL
+    if not hf_client:
+        raise RuntimeError("HF client não disponível — verifique HF_TOKEN nas Secrets do Space.")
+    # Text generation via InferenceClient
+    # Nota: dependendo do modelo, a API pode expor métodos diferentes (text_generation, generate, etc.)
+    try:
+        # método genérico text_generation
+        out = hf_client.text_generation(model=model, inputs=prompt, max_new_tokens=512)
+        # InferenceClient pode retornar dict/list — normalize
+        if isinstance(out, list):
+            return out[0].get("generated_text", str(out[0]))
+        if isinstance(out, dict):
+            return out.get("generated_text") or str(out)
+        return str(out)
+    except Exception as e:
+        # tentativa alternativa: chamar o endpoint genérico
+        try:
+            resp = hf_client(model=model, inputs=prompt)
+            return str(resp)
+        except Exception as e2:
+            raise RuntimeError(f"Erro na Inference API: {e}\n{e2}")
+
+def prepare_prompt_from_input(file_contents: Optional[str], text_input: Optional[str]) -> str:
+    """
+    Compose um prompt razoável para o modelo/função local.
+    Se o usuário subiu um binário/hex, a interface já deve pré-processar; aqui assumimos texto.
+    """
+    prompt_parts = []
+    if file_contents:
+        prompt_parts.append("Input (arquivo/hex/binário):\n" + file_contents)
+    if text_input:
+        prompt_parts.append("Input (texto):\n" + text_input)
+    prompt = "\n\n".join(prompt_parts)
+    # instrução para decompilar
+    prompt = "Por favor, tente decompilar / traduzir o seguinte conteúdo para um código legível. Explique suposições e indique se algo não pôde ser recuperado.\n\n" + prompt
+    return prompt
+
+def decompile_interface(file_obj, text_input, model_name):
+    """
+    Handler chamado pelo Gradio.
+    file_obj can be None or uploaded file (gr.File)
+    text_input is string
+    """
+    try:
+        file_contents = None
+        if file_obj is not None:
+            # file_obj pode ser um caminho/local file object (gr.File produz um dict em Spaces)
+            # Normalizamos: se for path, leia como binário e tentamos decodificar (utf-8/latin1/hex)
+            try:
+                # file_obj in Spaces is a dictionary with "name" and "data" occasionally; handle common cases:
+                path = getattr(file_obj, "name", None) or (file_obj if isinstance(file_obj, str) else None)
+                if path and os.path.exists(path):
+                    with open(path, "rb") as f:
+                        b = f.read()
+                        # tenta decodificar, se falhar, representa em hex
+                        try:
+                            file_contents = b.decode("utf-8")
+                        except Exception:
+                            try:
+                                file_contents = b.decode("latin-1")
+                            except Exception:
+                                file_contents = b.hex()
+                else:
+                    # talvez file_obj já seja string contents
+                    if isinstance(file_obj, (bytes, bytearray)):
+                        try:
+                            file_contents = file_obj.decode("utf-8")
+                        except Exception:
+                            file_contents = file_obj.hex()
+                    elif isinstance(file_obj, str):
+                        file_contents = file_obj
+                    else:
+                        file_contents = str(file_obj)
+            except Exception:
+                file_contents = f"<ERRO lendo arquivo: {traceback.format_exc()}>"
+
+        prompt = prepare_prompt_from_input(file_contents, text_input)
+
+        # Prioridade: função local (rápida e preferível)
+        if LOCAL_DECOMPILE_FN:
+            result = run_local_decompile(prompt)
+            return f"--- Resultado (função local) ---\n{result}"
+        # Fallback: HF inference
+        if hf_client:
+            result = run_hf_inference(prompt, model_name=model_name or INFERENCE_MODEL)
+            return f"--- Resultado (Hugging Face Inference API) ---\n{result}"
+        return "Nenhuma função local disponível e HF client não está configurado. Defina HF_TOKEN nas Secrets do Space."
+    except Exception as e:
+        tb = traceback.format_exc()
+        return f"Erro durante a decompilação:\n{e}\n\nTraceback:\n{tb}"
+
+# Construção da interface Gradio
+with gr.Blocks(title="DECOMPAI - Decompiler") as demo:
+    gr.Markdown("# DECOMPAI (Exemplo de Space)\nEnvie um arquivo ou cole texto e escolha o modelo (opcional).")
+    with gr.Row():
+        with gr.Column(scale=2):
+            file_in = gr.File(label="Arquivo (binário/hex) — opcional", file_count="single", type="file")
+            text_in = gr.Textbox(label="Ou cole conteúdo / hex / texto aqui", lines=8)
+            model_in = gr.Textbox(label="Modelo HF (opcional, ex: 'tiiuae/falcon-40b-instruct')", placeholder=INFERENCE_MODEL)
+            run_btn = gr.Button("Decompilar")
+        with gr.Column(scale=3):
+            output = gr.Textbox(label="Resultado", lines=24)
+    run_btn.click(fn=decompile_interface, inputs=[file_in, text_in, model_in], outputs=[output])
+
+if __name__ == "__main__":
+    demo.launch()