Upload 5 files

README.md

@@ -1,53 +1,52 @@
----
-title: English Helper
-emoji: 🎓
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-app_file: app.py
-pinned: false
-license: mit
-sdk_version: 5.49.1
----
-
-# 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)
-
----
-
+---
+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**

flask_app_hf.py

@@ -5,10 +5,21 @@ import json
 import base64
 from datetime import datetime
 from flask import Flask, request, jsonify, send_file, render_template, 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
+try:
+    from gtts import gTTS
+except Exception:
+    gTTS = None
+
+try:
+    from groq import Groq
+except Exception:
+    Groq = None
+
+try:
+    import google.generativeai as genai
+    from google.generativeai.types import GenerationConfig
+except Exception:
+    genai = None
 
 # --- CONFIGURAÇÃO INICIAL ---
 app = Flask(__name__)
@@ -19,62 +30,72 @@ app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
 
 print(f"✅ Flask HF app inicializado")
 print(f"✅ Working directory: {os.getcwd()}")
+# In-memory storage (suitable for HF Spaces testing only)
+IN_MEMORY = {
+    'users': {},            # user_id -> record dict
+    'flashcards': {},       # user_id -> [items]
+    'conversations': {},    # user_id -> [items]
+    'analytics': {},        # user_id -> [items]
+    'study_plans': {},      # user_id or 'global' -> plan dict/list
+}
+
+# Keep legacy DATA_ROOT variable for compatibility checks (unused in-memory)
+_module_dir = os.path.dirname(os.path.abspath(__file__))
+DATA_ROOT = os.environ.get('EH_DATA_ROOT', os.path.join(_module_dir, 'hf_data'))
 
 # --- UTILITÁRIOS DE ARMAZENAMENTO ---
 
 def save_user_data(user_id, data_type, data):
-    """Salvar dados do usuário em arquivos JSON"""
+    """Salvar dados do usuário em memória."""
     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)
-        
+        store = IN_MEMORY.setdefault(data_type, {})
+        lst = store.setdefault(user_id, [])
+        # attach timestamp
+        if isinstance(data, dict):
+            data = dict(data)
+        entry = data
+        if isinstance(entry, dict):
+            entry.setdefault('timestamp', datetime.now().isoformat())
+        lst.append(entry)
+        # keep last 100
+        if len(lst) > 100:
+            store[user_id] = lst[-100:]
         return True
     except Exception as e:
-        print(f"Erro ao salvar dados: {e}")
+        print(f"Erro ao salvar dados (in-memory): {e}")
+        return False
+
+
+def save_user_record(user_id, metadata=None):
+    """Create or update a simple user record in memory."""
+    try:
+        record = IN_MEMORY['users'].get(user_id, {})
+        record['id'] = user_id
+        record.setdefault('created_at', datetime.now().isoformat())
+        if metadata and isinstance(metadata, dict):
+            record.update(metadata)
+        IN_MEMORY['users'][user_id] = record
+        return True
+    except Exception as e:
+        print(f"save_user_record error (in-memory): {e}")
         return False
 
 def load_user_data(user_id, data_type):
-    """Carregar dados do usuário"""
+    """Load user data from memory."""
     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 []
+        store = IN_MEMORY.get(data_type, {})
+        return list(store.get(user_id, []))
     except Exception as e:
-        print(f"Erro ao carregar dados: {e}")
+        print(f"Erro ao carregar dados (in-memory): {e}")
         return []
 
 def get_all_users():
-    """Obter lista de todos os usuários"""
+    """Return sorted list of all user ids known in memory."""
     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))
+    users.update(IN_MEMORY.get('users', {}).keys())
+    for data_type in ['flashcards', 'conversations', 'analytics', 'study_plans']:
+        users.update(IN_MEMORY.get(data_type, {}).keys())
+    return sorted([u for u in users if u])
 
 # --- CONFIGURAÇÃO DE APIs ---
 
@@ -259,6 +280,31 @@ def get_users():
     users = get_all_users()
     return jsonify({'users': users, 'total': len(users)})
 
