master

.gitattributes

@@ -33,10 +33,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-FZKT_GBK.woff filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.woff filter=lfs diff=lfs merge=lfs -text
-*.ttf filter=lfs diff=lfs merge=lfs -text
-*.woff2 filter=lfs diff=lfs merge=lfs -text
-*.db filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,92 +0,0 @@
-# Python 编译文件
-*.pyc
-*.pyo
-*.pyd
-__pycache__/
-*.py[cod]
-*$py.class
-
-# C 扩展
-*.so
-
-# 分发/打包
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# PyInstaller
-*.manifest
-*.spec
-
-# 单元测试 / 覆盖率
-htmlcov/
-.tox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-.hypothesis/
-.pytest_cache/
-
-# 虚拟环境
-venv/
-ENV/
-env/
-.venv
-
-# Flask
-instance/
-.webassets-cache
-*.db
-
-# 日志文件
-logs/
-*.log
-
-# 环境变量
-.env
-.env.local
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-.DS_Store
-
-# 备份文件
-*.backup
-*.bak
-*.old
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# pyenv
-.python-version
-
-# pipenv
-Pipfile.lock
-
-# poetry
-poetry.lock
-
-# 项目特定
-# 如果不想提交某些大文件或临时文件，在这里添加
-

.vscode/PythonImportHelper-v2-Completion.json

