Upload 4 files

README.md

@@ -0,0 +1,52 @@
+---
+title: English Helper
+emoji: 🎓
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# English Helper - HF Spaces
+
+Sistema simplificado de aprendizado de inglês para Hugging Face Spaces.
+
+## 🚀 Funcionalidades
+
+- **Seleção de Usuário**: Escolha ou crie usuário (sem autenticação)
+- **Text-to-Speech**: Áudio dos textos com gTTS
+- **Flashcards**: Criação automática com IA
+- **Chat**: Conversação básica
+- **Admin Panel**: Gestão de usuários em `/admin`
+- **Status Page**: Monitoramento em `/status`
+
+## 🏗️ Arquitetura Simplificada
+
+- **Storage**: Arquivos JSON em `hf_data/`
+- **No Database**: Sistema baseado em arquivos
+- **No Authentication**: Seleção de usuário apenas
+- **Minimal Dependencies**: Flask + requests + gTTS
+
+## 📁 Estrutura
+
+```
+app.py              # Entry point HF
+flask_app_hf.py     # Flask simplificado
+requirements.txt    # Dependências mínimas
+templates/          # Interface HTML
+├── index.html     # Interface principal
+├── admin.html     # Painel admin
+└── status.html    # Status do sistema
+```
+
+## 🎯 Deploy
+
+1. Faça upload de todos os arquivos desta pasta para seu HF Space
+2. O app roda automaticamente na porta 7860
+3. Acesse a interface principal, admin (/admin) e status (/status)
+
+---
+
+**Versão simplificada para máxima compatibilidade com HF Spaces**

app.py

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+"""
+English Helper - HF Spaces Version (Simplified)
+Sistema de aprendizado de inglês sem autenticação para máxima compatibilidade
+"""
+
+import os
+import json
+from datetime import datetime
+
+def init_simple_storage():
+    """Inicializar armazenamento simples baseado em arquivos"""
+    try:
+        os.makedirs('hf_data', exist_ok=True)
+        os.makedirs('hf_data/flashcards', exist_ok=True)
+        os.makedirs('hf_data/conversations', exist_ok=True)
+        os.makedirs('hf_data/analytics', exist_ok=True)
+        print("✅ Sistema de armazenamento HF inicializado")
+        return True
+    except Exception as e:
+        print(f"❌ Erro na inicialização: {e}")
+        return False
+
+# Executar aplicação
+if __name__ == "__main__":
+    print("🎯 English Helper HF - Versão Simplificada")
+    
+    # Inicializar sistema
+    if not init_simple_storage():
+        print("❌ Falha na inicialização")
+        exit(1)
+    
+    try:
+        # Importar Flask app simplificado
+        import flask_app_hf
+        app = flask_app_hf.app
+        
+        print("🚀 Executando Flask na porta 7860 (HF Spaces)")
+        app.run(
+            host="0.0.0.0",
+            port=7860,
+            debug=False,
+            threaded=True,
+            use_reloader=False
+        )
+        
+    except Exception as e:
+        print(f"❌ Erro: {e}")
+        import traceback
+        traceback.print_exc()

flask_app_hf.py

