Upload 5 files

flask_app_hf.py

@@ -377,7 +377,8 @@ def system_status():
             'groq': groq_client is not None,
             'gemini': genai_client is not None
         },
-        'storage': 'file_based',
+        'storage': 'in_memory',
+        'demo_mode': True,
         'auth': 'disabled'
     })
 
@@ -388,30 +389,26 @@ def admin_system_health():
     """Return simple system health info using file-based storage (no external deps)."""
     try:
         import shutil
-        data_root = DATA_ROOT
+        # compute simple stats from IN_MEMORY
         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
+        for table, table_data in IN_MEMORY.items():
+            if isinstance(table_data, dict):
+                row_count = sum(1 for _ in table_data.keys())
+                # approximate size by serializing entries
+                size = 0
+                for k, v in table_data.items():
+                    try:
+                        size += len(json.dumps(v, ensure_ascii=False).encode('utf-8'))
+                    except Exception:
+                        pass
+                schema[table] = {'row_count': row_count, 'size_bytes': size}
+                total_rows += row_count
+                db_size += size
+
+        # disk usage for current filesystem (informational)
         try:
             du = shutil.disk_usage('.')
             disk = {
@@ -424,10 +421,10 @@ def admin_system_health():
             disk = {}
 
         health = {
-            'memory': None,
+            'memory': True,
             'disk': disk,
             'database': {
-                'data_root': data_root,
+                'storage': 'in_memory',
                 'total_rows': total_rows,
                 'estimated_size_bytes': db_size,
                 'tables': schema
@@ -445,36 +442,33 @@ def admin_system_health():
 def admin_database_schema():
     """Return a simple schema overview derived from hf_data folders."""
     try:
-        data_root = DATA_ROOT
+        # derive schema from IN_MEMORY
         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
+        for table, table_data in IN_MEMORY.items():
+            cols = []
+            row_count = 0
+            if isinstance(table_data, dict):
+                row_count = sum(1 for _ in table_data.keys())
+                # infer columns/types from first value
+                try:
+                    first_val = None
+                    for v in table_data.values():
+                        first_val = v
+                        break
+                    sample = None
+                    if isinstance(first_val, list) and first_val:
+                        sample = first_val[0]
+                    elif isinstance(first_val, dict):
+                        sample = first_val
+                    if isinstance(sample, dict):
+                        cols = [{'name': k, 'type': type(v).__name__} for k, v in sample.items()]
+                except Exception:
                     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 = {}
+            schema[table] = {
+                'row_count': row_count,
+                'columns': cols
+            }
 
         return jsonify({'success': True, 'schema': schema})
     except Exception as e:
@@ -502,21 +496,12 @@ def admin_list_users():
             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 from user record 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()
+                urec = IN_MEMORY.get('users', {}).get(uid)
+                if urec and isinstance(urec, dict):
+                    created_at = urec.get('created_at')
             except Exception:
                 created_at = None
 
@@ -540,16 +525,22 @@ 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
+            # remove in-memory records across tables
             removed = []
-            for folder in ['flashcards', 'conversations', 'analytics']:
-                p = os.path.join(DATA_ROOT, folder, f"{user_id}.json")
+            for folder in ['flashcards', 'conversations', 'analytics', 'study_plans']:
                 try:
-                    if os.path.exists(p):
-                        os.remove(p)
-                        removed.append(p)
+                    tbl = IN_MEMORY.get(folder, {})
+                    if user_id in tbl:
+                        del tbl[user_id]
+                        removed.append(f"{folder}/{user_id}")
                 except Exception as ex:
-                    print(f"Failed deleting {p}: {ex}")
+                    print(f"Failed deleting in-memory {folder}/{user_id}: {ex}")
+            # remove user record
+            try:
+                if user_id in IN_MEMORY.get('users', {}):
+                    del IN_MEMORY['users'][user_id]
+            except Exception:
+                pass
             return jsonify({'success': True, 'deleted': removed})
 
         # GET -> return analytics, flashcards, conversations
@@ -648,22 +639,30 @@ 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')
+        mem_zip = io.BytesIO()
+        with zipfile.ZipFile(mem_zip, 'w', compression=zipfile.ZIP_DEFLATED) as zf:
+            # dump each table as files
+            for table, table_data in IN_MEMORY.items():
+                if isinstance(table_data, dict):
+                    for uid, val in table_data.items():
+                        try:
+                            payload = json.dumps(val, ensure_ascii=False, indent=2)
+                        except Exception:
+                            payload = str(val)
+                        arcname = os.path.join(table, f"{uid}.json")
+                        zf.writestr(arcname, payload)
+                else:
+                    # serialize whole object
+                    try:
+                        payload = json.dumps(table_data, ensure_ascii=False, indent=2)
+                    except Exception:
+                        payload = str(table_data)
+                    arcname = f"{table}.json"
+                    zf.writestr(arcname, payload)
+
+        mem_zip.seek(0)
+        return send_file(mem_zip, 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