@@ -1,1277 +0,0 @@
-[
-    {
-        "label": "os",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "os",
-        "description": "os",
-        "detail": "os",
-        "documentation": {}
-    },
-    {
-        "label": "sys",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "sys",
-        "description": "sys",
-        "detail": "sys",
-        "documentation": {}
-    },
-    {
-        "label": "json",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "json",
-        "description": "json",
-        "detail": "json",
-        "documentation": {}
-    },
-    {
-        "label": "time",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "time",
-        "description": "time",
-        "detail": "time",
-        "documentation": {}
-    },
-    {
-        "label": "datetime",
-        "importPath": "datetime",
-        "description": "datetime",
-        "isExtraImport": true,
-        "detail": "datetime",
-        "documentation": {}
-    },
-    {
-        "label": "datetime",
-        "importPath": "datetime",
-        "description": "datetime",
-        "isExtraImport": true,
-        "detail": "datetime",
-        "documentation": {}
-    },
-    {
-        "label": "Path",
-        "importPath": "pathlib",
-        "description": "pathlib",
-        "isExtraImport": true,
-        "detail": "pathlib",
-        "documentation": {}
-    },
-    {
-        "label": "Path",
-        "importPath": "pathlib",
-        "description": "pathlib",
-        "isExtraImport": true,
-        "detail": "pathlib",
-        "documentation": {}
-    },
-    {
-        "label": "Path",
-        "importPath": "pathlib",
-        "description": "pathlib",
-        "isExtraImport": true,
-        "detail": "pathlib",
-        "documentation": {}
-    },
-    {
-        "label": "Path",
-        "importPath": "pathlib",
-        "description": "pathlib",
-        "isExtraImport": true,
-        "detail": "pathlib",
-        "documentation": {}
-    },
-    {
-        "label": "Path",
-        "importPath": "pathlib",
-        "description": "pathlib",
-        "isExtraImport": true,
-        "detail": "pathlib",
-        "documentation": {}
-    },
-    {
-        "label": "Path",
-        "importPath": "pathlib",
-        "description": "pathlib",
-        "isExtraImport": true,
-        "detail": "pathlib",
-        "documentation": {}
-    },
-    {
-        "label": "Path",
-        "importPath": "pathlib",
-        "description": "pathlib",
-        "isExtraImport": true,
-        "detail": "pathlib",
-        "documentation": {}
-    },
-    {
-        "label": "Flask",
-        "importPath": "flask",
-        "description": "flask",
-        "isExtraImport": true,
-        "detail": "flask",
-        "documentation": {}
-    },
-    {
-        "label": "render_template",
-        "importPath": "flask",
-        "description": "flask",
-        "isExtraImport": true,
-        "detail": "flask",
-        "documentation": {}
-    },
-    {
-        "label": "send_from_directory",
-        "importPath": "flask",
-        "description": "flask",
-        "isExtraImport": true,
-        "detail": "flask",
-        "documentation": {}
-    },
-    {
-        "label": "jsonify",
-        "importPath": "flask",
-        "description": "flask",
-        "isExtraImport": true,
-        "detail": "flask",
-        "documentation": {}
-    },
-    {
-        "label": "request",
-        "importPath": "flask",
-        "description": "flask",
-        "isExtraImport": true,
-        "detail": "flask",
-        "documentation": {}
-    },
-    {
-        "label": "session",
-        "importPath": "flask",
-        "description": "flask",
-        "isExtraImport": true,
-        "detail": "flask",
-        "documentation": {}
-    },
-    {
-        "label": "CORS",
-        "importPath": "flask_cors",
-        "description": "flask_cors",
-        "isExtraImport": true,
-        "detail": "flask_cors",
-        "documentation": {}
-    },
-    {
-        "label": "logging",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "logging",
-        "description": "logging",
-        "detail": "logging",
-        "documentation": {}
-    },
-    {
-        "label": "RotatingFileHandler",
-        "importPath": "logging.handlers",
-        "description": "logging.handlers",
-        "isExtraImport": true,
-        "detail": "logging.handlers",
-        "documentation": {}
-    },
-    {
-        "label": "get_db_instance",
-        "importPath": "db_manager",
-        "description": "db_manager",
-        "isExtraImport": true,
-        "detail": "db_manager",
-        "documentation": {}
-    },
-    {
-        "label": "re",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "re",
-        "description": "re",
-        "detail": "re",
-        "documentation": {}
-    },
-    {
-        "label": "subprocess",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "subprocess",
-        "description": "subprocess",
-        "detail": "subprocess",
-        "documentation": {}
-    },
-    {
-        "label": "urllib.parse",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "urllib.parse",
-        "description": "urllib.parse",
-        "detail": "urllib.parse",
-        "documentation": {}
-    },
-    {
-        "label": "urlparse",
-        "importPath": "urllib.parse",
-        "description": "urllib.parse",
-        "isExtraImport": true,
-        "detail": "urllib.parse",
-        "documentation": {}
-    },
-    {
-        "label": "unquote",
-        "importPath": "urllib.parse",
-        "description": "urllib.parse",
-        "isExtraImport": true,
-        "detail": "urllib.parse",
-        "documentation": {}
-    },
-    {
-        "label": "List",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "Dict",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "Set",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "Dict",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "List",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "Optional",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "Tuple",
-        "importPath": "typing",
-        "description": "typing",
-        "isExtraImport": true,
-        "detail": "typing",
-        "documentation": {}
-    },
-    {
-        "label": "hashlib",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "hashlib",
-        "description": "hashlib",
-        "detail": "hashlib",
-        "documentation": {}
-    },
-    {
-        "label": "sqlite3",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "sqlite3",
-        "description": "sqlite3",
-        "detail": "sqlite3",
-        "documentation": {}
-    },
-    {
-        "label": "requests",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "requests",
-        "description": "requests",
-        "detail": "requests",
-        "documentation": {}
-    },
-    {
-        "label": "multiprocessing",
-        "kind": 6,
-        "isExtraImport": true,
-        "importPath": "multiprocessing",
-        "description": "multiprocessing",
-        "detail": "multiprocessing",
-        "documentation": {}
-    },
-    {
-        "label": "OpenSearch",
-        "importPath": "opensearchpy",
-        "description": "opensearchpy",
-        "isExtraImport": true,
-        "detail": "opensearchpy",
-        "documentation": {}
-    },
-    {
-        "label": "RequestsHttpConnection",
-        "importPath": "opensearchpy",
-        "description": "opensearchpy",
-        "isExtraImport": true,
-        "detail": "opensearchpy",
-        "documentation": {}
-    },
-    {
-        "label": "OpenSearchException",
-        "importPath": "opensearchpy.exceptions",
-        "description": "opensearchpy.exceptions",
-        "isExtraImport": true,
-        "detail": "opensearchpy.exceptions",
-        "documentation": {}
-    },
-    {
-        "label": "setup_logging",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def setup_logging():\n    \"\"\"配置日志系统\"\"\"\n    if not app.debug:\n        # 创建日志目录\n        log_dir = Path('logs')\n        log_dir.mkdir(exist_ok=True)\n        # 文件日志处理器（每个文件最大10MB，保留10个备份）\n        file_handler = RotatingFileHandler(\n            log_dir / 'app.log',\n            maxBytes=10 * 1024 * 1024,",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_client_ip",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_client_ip():\n    \"\"\"\n    获取客户端真实 IP 地址\n    在代理服务器（如 Hugging Face Spaces）后面时，需要检查代理头部\n    \"\"\"\n    # 按优先级检查各种代理头部\n    headers_to_check = [\n        'X-Forwarded-For',\n        'X-Real-IP',\n        'CF-Connecting-IP',  # Cloudflare",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "load_book_data",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def load_book_data():\n    \"\"\"\n    加载书籍数据（已废弃，保留是为了兼容性）\n    现在使用数据库接口，不再加载JSON文件\n    \"\"\"\n    global BOOK_DATA\n    app.logger.info('ℹ️ load_book_data 已废弃，使用数据库接口')\n    # 设置为空字典表示已初始化，但不再使用\n    BOOK_DATA = {}\n    return True",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "init_database",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def init_database():\n    \"\"\"初始化数据库连接\"\"\"\n    global DB\n    try:\n        DB = get_db_instance('books.db')\n        app.logger.info('✅ 数据库连接初始化成功')\n        return True\n    except Exception as e:\n        app.logger.error(f'❌ 数据库初始化失败: {e}')\n        return False",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "index",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def index():\n    \"\"\"主页 - 书籍目录\"\"\"\n    return send_from_directory('.', 'index.html')\n@app.route('/reader')\ndef reader():\n    \"\"\"阅读页面\"\"\"\n    return send_from_directory('.', 'reader.html')\n@app.route('/<path:filename>')\ndef serve_static(filename):\n    \"\"\"提供根目录下的静态文件（如 style.css, script.js）\"\"\"",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "reader",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def reader():\n    \"\"\"阅读页面\"\"\"\n    return send_from_directory('.', 'reader.html')\n@app.route('/<path:filename>')\ndef serve_static(filename):\n    \"\"\"提供根目录下的静态文件（如 style.css, script.js）\"\"\"\n    # 避免与API路由冲突\n    if filename.startswith('api/'):\n        return jsonify({'error': '接口不存在'}), 404\n    return send_from_directory('.', filename)",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "serve_static",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def serve_static(filename):\n    \"\"\"提供根目录下的静态文件（如 style.css, script.js）\"\"\"\n    # 避免与API路由冲突\n    if filename.startswith('api/'):\n        return jsonify({'error': '接口不存在'}), 404\n    return send_from_directory('.', filename)\n# ============================================================================\n# 路由：API 端点\n# ============================================================================\n@app.route('/api/health')",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "health_check",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def health_check():\n    \"\"\"健康检查端点\"\"\"\n    return jsonify({\n        'status': 'healthy',\n        'timestamp': datetime.now().isoformat(),\n        'version': '2.0.0-flask'\n    })\n@app.route('/api/book/info')\ndef get_book_info():\n    \"\"\"",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_book_info",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_book_info():\n    \"\"\"\n    获取书籍信息（旧接口，保留兼容性）\n    推荐使用: /api/v2/books/<book_id>\n    \"\"\"\n    try:\n        if not DB:\n            return jsonify({'error': '数据库未初始化'}), 500\n        # 默认获取第一本书的信息（为了兼容旧版本）\n        books = DB.get_all_books()",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_page_content",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_page_content(page_num):\n    \"\"\"\n    获取指定页面内容（旧接口，保留兼容性）\n    推荐使用: /api/v2/books/<book_id>/pages/<page_num>\n    \"\"\"\n    try:\n        if not DB:\n            return jsonify({'error': '数据库未初始化'}), 500\n        # 获取最后导入的书籍\n        books = DB.get_all_books()",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "save_progress",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def save_progress():\n    \"\"\"保存学习进度\"\"\"\n    try:\n        data = request.get_json()\n        # 这里可以保存到数据库，现在先存到 session\n        if 'progress' not in session:\n            session['progress'] = {}\n        session['progress'].update({\n            'current_page': data.get('current_page', 0),\n            'bookmarks': data.get('bookmarks', []),",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "load_progress",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def load_progress():\n    \"\"\"加载学习进度\"\"\"\n    progress = session.get('progress', {\n        'current_page': 0,\n        'bookmarks': [],\n        'settings': {}\n    })\n    return jsonify(progress)\n@app.route('/api/search', methods=['POST'])\ndef search_content():",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "search_content",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def search_content():\n    \"\"\"搜索内容（未来可集成 OpenSearch）\"\"\"\n    try:\n        data = request.get_json()\n        keyword = data.get('keyword', '').strip()\n        if not keyword:\n            return jsonify({'error': '搜索关键词不能为空'}), 400\n        # 简单搜索实现（在书籍数据中搜索）\n        if not BOOK_DATA:\n            return jsonify({'error': '书籍数据未加载'}), 500",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "opensearch_status",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def opensearch_status():\n    \"\"\"检查 OpenSearch 连接状态（示例）\"\"\"\n    try:\n        # 这里可以实际连接 OpenSearch\n        # from opensearchpy import OpenSearch\n        # client = OpenSearch([{'host': OPENSEARCH_CONFIG['host'], 'port': OPENSEARCH_CONFIG['port']}])\n        # info = client.info()\n        return jsonify({\n            'configured': True,\n            'host': OPENSEARCH_CONFIG['host'],",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_stats",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_stats():\n    \"\"\"获取学习统计数据\"\"\"\n    # 从 session 或数据库获取统计数据\n    progress = session.get('progress', {})\n    return jsonify({\n        'current_page': progress.get('current_page', 0),\n        'total_bookmarks': len(progress.get('bookmarks', [])),\n        'last_visit': progress.get('last_updated', None),\n        'total_pages': len(BOOK_DATA.get('pages', [])) if BOOK_DATA else 0\n    })",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_books",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_books():\n    \"\"\"\n    获取所有书籍列表\n    Query Parameters:\n        grade_id: 年级ID（可选）\n    Returns:\n        {\n            \"success\": true,\n            \"count\": 10,\n            \"books\": [",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_book_info_v2",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_book_info_v2(book_id):\n    \"\"\"\n    获取指定书籍的详细信息\n    Args:\n        book_id: 书籍ID\n    Returns:\n        {\n            \"success\": true,\n            \"book\": {\n                \"book_id\": 1,",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_book_pages",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_book_pages(book_id):\n    \"\"\"\n    获取书籍的所有页面列表（不含片段内容）\n    Args:\n        book_id: 书籍ID\n    Returns:\n        {\n            \"success\": true,\n            \"book_id\": 168,\n            \"book_name\": \"一年级上册\",",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_book_catalog",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_book_catalog(book_id):\n    \"\"\"\n    获取书籍目录结构（章节目录）\n    Args:\n        book_id: 书籍ID\n    Returns:\n        {\n            \"success\": true,\n            \"book_id\": 168,\n            \"book_name\": \"一年级上册\",",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_page_content_v2",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_page_content_v2(book_id, page_num):\n    \"\"\"\n    获取指定页面的完整内容\n    Args:\n        book_id: 书籍ID\n        page_num: 页码\n    Returns:\n        {\n            \"success\": true,\n            \"book_id\": 1,",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "search_book_content",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def search_book_content(book_id):\n    \"\"\"\n    在书籍中搜索内容\n    Query Parameters:\n        keyword: 搜索关键词\n        limit: 返回结果数量（默认20）\n    Returns:\n        {\n            \"success\": true,\n            \"book_id\": 168,",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "search_all_content",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def search_all_content():\n    \"\"\"\n    在所有书籍中搜索内容\n    Query Parameters:\n        keyword: 搜索关键词\n        limit: 返回结果数量（默认50）\n    Returns:\n        {\n            \"success\": true,\n            \"keyword\": \"hello\",",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_book_statistics",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_book_statistics(book_id):\n    \"\"\"\n    获取书籍统计信息\n    Args:\n        book_id: 书籍ID\n    Returns:\n        {\n            \"success\": true,\n            \"statistics\": {\n                \"book_id\": 168,",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "get_overall_statistics",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def get_overall_statistics():\n    \"\"\"\n    获取整体统计信息\n    Returns:\n        {\n            \"success\": true,\n            \"statistics\": {\n                \"total_books\": 30,\n                \"total_pages\": 2000,\n                \"total_pieces\": 50000,",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "not_found",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def not_found(error):\n    \"\"\"404错误处理\"\"\"\n    if request.path.startswith('/api/'):\n        return jsonify({'error': '接口不存在'}), 404\n    return send_from_directory('.', 'index.html')\n@app.errorhandler(500)\ndef internal_error(error):\n    \"\"\"500错误处理\"\"\"\n    app.logger.error(f'服务器错误: {error}')\n    return jsonify({'error': '服务器内部错误'}), 500",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "internal_error",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def internal_error(error):\n    \"\"\"500错误处理\"\"\"\n    app.logger.error(f'服务器错误: {error}')\n    return jsonify({'error': '服务器内部错误'}), 500\n# ============================================================================\n# 请求钩子\n# ============================================================================\n@app.before_request\ndef before_request():\n    \"\"\"请求前处理\"\"\"",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "before_request",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def before_request():\n    \"\"\"请求前处理\"\"\"\n    # 获取客户端真实 IP\n    client_ip = get_client_ip()\n    # 记录所有请求信息（包括静态文件）\n    user_agent = request.headers.get('User-Agent', 'Unknown')[:100]  # 限制长度\n    # API 请求记录详细信息\n    if request.path.startswith('/api/'):\n        app.logger.info(\n            f\"[{client_ip}] {request.method} {request.path} \"",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "after_request",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def after_request(response):\n    \"\"\"请求后处理 - 添加缓存控制\"\"\"\n    # API 端点不缓存\n    if request.path.startswith('/api/'):\n        response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'\n        response.headers['Pragma'] = 'no-cache'\n        response.headers['Expires'] = '0'\n    else:\n        # 静态资源缓存1小时\n        response.headers['Cache-Control'] = 'public, max-age=3600'",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "auto_generate_database",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def auto_generate_database():\n    \"\"\"\n    自动生成数据库\n    如果 books.db 不存在，自动运行导入脚本生成数据库\n    \"\"\"\n    db_path = 'books.db'\n    schema_path = 'db_schema.sql'\n    data_dir = 'books_api_data'\n    # 检查必要的文件和目录\n    if not os.path.exists(schema_path):",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "initialize_app",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def initialize_app():\n    \"\"\"初始化应用\"\"\"\n    print(\"🚀 交互式英语学习应用 - Flask 版本\")\n    print(\"=\" * 60)\n    # 设置日志\n    setup_logging()\n    # 检查必要文件（暂时不检查 books.db，因为会自动生成）\n    if not os.path.exists('index.html'):\n        app.logger.error(f\"❌ 缺少必要文件: index.html\")\n        return False",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "main",
-        "kind": 2,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "def main():\n    \"\"\"主函数\"\"\"\n    # 初始化应用\n    if not initialize_app():\n        print(\"❌ 应用初始化失败\")\n        return 1\n    # Hugging Face Spaces 要求监听 7860 端口\n    port = int(os.environ.get('PORT', 7860))\n    debug = os.environ.get('FLASK_DEBUG', 'False').lower() == 'true'\n    print(f\"🌐 监听端口: {port}\")",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "app",
-        "kind": 5,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "app = Flask(__name__, \n           static_folder='static',\n           static_url_path='/static')\n# 配置\napp.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'dev-secret-key-change-in-production')\napp.config['JSON_AS_ASCII'] = False  # 支持中文JSON\napp.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 最大上传16MB\n# 启用CORS\nCORS(app, resources={\n    r\"/*\": {",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "app.config['SECRET_KEY']",
-        "kind": 5,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'dev-secret-key-change-in-production')\napp.config['JSON_AS_ASCII'] = False  # 支持中文JSON\napp.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 最大上传16MB\n# 启用CORS\nCORS(app, resources={\n    r\"/*\": {\n        \"origins\": \"*\",\n        \"methods\": [\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\"],\n        \"allow_headers\": [\"Content-Type\", \"Authorization\"]\n    }",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "app.config['JSON_AS_ASCII']",
-        "kind": 5,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "app.config['JSON_AS_ASCII'] = False  # 支持中文JSON\napp.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 最大上传16MB\n# 启用CORS\nCORS(app, resources={\n    r\"/*\": {\n        \"origins\": \"*\",\n        \"methods\": [\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\"],\n        \"allow_headers\": [\"Content-Type\", \"Authorization\"]\n    }\n})",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "app.config['MAX_CONTENT_LENGTH']",
-        "kind": 5,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 最大上传16MB\n# 启用CORS\nCORS(app, resources={\n    r\"/*\": {\n        \"origins\": \"*\",\n        \"methods\": [\"GET\", \"POST\", \"PUT\", \"DELETE\", \"OPTIONS\"],\n        \"allow_headers\": [\"Content-Type\", \"Authorization\"]\n    }\n})\n# 配置日志",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "OPENSEARCH_CONFIG",
-        "kind": 5,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "OPENSEARCH_CONFIG = {\n    'host': os.environ.get('OPENSEARCH_HOST', '192.168.3.33'),\n    'port': int(os.environ.get('OPENSEARCH_PORT', 9200)),\n    'use_ssl': os.environ.get('OPENSEARCH_USE_SSL', 'False').lower() == 'true',\n}\n# 全局变量：存储学习数据\nBOOK_DATA = None\n# 数据库实例\nDB = None\ndef get_client_ip():",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "BOOK_DATA",
-        "kind": 5,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "BOOK_DATA = None\n# 数据库实例\nDB = None\ndef get_client_ip():\n    \"\"\"\n    获取客户端真实 IP 地址\n    在代理服务器（如 Hugging Face Spaces）后面时，需要检查代理头部\n    \"\"\"\n    # 按优先级检查各种代理头部\n    headers_to_check = [",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "DB",
-        "kind": 5,
-        "importPath": "app",
-        "description": "app",
-        "peekOfCode": "DB = None\ndef get_client_ip():\n    \"\"\"\n    获取客户端真实 IP 地址\n    在代理服务器（如 Hugging Face Spaces）后面时，需要检查代理头部\n    \"\"\"\n    # 按优先级检查各种代理头部\n    headers_to_check = [\n        'X-Forwarded-For',\n        'X-Real-IP',",
-        "detail": "app",
-        "documentation": {}
-    },
-    {
-        "label": "ResourceManager",
-        "kind": 6,
-        "importPath": "check_and_download",
-        "description": "check_and_download",
-        "peekOfCode": "class ResourceManager:\n    def __init__(self, json_file: str, assets_dir: str):\n        self.json_file = json_file\n        self.assets_dir = Path(assets_dir)\n        self.audio_dir = self.assets_dir / \"audios\"\n        self.image_dir = self.assets_dir / \"images\"\n        # 确保目录存在\n        self.audio_dir.mkdir(parents=True, exist_ok=True)\n        self.image_dir.mkdir(parents=True, exist_ok=True)\n    def load_json_data(self) -> Dict:",
-        "detail": "check_and_download",
-        "documentation": {}
-    },
-    {
-        "label": "main",
-        "kind": 2,
-        "importPath": "check_and_download",
-        "description": "check_and_download",
-        "peekOfCode": "def main():\n    rm = ResourceManager(\"book_10242.json\", \"assets\")\n    print(\"=== 资源完整性检查和下载脚本 ===\")\n    # 检查并找出缺失的文件\n    missing_urls = rm.check_and_find_missing()\n    if not missing_urls[\"audio\"] and not missing_urls[\"image\"]:\n        print(\"\\n所有文件都已正确下载，无需额外操作！\")\n        return\n    # 生成下载脚本\n    script_content = rm.generate_download_script(missing_urls)",
-        "detail": "check_and_download",
-        "documentation": {}
-    },
-    {
-        "label": "Config",
-        "kind": 6,
-        "importPath": "config",
-        "description": "config",
-        "peekOfCode": "class Config:\n    \"\"\"基础配置\"\"\"\n    # Flask 基础配置\n    SECRET_KEY = os.environ.get('SECRET_KEY') or 'dev-secret-key-please-change-in-production'\n    JSON_AS_ASCII = False  # 支持中文JSON\n    MAX_CONTENT_LENGTH = 16 * 1024 * 1024  # 最大上传16MB\n    # 会话配置\n    SESSION_TYPE = 'filesystem'\n    SESSION_PERMANENT = False\n    SESSION_USE_SIGNER = True",
-        "detail": "config",
-        "documentation": {}
-    },
-    {
-        "label": "DevelopmentConfig",
-        "kind": 6,
-        "importPath": "config",
-        "description": "config",
-        "peekOfCode": "class DevelopmentConfig(Config):\n    \"\"\"开发环境配置\"\"\"\n    DEBUG = True\n    TESTING = False\nclass ProductionConfig(Config):\n    \"\"\"生产环境配置\"\"\"\n    DEBUG = False\n    TESTING = False\n    # 生产环境应该从环境变量读取敏感信息\n    # SECRET_KEY 验证在应用启动时进行，而不是在导入时",
-        "detail": "config",
-        "documentation": {}
-    },
-    {
-        "label": "ProductionConfig",
-        "kind": 6,
-        "importPath": "config",
-        "description": "config",
-        "peekOfCode": "class ProductionConfig(Config):\n    \"\"\"生产环境配置\"\"\"\n    DEBUG = False\n    TESTING = False\n    # 生产环境应该从环境变量读取敏感信息\n    # SECRET_KEY 验证在应用启动时进行，而不是在导入时\n    SECRET_KEY = os.environ.get('SECRET_KEY', Config.SECRET_KEY)\nclass TestingConfig(Config):\n    \"\"\"测试环境配置\"\"\"\n    TESTING = True",
-        "detail": "config",
-        "documentation": {}
-    },
-    {
-        "label": "TestingConfig",
-        "kind": 6,
-        "importPath": "config",
-        "description": "config",
-        "peekOfCode": "class TestingConfig(Config):\n    \"\"\"测试环境配置\"\"\"\n    TESTING = True\n    DEBUG = True\n    # 使用内存数据库进行测试\n    # SQLALCHEMY_DATABASE_URI = 'sqlite:///:memory:'\n# 配置字典\nconfig = {\n    'development': DevelopmentConfig,\n    'production': ProductionConfig,",
-        "detail": "config",
-        "documentation": {}
-    },
-    {
-        "label": "config",
-        "kind": 5,
-        "importPath": "config",
-        "description": "config",
-        "peekOfCode": "config = {\n    'development': DevelopmentConfig,\n    'production': ProductionConfig,\n    'testing': TestingConfig,\n    'default': DevelopmentConfig\n}",
-        "detail": "config",
-        "documentation": {}
-    },
-    {
-        "label": "DatabaseManager",
-        "kind": 6,
-        "importPath": "db_manager",
-        "description": "db_manager",
-        "peekOfCode": "class DatabaseManager:\n    \"\"\"数据库管理器类\"\"\"\n    def __init__(self, db_path: str = 'books.db'):\n        \"\"\"\n        初始化数据库管理器\n        Args:\n            db_path: 数据库文件路径\n        \"\"\"\n        self.db_path = db_path\n        self.conn = None",
-        "detail": "db_manager",
-        "documentation": {}
-    },
-    {
-        "label": "get_db_instance",
-        "kind": 2,
-        "importPath": "db_manager",
-        "description": "db_manager",
-        "peekOfCode": "def get_db_instance(db_path: str = 'books.db') -> DatabaseManager:\n    \"\"\"\n    获取数据库管理器单例\n    Args:\n        db_path: 数据库文件路径\n    Returns:\n        DatabaseManager实例\n    \"\"\"\n    global _db_instance\n    if _db_instance is None:",
-        "detail": "db_manager",
-        "documentation": {}
-    },
-    {
-        "label": "close_db",
-        "kind": 2,
-        "importPath": "db_manager",
-        "description": "db_manager",
-        "peekOfCode": "def close_db():\n    \"\"\"关闭全局数据库连接\"\"\"\n    global _db_instance\n    if _db_instance:\n        _db_instance.close()\n        _db_instance = None",
-        "detail": "db_manager",
-        "documentation": {}
-    },
-    {
-        "label": "logger",
-        "kind": 5,
-        "importPath": "db_manager",
-        "description": "db_manager",
-        "peekOfCode": "logger = logging.getLogger(__name__)\nclass DatabaseManager:\n    \"\"\"数据库管理器类\"\"\"\n    def __init__(self, db_path: str = 'books.db'):\n        \"\"\"\n        初始化数据库管理器\n        Args:\n            db_path: 数据库文件路径\n        \"\"\"\n        self.db_path = db_path",
-        "detail": "db_manager",
-        "documentation": {}
-    },
-    {
-        "label": "_db_instance",
-        "kind": 5,
-        "importPath": "db_manager",
-        "description": "db_manager",
-        "peekOfCode": "_db_instance = None\ndef get_db_instance(db_path: str = 'books.db') -> DatabaseManager:\n    \"\"\"\n    获取数据库管理器单例\n    Args:\n        db_path: 数据库文件路径\n    Returns:\n        DatabaseManager实例\n    \"\"\"\n    global _db_instance",
-        "detail": "db_manager",
-        "documentation": {}
-    },
-    {
-        "label": "main",
-        "kind": 2,
-        "importPath": "debug_pages",
-        "description": "debug_pages",
-        "peekOfCode": "def main():\n    \"\"\"检查第4页和第5页的数据\"\"\"\n    try:\n        with open('book_10242.json', 'r', encoding='utf-8') as f:\n            data = json.load(f)\n        # 解析Data字段中的JSON字符串\n        pages_data = json.loads(data['Data'])\n        print(f\"总页数: {len(pages_data)}\")\n        print(\"=\" * 80)\n        # 检查第4页和第5页（数组索引为3和4）",
-        "detail": "debug_pages",
-        "documentation": {}
-    },
-    {
-        "label": "extract_filename_from_url",
-        "kind": 2,
-        "importPath": "delete_encrypted_files",
-        "description": "delete_encrypted_files",
-        "peekOfCode": "def extract_filename_from_url(url):\n    \"\"\"从URL中提取文件名\"\"\"\n    if not url:\n        return None\n    # 解析URL，去掉查询参数\n    parsed = urlparse(url)\n    path = parsed.path\n    # URL解码\n    path = unquote(path)\n    # 提取文件名",
-        "detail": "delete_encrypted_files",
-        "documentation": {}
-    },
-    {
-        "label": "main",
-        "kind": 2,
-        "importPath": "delete_encrypted_files",
-        "description": "delete_encrypted_files",
-        "peekOfCode": "def main():\n    json_file = '/data/zhangl/code/hf/point/book_10242.json'\n    audio_dir = '/data/zhangl/code/hf/point/assets/audios'\n    image_dir = '/data/zhangl/code/hf/point/assets/images'\n    print(\"正在解析 JSON 文件...\")\n    try:\n        with open(json_file, 'r', encoding='utf-8') as f:\n            data = json.load(f)\n        # 解析Data字段中的JSON字符串\n        pages_data = json.loads(data['Data'])",
-        "detail": "delete_encrypted_files",
-        "documentation": {}
-    },
-    {
-        "label": "create_directories",
-        "kind": 2,
-        "importPath": "download_resources",
-        "description": "download_resources",
-        "peekOfCode": "def create_directories():\n    \"\"\"创建assets目录结构\"\"\"\n    assets_dir = Path(\"assets\")\n    images_dir = assets_dir / \"images\"\n    audios_dir = assets_dir / \"audios\"\n    images_dir.mkdir(parents=True, exist_ok=True)\n    audios_dir.mkdir(parents=True, exist_ok=True)\n    print(f\"✅ 创建目录: {images_dir}\")\n    print(f\"✅ 创建目录: {audios_dir}\")\n    return images_dir, audios_dir",
-        "detail": "download_resources",
-        "documentation": {}
-    },
-    {
-        "label": "get_filename_from_url",
-        "kind": 2,
-        "importPath": "download_resources",
-        "description": "download_resources",
-        "peekOfCode": "def get_filename_from_url(url):\n    \"\"\"从URL中提取文件名\"\"\"\n    # 解析URL并获取路径部分\n    parsed_url = urllib.parse.urlparse(url)\n    path = parsed_url.path\n    # 获取文件名\n    filename = os.path.basename(path)\n    # 如果没有文件名，使用URL的hash作为文件名\n    if not filename or '.' not in filename:\n        url_hash = hashlib.md5(url.encode()).hexdigest()[:8]",
-        "detail": "download_resources",
-        "documentation": {}
-    },
-    {
-        "label": "download_file",
-        "kind": 2,
-        "importPath": "download_resources",
-        "description": "download_resources",
-        "peekOfCode": "def download_file(url, save_path, max_retries=3):\n    \"\"\"下载文件\"\"\"\n    headers = {\n        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'\n    }\n    for attempt in range(max_retries):\n        try:\n            print(f\"📥 下载中: {os.path.basename(save_path)}\")\n            response = requests.get(url, headers=headers, timeout=30)\n            response.raise_for_status()",
-        "detail": "download_resources",
-        "documentation": {}
-    },
-    {
-        "label": "extract_urls_from_json",
-        "kind": 2,
-        "importPath": "download_resources",
-        "description": "download_resources",
-        "peekOfCode": "def extract_urls_from_json(json_file):\n    \"\"\"从JSON文件中提取所有图片和音频URL\"\"\"\n    with open(json_file, 'r', encoding='utf-8') as f:\n        data = json.load(f)\n    urls = {\n        'images': set(),\n        'audios': set()\n    }\n    # 解析Data字段中的JSON字符串\n    if 'Data' in data:",
-        "detail": "download_resources",
-        "documentation": {}
-    },
-    {
-        "label": "main",
-        "kind": 2,
-        "importPath": "download_resources",
-        "description": "download_resources",
-        "peekOfCode": "def main():\n    \"\"\"主函数\"\"\"\n    print(\"🚀 开始下载资源...\")\n    # 创建目录\n    images_dir, audios_dir = create_directories()\n    # 提取URL\n    print(\"📋 解析JSON文件...\")\n    urls = extract_urls_from_json('book_10242.json')\n    print(f\"📊 找到 {len(urls['images'])} 个图片URL\")\n    print(f\"📊 找到 {len(urls['audios'])} 个音频URL\")",
-        "detail": "download_resources",
-        "documentation": {}
-    },
-    {
-        "label": "extract_data_field",
-        "kind": 2,
-        "importPath": "extract_data",
-        "description": "extract_data",
-        "peekOfCode": "def extract_data_field(input_file, output_file):\n    \"\"\"\n    从输入文件中提取Data字段并保存到输出文件\n    Args:\n        input_file: 输入JSON文件路径\n        output_file: 输出JSON文件路径\n    \"\"\"\n    try:\n        # 读取输入文件\n        print(f\"正在读取文件: {input_file}\")",
-        "detail": "extract_data",
-        "documentation": {}
-    },
-    {
-        "label": "on_starting",
-        "kind": 2,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "def on_starting(server):\n    \"\"\"服务器启动时执行\"\"\"\n    print(\"=\" * 60)\n    print(\"🚀 Gunicorn 服务器启动\")\n    print(f\"📍 绑定地址: {bind}\")\n    print(f\"👷 工作进程数: {workers}\")\n    print(f\"🧵 每进程线程数: {threads}\")\n    print(f\"⏱️  超时时间: {timeout}s\")\n    print(\"=\" * 60)\ndef worker_int(worker):",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "worker_int",
-        "kind": 2,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "def worker_int(worker):\n    \"\"\"工作进程被中断时执行\"\"\"\n    print(f\"⚠️  工作进程 {worker.pid} 被中断\")\ndef worker_abort(worker):\n    \"\"\"工作进程异常退出时执行\"\"\"\n    print(f\"❌ 工作进程 {worker.pid} 异常退出\")\ndef post_worker_init(worker):\n    \"\"\"工作进程初始化后执行\"\"\"\n    print(f\"✅ 工作进程 {worker.pid} 初始化完成\")",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "worker_abort",
-        "kind": 2,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "def worker_abort(worker):\n    \"\"\"工作进程异常退出时执行\"\"\"\n    print(f\"❌ 工作进程 {worker.pid} 异常退出\")\ndef post_worker_init(worker):\n    \"\"\"工作进程初始化后执行\"\"\"\n    print(f\"✅ 工作进程 {worker.pid} 初始化完成\")",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "post_worker_init",
-        "kind": 2,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "def post_worker_init(worker):\n    \"\"\"工作进程初始化后执行\"\"\"\n    print(f\"✅ 工作进程 {worker.pid} 初始化完成\")",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "bind",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "bind = f\"0.0.0.0:{os.environ.get('PORT', 7860)}\"\n# 工作进程数（根据 CPU 核心数自动调整）\nworkers = int(os.environ.get('GUNICORN_WORKERS', multiprocessing.cpu_count() * 2 + 1))\n# 如果资源受限，可以手动设置较小的值\nworkers = min(workers, 4)\n# 工作进程类型\nworker_class = 'sync'\n# 每个工作进程的线程数\nthreads = 2\n# 超时时间（秒）",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "workers",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "workers = int(os.environ.get('GUNICORN_WORKERS', multiprocessing.cpu_count() * 2 + 1))\n# 如果资源受限，可以手动设置较小的值\nworkers = min(workers, 4)\n# 工作进程类型\nworker_class = 'sync'\n# 每个工作进程的线程数\nthreads = 2\n# 超时时间（秒）\ntimeout = 120\n# 保持活动连接的时间",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "workers",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "workers = min(workers, 4)\n# 工作进程类型\nworker_class = 'sync'\n# 每个工作进程的线程数\nthreads = 2\n# 超时时间（秒）\ntimeout = 120\n# 保持活动连接的时间\nkeepalive = 5\n# 最大请求数（处理后重启进程，防止内存泄漏）",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "worker_class",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "worker_class = 'sync'\n# 每个工作进程的线程数\nthreads = 2\n# 超时时间（秒）\ntimeout = 120\n# 保持活动连接的时间\nkeepalive = 5\n# 最大请求数（处理后重启进程，防止内存泄漏）\nmax_requests = 1000\nmax_requests_jitter = 50",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "threads",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "threads = 2\n# 超时时间（秒）\ntimeout = 120\n# 保持活动连接的时间\nkeepalive = 5\n# 最大请求数（处理后重启进程，防止内存泄漏）\nmax_requests = 1000\nmax_requests_jitter = 50\n# 日志配置\naccesslog = '-'  # 输出到 stdout",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "timeout",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "timeout = 120\n# 保持活动连接的时间\nkeepalive = 5\n# 最大请求数（处理后重启进程，防止内存泄漏）\nmax_requests = 1000\nmax_requests_jitter = 50\n# 日志配置\naccesslog = '-'  # 输出到 stdout\nerrorlog = '-'   # 输出到 stderr\nloglevel = 'info'",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "keepalive",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "keepalive = 5\n# 最大请求数（处理后重启进程，防止内存泄漏）\nmax_requests = 1000\nmax_requests_jitter = 50\n# 日志配置\naccesslog = '-'  # 输出到 stdout\nerrorlog = '-'   # 输出到 stderr\nloglevel = 'info'\n# 自定义访问日志格式 - 包含真实客户端 IP\n# %(h)s - 远程地址",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "max_requests",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "max_requests = 1000\nmax_requests_jitter = 50\n# 日志配置\naccesslog = '-'  # 输出到 stdout\nerrorlog = '-'   # 输出到 stderr\nloglevel = 'info'\n# 自定义访问日志格式 - 包含真实客户端 IP\n# %(h)s - 远程地址\n# %({X-Forwarded-For}i)s - X-Forwarded-For 头部（代理后面的真实 IP）\n# %(t)s - 时间",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "max_requests_jitter",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "max_requests_jitter = 50\n# 日志配置\naccesslog = '-'  # 输出到 stdout\nerrorlog = '-'   # 输出到 stderr\nloglevel = 'info'\n# 自定义访问日志格式 - 包含真实客户端 IP\n# %(h)s - 远程地址\n# %({X-Forwarded-For}i)s - X-Forwarded-For 头部（代理后面的真实 IP）\n# %(t)s - 时间\n# %(m)s - 请求方法",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "accesslog",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "accesslog = '-'  # 输出到 stdout\nerrorlog = '-'   # 输出到 stderr\nloglevel = 'info'\n# 自定义访问日志格式 - 包含真实客户端 IP\n# %(h)s - 远程地址\n# %({X-Forwarded-For}i)s - X-Forwarded-For 头部（代理后面的真实 IP）\n# %(t)s - 时间\n# %(m)s - 请求方法\n# %(U)s - URL 路径\n# %(q)s - 查询字符串",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "errorlog",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "errorlog = '-'   # 输出到 stderr\nloglevel = 'info'\n# 自定义访问日志格式 - 包含真实客户端 IP\n# %(h)s - 远程地址\n# %({X-Forwarded-For}i)s - X-Forwarded-For 头部（代理后面的真实 IP）\n# %(t)s - 时间\n# %(m)s - 请求方法\n# %(U)s - URL 路径\n# %(q)s - 查询字符串\n# %(s)s - 状态码",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "loglevel",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "loglevel = 'info'\n# 自定义访问日志格式 - 包含真实客户端 IP\n# %(h)s - 远程地址\n# %({X-Forwarded-For}i)s - X-Forwarded-For 头部（代理后面的真实 IP）\n# %(t)s - 时间\n# %(m)s - 请求方法\n# %(U)s - URL 路径\n# %(q)s - 查询字符串\n# %(s)s - 状态码\n# %(b)s - 响应大小",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "access_log_format",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "access_log_format = (\n    '[%(t)s] '\n    'Client: %({X-Forwarded-For}i)s (Remote: %(h)s) '\n    '%(m)s %(U)s%(q)s '\n    'Status: %(s)s '\n    'Size: %(b)s bytes '\n    'Time: %(D)s μs '\n    'UA: \"%({User-Agent}i)s\"'\n)\n# 进程名称前缀",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "proc_name",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "proc_name = 'english_learning_app'\n# 守护进程（通常设为 False，让容器管理进程）\ndaemon = False\n# 预加载应用（减少内存占用）\npreload_app = True\n# 在请求处理前后执行的钩子\ndef on_starting(server):\n    \"\"\"服务器启动时执行\"\"\"\n    print(\"=\" * 60)\n    print(\"🚀 Gunicorn 服务器启动\")",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "daemon",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "daemon = False\n# 预加载应用（减少内存占用）\npreload_app = True\n# 在请求处理前后执行的钩子\ndef on_starting(server):\n    \"\"\"服务器启动时执行\"\"\"\n    print(\"=\" * 60)\n    print(\"🚀 Gunicorn 服务器启动\")\n    print(f\"📍 绑定地址: {bind}\")\n    print(f\"👷 工作进程数: {workers}\")",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "preload_app",
-        "kind": 5,
-        "importPath": "gunicorn_config",
-        "description": "gunicorn_config",
-        "peekOfCode": "preload_app = True\n# 在请求处理前后执行的钩子\ndef on_starting(server):\n    \"\"\"服务器启动时执行\"\"\"\n    print(\"=\" * 60)\n    print(\"🚀 Gunicorn 服务器启动\")\n    print(f\"📍 绑定地址: {bind}\")\n    print(f\"👷 工作进程数: {workers}\")\n    print(f\"🧵 每进程线程数: {threads}\")\n    print(f\"⏱️  超时时间: {timeout}s\")",
-        "detail": "gunicorn_config",
-        "documentation": {}
-    },
-    {
-        "label": "create_database",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def create_database(db_path='books.db', schema_path='db_schema.sql'):\n    \"\"\"\n    创建数据库和表结构\n    Args:\n        db_path: 数据库文件路径\n        schema_path: Schema SQL文件路径\n    Returns:\n        sqlite3.Connection: 数据库连接对象\n    \"\"\"\n    logger.info(f\"📦 创建数据库: {db_path}\")",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "import_book_info",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def import_book_info(conn, book_dir: Path) -> int:\n    \"\"\"\n    导入书籍基本信息\n    Args:\n        conn: 数据库连接\n        book_dir: 书籍目录\n    Returns:\n        int: 书籍ID\n    \"\"\"\n    book_info_file = book_dir / \"book_info.json\"",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "import_pages",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def import_pages(conn, book_dir: Path, book_id: int):\n    \"\"\"\n    导入页面数据\n    Args:\n        conn: 数据库连接\n        book_dir: 书籍目录\n        book_id: 书籍ID\n    \"\"\"\n    pages_file = book_dir / \"pages.json\"\n    if not pages_file.exists():",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "generate_catalog_from_pages",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def generate_catalog_from_pages(book_dir: Path, book_id: int, pages_data: list) -> list:\n    \"\"\"\n    从pages.json自动生成目录结构\n    为每一页生成一个目录项，使用该页第一个piece的文本作为标题\n    Args:\n        book_dir: 书籍目录\n        book_id: 书籍ID\n        pages_data: 页面数据列表\n    Returns:\n        生成的目录列表",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "import_catalog",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def import_catalog(conn, book_dir: Path, book_id: int, pages_data: list = None):\n    \"\"\"\n    导入目录数据（强制从pages.json生成）\n    Args:\n        conn: 数据库连接\n        book_dir: 书籍目录\n        book_id: 书籍ID\n        pages_data: 页面数据（用于自动生成目录）\n    \"\"\"\n    catalogs = []",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "import_book",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def import_book(conn, book_dir: Path):\n    \"\"\"\n    导入单本书籍的完整数据\n    Args:\n        conn: 数据库连接\n        book_dir: 书籍目录\n    \"\"\"\n    book_name = book_dir.name\n    logger.info(f\"\\n{'=' * 60}\")\n    logger.info(f\"开始导入书籍: {book_name}\")",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "import_all_books",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def import_all_books(conn, data_dir: str):\n    \"\"\"\n    导入所有书籍\n    Args:\n        conn: 数据库连接\n        data_dir: books_api_data 目录路径\n    \"\"\"\n    logger.info(\"=\" * 60)\n    logger.info(\"开始批量导入书籍数据\")\n    logger.info(f\"数据目录: {data_dir}\")",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "verify_data",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def verify_data(conn):\n    \"\"\"\n    验证导入的数据\n    Args:\n        conn: 数据库连接\n    \"\"\"\n    logger.info(\"\\n🔍 验证数据...\")\n    cursor = conn.cursor()\n    # 统计数据\n    cursor.execute('SELECT COUNT(*) FROM books')",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "main",
-        "kind": 2,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "def main():\n    \"\"\"主函数\"\"\"\n    import argparse\n    print(\"=\" * 80)\n    print(\"📚 Books API Data 导入工具\")\n    print(\"=\" * 80)\n    # 命令行参数解析\n    parser = argparse.ArgumentParser(description='导入 books_api_data 数据到 SQLite 数据库')\n    parser.add_argument('data_dir', nargs='?', default='books_api_data',\n                      help='books_api_data 数据目录路径 (默认: books_api_data)')",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "logger",
-        "kind": 5,
-        "importPath": "import_book_data",
-        "description": "import_book_data",
-        "peekOfCode": "logger = logging.getLogger(__name__)\ndef create_database(db_path='books.db', schema_path='db_schema.sql'):\n    \"\"\"\n    创建数据库和表结构\n    Args:\n        db_path: 数据库文件路径\n        schema_path: Schema SQL文件路径\n    Returns:\n        sqlite3.Connection: 数据库连接对象\n    \"\"\"",
-        "detail": "import_book_data",
-        "documentation": {}
-    },
-    {
-        "label": "OpenSearchClient",
-        "kind": 6,
-        "importPath": "opensearch_client",
-        "description": "opensearch_client",
-        "peekOfCode": "class OpenSearchClient:\n    \"\"\"OpenSearch 客户端封装类\"\"\"\n    def __init__(self, host='192.168.3.33', port=9200, use_ssl=False, verify_certs=False):\n        \"\"\"\n        初始化 OpenSearch 客户端\n        Args:\n            host: OpenSearch 主机地址\n            port: OpenSearch 端口\n            use_ssl: 是否使用 SSL\n            verify_certs: 是否验证证书",
-        "detail": "opensearch_client",
-        "documentation": {}
-    },
-    {
-        "label": "initialize_learning_index",
-        "kind": 2,
-        "importPath": "opensearch_client",
-        "description": "opensearch_client",
-        "peekOfCode": "def initialize_learning_index(client, index_name='english_learning_content'):\n    \"\"\"\n    初始化英语学习内容索引\n    索引包含：单词、例句、页面内容等\n    \"\"\"\n    # 定义索引映射\n    mappings = {\n        'properties': {\n            'type': {'type': 'keyword'},  # 内容类型：word, sentence, page\n            'page_num': {'type': 'integer'},  # 页码",
-        "detail": "opensearch_client",
-        "documentation": {}
-    },
-    {
-        "label": "search_english_content",
-        "kind": 2,
-        "importPath": "opensearch_client",
-        "description": "opensearch_client",
-        "peekOfCode": "def search_english_content(client, keyword, index_name='english_learning_content'):\n    \"\"\"\n    搜索英语学习内容\n    Args:\n        client: OpenSearchClient 实例\n        keyword: 搜索关键词\n        index_name: 索引名��\n    Returns:\n        搜索结果列表\n    \"\"\"",
-        "detail": "opensearch_client",
-        "documentation": {}
-    },
-    {
-        "label": "logger",
-        "kind": 5,
-        "importPath": "opensearch_client",
-        "description": "opensearch_client",
-        "peekOfCode": "logger = logging.getLogger(__name__)\nclass OpenSearchClient:\n    \"\"\"OpenSearch 客户端封装类\"\"\"\n    def __init__(self, host='192.168.3.33', port=9200, use_ssl=False, verify_certs=False):\n        \"\"\"\n        初始化 OpenSearch 客户端\n        Args:\n            host: OpenSearch 主机地址\n            port: OpenSearch 端口\n            use_ssl: 是否使用 SSL",
-        "detail": "opensearch_client",
-        "documentation": {}
-    },
-    {
-        "label": "main",
-        "kind": 2,
-        "importPath": "quick_check",
-        "description": "quick_check",
-        "peekOfCode": "def main():\n    with open('book_10242.json', 'r', encoding='utf-8') as f:\n        data = json.load(f)\n    pages_data = json.loads(data['Data'])\n    # 检查第4页（索引3）和第5页（索引4）\n    for i in [3, 4]:\n        if i < len(pages_data):\n            page = pages_data[i]\n            print(f\"=== 第{page['pageNumber']}页 ===\")\n            print(f\"pageId: {page['pageId']}\")",
-        "detail": "quick_check",
-        "documentation": {}
-    },
-    {
-        "label": "test_ip_logging",
-        "kind": 2,
-        "importPath": "test_ip_logging",
-        "description": "test_ip_logging",
-        "peekOfCode": "def test_ip_logging():\n    \"\"\"测试 IP 地址记录\"\"\"\n    base_url = \"http://localhost:7860\"\n    print(\"=\" * 60)\n    print(\"🧪 测试客户端 IP 记录功能\")\n    print(\"=\" * 60)\n    # 测试场景\n    test_cases = [\n        {\n            \"name\": \"正常请求（无代理）\",",
-        "detail": "test_ip_logging",
-        "documentation": {}
-    },
-    {
-        "label": "show_example_logs",
-        "kind": 2,
-        "importPath": "test_ip_logging",
-        "description": "test_ip_logging",
-        "peekOfCode": "def show_example_logs():\n    \"\"\"显示日志示例\"\"\"\n    print(\"\\n\" + \"=\" * 60)\n    print(\"📝 日志输出示例\")\n    print(\"=\" * 60)\n    examples = [\n        \"[2025-10-16 18:58:23] INFO in app: [203.0.113.1] GET /api/health | UA: Mozilla/5.0 (Windows NT 10.0)\",\n        \"[2025-10-16 18:58:24] INFO in app: [198.51.100.1] POST /api/search | UA: Mozilla/5.0 (iPhone; CPU iPhone OS)\",\n        \"[2025-10-16 18:58:25] INFO in app: [192.0.2.1] GET /api/book/info | UA: curl/7.68.0\",\n    ]",
-        "detail": "test_ip_logging",
-        "documentation": {}
-    },
-    {
-        "label": "print_status",
-        "kind": 2,
-        "importPath": "test_setup",
-        "description": "test_setup",
-        "peekOfCode": "def print_status(message, status):\n    \"\"\"打印状态信息\"\"\"\n    if status:\n        print(f\"✅ {message}\")\n    else:\n        print(f\"❌ {message}\")\n    return status\ndef check_python_version():\n    \"\"\"检查Python版本\"\"\"\n    version = sys.version_info",
-        "detail": "test_setup",
-        "documentation": {}
-    },
-    {
-        "label": "check_python_version",
-        "kind": 2,
-        "importPath": "test_setup",
-        "description": "test_setup",
-        "peekOfCode": "def check_python_version():\n    \"\"\"检查Python版本\"\"\"\n    version = sys.version_info\n    is_ok = version.major == 3 and version.minor >= 12\n    print_status(\n        f\"Python版本: {version.major}.{version.minor}.{version.micro} {'(需要 3.12+)' if not is_ok else ''}\",\n        is_ok\n    )\n    return is_ok\ndef check_dependencies():",
-        "detail": "test_setup",
-        "documentation": {}
-    },
-    {
-        "label": "check_dependencies",
-        "kind": 2,
-        "importPath": "test_setup",
-        "description": "test_setup",
-        "peekOfCode": "def check_dependencies():\n    \"\"\"检查Python依赖\"\"\"\n    dependencies = ['flask', 'flask_cors']\n    all_ok = True\n    for dep in dependencies:\n        try:\n            __import__(dep)\n            print_status(f\"Python包 '{dep}' 已安装\", True)\n        except ImportError:\n            print_status(f\"Python包 '{dep}' 未安装\", False)",
-        "detail": "test_setup",
-        "documentation": {}
-    },
-    {
-        "label": "check_files",
-        "kind": 2,
-        "importPath": "test_setup",
-        "description": "test_setup",
-        "peekOfCode": "def check_files():\n    \"\"\"检查必要文件\"\"\"\n    files = [\n        'app.py',\n        'db_manager.py',\n        'import_book_data.py',\n        'db_schema.sql',\n        'index.html',\n        'reader.html',\n        'static/js/catalog.js',",
-        "detail": "test_setup",
-        "documentation": {}
-    },
-    {
-        "label": "check_data_directory",
-        "kind": 2,
-        "importPath": "test_setup",
-        "description": "test_setup",
-        "peekOfCode": "def check_data_directory():\n    \"\"\"检查数据目录\"\"\"\n    data_dir = Path('books_api_data')\n    if not data_dir.exists():\n        print_status(\"数据目录 'books_api_data' 不存在\", False)\n        print(\"   提示: 请将 books_api_data 目录放置在项目根目录下\")\n        return False\n    # 检查是否有书籍数据\n    book_dirs = [d for d in data_dir.iterdir() if d.is_dir()]\n    if len(book_dirs) == 0:",
-        "detail": "test_setup",
-        "documentation": {}
-    },
-    {
-        "label": "check_database",
-        "kind": 2,
-        "importPath": "test_setup",
-        "description": "test_setup",
-        "peekOfCode": "def check_database():\n    \"\"\"检查数据库\"\"\"\n    db_file = Path('books.db')\n    if not db_file.exists():\n        print_status(\"数据库 'books.db' 不存在\", False)\n        print(\"   提示: 运行 'python3 import_book_data.py books_api_data' 来导入数据\")\n        return False\n    print_status(\"数据库 'books.db' 存在\", True)\n    # 检查数据库内容\n    try:",
-        "detail": "test_setup",
-        "documentation": {}
-    },
-    {
-        "label": "main",
-        "kind": 2,
-        "importPath": "test_setup",
-        "description": "test_setup",
-        "peekOfCode": "def main():\n    \"\"\"主函数\"\"\"\n    print(\"=\" * 70)\n    print(\"🔍 交互式英语学习平台 - 系统设置检查\")\n    print(\"=\" * 70)\n    print()\n    checks = [\n        (\"Python版本\", check_python_version),\n        (\"Python依赖\", check_dependencies),\n        (\"必要文件\", check_files),",
-        "detail": "test_setup",
-        "documentation": {}
-    }
-]