@@ -0,0 +1,366 @@
+# --- STUDY PLANNER (PLANO DE ESTUDOS) ---
+
+STUDY_PLAN_PATH = 'hf_data/study_plan.json'
+
+@app.route('/study-plan', methods=['GET', 'POST'])
+def study_plan():
+    """Salvar ou carregar plano de estudos global (sem autenticação)"""
+    if request.method == 'POST':
+        try:
+            data = request.get_json()
+            with open(STUDY_PLAN_PATH, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+            return jsonify({'success': True, 'message': 'Study plan saved'})
+        except Exception as e:
+            print(f"Erro ao salvar study plan: {e}")
+            return jsonify({'success': False, 'message': 'Failed to save study plan'}), 500
+    else:
+        try:
+            if os.path.exists(STUDY_PLAN_PATH):
+                with open(STUDY_PLAN_PATH, 'r', encoding='utf-8') as f:
+                    plan = json.load(f)
+                return jsonify({'success': True, 'plan': plan})
+            else:
+                return jsonify({'success': True, 'plan': None})
+        except Exception as e:
+            print(f"Erro ao carregar study plan: {e}")
+            return jsonify({'success': False, 'message': 'Failed to load study plan'}), 500
+# flask_app_hf.py - English Helper HF Spaces (Sem Autenticação)
+import os
+import io
+import json
+import base64
+from datetime import datetime
+from flask import Flask, request, jsonify, send_file, render_template_string, redirect, url_for, Response
+from gtts import gTTS
+from groq import Groq
+import google.generativeai as genai
+from google.generativeai.types import GenerationConfig
+
+# --- CONFIGURAÇÃO INICIAL ---
+app = Flask(__name__)
+
+# Configuração simplificada para HF Spaces
+app.config['SECRET_KEY'] = 'hf-simple-key-no-auth'
+app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
+
+print(f"✅ Flask HF app inicializado")
+print(f"✅ Working directory: {os.getcwd()}")
+
+# --- UTILITÁRIOS DE ARMAZENAMENTO ---
+
+def save_user_data(user_id, data_type, data):
+    """Salvar dados do usuário em arquivos JSON"""
+    try:
+        user_dir = f"hf_data/{data_type}"
+        os.makedirs(user_dir, exist_ok=True)
+        
+        file_path = f"{user_dir}/{user_id}.json"
+        
+        # Carregar dados existentes
+        existing_data = []
+        if os.path.exists(file_path):
+            with open(file_path, 'r', encoding='utf-8') as f:
+                existing_data = json.load(f)
+        
+        # Adicionar novos dados
+        data['timestamp'] = datetime.now().isoformat()
+        existing_data.append(data)
+        
+        # Manter apenas os últimos 100 itens
+        if len(existing_data) > 100:
+            existing_data = existing_data[-100:]
+        
+        # Salvar
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(existing_data, f, ensure_ascii=False, indent=2)
+        
+        return True
+    except Exception as e:
+        print(f"Erro ao salvar dados: {e}")
+        return False
+
+def load_user_data(user_id, data_type):
+    """Carregar dados do usuário"""
+    try:
+        file_path = f"hf_data/{data_type}/{user_id}.json"
+        if os.path.exists(file_path):
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return json.load(f)
+        return []
+    except Exception as e:
+        print(f"Erro ao carregar dados: {e}")
+        return []
+
+def get_all_users():
+    """Obter lista de todos os usuários"""
+    users = set()
+    for data_type in ['flashcards', 'conversations', 'analytics']:
+        data_dir = f"hf_data/{data_type}"
+        if os.path.exists(data_dir):
+            for filename in os.listdir(data_dir):
+                if filename.endswith('.json'):
+                    users.add(filename[:-5])  # Remove .json
+    return sorted(list(users))
+
+# --- CONFIGURAÇÃO DE APIs ---
+
+# Configurar APIs
+groq_client = None
+genai_client = None
+
+try:
+    groq_api_key = os.environ.get('GROQ_API_KEY')
+    if groq_api_key:
+        groq_client = Groq(api_key=groq_api_key)
+        print("✅ Groq API configurada")
+except Exception as e:
+    print(f"⚠️ Groq API não configurada: {e}")
+
+try:
+    gemini_api_key = os.environ.get('GEMINI_API_KEY')
+    if gemini_api_key:
+        genai.configure(api_key=gemini_api_key)
+        genai_client = genai
+        print("✅ Gemini API configurada")
+except Exception as e:
+    print(f"⚠️ Gemini API não configurada: {e}")
+
+# --- ROTAS PRINCIPAIS ---
+
+@app.route('/')
+def index():
+    return send_file('../templates_hf/index.html')
+
+@app.route('/admin')
+def admin():
+    return send_file('../templates_hf/admin.html')
+
+@app.route('/status')
+def status():
+    return send_file('../templates_hf/status.html')
+
+# --- API ENDPOINTS ---
+
+@app.route('/list-models', methods=['GET'])
+def list_models():
+    """Listar modelos disponíveis"""
+    available_models = []
+    
+    if groq_client:
+        available_models.extend([
+            {"name": "Llama 3.2 90B (Ultra Fast)", "value": "groq:llama-3.2-90b-text-preview"},
+            {"name": "Llama 3.2 11B Vision (Fast)", "value": "groq:llama-3.2-11b-vision-preview"},
+            {"name": "Llama 3.1 70B (Fast)", "value": "groq:llama-3.1-70b-versatile"},
+            {"name": "Mixtral 8x7B (Fast)", "value": "groq:mixtral-8x7b-32768"}
+        ])
+    
+    if genai_client:
+        available_models.extend([
+            {"name": "Gemini 2.5 Flash (Recommended)", "value": "gemini:gemini-2.5-flash-latest"},
+            {"name": "Gemini 2.5 Pro Experimental", "value": "gemini:gemini-2.5-pro-exp"},
+            {"name": "Gemini 1.5 Flash", "value": "gemini:gemini-1.5-flash-latest"},
+            {"name": "Gemini 1.5 Pro", "value": "gemini:gemini-1.5-pro-latest"}
+        ])
+    
+    return jsonify(available_models)
+
+# Cache de áudio TTS em memória
+tts_cache = {}
+
+@app.route('/tts-proxy', methods=['POST'])
+def tts_proxy():
+    data = request.get_json()
+    text = data.get('text', '')
+    tld = data.get('tld', 'co.uk') 
+    if not text: return jsonify({"error": "No text provided"}), 400
+    
+    if len(text) > 10000:
+        return jsonify({"error": "Text is too long. Maximum 10,000 characters allowed."}), 400
+    
+    import hashlib
+    cache_key = hashlib.md5(f"{text}_{tld}".encode()).hexdigest()
+    
+    try:
+        if cache_key in tts_cache:
+            print(f"🎵 TTS Cache HIT: {len(text)} chars")
+            cached_audio = tts_cache[cache_key]
+            audio_fp = io.BytesIO(cached_audio)
+            return send_file(audio_fp, mimetype='audio/mpeg', as_attachment=False)
+        
+        print(f"🎵 TTS Cache MISS: Gerando áudio para {len(text)} chars, tld: {tld}")
+        
+        tts = gTTS(text=text, lang='en', tld=tld)
+        mp3_fp = io.BytesIO()
+        tts.write_to_fp(mp3_fp)
+        mp3_fp.seek(0)
+        
+        audio_data = mp3_fp.read()
+        tts_cache[cache_key] = audio_data
+        
+        if len(tts_cache) > 50:
+            oldest_key = next(iter(tts_cache))
+            del tts_cache[oldest_key]
+            
+        audio_fp = io.BytesIO(audio_data)
+        return send_file(audio_fp, mimetype='audio/mpeg', as_attachment=False)
+        
+    except Exception as e:
+        print(f"❌ TTS Error: {e}")
+        return jsonify({"error": f"Failed to generate audio via gTTS: {e}"}), 500
+
+@app.route('/explain-proxy', methods=['POST'])
+def explain_proxy():
+    """Gerar explicação/flashcard"""
+    data = request.get_json()
+    selected_text = data.get('selectedText', '')
+    model_info = data.get('model', 'gemini:gemini-2.5-flash-latest').split(':', 1)
+    
+    if len(model_info) != 2:
+        return jsonify({"error": "Invalid model format"}), 400
+    
+    model_provider, model_name = model_info
+    
+    if not selected_text:
+        return jsonify({"error": "No text selected"}), 400
+    
+    try:
+        prompt = f"""
+        Create a comprehensive flashcard for the English term/phrase: "{selected_text}"
+        
+        Provide:
+        1. Clear definition in English
+        2. Translation to Portuguese 
+        3. Example sentence using the term
+        4. Same sentence with the term replaced by "____" for practice
+        
+        Return as JSON with keys: definition, translation, context_sentence, gapped_sentence
+        """
+        
+        if model_provider == 'gemini' and genai_client:
+            model = genai_client.GenerativeModel(model_name)
+            response = model.generate_content(prompt)
+            
+            # Extrair JSON da resposta
+            response_text = response.text
+            if '```json' in response_text:
+                json_start = response_text.find('```json') + 7
+                json_end = response_text.find('```', json_start)
+                response_text = response_text[json_start:json_end].strip()
+            
+            result = json.loads(response_text)
+            result['term'] = selected_text
+            
+            return jsonify(result)
+            
+        elif model_provider == 'groq' and groq_client:
+            response = groq_client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model=model_name,
+                temperature=0.3
+            )
+            
+            response_text = response.choices[0].message.content
+            if '```json' in response_text:
+                json_start = response_text.find('```json') + 7
+                json_end = response_text.find('```', json_start)
+                response_text = response_text[json_start:json_end].strip()
+            
+            result = json.loads(response_text)
+            result['term'] = selected_text
+            
+            return jsonify(result)
+        
+        else:
+            return jsonify({"error": f"{model_provider.upper()}_API_KEY not configured"}), 503
+            
+    except Exception as e:
+        print(f"AI ANALYSIS ERROR: {e}")
+        return jsonify({"error": str(e)}), 500
+
+# --- ROUTES DE DADOS (SEM AUTENTICAÇÃO) ---
+
+@app.route('/users', methods=['GET'])
+def get_users():
+    """Obter lista de usuários"""
+    users = get_all_users()
+    return jsonify({'users': users, 'total': len(users)})
+
+@app.route('/user/<user_id>/flashcards', methods=['GET', 'POST'])
+def user_flashcards(user_id):
+    """Gerenciar flashcards do usuário"""
+    if request.method == 'POST':
+        data = request.get_json()
+        if save_user_data(user_id, 'flashcards', data):
+            return jsonify({'success': True, 'message': 'Flashcard saved'})
+        else:
+            return jsonify({'success': False, 'message': 'Failed to save flashcard'}), 500
+    else:
+        flashcards = load_user_data(user_id, 'flashcards')
+        return jsonify({'flashcards': flashcards})
+
+@app.route('/user/<user_id>/conversations', methods=['GET', 'POST'])
+def user_conversations(user_id):
+    """Gerenciar conversas do usuário"""
+    if request.method == 'POST':
+        data = request.get_json()
+        if save_user_data(user_id, 'conversations', data):
+            return jsonify({'success': True, 'message': 'Conversation saved'})
+        else:
+            return jsonify({'success': False, 'message': 'Failed to save conversation'}), 500
+    else:
+        conversations = load_user_data(user_id, 'conversations')
+        return jsonify({'conversations': conversations})
+
+@app.route('/user/<user_id>/analytics', methods=['GET'])
+def user_analytics(user_id):
+    """Obter analytics do usuário"""
+    analytics = load_user_data(user_id, 'analytics')
+    flashcards = load_user_data(user_id, 'flashcards')
+    conversations = load_user_data(user_id, 'conversations')
+    
+    return jsonify({
+        'total_flashcards': len(flashcards),
+        'total_conversations': len(conversations),
+        'total_sessions': len(analytics),
+        'recent_activity': analytics[-10:] if analytics else []
+    })
+
+# --- STATUS E ADMIN ---
+
+@app.route('/admin/stats', methods=['GET'])
+def admin_stats():
+    """Estatísticas do sistema"""
+    users = get_all_users()
+    stats = {
+        'total_users': len(users),
+        'users': []
+    }
+    
+    for user_id in users:
+        flashcards = len(load_user_data(user_id, 'flashcards'))
+        conversations = len(load_user_data(user_id, 'conversations'))
+        stats['users'].append({
+            'user_id': user_id,
+            'flashcards': flashcards,
+            'conversations': conversations
+        })
+    
+    return jsonify(stats)
+
+@app.route('/system/status', methods=['GET'])
+def system_status():
+    """Status do sistema"""
+    return jsonify({
+        'status': 'running',
+        'version': 'HF-Simplified-1.0',
+        'apis': {
+            'groq': groq_client is not None,
+            'gemini': genai_client is not None
+        },
+        'storage': 'file_based',
+        'auth': 'disabled'
+    })
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=7860, debug=True)

requirements.txt

@@ -0,0 +1,3 @@
+flask==2.3.3
+requests==2.31.0
+gtts==2.4.0