+
+@app.route('/user/create', methods=['POST'])
+def create_user():
+    """Create a lightweight user record for HF Spaces (no auth)."""
+    try:
+        data = request.get_json() or {}
+        user_id = data.get('user_id') or data.get('email') or data.get('name')
+        if not user_id:
+            return jsonify({'success': False, 'error': 'user_id (or email/name) required'}), 400
+
+        # sanitize user_id to a filename-friendly string
+        safe_id = ''.join(c for c in user_id if c.isalnum() or c in ('-', '_')).lower()
+        if not safe_id:
+            return jsonify({'success': False, 'error': 'invalid user_id'}), 400
+
+        ok = save_user_record(safe_id, {'raw': user_id})
+        if not ok:
+            return jsonify({'success': False, 'error': 'failed to save user record'}), 500
+
+        users = get_all_users()
+        return jsonify({'success': True, 'user_id': safe_id, 'users': users})
+    except Exception as e:
+        print(f"create_user error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
 @app.route('/user/<user_id>/flashcards', methods=['GET', 'POST'])
 def user_flashcards(user_id):
     """Gerenciar flashcards do usuário"""
@@ -335,6 +381,304 @@ def system_status():
         'auth': 'disabled'
     })
 
+
+# --- ADMIN / HEALTH / EXPORT (file-based implementations for HF Spaces) ---
+@app.route('/admin/system/health', methods=['GET'])
+def admin_system_health():
+    """Return simple system health info using file-based storage (no external deps)."""
+    try:
+        import shutil
+        data_root = DATA_ROOT
+        schema = {}
+        total_rows = 0
+        db_size = 0
+
+        if os.path.exists(data_root):
+            for folder in os.listdir(data_root):
+                folder_path = os.path.join(data_root, folder)
+                if os.path.isdir(folder_path):
+                    files = [f for f in os.listdir(folder_path) if f.endswith('.json')]
+                    row_count = len(files)
+                    total_rows += row_count
+                    # approximate size
+                    size = 0
+                    for fn in files:
+                        p = os.path.join(folder_path, fn)
+                        try:
+                            size += os.path.getsize(p)
+                        except Exception:
+                            pass
+                    db_size += size
+                    schema[folder] = {'row_count': row_count, 'size_bytes': size}
+
+        # disk usage for current filesystem
+        try:
+            du = shutil.disk_usage('.')
+            disk = {
+                'total': du.total,
+                'used': du.used,
+                'free': du.free,
+                'percent': round(du.used / du.total * 100, 2) if du.total else 0
+            }
+        except Exception:
+            disk = {}
+
+        health = {
+            'memory': None,
+            'disk': disk,
+            'database': {
+                'data_root': data_root,
+                'total_rows': total_rows,
+                'estimated_size_bytes': db_size,
+                'tables': schema
+            },
+            'uptime': datetime.now().isoformat()
+        }
+
+        return jsonify({'success': True, 'health': health})
+    except Exception as e:
+        print(f"Health endpoint error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/admin/database/schema', methods=['GET'])
+def admin_database_schema():
+    """Return a simple schema overview derived from hf_data folders."""
+    try:
+        data_root = DATA_ROOT
+        schema = {}
+        if os.path.exists(data_root):
+            for folder in os.listdir(data_root):
+                folder_path = os.path.join(data_root, folder)
+                if os.path.isdir(folder_path):
+                    files = [f for f in os.listdir(folder_path) if f.endswith('.json')]
+                    # try to infer columns from first file
+                    cols = []
+                    if files:
+                        sample_path = os.path.join(folder_path, files[0])
+                        try:
+                            with open(sample_path, 'r', encoding='utf-8') as fh:
+                                data = json.load(fh)
+                                if isinstance(data, list) and data:
+                                    sample = data[0]
+                                elif isinstance(data, dict):
+                                    sample = data
+                                else:
+                                    sample = {}
+                                cols = [{'name': k, 'type': type(v).__name__} for k, v in (sample or {}).items()]
+                        except Exception:
+                            cols = []
+
+                    schema[folder] = {
+                        'row_count': len(files),
+                        'columns': cols
+                    }
+        else:
+            schema = {}
+
+        return jsonify({'success': True, 'schema': schema})
+    except Exception as e:
+        print(f"Schema error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/admin/users', methods=['GET'])
+def admin_list_users():
+    """Return paginated list of users (derived from hf_data files)."""
+    try:
+        page = int(request.args.get('page', 1))
+        per_page = int(request.args.get('per_page', 20))
+
+        users = get_all_users()
+        total = len(users)
+        total_pages = max(1, (total + per_page - 1) // per_page)
+
+        start = (page - 1) * per_page
+        end = start + per_page
+        users_page = []
+
+        for uid in users[start:end]:
+            # gather basic stats
+            flashcards = len(load_user_data(uid, 'flashcards'))
+            conversations = len(load_user_data(uid, 'conversations'))
+            analytics = len(load_user_data(uid, 'analytics'))
+
+            # estimate created_at by file mtime if available
+            created_at = None
+            try:
+                path_candidates = [
+                    os.path.join(DATA_ROOT, 'flashcards', f"{uid}.json"),
+                    os.path.join(DATA_ROOT, 'conversations', f"{uid}.json"),
+                    os.path.join(DATA_ROOT, 'analytics', f"{uid}.json")
+                ]
+                mtimes = []
+                for p in path_candidates:
+                    if os.path.exists(p):
+                        mtimes.append(os.path.getmtime(p))
+                if mtimes:
+                    created_at = datetime.fromtimestamp(min(mtimes)).isoformat()
+            except Exception:
+                created_at = None
+
+            users_page.append({
+                'id': uid,
+                'email': uid,
+                'created_at': created_at,
+                'flashcard_count': flashcards,
+                'conversation_count': conversations,
+                'session_count': analytics
+            })
+
+        return jsonify({'success': True, 'data': {'users': users_page, 'page': page, 'per_page': per_page, 'total': total, 'total_pages': total_pages}})
+    except Exception as e:
+        print(f"admin_list_users error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/admin/users/<path:user_id>', methods=['GET', 'DELETE'])
+def admin_user_detail(user_id):
+    """Get detailed info for a user or delete their data (file-based)."""
+    try:
+        if request.method == 'DELETE':
+            # remove files across hf_data
+            removed = []
+            for folder in ['flashcards', 'conversations', 'analytics']:
+                p = os.path.join(DATA_ROOT, folder, f"{user_id}.json")
+                try:
+                    if os.path.exists(p):
+                        os.remove(p)
+                        removed.append(p)
+                except Exception as ex:
+                    print(f"Failed deleting {p}: {ex}")
+            return jsonify({'success': True, 'deleted': removed})
+
+        # GET -> return analytics, flashcards, conversations
+        flashcards = load_user_data(user_id, 'flashcards')
+        conversations = load_user_data(user_id, 'conversations')
+        analytics = load_user_data(user_id, 'analytics')
+
+        # Build token_usage overview if present in analytics entries
+        token_usage = {}
+        for entry in analytics:
+            if isinstance(entry, dict) and 'token_usage' in entry:
+                for prov, usage in entry['token_usage'].items():
+                    s = token_usage.setdefault(prov, {'input': 0, 'output': 0, 'calls': 0})
+                    s['input'] += usage.get('input_tokens', 0)
+                    s['output'] += usage.get('output_tokens', 0)
+                    s['calls'] += 1
+
+        user_info = {
+            'user': {'id': user_id, 'email': user_id, 'created_at': None},
+            'flashcards': flashcards,
+            'conversations': conversations,
+            'recent_sessions': analytics[-10:] if analytics else [],
+            'settings': {},
+            'token_usage': [{'provider': k, 'input_tokens': v['input'], 'output_tokens': v['output'], 'calls': v['calls']} for k, v in token_usage.items()]
+        }
+
+        return jsonify({'success': True, 'user': user_info})
+    except Exception as e:
+        print(f"admin_user_detail error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/admin/system/alerts', methods=['GET'])
+def admin_system_alerts():
+    """Return current system alerts (file-based: empty by default)."""
+    # In HF file-based mode we have no centralized alerting - return empty list
+    return jsonify({'success': True, 'alerts': []})
+
+
+@app.route('/admin/export/users', methods=['GET'])
+def admin_export_users():
+    """Export users list as CSV (file-based)."""
+    try:
+        import csv
+        users = get_all_users()
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerow(['id', 'email', 'flashcards', 'conversations', 'analytics'])
+        for uid in users:
+            fc = len(load_user_data(uid, 'flashcards'))
+            conv = len(load_user_data(uid, 'conversations'))
+            an = len(load_user_data(uid, 'analytics'))
+            writer.writerow([uid, uid, fc, conv, an])
+
+        mem = io.BytesIO(output.getvalue().encode('utf-8'))
+        mem.seek(0)
+        return send_file(mem, mimetype='text/csv', as_attachment=True, download_name='users_export.csv')
+    except Exception as e:
+        print(f"export users error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/admin/export/tokens', methods=['GET'])
+def admin_export_tokens():
+    """Export token usage summary as CSV (aggregated from analytics)."""
+    try:
+        import csv
+        users = get_all_users()
+        output = io.StringIO()
+        writer = csv.writer(output)
+        writer.writerow(['user_id', 'provider', 'input_tokens', 'output_tokens', 'calls'])
+
+        for uid in users:
+            analytics = load_user_data(uid, 'analytics')
+            agg = {}
+            for entry in analytics:
+                if isinstance(entry, dict) and 'token_usage' in entry:
+                    for prov, usage in entry['token_usage'].items():
+                        a = agg.setdefault(prov, {'input': 0, 'output': 0, 'calls': 0})
+                        a['input'] += usage.get('input_tokens', 0)
+                        a['output'] += usage.get('output_tokens', 0)
+                        a['calls'] += 1
+            for prov, vals in agg.items():
+                writer.writerow([uid, prov, vals['input'], vals['output'], vals['calls']])
+
+        mem = io.BytesIO(output.getvalue().encode('utf-8'))
+        mem.seek(0)
+        return send_file(mem, mimetype='text/csv', as_attachment=True, download_name='tokens_export.csv')
+    except Exception as e:
+        print(f"export tokens error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/admin/export/all', methods=['GET'])
+def admin_export_all():
+    """Package the entire DATA_ROOT into a zip and send for download."""
+    try:
+        import zipfile
+        import tempfile
+
+        if not os.path.exists(DATA_ROOT):
+            return jsonify({'success': False, 'error': 'No data directory found'}), 404
+
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix='.zip')
+        tmp.close()
+
+        with zipfile.ZipFile(tmp.name, 'w', compression=zipfile.ZIP_DEFLATED) as zf:
+            for root, dirs, files in os.walk(DATA_ROOT):
+                for f in files:
+                    full = os.path.join(root, f)
+                    arcname = os.path.relpath(full, DATA_ROOT)
+                    zf.write(full, arcname)
+
+        return send_file(tmp.name, mimetype='application/zip', as_attachment=True, download_name='hf_data_export.zip')
+    except Exception as e:
+        print(f"export all error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
+
+@app.route('/admin/dashboard', methods=['GET'])
+def admin_dashboard_compat():
+    """Compatibility endpoint for older admin UI that expects /admin/dashboard."""
+    try:
+        stats = admin_stats()  # reuse existing
+        return jsonify({'success': True, 'stats': stats.get_json() if isinstance(stats, Response) else stats})
+    except Exception as e:
+        print(f"admin_dashboard error: {e}")
+        return jsonify({'success': False, 'error': str(e)}), 500
+
 from study_plan import save_study_plan, load_study_plan, generate_study_plan
 
 @app.route('/study-plan', methods=['GET', 'POST'])
@@ -343,8 +687,13 @@ def study_plan():
     if request.method == 'POST':
         try:
             data = request.get_json()
+            user_id = data.get('user_id')
             plan = generate_study_plan(data)
+            # save globally
             save_study_plan(plan)
+            # also save per-user if provided
+            if user_id:
+                save_user_data(user_id, 'study_plans', plan)
             return jsonify({'success': True, 'message': 'Study plan generated and saved', 'plan': plan})
         except Exception as e:
             print(f"Erro ao salvar study plan: {e}")

study_plan.py

@@ -1,4 +1,5 @@
 import logging
+import os
 try:
     from groq import Groq
 except ImportError:
@@ -181,23 +182,25 @@ def generate_study_plan(user_data):
         'study_goals': study_goals
     }
     return plan
-import os
 import json
 from datetime import datetime
 
-STUDY_PLAN_PATH = 'hf_data/study_plan.json'
+# In-memory study plan storage (testing only)
+_MEM_STUDY_PLAN = None
 
 def save_study_plan(plan_data):
-    """Salva o plano de estudos em JSON."""
-    os.makedirs(os.path.dirname(STUDY_PLAN_PATH), exist_ok=True)
-    plan_data['saved_at'] = datetime.now().isoformat()
-    with open(STUDY_PLAN_PATH, 'w', encoding='utf-8') as f:
-        json.dump(plan_data, f, ensure_ascii=False, indent=2)
-    return True
+    """Store the study plan in memory (no disk IO)."""
+    global _MEM_STUDY_PLAN
+    try:
+        if isinstance(plan_data, dict):
+            plan_data = dict(plan_data)
+        plan_data['saved_at'] = datetime.now().isoformat()
+        _MEM_STUDY_PLAN = plan_data
+        return True
+    except Exception as e:
+        logger.warning(f"Failed to save study plan in-memory: {e}")
+        return False
 
 def load_study_plan():
-    """Carrega o plano de estudos do JSON."""
-    if os.path.exists(STUDY_PLAN_PATH):
-        with open(STUDY_PLAN_PATH, 'r', encoding='utf-8') as f:
-            return json.load(f)
-    return None
+    """Load the study plan from in-memory storage."""
+    return _MEM_STUDY_PLAN