Dockerfile

@@ -1,42 +0,0 @@
-FROM python:3.12-slim
-
-# 设置工作目录
-WORKDIR /app
-
-# 设置环境变量
-ENV PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    PORT=7860 \
-    FLASK_ENV=production
-
-# 安装系统依赖（如需要）
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# 复制requirements文件
-COPY requirements.txt .
-
-# 安装Python依赖
-RUN pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
-
-# 复制应用文件
-COPY . .
-
-# 创建日志目录并设置权限
-RUN mkdir -p logs && chmod 777 logs
-
-# 暴露7860端口（Hugging Face Spaces要求）
-EXPOSE 7860
-
-# 健康检查
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-    CMD curl -f http://localhost:7860/api/health || exit 1
-
-# 使用 Gunicorn 启动 Flask 应用（生产环境推荐）
-# 使用配置文件以显示客户端真实 IP
-CMD ["gunicorn", "-c", "gunicorn_config.py", "app:app"]
-
-# 如果想使用 Flask 内置服务器（开发/测试用），使用下面这行：
-# CMD ["python3.12", "app.py"]

README.md

@@ -1,332 +1,10 @@
 ---
-title: 交互式学习平台
-emoji: 📚
-colorFrom: blue
-colorTo: purple
+title: Point
+emoji: 🐢
+colorFrom: indigo
+colorTo: blue
 sdk: docker
