Spaces:
Running
Running
| import gradio as gr | |
| import os | |
| import json | |
| import requests | |
| from huggingface_hub import InferenceClient | |
| # Configuração da API HuggingFace | |
| HF_TOKEN = os.environ.get('HF_TOKEN', '') # Token pode ser configurado como variável de ambiente | |
| DEFAULT_CODE_MODEL = "bigcode/starcoder2-15b" # Modelo padrão para análise de código | |
| def get_hf_client(): | |
| """ | |
| Cria e retorna um cliente de inferência HuggingFace | |
| """ | |
| try: | |
| client = InferenceClient( | |
| model=DEFAULT_CODE_MODEL, | |
| token=HF_TOKEN | |
| ) | |
| return client | |
| except Exception as e: | |
| print(f"Erro ao criar cliente HuggingFace: {str(e)}") | |
| return None | |
| def analyze_code(code, language="python", model_id=DEFAULT_CODE_MODEL): | |
| """ | |
| Analisa código usando a API HuggingFace | |
| """ | |
| if not code: | |
| return { | |
| 'success': False, | |
| 'message': 'É necessário fornecer o código para análise', | |
| 'analysis': None, | |
| 'language': language | |
| } | |
| try: | |
| # Criar prompt para análise de código | |
| prompt = f""" | |
| Analise o seguinte código {language}: | |
| ```{language} | |
| {code} | |
| ``` | |
| Por favor, forneça: | |
| 1. Uma análise geral da qualidade do código | |
| 2. Identificação de possíveis bugs ou problemas | |
| 3. Sugestões de melhoria e boas práticas | |
| 4. Avaliação de segurança (se aplicável) | |
| """ | |
| # Usar cliente HuggingFace para análise | |
| client = get_hf_client() | |
| if not client: | |
| # Fallback para análise simulada se o cliente não estiver disponível | |
| return { | |
| 'success': True, | |
| 'message': 'Análise de código realizada localmente (API HuggingFace não disponível)', | |
| 'analysis': { | |
| 'quality': 'Não foi possível conectar à API HuggingFace. Esta é uma análise simulada.', | |
| 'issues': ['API HuggingFace não disponível - token não configurado ou serviço indisponível'], | |
| 'suggestions': ['Configure o token HuggingFace como variável de ambiente para análise completa'], | |
| 'security': 'Não avaliado' | |
| }, | |
| 'language': language | |
| } | |
| # Fazer a chamada à API | |
| response = client.text_generation( | |
| prompt, | |
| max_new_tokens=500, | |
| temperature=0.3, | |
| top_p=0.95, | |
| repetition_penalty=1.2 | |
| ) | |
| # Processar a resposta | |
| analysis_text = response | |
| # Tentar extrair seções da resposta | |
| quality = "Análise realizada com sucesso" | |
| issues = [] | |
| suggestions = [] | |
| security = "Verificado" | |
| # Análise básica do texto para extrair seções | |
| if "qualidade" in analysis_text.lower(): | |
| quality_section = analysis_text.lower().split("qualidade")[1].split("\n")[0] | |
| quality = quality_section[:100] + "..." if len(quality_section) > 100 else quality_section | |
| if "problemas" in analysis_text.lower() or "bugs" in analysis_text.lower(): | |
| issues_text = analysis_text.lower().split("problemas")[1].split("sugestões")[0] if "problemas" in analysis_text.lower() else analysis_text.lower().split("bugs")[1].split("sugestões")[0] | |
| issues = [issue.strip() for issue in issues_text.split("-") if issue.strip()] | |
| if "sugestões" in analysis_text.lower(): | |
| suggestions_text = analysis_text.lower().split("sugestões")[1].split("segurança")[0] if "segurança" in analysis_text.lower() else analysis_text.lower().split("sugestões")[1] | |
| suggestions = [suggestion.strip() for suggestion in suggestions_text.split("-") if suggestion.strip()] | |
| if "segurança" in analysis_text.lower(): | |
| security_section = analysis_text.lower().split("segurança")[1].split("\n")[0] | |
| security = security_section[:100] + "..." if len(security_section) > 100 else security_section | |
| analysis = { | |
| 'raw_response': analysis_text, | |
| 'quality': quality, | |
| 'issues': issues[:5], # Limitar a 5 issues | |
| 'suggestions': suggestions[:5], # Limitar a 5 sugestões | |
| 'security': security | |
| } | |
| return { | |
| 'success': True, | |
| 'message': 'Código analisado com sucesso', | |
| 'analysis': analysis, | |
| 'language': language | |
| } | |
| except Exception as e: | |
| return { | |
| 'success': False, | |
| 'message': f'Erro ao analisar código: {str(e)}', | |
| 'analysis': None, | |
| 'language': language | |
| } | |
| def get_supported_models(): | |
| """ | |
| Retorna lista de modelos suportados para análise de código | |
| """ | |
| # Lista de modelos recomendados para análise de código | |
| models = [ | |
| { | |
| "id": "bigcode/starcoder2-15b", | |
| "name": "StarCoder 2 (15B)", | |
| "description": "Modelo especializado em código com 15B de parâmetros", | |
| "languages": ["python", "javascript", "java", "c++", "php", "ruby", "go", "rust"] | |
| }, | |
| { | |
| "id": "bigcode/starcoder2-7b", | |
| "name": "StarCoder 2 (7B)", | |
| "description": "Versão mais leve do StarCoder com 7B de parâmetros", | |
| "languages": ["python", "javascript", "java", "c++", "php", "ruby", "go", "rust"] | |
| }, | |
| { | |
| "id": "microsoft/codebert-base", | |
| "name": "CodeBERT", | |
| "description": "Modelo pré-treinado para compreensão de código", | |
| "languages": ["python", "javascript", "java", "c#", "php", "go"] | |
| } | |
| ] | |
| return models | |
| def generate_app_structure(prompt): | |
| """ | |
| Gera estrutura de aplicação com base no prompt usando a API HuggingFace | |
| """ | |
| try: | |
| client = get_hf_client() | |
| if not client: | |
| # Fallback para geração simulada | |
| return { | |
| "type": "web_application", | |
| "components": [ | |
| { | |
| "type": "frontend", | |
| "framework": "React", | |
| "pages": [ | |
| {"name": "Home", "path": "/"}, | |
| {"name": "About", "path": "/about"}, | |
| {"name": "Contact", "path": "/contact"} | |
| ] | |
| }, | |
| { | |
| "type": "backend", | |
| "framework": "Flask", | |
| "endpoints": [ | |
| {"path": "/api/data", "method": "GET"}, | |
| {"path": "/api/submit", "method": "POST"} | |
| ] | |
| } | |
| ], | |
| "description": f"Aplicação gerada com base no prompt: {prompt}" | |
| } | |
| # Criar prompt para geração de estrutura | |
| generation_prompt = f""" | |
| Crie uma estrutura de aplicação web com base na seguinte descrição: | |
| "{prompt}" | |
| Responda apenas com um objeto JSON válido com a seguinte estrutura: | |
| {{ | |
| "type": "web_application", | |
| "components": [ | |
| {{ | |
| "type": "frontend", | |
| "framework": "string", | |
| "pages": [ | |
| {{"name": "string", "path": "string"}} | |
| ] | |
| }}, | |
| {{ | |
| "type": "backend", | |
| "framework": "string", | |
| "endpoints": [ | |
| {{"path": "string", "method": "string"}} | |
| ] | |
| }} | |
| ], | |
| "description": "string" | |
| }} | |
| """ | |
| # Fazer a chamada à API | |
| response = client.text_generation( | |
| generation_prompt, | |
| max_new_tokens=800, | |
| temperature=0.7, | |
| top_p=0.95 | |
| ) | |
| # Tentar extrair JSON da resposta | |
| try: | |
| # Encontrar o início e fim do JSON na resposta | |
| start_idx = response.find('{') | |
| end_idx = response.rfind('}') + 1 | |
| if start_idx >= 0 and end_idx > start_idx: | |
| json_str = response[start_idx:end_idx] | |
| app_structure = json.loads(json_str) | |
| return app_structure | |
| else: | |
| # Fallback para estrutura padrão | |
| return { | |
| "type": "web_application", | |
| "components": [ | |
| { | |
| "type": "frontend", | |
| "framework": "React", | |
| "pages": [ | |
| {"name": "Home", "path": "/"}, | |
| {"name": "Dashboard", "path": "/dashboard"} | |
| ] | |
| }, | |
| { | |
| "type": "backend", | |
| "framework": "Flask", | |
| "endpoints": [ | |
| {"path": "/api/data", "method": "GET"}, | |
| {"path": "/api/submit", "method": "POST"} | |
| ] | |
| } | |
| ], | |
| "description": f"Aplicação gerada com base no prompt: {prompt}" | |
| } | |
| except: | |
| # Fallback para estrutura padrão em caso de erro no parsing | |
| return { | |
| "type": "web_application", | |
| "components": [ | |
| { | |
| "type": "frontend", | |
| "framework": "React", | |
| "pages": [ | |
| {"name": "Home", "path": "/"}, | |
| {"name": "Features", "path": "/features"} | |
| ] | |
| }, | |
| { | |
| "type": "backend", | |
| "framework": "Flask", | |
| "endpoints": [ | |
| {"path": "/api/data", "method": "GET"} | |
| ] | |
| } | |
| ], | |
| "description": f"Aplicação gerada com base no prompt: {prompt}" | |
| } | |
| except Exception as e: | |
| # Estrutura padrão em caso de erro | |
| return { | |
| "type": "web_application", | |
| "components": [ | |
| { | |
| "type": "frontend", | |
| "framework": "React", | |
| "pages": [ | |
| {"name": "Home", "path": "/"} | |
| ] | |
| }, | |
| { | |
| "type": "backend", | |
| "framework": "Flask", | |
| "endpoints": [ | |
| {"path": "/api/data", "method": "GET"} | |
| ] | |
| } | |
| ], | |
| "description": f"Erro na geração: {str(e)}" | |
| } | |
| # Interface Gradio para análise de código | |
| def code_analysis_interface(code, language, model_id): | |
| result = analyze_code(code, language, model_id) | |
| if not result['success']: | |
| return f"Erro: {result['message']}" | |
| analysis = result['analysis'] | |
| output = f"## Análise de Código ({language})\n\n" | |
| output += f"### Qualidade Geral\n{analysis['quality']}\n\n" | |
| if analysis['issues']: | |
| output += "### Problemas Identificados\n" | |
| for issue in analysis['issues']: | |
| output += f"- {issue}\n" | |
| output += "\n" | |
| if analysis['suggestions']: | |
| output += "### Sugestões de Melhoria\n" | |
| for suggestion in analysis['suggestions']: | |
| output += f"- {suggestion}\n" | |
| output += "\n" | |
| output += f"### Segurança\n{analysis['security']}\n\n" | |
| return output | |
| # Interface Gradio para geração de aplicação | |
| def app_generation_interface(prompt): | |
| app_structure = generate_app_structure(prompt) | |
| output = f"## Aplicação Gerada\n\n" | |
| output += f"### Descrição\n{app_structure['description']}\n\n" | |
| output += "### Estrutura\n" | |
| output += f"Tipo: {app_structure['type']}\n\n" | |
| for component in app_structure['components']: | |
| output += f"#### {component['type'].capitalize()}\n" | |
| output += f"Framework: {component['framework']}\n\n" | |
| if component['type'] == 'frontend': | |
| output += "Páginas:\n" | |
| for page in component['pages']: | |
| output += f"- {page['name']}: {page['path']}\n" | |
| output += "\n" | |
| if component['type'] == 'backend': | |
| output += "Endpoints:\n" | |
| for endpoint in component['endpoints']: | |
| output += f"- {endpoint['path']} ({endpoint['method']})\n" | |
| output += "\n" | |
| return output | |
| # Interface principal | |
| with gr.Blocks(title="App Generator - IA Real") as demo: | |
| gr.Markdown("# App Generator - Crie aplicações com IA") | |
| gr.Markdown("Crie aplicações incríveis com IA, a partir de prompts, imagens ou ficheiros") | |
| with gr.Tabs(): | |
| with gr.TabItem("Gerador de Aplicações"): | |
| with gr.Row(): | |
| with gr.Column(): | |
| prompt_input = gr.Textbox( | |
| label="Descrição da Aplicação", | |
| placeholder="Ex: Uma aplicação de lista de tarefas com autenticação de utilizadores", | |
| lines=5 | |
| ) | |
| generate_btn = gr.Button("Gerar Aplicação") | |
| app_output = gr.Markdown(label="Resultado") | |
| generate_btn.click( | |
| fn=app_generation_interface, | |
| inputs=[prompt_input], | |
| outputs=[app_output] | |
| ) | |
| with gr.TabItem("Análise de Código"): | |
| with gr.Row(): | |
| with gr.Column(scale=2): | |
| language_select = gr.Dropdown( | |
| choices=["python", "javascript", "java", "c++", "php", "ruby", "go", "rust"], | |
| value="python", | |
| label="Linguagem" | |
| ) | |
| code_input = gr.Textbox( | |
| label="Código para Análise", | |
| placeholder="Cole seu código aqui para análise...", | |
| lines=10 | |
| ) | |
| model_select = gr.Dropdown( | |
| choices=[ | |
| "bigcode/starcoder2-15b", | |
| "bigcode/starcoder2-7b", | |
| "microsoft/codebert-base" | |
| ], | |
| value="bigcode/starcoder2-15b", | |
| label="Modelo de IA" | |
| ) | |
| analyze_btn = gr.Button("Analisar Código") | |
| analysis_output = gr.Markdown(label="Resultado da Análise") | |
| analyze_btn.click( | |
| fn=code_analysis_interface, | |
| inputs=[code_input, language_select, model_select], | |
| outputs=[analysis_output] | |
| ) | |
| with gr.Column(scale=1): | |
| gr.Markdown("### Sobre a Análise de Código") | |
| gr.Markdown(""" | |
| Esta funcionalidade utiliza a API HuggingFace para analisar código em tempo real. | |
| **Modelos disponíveis:** | |
| - StarCoder 2 (15B): Modelo especializado em código com 15B de parâmetros | |
| - StarCoder 2 (7B): Versão mais leve do StarCoder | |
| - CodeBERT: Modelo pré-treinado para compreensão de código | |
| **Linguagens suportadas:** | |
| Python, JavaScript, Java, C++, PHP, Ruby, Go, Rust | |
| Para resultados mais precisos, configure um token HuggingFace nas variáveis de ambiente. | |
| """) | |
| gr.Markdown("### Sobre o App Generator") | |
| gr.Markdown(""" | |
| App Generator é uma aplicação open source que utiliza IA para gerar estruturas de aplicações e analisar código. | |
| Desenvolvido com Gradio e HuggingFace, este projeto é totalmente gratuito e open source. | |
| © 2025 App Generator - Licenciado sob MIT License | |
| """) | |
| # Iniciar a aplicação | |
| demo.launch() | |