-app_port: 7860
 pinned: false
 ---
 
-# 交互式英语学习平台
-
-基于 data 数据结构的交互式英语学习应用，支持点读、音频播放、翻译显示等功能。
-
-## 📋 功能特性
-
-### 书籍目录页面
-- 📚 显示所有可用教材
-- 🔍 搜索教材名称和分类
-- 📊 显示统计信息（教材数、页面数、内容片段数等）
-- 🎨 精美的卡片式布局
-
-### 阅读页面
-- 📖 交互式点读功能
-- 🔊 音频播放控制
-- 🌐 中英文翻译切换
-- 📑 章节目录导航
-- 🔖 书签功能
-- 🔍 全文搜索
-- ⚙️ 个性化设置（播放速度、自动翻译等）
-- ⌨️ 键盘快捷键支持
-
-## 🚀 快速开始
-
-### 1. 环境要求
-
-- Python 3.12
-- SQLite 3
-- 现代浏览器（Chrome、Firefox、Safari、Edge）
-
-### 2. 安装依赖
-
-```bash
-pip install flask flask-cors
-```
-
-### 3. 准备数据
-
-将 `data` 目录放置在项目根目录下：
-
-```
-/data/zhangl/code/hf/point/
-├── data/          # 教材数据目录
-│   ├── 168_一年级上册/
-│   │   ├── book_info.json
-│   │   ├── pages.json
-│   │   ├── catalog.json
-│   │   ├── images/
-│   │   └── audios/
-│   ├── 169_二年级上册/
-│   └── ...
-├── app.py
-├── import_book_data.py
-└── ...
-```
-
-### 4. 导入数据到数据库
-
-```bash
-# 首次导入（会自动创建数据库）
-python3 import_book_data.py data
-
-# 重新导入所有数据（删除现有数据库）
-python3 import_book_data.py data --recreate
-
-# 仅验证数据
-python3 import_book_data.py --verify-only
-```
-
-导入选项：
-- `data_dir`: 数据目录路径（默认：data）
-- `--db`: 数据库文件路径（默认：books.db）
-- `--schema`: Schema 文件路径（默认：db_schema.sql）
-- `--recreate`: 删除现有数据库并重新创建
-- `--verify-only`: 仅验证数据，不导入
-
-### 5. 启动应用
-
-```bash
-python3 app.py
-```
-
-应用将在 `http://0.0.0.0:7860` 启动。
-
-访问地址：
-- 书籍目录：`http://localhost:7860/`
-- 阅读页面：`http://localhost:7860/reader?book_id=168`
-
-## 📁 项目结构
-
-```
-/data/zhangl/code/hf/point/
-├── data/          # 教材数据目录
-├── static/
-│   ├── css/
-│   │   ├── style.css        # 主样式文件
-│   │   ├── inter.css        # Inter 字体
-│   │   └── all.min.css      # Font Awesome 图标
-│   └── js/
-│       ├── catalog.js       # 书籍目录页面逻辑
-│       └── reader.js        # 阅读页面逻辑
-├── app.py                   # Flask 应用主文件
-├── db_manager.py            # 数据库管理器
-├── import_book_data.py      # 数据导入脚本
-├── db_schema.sql            # 数据库结构定义
-├── index.html               # 书籍目录页面
-├── reader.html              # 阅读页面
-├── books.db                 # SQLite 数据库（自动生成）
-└── README.md
-```
-
-## 🗄️ 数据库结构
-
-### books 表
-存储书籍的基本信息：
-- `market_book_id`: 书籍ID（主键）
-- `market_book_name`: 书籍名称
-- `market_book_cover`: 封面图片路径
-- `max_page`: 最大页码
-- `grade_id`: 年级ID
-- `reel_id`: 学期ID（1=上册，2=下册）
-- 等等...
-
-### pages 表
-存储页面信息：
-- `page_id`: 页面ID（主键）
-- `book_id`: 所属书籍ID
-- `page_number`: 页码
-- `origin_img_url`: 原始图片路径
-- `encrypt_img_url`: 加密图片路径
-
-### pieces 表
-存储页面内容片段：
-- `piece_id`: 片段ID（主键）
-- `page_id`: 所属页面ID
-- `original`: 原文（英文）
-- `translation`: 译文（中文）
-- `origin_sound_url`: 音频路径
-- `duration`: 音频时长
-- `coordinate_x/y/width/height`: 坐标信息
-- 等等...
-
-### catalogs 表
-存储书籍目录结构：
-- `catalog_id`: 目录项ID（主键）
-- `book_id`: 所属书籍ID
-- `catalog_name`: 目录名称（英文）
-- `catalog_name_cn`: 目录名称（中文）
-- `start_page/end_page`: 起止页码
-- `parent_id`: 父级目录ID（支持树形结构）
-
-### pieces_fts 表
-全文搜索索引（FTS5）：
-- 支持在 `original` 和 `translation` 字段中快速搜索
-
-## 🔌 API 接口
-
-### 书籍相关
-
-#### 获取所有书籍列表
-```
-GET /api/v2/books?grade_id=40
-```
-
-#### 获取书籍详情
-```
-GET /api/v2/books/{book_id}
-```
-
-#### 获取书籍页面列表
-```
-GET /api/v2/books/{book_id}/pages
-```
-
-#### 获取书籍目录结构
-```
-GET /api/v2/books/{book_id}/catalog
-```
-
-#### 获取页面内容
-```
-GET /api/v2/books/{book_id}/pages/{page_number}
-```
-
-### 搜索相关
-
-#### 在书籍中搜索
-```
-GET /api/v2/books/{book_id}/search?keyword=hello&limit=20
-```
-
-#### 全局搜索
-```
-GET /api/v2/search?keyword=hello&limit=50
-```
-
-### 统计相关
-
-#### 获取书籍统计信息
-```
-GET /api/v2/books/{book_id}/statistics
-```
-
-#### 获取整体统计信息
-```
-GET /api/v2/statistics
-```
-
-## ⌨️ 键盘快捷键
-
-在阅读页面中：
-- `←` / `→`: 上一页 / 下一页
-- `Space`: 播放/暂停音频
-- `T`: 切换翻译显示
-- `I`: 切换交互区域显示
-- `Esc`: 关闭弹出面板
-
-## 🎨 功能亮点
-
-1. **按需加载**: 页面内容按需加载，提高性能
-2. **全文搜索**: 使用 SQLite FTS5 实现高效全文搜索
-3. **响应式设计**: 自适应不同屏幕尺寸
-4. **交互式点读**: 点击文本片段播放对应音频
-5. **坐标系统**: 使用相对坐标，适配不同分辨率
-6. **目录导航**: 支持章节目录快速跳转
-7. **本地资源**: 支持从本地 data 目录加载资源
-
-## 🔧 开发调试
-
-### 启用调试模式
-
-```bash
-export FLASK_DEBUG=True
-python3 app.py
-```
-
-### 查看日志
-
-应用日志存储在 `logs/app.log`
-
-### 数据库操作
-
-使用 `db_manager.py` 提供的数据库管理器：
-
-```python
-from db_manager import get_db_instance
-
-db = get_db_instance('books.db')
-
-# 获取所有书籍
-books = db.get_all_books()
-
-# 搜索内容
-results = db.search_content(book_id=168, keyword='hello', limit=20)
-
-# 获取统计信息
-stats = db.get_overall_statistics()
-```
-
-## 📝 数据格式说明
-
-### 坐标系统
-文本片段的坐标使用相对坐标（0-1范围）：
-```json
-{
-  "coordinate": {
-    "x": 0.0482,      // 左上角X坐标（相对于图片宽度）
-    "y": 0.0357,      // 左上角Y坐标（相对于图片高度）
-    "width": 0.3195,  // 宽度（相对于图片宽度）
-    "height": 0.0982  // 高度（相对于图片高度）
-  }
-}
-```
-
-### 资源路径
-资源路径采用相对路径格式：
-```
-168_一年级上册/images/page_001.jpg
-168_一年级上册/audios/page_002_piece_00.mp3
-```
-
-实际访问时会自动拼接为：
-```
-data/168_一年级上册/images/page_001.jpg
-data/168_一年级上册/audios/page_002_piece_00.mp3
-```
-
-## 🐛 故障排除
-
-### 数据库导入失败
-- 检查 data 目录是否存在
-- 确保每个书籍目录包含 book_info.json、pages.json
-- 检查 db_schema.sql 文件是否存在
-
-### 页面加载失败
-- 检查数据库是否正确导入
-- 查看浏览器控制台是否有错误
-- 检查 data 目录下的资源文件是否完整
-
-### 音频播放失败
-- 检查音频文件路径是否正确
-- 确保浏览器支持 MP3 格式
-- 查看浏览器控制台错误信息
-
-## 📄 许可证
-
-本项目仅供学习和研究使用。
-
-## 👥 贡献
-
-欢迎提交 Issue 和 Pull Request。
-
-## 📞 联系方式
-
-如有问题或建议，请联系开发团队。
-
----
-
-**版本**: v2.0.0  
-**更新日期**: 2025-10-17  
-**Python版本**: 3.12  
-**数据库**: SQLite 3
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,1068 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-交互式英语学习应用 - Flask 重构版本
-在7860端口提供HTTP服务，支持静态文件和RESTful API
-"""
-
-import os
-import sys
-import json
-import time
-from datetime import datetime
-from pathlib import Path
-
-from flask import Flask, render_template, send_from_directory, jsonify, request, session
-from flask_cors import CORS
-import logging
-from logging.handlers import RotatingFileHandler
-from database.db_manager import get_db_instance
-
-# 创建 Flask 应用
-app = Flask(__name__, 
-           static_folder='static',
-           static_url_path='/static')
-
-# 配置
-app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'dev-secret-key-change-in-production')
-app.config['JSON_AS_ASCII'] = False  # 支持中文JSON
-app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 最大上传16MB
-
-# 启用CORS
-CORS(app, resources={
-    r"/*": {
-        "origins": "*",
-        "methods": ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-        "allow_headers": ["Content-Type", "Authorization"]
-    }
-})
-
-# 配置日志
-def setup_logging():
-    """配置日志系统"""
-    if not app.debug:
-        try:
-            # 尝试在当前目录创建日志目录
-            log_dir = Path('logs')
-            log_dir.mkdir(exist_ok=True)
-            log_file = log_dir / 'app.log'
-        except (PermissionError, OSError):
-            # 如果当前目录无权限，使用 /tmp 目录
-            try:
-                log_dir = Path('/tmp/logs')
-                log_dir.mkdir(exist_ok=True)
-                log_file = log_dir / 'app.log'
-                print(f"⚠️  使用临时日志目录: {log_file}")
-            except (PermissionError, OSError):
-                # 如果都失败，只使用控制台日志
-                print("⚠️  无法创建日志文件，仅输出到控制台")
-                log_file = None
-        
-        # 如果有有效的日志文件路径，添加文件处理器
-        if log_file:
-            try:
-                file_handler = RotatingFileHandler(
-                    log_file,
-                    maxBytes=10 * 1024 * 1024,
-                    backupCount=10,
-                    encoding='utf-8'
-                )
-                file_handler.setFormatter(logging.Formatter(
-                    '[%(asctime)s] %(levelname)s in %(module)s: %(message)s'
-                ))
-                file_handler.setLevel(logging.INFO)
-                app.logger.addHandler(file_handler)
-            except (PermissionError, OSError) as e:
-                print(f"⚠️  无法创建日志处理器: {e}")
-    
-    # 确保至少有控制台输出
-    if not app.logger.handlers:
-        console_handler = logging.StreamHandler()
-        console_handler.setFormatter(logging.Formatter(
-            '[%(asctime)s] %(levelname)s: %(message)s'
-        ))
-        console_handler.setLevel(logging.INFO)
-        app.logger.addHandler(console_handler)
-    
-    app.logger.setLevel(logging.INFO)
-    app.logger.info('🚀 Flask 应用启动')
-
-# OpenSearch 配置（根据项目需求）
-OPENSEARCH_CONFIG = {
-    'host': os.environ.get('OPENSEARCH_HOST', '192.168.3.33'),
-    'port': int(os.environ.get('OPENSEARCH_PORT', 9200)),
-    'use_ssl': os.environ.get('OPENSEARCH_USE_SSL', 'False').lower() == 'true',
-}
-
-# 全局变量：存储学习数据
-BOOK_DATA = None
-
-# 数据库实例
-DB = None
-
-def get_client_ip():
-    """
-    获取客户端真实 IP 地址
-    在代理服务器（如 Hugging Face Spaces）后面时，需要检查代理头部
-    """
-    # 按优先级检查各种代理头部
-    headers_to_check = [
-        'X-Forwarded-For',
-        'X-Real-IP',
-        'CF-Connecting-IP',  # Cloudflare
-        'True-Client-IP',
-        'X-Client-IP',
-    ]
-    
-    for header in headers_to_check:
-        ip = request.headers.get(header)
-        if ip:
-            # X-Forwarded-For 可能包含多个 IP，取第一个
-            return ip.split(',')[0].strip()
-    
-    # 如果没有代理头部，使用 remote_addr
-    return request.remote_addr or 'Unknown'
-
-def load_book_data():
-    """
-    加载书籍数据（已废弃，保留是为了兼容性）
-    现在使用数据库接口，不再加载JSON文件
-    """
-    global BOOK_DATA
-    app.logger.info('ℹ️ load_book_data 已废弃，使用数据库接口')
-    # 设置为空字典表示已初始化，但不再使用
-    BOOK_DATA = {}
-    return True
-
-def init_database():
-    """初始化数据库连接"""
-    global DB
-    try:
-        DB = get_db_instance('books.db')
-        app.logger.info('✅ 数据库连接初始化成功')
-        return True
-    except Exception as e:
-        app.logger.error(f'❌ 数据库初始化失败: {e}')
-        return False
-
-
-# ============================================================================
-# 路由：静态文件服务
-# ============================================================================
-
-@app.route('/')
-def index():
-    """主页 - 书籍目录"""
-    return send_from_directory('.', 'index.html')
-
-@app.route('/reader')
-def reader():
-    """阅读页面"""
-    return send_from_directory('.', 'reader.html')
-
-@app.route('/<path:filename>')
-def serve_static(filename):
-    """提供根目录下的静态文件（如 style.css, script.js）"""
-    # 避免与API路由冲突
-    if filename.startswith('api/'):
-        return jsonify({'error': '接口不存在'}), 404
-    return send_from_directory('.', filename)
-
-# ============================================================================
-# 路由：API 端点
-# ============================================================================
-
-@app.route('/api/health')
-def health_check():
-    """健康检查端点"""
-    return jsonify({
-        'status': 'healthy',
-        'timestamp': datetime.now().isoformat(),
-        'version': '2.0.0-flask'
-    })
-
-@app.route('/api/book/info')
-def get_book_info():
-    """
-    获取书籍信息（旧接口，保留兼容性）
-    推荐使用: /api/v2/books/<book_id>
-    """
-    try:
-        if not DB:
-            return jsonify({'error': '数据库未初始化'}), 500
-        
-        # 默认获取第一本书的信息（为了兼容旧版本）
-        books = DB.get_all_books()
-        if not books:
-            return jsonify({'error': '没有找到书籍数据'}), 404
-        
-        # 使用最后导入的书籍
-        book = books[-1]
-        
-        # 返回书籍元信息
-        info = {
-            'book_id': book['market_book_id'],
-            'total_pages': book['max_page'],
-            'title': book['market_book_name'],
-            'loaded': True
-        }
-        return jsonify(info)
-    except Exception as e:
-        app.logger.error(f"获取书籍信息失败: {e}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/book/page/<int:page_num>')
-def get_page_content(page_num):
-    """
-    获取指定页面内容（旧接口，保留兼容性）
-    推荐使用: /api/v2/books/<book_id>/pages/<page_num>
-    """
-    try:
-        if not DB:
-            return jsonify({'error': '数据库未初始化'}), 500
-        
-        # 获取最后导入的书籍
-        books = DB.get_all_books()
-        if not books:
-            return jsonify({'error': '没有找到书籍数据'}), 404
-        
-        book = books[-1]
-        book_id = book['market_book_id']
-        
-        # 获取页面内容
-        page = DB.get_page_content(book_id, page_num)
-        if not page:
-            return jsonify({'error': '页码超出范围'}), 404
-        
-        return jsonify({
-            'page_num': page_num,
-            'content': page,
-            'total_pages': book['max_page']
-        })
-    except Exception as e:
-        app.logger.error(f"获取页面内容失败: {e}")
-        return jsonify({'error': str(e)}), 500
-
-@app.route('/api/progress/save', methods=['POST'])
-def save_progress():
-    """保存学习进度"""
-    try:
-        data = request.get_json()
-        
-        # 这里可以保存到数据库，现在先存到 session
-        if 'progress' not in session:
-            session['progress'] = {}
-        
-        session['progress'].update({
-            'current_page': data.get('current_page', 0),
-            'bookmarks': data.get('bookmarks', []),
-            'settings': data.get('settings', {}),
-            'last_updated': datetime.now().isoformat()
-        })
-        
-        app.logger.info(f"保存学习进度: 第 {data.get('current_page')} 页")
-        
-        return jsonify({
-            'success': True,
-            'message': '学习进度已保存'
-        })
-    except Exception as e:
-        app.logger.error(f"保存进度失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/progress/load', methods=['GET'])
-def load_progress():
-    """加载学习进度"""
-    progress = session.get('progress', {
-        'current_page': 0,
-        'bookmarks': [],
-        'settings': {}
-    })
-    return jsonify(progress)
-
-@app.route('/api/search', methods=['POST'])
-def search_content():
-    """搜索内容（未来可集成 OpenSearch）"""
-    try:
-        data = request.get_json()
-        keyword = data.get('keyword', '').strip()
-        
-        if not keyword:
-            return jsonify({'error': '搜索关键词不能为空'}), 400
-        
-        # 简单搜索实现（在书籍数据中搜索）
-        if not BOOK_DATA:
-            return jsonify({'error': '书籍数据未加载'}), 500
-        
-        results = []
-        pages = BOOK_DATA.get('pages', [])
-        
-        for page_num, page_content in enumerate(pages):
-            # 在页面内容中搜索关键词
-            page_str = json.dumps(page_content, ensure_ascii=False)
-            if keyword.lower() in page_str.lower():
-                results.append({
-                    'page_num': page_num,
-                    'preview': str(page_content)[:200] + '...'
-                })
-        
-        app.logger.info(f"搜索 '{keyword}': 找到 {len(results)} 个结果")
-        
-        return jsonify({
-            'keyword': keyword,
-            'total': len(results),
-            'results': results[:20]  # 限制返回前20个结果
-        })
-    except Exception as e:
-        app.logger.error(f"搜索失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/opensearch/status')
-def opensearch_status():
-    """检查 OpenSearch 连接状态（示例）"""
-    try:
-        # 这里可以实际连接 OpenSearch
-        # from opensearchpy import OpenSearch
-        # client = OpenSearch([{'host': OPENSEARCH_CONFIG['host'], 'port': OPENSEARCH_CONFIG['port']}])
-        # info = client.info()
-        
-        return jsonify({
-            'configured': True,
-            'host': OPENSEARCH_CONFIG['host'],
-            'port': OPENSEARCH_CONFIG['port'],
-            'status': 'not_implemented',
-            'message': 'OpenSearch 集成待实现'
-        })
-    except Exception as e:
-        return jsonify({
-            'configured': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/stats')
-def get_stats():
-    """获取学习统计数据"""
-    # 从 session 或数据库获取统计数据
-    progress = session.get('progress', {})
-    
-    return jsonify({
-        'current_page': progress.get('current_page', 0),
-        'total_bookmarks': len(progress.get('bookmarks', [])),
-        'last_visit': progress.get('last_updated', None),
-        'total_pages': len(BOOK_DATA.get('pages', [])) if BOOK_DATA else 0
-    })
-
-# ============================================================================
-# 路由：新版API端点（基于SQLite数据库）
-# ============================================================================
-
-@app.route('/api/v2/books')
-def get_books():
-    """
-    获取所有书籍列表
-    
-    Query Parameters:
-        grade_id: 年级ID（可选）
-    
-    Returns:
-        {
-            "success": true,
-            "count": 10,
-            "books": [
-                {
-                    "market_book_id": 168,
-                    "market_book_name": "一年级上册",
-                    "market_book_cover": "168_一年级上册/images/page_001.jpg",
-                    "max_page": 73,
-                    "market_classify_name": "沪教版（深圳）",
-                    "grade_id": 40,
-                    "reel_id": 1
-                }
-            ]
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        # 检查是否有年级筛选
-        grade_id = request.args.get('grade_id', type=int)
-        
-        if grade_id:
-            books = DB.get_books_by_grade(grade_id)
-        else:
-            books = DB.get_all_books()
-        
-        app.logger.info(f"获取书籍列表: {len(books)} 本书")
-        
-        return jsonify({
-            'success': True,
-            'count': len(books),
-            'books': books
-        })
-    except Exception as e:
-        app.logger.error(f"获取书籍列表失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/v2/books/<int:book_id>')
-def get_book_info_v2(book_id):
-    """
-    获取指定书籍的详细信息
-    
-    Args:
-        book_id: 书籍ID
-        
-    Returns:
-        {
-            "success": true,
-            "book": {
-                "book_id": 1,
-                "book_name": "书籍名称",
-                "total_pages": 100,
-                ...
-            }
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        book = DB.get_book_by_id(book_id)
-        if not book:
-            return jsonify({
-                'success': False,
-                'error': '书籍不存在'
-            }), 404
-        
-        app.logger.info(f"获取书籍信息: ID={book_id}")
-        
-        return jsonify({
-            'success': True,
-            'book': book
-        })
-    except Exception as e:
-        app.logger.error(f"获取书籍信息失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/v2/books/<int:book_id>/pages')
-def get_book_pages(book_id):
-    """
-    获取书籍的所有页面列表（不含片段内容）
-    
-    Args:
-        book_id: 书籍ID
-        
-    Returns:
-        {
-            "success": true,
-            "book_id": 168,
-            "book_name": "一年级上册",
-            "total_pages": 73,
-            "pages": [
-                {
-                    "page_id": 2111,
-                    "page_number": 1,
-                    "origin_img_url": "...",
-                    "encrypt_img_url": "..."
-                }
-            ]
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        # 检查书籍是否存在
-        book = DB.get_book_by_id(book_id)
-        if not book:
-            return jsonify({
-                'success': False,
-                'error': '书籍不存在'
-            }), 404
-        
-        # 获取页面列表
-        pages = DB.get_book_pages(book_id)
-        
-        app.logger.info(f"获取书籍页面列表: 书籍ID={book_id}, 页数={len(pages)}")
-        
-        return jsonify({
-            'success': True,
-            'book_id': book_id,
-            'book_name': book['market_book_name'],
-            'total_pages': len(pages),
-            'pages': pages
-        })
-    except Exception as e:
-        app.logger.error(f"获取书籍页面列表失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/v2/books/<int:book_id>/catalog')
-def get_book_catalog(book_id):
-    """
-    获取书籍目录结构（章节目录）
-    
-    Args:
-        book_id: 书籍ID
-        
-    Returns:
-        {
-            "success": true,
-            "book_id": 168,
-            "book_name": "一年级上册",
-            "catalog": [
-                {
-                    "catalog_id": 1,
-                    "catalog_name": "Unit 1 Hello",
-                    "catalog_name_cn": "第一单元 你好",
-                    "start_page": 2,
-                    "end_page": 10,
-                    "thumbnail": "...",
-                    "children": []
-                }
-            ]
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        # 检查书籍是否存在
-        book = DB.get_book_by_id(book_id)
-        if not book:
-            return jsonify({
-                'success': False,
-                'error': '书籍不存在'
-            }), 404
-        
-        # 获取目录
-        catalog = DB.get_book_catalog(book_id)
-        
-        app.logger.info(f"获取书籍目录: 书籍ID={book_id}, 目录项={len(catalog)}")
-        
-        return jsonify({
-            'success': True,
-            'book_id': book_id,
-            'book_name': book['market_book_name'],
-            'catalog': catalog
-        })
-    except Exception as e:
-        app.logger.error(f"获取书籍目录失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/v2/books/<int:book_id>/pages/<int:page_num>')
-def get_page_content_v2(book_id, page_num):
-    """
-    获取指定页面的完整内容
-    
-    Args:
-        book_id: 书籍ID
-        page_num: 页码
-        
-    Returns:
-        {
-            "success": true,
-            "book_id": 1,
-            "page": {
-                "page_id": 1001,
-                "page_number": 1,
-                "origin_img_url": "https://...",
-                "pieces": [
-                    {
-                        "piece_id": 10001,
-                        "original": "Hello",
-                        "translation": "你好",
-                        "origin_sound_url": "https://...",
-                        ...
-                    }
-                ],
-                "piece_count": 10
-            }
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        # 检查书籍是否存在
-        book = DB.get_book_by_id(book_id)
-        if not book:
-            return jsonify({
-                'success': False,
-                'error': '书籍不存在'
-            }), 404
-        
-        # 获取页面内容
-        page = DB.get_page_content(book_id, page_num)
-        if not page:
-            return jsonify({
-                'success': False,
-                'error': f'页码 {page_num} 不存在'
-            }), 404
-        
-        app.logger.info(f"获取页面内容: 书籍ID={book_id}, 页码={page_num}")
-        
-        return jsonify({
-            'success': True,
-            'book_id': book_id,
-            'book_name': book['market_book_name'],
-            'page': page
-        })
-    except Exception as e:
-        app.logger.error(f"获取页面内容失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/v2/books/<int:book_id>/search')
-def search_book_content(book_id):
-    """
-    在书籍中搜索内容
-    
-    Query Parameters:
-        keyword: 搜索关键词
-        limit: ��回结果数量（默认20）
-        
-    Returns:
-        {
-            "success": true,
-            "book_id": 168,
-            "keyword": "hello",
-            "count": 5,
-            "results": [
-                {
-                    "page_number": 2,
-                    "piece_id": 26342,
-                    "original": "Hello",
-                    "translation": "你好",
-                    "origin_sound_url": "..."
-                }
-            ]
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        keyword = request.args.get('keyword', '').strip()
-        if not keyword:
-            return jsonify({
-                'success': False,
-                'error': '请提供搜索关键词'
-            }), 400
-        
-        limit = request.args.get('limit', 20, type=int)
-        
-        # 检查书籍是否存在
-        book = DB.get_book_by_id(book_id)
-        if not book:
-            return jsonify({
-                'success': False,
-                'error': '书籍不存在'
-            }), 404
-        
-        # 搜索
-        results = DB.search_content(book_id, keyword, limit)
-        
-        app.logger.info(f"搜索内容: 书籍ID={book_id}, 关键词={keyword}, 结果数={len(results)}")
-        
-        return jsonify({
-            'success': True,
-            'book_id': book_id,
-            'book_name': book['market_book_name'],
-            'keyword': keyword,
-            'count': len(results),
-            'results': results
-        })
-    except Exception as e:
-        app.logger.error(f"搜索失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/v2/search')
-def search_all_content():
-    """
-    在所有书籍中搜索内容
-    
-    Query Parameters:
-        keyword: 搜索关键词
-        limit: 返回结果数量（默认50）
-        
-    Returns:
-        {
-            "success": true,
-            "keyword": "hello",
-            "count": 15,
-            "results": [
-                {
-                    "market_book_id": 168,
-                    "market_book_name": "一年级上册",
-                    "page_number": 2,
-                    "piece_id": 26342,
-                    "original": "Hello",
-                    "translation": "你好",
-                    "origin_sound_url": "..."
-                }
-            ]
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        keyword = request.args.get('keyword', '').strip()
-        if not keyword:
-            return jsonify({
-                'success': False,
-                'error': '请提供搜索关键词'
-            }), 400
-        
-        limit = request.args.get('limit', 50, type=int)
-        
-        # 搜索所有书籍
-        results = DB.search_all_books(keyword, limit)
-        
-        app.logger.info(f"全局搜索: 关键词={keyword}, 结果数={len(results)}")
-        
-        return jsonify({
-            'success': True,
-            'keyword': keyword,
-            'count': len(results),
-            'results': results
-        })
-    except Exception as e:
-        app.logger.error(f"搜索失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/v2/books/<int:book_id>/statistics')
-def get_book_statistics(book_id):
-    """
-    获取书籍统计信息
-    
-    Args:
-        book_id: 书籍ID
-        
-    Returns:
-        {
-            "success": true,
-            "statistics": {
-                "book_id": 168,
-                "total_pages": 73,
-                "total_pieces": 500,
-                "total_audio": 450,
-                "total_catalogs": 12
-            }
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        # 检查书籍是否存在
-        book = DB.get_book_by_id(book_id)
-        if not book:
-            return jsonify({
-                'success': False,
-                'error': '书籍不存在'
-            }), 404
-        
-        # 获取统计信息
-        stats = DB.get_book_statistics(book_id)
-        
-        app.logger.info(f"获取统计信息: 书籍ID={book_id}")
-        
-        return jsonify({
-            'success': True,
-            'statistics': stats
-        })
-    except Exception as e:
-        app.logger.error(f"获取统计信息失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-@app.route('/api/v2/statistics')
-def get_overall_statistics():
-    """
-    获取整体统计信息
-    
-    Returns:
-        {
-            "success": true,
-            "statistics": {
-                "total_books": 30,
-                "total_pages": 2000,
-                "total_pieces": 50000,
-                "total_catalogs": 360
-            }
-        }
-    """
-    try:
-        if not DB:
-            return jsonify({
-                'success': False,
-                'error': '数据库未初始化'
-            }), 500
-        
-        stats = DB.get_overall_statistics()
-        
-        app.logger.info("获取整体统计信息")
-        
-        return jsonify({
-            'success': True,
-            'statistics': stats
-        })
-    except Exception as e:
-        app.logger.error(f"获取统计信息失败: {e}")
-        return jsonify({
-            'success': False,
-            'error': str(e)
-        }), 500
-
-# ============================================================================
-# 错误处理
-# ============================================================================
-
-@app.errorhandler(404)
-def not_found(error):
-    """404错误处理"""
-    if request.path.startswith('/api/'):
-        return jsonify({'error': '接口不存在'}), 404
-    return send_from_directory('.', 'index.html')
-
-@app.errorhandler(500)
-def internal_error(error):
-    """500错误处理"""
-    app.logger.error(f'服务器错误: {error}')
-    return jsonify({'error': '服务器内部错误'}), 500
-
-# ============================================================================
-# 请求钩子
-# ============================================================================
-
-@app.before_request
-def before_request():
-    """请求前处理"""
-    # 获取客户端真实 IP
-    client_ip = get_client_ip()
-    
-    # 记录所有请求信息（包括静态文件）
-    user_agent = request.headers.get('User-Agent', 'Unknown')[:100]  # 限制长度
-    
-    # API 请求记录详细信息
-    if request.path.startswith('/api/'):
-        app.logger.info(
-            f"[{client_ip}] {request.method} {request.path} "
-            f"| UA: {user_agent}"
-        )
-    # 静态资源只记录简要信息
-    elif app.debug:
-        app.logger.debug(f"[{client_ip}] {request.method} {request.path}")
-    
-    # 将 IP 存储到 g 对象，方便在其他地方使用
-    from flask import g
-    g.client_ip = client_ip
-
-@app.after_request
-def after_request(response):
-    """请求后处理 - 添加缓存控制"""
-    # API 端点不缓存
-    if request.path.startswith('/api/'):
-        response.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
-        response.headers['Pragma'] = 'no-cache'
-        response.headers['Expires'] = '0'
-    else:
-        # 静态资源缓存1小时
-        response.headers['Cache-Control'] = 'public, max-age=3600'
-    
-    return response
-
-# ============================================================================
-# 应用初始化和启动
-# ============================================================================
-
-def auto_generate_database():
-    """
-    自动生成数据库
-    如果 books.db 不存在，自动运行导入脚本生成数据库
-    """
-    db_path = 'books.db'
-    schema_path = 'database/db_schema.sql'
-    data_dir = 'data'
-    
-    # 检查必要的文件和目录
-    if not os.path.exists(schema_path):
-        print(f"❌ 错误: Schema文件 {schema_path} 不存在")
-        return False
-    
-    if not os.path.exists(data_dir):
-        print(f"❌ 错误: 数据目录 {data_dir} 不存在")
-        print(f"   无法自动生成数据库，请先准备数据")
-        return False
-    
-    print(f"📦 未找到数据库文件，正在自动生成...")
-    print(f"   数据目录: {data_dir}")
-    print(f"   这可能需要几分钟时间，请稍候...")
-    print("=" * 60)
-    
-    try:
-        # 导入必要的函数
-        from database.import_book_data import create_database, import_all_books, verify_data
-        
-        # 创建数据库
-        conn = create_database(db_path, schema_path)
-        
-        # 导入所有书籍数据
-        import_all_books(conn, data_dir)
-        
-        # 验证数据
-        verify_data(conn)
-        
-        # 关闭连接
-        conn.close()
-        
-        print("=" * 60)
-        print("✅ 数据库自动生成完成!")
-        print("=" * 60)
-        return True
-        
-    except Exception as e:
-        print(f"❌ 自动生成数据库失败: {e}")
-        app.logger.error(f"自动生成数据库失败: {e}", exc_info=True)
-        return False
-
-def initialize_app():
-    """初始化应用"""
-    print("🚀 交互式英语学习应用 - Flask 版本")
-    print("=" * 60)
-    
-    # 设置日志
-    setup_logging()
-    
-    # 检查必要文件（暂时不检查 books.db，因为会自动生成）
-    if not os.path.exists('index.html'):
-        app.logger.error(f"❌ 缺少必要文件: index.html")
-        return False
-    
-    # 加载书籍数据
-    if not load_book_data():
-        return False
-    
-    # 检查数据库文件
-    if not os.path.exists('books.db'):
-        print("ℹ️  未找到数据库文件 books.db")
-        print("🔄 正在自动生成数据库...")
-        
-        # 自动生成数据库
-        if not auto_generate_database():
-            print("❌ 数据库自动生成失败")
-            print("   请手动运行: python3 database/import_book_data.py")
-            return False
-    
-    # 初始化数据库连接
-    print("📚 正在初始化数据库连接...")
-    if not init_database():
-        print("❌ 数据库初始化失败")
-        return False
-    
-    print("✅ 应用初始化完成")
-    return True
-
-def main():
-    """主函数"""
-    # 初始化应用（如果还未初始化）
-    if not DB:
-        if not initialize_app():
-            print("❌ 应用初始化失败")
-            return 1
-    
-    # Hugging Face Spaces 要求监听 7860 端口
-    port = int(os.environ.get('PORT', 7860))
-    debug = os.environ.get('FLASK_DEBUG', 'False').lower() == 'true'
-    
-    print(f"🌐 监听端口: {port}")
-    print(f"📁 工作目录: {os.getcwd()}")
-    print(f"🔧 调试模式: {'开启' if debug else '关闭'}")
-    print("=" * 60)
-    print("🎉 应用已准备就绪!")
-    print("=" * 60)
-            
-    try:
-        # 启动 Flask 应用
-        app.run(
-            host='0.0.0.0',
-            port=port,
-            debug=debug,
-            threaded=True,  # 多线程处理请求
-            use_reloader=debug  # 开发模式下启用热重载
-        )
-    except KeyboardInterrupt:
-        print("\n\n🛑 服务器已停止")
-        return 0
-    except Exception as e:
-        print(f"❌ 服务器启动失败: {e}")
-        app.logger.error(f"服务器启动失败: {e}")
-        return 1
-
-# ============================================================================
-# 应用初始化（支持 Gunicorn 和直接运行）
-# ============================================================================
-
-# 在模块加载时初始化应用（无论是 gunicorn 还是直接运行都会执行）
-# 这确保了在 HuggingFace Spaces 上使用 gunicorn 时也能正确初始化
-if not DB:  # 避免重复初始化
-    print("🔧 开始初始化应用...")
-    if not initialize_app():
-        print("❌ 应用初始化失败")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    sys.exit(main())

books.db

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b95bb63da9498f42a3e27b60303a62bd8071958b4d1cb8e4475312ac68838d8f
-size 516096

data/10005_一年级上册/audios/page_002_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a5f33e7250177e0b9919b0c2b2f1e1eb58f059efd17146821b49aeb6cac19bf3
-size 51826

data/10005_一年级上册/audios/page_003_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f3db8d98e71f8fadcb57b1eff3fd1652dfd0b12f3fb3021881df15ca7a884921
-size 45139

data/10005_一年级上册/audios/page_004_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0b43ed35c99df647d6205526e780b0492982f42e8e7bc86276674b82305a3d44
-size 42631

data/10005_一年级上册/audios/page_004_piece_01.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f976fad7083db695b0210e81c7c37fdc1a3751be9d0cf52c6452454158b05827
-size 36362

data/10005_一年级上册/audios/page_004_piece_02.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:db1910ca633d8ca10e97f09dd3edc210ed66772510013b4525fd56bdc1ce0cb7
-size 59768

data/10005_一年级上册/audios/page_004_piece_03.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5823b138fa96edbff4e42c46d3de1eed62e76c27040a623388865450ab207901
-size 52245

data/10005_一年级上册/audios/page_004_piece_04.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1c2ecddb71a94cea2fedffecee8babd2e20d949aa63e0c45073e9565c7ebaca0
-size 71053

data/10005_一年级上册/audios/page_004_piece_05.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d143cccfe5d0c48dd7f2f039fb244bacc3c346741b9179866e7b6258e6df6f3d
-size 82338

data/10005_一年级上册/audios/page_004_piece_06.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7d1a9b7680628a28f861105a30f66d9b32b1e2f5d228282c84e3b743e5747aa8
-size 50155

data/10005_一年级上册/audios/page_004_piece_07.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:dd5afef021a9e411b217b81fa90d8d6760e014aab881ead835b6d205a153d316
-size 49737

data/10005_一年级上册/audios/page_004_piece_08.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:892987c43bbc5b99242fd554d8ae99015ccb0849ed98000f2f8b4aa1af52bb73
-size 58514

data/10005_一年级上册/audios/page_004_piece_09.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:873cdbbb4978f991636e332a5dc5dad869c9d754ad1a1872ffb2136a16342079
-size 90379

data/10005_一年级上册/audios/page_005_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2ef96ddf79d08895258099e26255c97cb6cff1dd493dc83970f25759788b120c
-size 45975

data/10005_一年级上册/audios/page_005_piece_01.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c9ef26e060ca1db607b9362413332a2f3abd24992348565abc785a299a513266
-size 32182

data/10005_一年级上册/audios/page_005_piece_02.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:85864c7d35a0cb0e57f796a760c653d2a44fb2b6e17812a7ab36332fcd835bc2
-size 28839

data/10005_一年级上册/audios/page_005_piece_03.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6eb99945c52d876ed1c4efbe6ecf4dc68ed199fc4bbbfd6c654806c6fc30adca
-size 33436

data/10005_一年级上册/audios/page_005_piece_04.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:21c220fd9848e6d77f2fb977bc79c44e7df817acfc6a1e934b989a85e99b6f59
-size 32600

data/10005_一年级上册/audios/page_006_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1fb27d35047bb161899fcf97d84bc906ae17dcc5328230bc78e62b9c91316bbb
-size 46811

data/10005_一年级上册/audios/page_006_piece_01.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:975e3dc752f7477e7a514f57cc0a78f8bd8aaeefd991d7155d763fe27faf4974
-size 25913

data/10005_一年级上册/audios/page_006_piece_02.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e5683b45230fb533fd2793b8bc1dd28f00005b228fa02fc0ef74adae24e6044a
-size 23823

data/10005_一年级上册/audios/page_006_piece_03.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0d244ffdd82258c463048e5c7739d629f0d0d9e11f5fae8a39beb5121c25ee89
-size 25077

data/10005_一年级上册/audios/page_006_piece_04.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4d01f72dc5ad26b83a1af2e69788fa51a164101a08b51fb0028cadd66c17b4d6
-size 25495

data/10005_一年级上册/audios/page_006_piece_05.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3881dd3a52388c87a166100276b975c909821ea2ed5df9fde9ea0d317ff0ed61
-size 24659

data/10005_一年级上册/audios/page_006_piece_06.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b8836ad3b13c0f167b3440948212a5ea33215989074275dd59542e07d3f37dd4
-size 21733

data/10005_一年级上册/audios/page_007_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:384454cc204eec379e8c53aba0eddcff8a4a727bd91cc9891077d0c886418698
-size 53080

data/10005_一年级上册/audios/page_007_piece_01.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:faa75a6c25c33bc530d574534debc1cda01e8780276a8bda3df93f8ddfaa38bd
-size 129567

data/10005_一年级上册/audios/page_007_piece_02.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9531cb7e9b1cc2a5758ee920ab7182d7a5be60e845e965c4821b34376e2a9288
-size 133746

data/10005_一年级上册/audios/page_009_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8a5b4467fbdb87518d42a31bad1ed7b4a3d747cdafaf2b79cbadd5d9312f1a10
-size 47647

data/10005_一年级上册/audios/page_009_piece_01.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b0deea352ddba234530ed7ba0cbb9058fc800ca0fb40ded8d3999bcb44170255
-size 22569

data/10005_一年级上册/audios/page_009_piece_02.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:97d098d3294bcceda1ef9425afa47945d7d38dbe1bfc5d0680fdd3addd8033db
-size 20897

data/10005_一年级上册/audios/page_009_piece_03.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4c12fd9818d9f1923828e2a3dc839fb297b1f2120497f0d6f00900054384fdd9
-size 25495

data/10005_一年级上册/audios/page_009_piece_04.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ccbb125b0451f64214a84f9e79d4b7cfc70d243c5822ecb57d447eba3fa7083e
-size 27585

data/10005_一年级上册/audios/page_009_piece_05.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a755929366404882216e8f397a126e40cf3c9ca490afd65ac65ae907dd885528
-size 28003

data/10005_一年级上册/audios/page_010_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f7d47bf1be6e08099577644d3123d508064fc076b057c37f659db2c8d2e6b68d
-size 83173

data/10005_一年级上册/audios/page_010_piece_01.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5b6519fab7096620a24834db703a5e8ecf43d3b857ced4e779c00952b77ec922
-size 87353

data/10005_一年级上册/audios/page_011_piece_00.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:555ec8a313d6de63854fdb07c4e4d0a89e6ee6e96b99a483ef2fa9eafede9209
-size 53498

data/10005_一年级上册/audios/page_011_piece_01.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:be324c440873e425aef730222704af1e3f681d9a025396df748e24f98e1aee4a
-size 23405

data/10005_一年级上册/audios/page_011_piece_02.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ba6abf1c452b6dfba05484e2dde2422274cbfdac03d83dd016dd9ed6ec1f4d4a
-size 23823

data/10005_一年级上册/audios/page_011_piece_03.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4538306b11fb20ea1b5e279fd4f71314051480e04d14ee608dd636c63d9bb3b3
-size 32600

data/10005_一年级上册/audios/page_011_piece_04.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1813f326124a81b5a8a6dac0967fffac8f21b316597fd59a0ee9c577f5a967e4
-size 29257

data/10005_一年级上册/audios/page_011_piece_05.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d40d3aabfb6296af236f622b39bcbbcb2d095d948c69f56882acec9780b97642
-size 29257

data/10005_一年级上册/audios/page_011_piece_06.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0fb841e233e063d5fbfb36a27ff2270bc3d970da883fb3d5459f29f8ec4bce58
-size 30093

data/10005_一年级上册/audios/page_011_piece_07.mp3

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1786b7c7835750b76eb8e707ba40a4483ebcc8c21a14e9a1b34ae1a32097ac7c
-size 28839