voice-input 1.0.0__py3-none-any.whl

voice_input/__init__.py

@@ -0,0 +1,4 @@
+"""跨设备语音输入传输系统 - 将手机端语音识别文本传送到电脑"""
+
+__version__ = "1.0.0"
+__author__ = "mofanx"

voice_input/__main__.py

@@ -0,0 +1,5 @@
+"""支持 python -m voice_input 方式运行"""
+
+from .cli import main
+
+main()

voice_input/cli.py

@@ -0,0 +1,158 @@
+"""命令行入口 - 支持参数与配置文件"""
+
+import argparse
+import logging
+import platform
+import sys
+
+from . import __version__
+from .config import build_config
+from .utils import get_local_ip
+
+
+def parse_args(argv=None):
+    p = argparse.ArgumentParser(
+        prog="voice-input",
+        description="跨设备语音输入传输系统 - 将手机端语音识别文本传送到电脑",
+    )
+    p.add_argument("-V", "--version", action="version", version=f"%(prog)s {__version__}")
+    p.add_argument("-c", "--config", metavar="FILE", help="YAML 配置文件路径")
+
+    # 网络
+    net = p.add_argument_group("网络")
+    net.add_argument("-H", "--host", metavar="ADDR", help="监听地址 (默认 0.0.0.0)")
+    net.add_argument("-p", "--port", type=int, metavar="PORT", help="监听端口 (默认 8080)")
+    net.add_argument(
+        "--allowed-ips",
+        metavar="CIDR",
+        help="IP 白名单，逗号分隔 (如 192.168.0.0/16,10.0.0.0/8)",
+    )
+
+    # 安全
+    sec = p.add_argument_group("安全")
+    sec.add_argument("-t", "--token", metavar="TOKEN", help="鉴权 Token")
+    sec.add_argument(
+        "--require-token",
+        action="store_true",
+        default=None,
+        help="强制启用 Token 鉴权 (未设 --token 时自动生成)",
+    )
+
+    # 行为
+    beh = p.add_argument_group("行为")
+    beh.add_argument(
+        "--no-auto-paste",
+        action="store_true",
+        default=False,
+        help="默认不自动粘贴，仅复制到剪贴板",
+    )
+    beh.add_argument("--history-size", type=int, metavar="N", help="历史记录条数 (默认 50)")
+
+    # 生产
+    prod = p.add_argument_group("生产部署")
+    prod.add_argument(
+        "--production",
+        action="store_true",
+        default=False,
+        help="使用 waitress 作为生产 WSGI 服务器",
+    )
+    prod.add_argument("--workers", type=int, metavar="N", help="WSGI 工作线程数 (默认 4)")
+    prod.add_argument(
+        "--log-level",
+        choices=["debug", "info", "warning", "error"],
+        help="日志级别 (默认 info)",
+    )
+
+    return p.parse_args(argv)
+
+
+def main(argv=None):
+    args = parse_args(argv)
+
+    # 将 argparse 结果转为 config dict（None 表示未指定）
+    cli_dict = {}
+    if args.host is not None:
+        cli_dict["host"] = args.host
+    if args.port is not None:
+        cli_dict["port"] = args.port
+    if args.allowed_ips is not None:
+        cli_dict["allowed_ips"] = [s.strip() for s in args.allowed_ips.split(",") if s.strip()]
+    if args.token is not None:
+        cli_dict["token"] = args.token
+    if args.require_token is True:
+        cli_dict["require_token"] = True
+    if args.no_auto_paste:
+        cli_dict["auto_paste"] = False
+    if args.history_size is not None:
+        cli_dict["history_size"] = args.history_size
+    if args.workers is not None:
+        cli_dict["workers"] = args.workers
+    if args.log_level is not None:
+        cli_dict["log_level"] = args.log_level
+
+    # 构建配置
+    cfg = build_config(cli_args=cli_dict, config_file=args.config)
+
+    # 配置日志
+    logging.basicConfig(
+        level=getattr(logging, cfg.log_level.upper(), logging.INFO),
+        format="%(asctime)s - %(levelname)s - %(message)s",
+    )
+
+    # 创建应用
+    from .server import create_app
+
+    app = create_app(cfg)
+
+    # 打印启动信息
+    local_ip = get_local_ip()
+    banner = f"""
+{'=' * 60}
+  跨设备语音输入传输系统 v{__version__}
+{'=' * 60}
+  服务地址:  http://{local_ip}:{cfg.port}
+  手机页面:  http://{local_ip}:{cfg.port}/
+  状态检查:  http://{local_ip}:{cfg.port}/status
+  API 接口:  http://{local_ip}:{cfg.port}/input  (POST)
+  历史记录:  http://{local_ip}:{cfg.port}/history"""
+
+    if cfg.token:
+        banner += f"\n  Token:     {cfg.token}"
+    else:
+        banner += "\n  Token:     未启用"
+
+    is_windows = platform.system() == "Windows"
+    banner += f"""
+{'=' * 60}
+  提示: 手机和电脑需在同一局域网"""
+    if not is_windows:
+        banner += "\n  提示: 自动粘贴功能需要 root/sudo 权限 (Linux)"
+    banner += f"\n{'=' * 60}"
+    print(banner)
+
+    # 启动服务器
+    if args.production:
+        _run_production(app, cfg)
+    else:
+        app.run(host=cfg.host, port=cfg.port, debug=False)
+
+
+def _run_production(app, cfg):
+    """使用 waitress 启动生产服务器"""
+    try:
+        from waitress import serve
+
+        workers = cfg.workers if cfg.workers > 1 else 4
+        print(f"  [waitress] threads={workers}")
+        serve(app, host=cfg.host, port=cfg.port, threads=workers)
+    except ImportError:
+        print(
+            "waitress 未安装，回退到 Flask 开发服务器。\n"
+            "生产环境请执行: pip install waitress",
+            file=sys.stderr,
+        )
+        app.run(host=cfg.host, port=cfg.port, debug=False)
+
+
+if __name__ == "__main__":
+    main()

voice_input/config.py

@@ -0,0 +1,116 @@
+"""配置管理 - 支持 YAML 配置文件、环境变量、CLI 参数三级合并"""
+
+import os
+import secrets
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+
+@dataclass
+class AppConfig:
+    """应用配置，优先级：CLI 参数 > 环境变量 > 配置文件 > 默认值"""
+
+    # 网络
+    host: str = "0.0.0.0"
+    port: int = 8080
+
+    # 安全
+    allowed_ips: List[str] = field(
+        default_factory=lambda: ["192.168.0.0/16", "10.0.0.0/8", "172.16.0.0/12"]
+    )
+    token: str = ""
+    require_token: bool = False
+
+    # 行为
+    auto_paste: bool = True
+    history_size: int = 50
+    max_content_length: int = 10 * 1024  # 10KB
+
+    # 生产部署
+    workers: int = 1
+    log_level: str = "info"
+
+    def __post_init__(self):
+        if self.require_token and not self.token:
+            self.token = secrets.token_urlsafe(18)
+
+
+def _parse_bool(val: str) -> bool:
+    return val.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def load_from_yaml(path: str) -> dict:
+    """从 YAML 文件加载配置"""
+    try:
+        import yaml
+    except ImportError:
+        raise ImportError(
+            "需要 PyYAML 来读取配置文件，请执行: pip install pyyaml"
+        )
+    with open(path, "r", encoding="utf-8") as f:
+        data = yaml.safe_load(f) or {}
+    return data
+
+
+def load_from_env() -> dict:
+    """从环境变量加载配置（VOICE_INPUT_ 前缀）"""
+    mapping = {
+        "VOICE_INPUT_HOST": "host",
+        "VOICE_INPUT_PORT": "port",
+        "VOICE_INPUT_ALLOWED_IPS": "allowed_ips",
+        "VOICE_INPUT_TOKEN": "token",
+        "VOICE_INPUT_REQUIRE_TOKEN": "require_token",
+        "VOICE_INPUT_AUTO_PASTE": "auto_paste",
+        "VOICE_INPUT_HISTORY_SIZE": "history_size",
+        "VOICE_INPUT_MAX_CONTENT_LENGTH": "max_content_length",
+        "VOICE_INPUT_WORKERS": "workers",
+        "VOICE_INPUT_LOG_LEVEL": "log_level",
+    }
+    result = {}
+    for env_key, cfg_key in mapping.items():
+        val = os.environ.get(env_key)
+        if val is None:
+            continue
+        result[cfg_key] = val
+    return result
+
+
+def _coerce(key: str, val):
+    """将字符串值转为目标类型"""
+    bool_keys = {"require_token", "auto_paste"}
+    int_keys = {"port", "history_size", "max_content_length", "workers"}
+    list_keys = {"allowed_ips"}
+
+    if key in bool_keys and isinstance(val, str):
+        return _parse_bool(val)
+    if key in int_keys and isinstance(val, str):
+        return int(val)
+    if key in list_keys and isinstance(val, str):
+        return [s.strip() for s in val.split(",") if s.strip()]
+    return val
+
+
+def build_config(
+    cli_args: Optional[dict] = None,
+    config_file: Optional[str] = None,
+) -> AppConfig:
+    """三级合并构建最终配置"""
+    merged: dict = {}
+
+    # 1. 配置文件
+    if config_file:
+        merged.update(load_from_yaml(config_file))
+
+    # 2. 环境变量覆盖
+    merged.update(load_from_env())
+
+    # 3. CLI 参数覆盖（过滤 None 值）
+    if cli_args:
+        for k, v in cli_args.items():
+            if v is not None:
+                merged[k] = v
+
+    # 类型转换
+    coerced = {k: _coerce(k, v) for k, v in merged.items()}
+
+    return AppConfig(**coerced)

voice_input/server.py

@@ -0,0 +1,341 @@
+"""Flask 应用与路由定义"""
+
+import io
+import csv
+import json
+import os
+import platform
+import time
+import logging
+import threading
+from collections import deque
+
+from flask import Flask, request, jsonify, render_template, Response
+
+from .config import AppConfig
+from .utils import get_local_ip, get_client_ip, is_ip_allowed, is_token_valid
+
+
+_PASTE_DELAY = 0.08  # 剪贴板写入后等待时间（秒），确保 X11 剪贴板同步完成
+_RESTORE_DELAY = 0.15  # 粘贴操作后等待时间（秒），确保目标程序完成读取剪贴板
+
+
+def _do_keyboard_action(action: str, text: str):
+    """执行键盘操作（跨平台），在 copy 之后调用"""
+    try:
+        import keyboard
+    except ImportError:
+        logging.warning("keyboard 模块未安装，跳过自动粘贴（文本已复制到剪贴板）")
+        return
+    except Exception as e:
+        logging.warning(f"keyboard 模块加载失败: {e}")
+        return
+
+    try:
+        time.sleep(_PASTE_DELAY)
+        is_windows = platform.system() == "Windows"
+        if action == "paste":
+            keyboard.press_and_release("ctrl+v")
+            logging.info("已执行粘贴操作")
+        elif action == "paste_terminal":
+            if is_windows:
+                keyboard.press_and_release("ctrl+v")
+            else:
+                keyboard.press_and_release("ctrl+shift+v")
+            logging.info("已执行终端粘贴操作")
+        elif action == "type":
+            keyboard.write(text)
+            logging.info("已执行键入操作")
+    except Exception as e:
+        logging.warning(f"自动粘贴失败（文本已复制到剪贴板）: {e}")
+
+
+def _save_clipboard() -> bytes | None:
+    """保存当前剪贴板内容，失败返回 None"""
+    try:
+        import pyclip
+        return pyclip.paste()
+    except Exception:
+        return None
+
+
+def _restore_clipboard(old_content: bytes | None):
+    """恢复剪贴板内容"""
+    if old_content is None:
+        return
+    try:
+        import pyclip
+        time.sleep(_RESTORE_DELAY)
+        pyclip.copy(old_content)
+        logging.info("已恢复原有剪贴板内容")
+    except Exception as e:
+        logging.warning(f"恢复剪贴板失败: {e}")
+
+
+def create_app(config: AppConfig) -> Flask:
+    """应用工厂：根据配置创建 Flask 实例"""
+
+    template_dir = os.path.join(os.path.dirname(__file__), "templates")
+    app = Flask(__name__, template_folder=template_dir)
+    app.config["MAX_CONTENT_LENGTH"] = config.max_content_length
+
+    # 存储配置到 app 上下文
+    app.voice_config = config
+    app.voice_history = deque(maxlen=config.history_size)
+    app.voice_history_lock = threading.Lock()
+    app.voice_history_counter = 0
+
+    # ==================== 路由 ====================
+
+    @app.route("/", methods=["GET"])
+    def index():
+        local_ip = get_local_ip()
+        cfg = app.voice_config
+        return render_template(
+            "index.html",
+            server_ip=local_ip,
+            port=cfg.port,
+            require_token=bool(cfg.token) or cfg.require_token,
+            auto_paste=cfg.auto_paste,
+            platform_name=platform.system(),
+        )
+
+    @app.route("/status", methods=["GET"])
+    def status():
+        local_ip = get_local_ip()
+        cfg = app.voice_config
+        return jsonify(
+            {
+                "code": 200,
+                "message": "service running",
+                "version": "2.0.0",
+                "server_ip": local_ip,
+                "port": cfg.port,
+                "platform": platform.system(),
+                "require_token": bool(cfg.token) or cfg.require_token,
+                "auto_paste": cfg.auto_paste,
+                "history_size": cfg.history_size,
+                "timestamp": int(time.time() * 1000),
+            }
+        )
+
+    @app.route("/history", methods=["GET"])
+    def get_history():
+        with app.voice_history_lock:
+            items = list(app.voice_history)
+        return jsonify(
+            {
+                "code": 200,
+                "message": "success",
+                "items": items,
+                "timestamp": int(time.time() * 1000),
+            }
+        )
+
+    @app.route("/history/<int:item_id>", methods=["DELETE"])
+    def delete_history_item(item_id):
+        with app.voice_history_lock:
+            before = len(app.voice_history)
+            app.voice_history = deque(
+                (item for item in app.voice_history if item.get("id") != item_id),
+                maxlen=config.history_size,
+            )
+            removed = before - len(app.voice_history)
+        return jsonify({"code": 200, "message": "success", "removed": removed})
+
+    @app.route("/history", methods=["DELETE"])
+    def clear_history():
+        with app.voice_history_lock:
+            count = len(app.voice_history)
+            app.voice_history.clear()
+        return jsonify({"code": 200, "message": "success", "cleared": count})
+
+    @app.route("/history/export", methods=["GET"])
+    def export_history():
+        fmt = request.args.get("format", "json")
+        with app.voice_history_lock:
+            items = list(app.voice_history)
+
+        if fmt == "csv":
+            output = io.StringIO()
+            writer = csv.writer(output)
+            writer.writerow(["id", "time", "text", "action", "device_id", "client_ip"])
+            for item in items:
+                t = time.strftime(
+                    "%Y-%m-%d %H:%M:%S", time.localtime(item["server_time"] / 1000)
+                )
+                writer.writerow(
+                    [
+                        item.get("id", ""),
+                        t,
+                        item.get("text", ""),
+                        item.get("action", ""),
+                        item.get("device_id", ""),
+                        item.get("client_ip", ""),
+                    ]
+                )
+            return Response(
+                output.getvalue(),
+                mimetype="text/csv",
+                headers={"Content-Disposition": "attachment; filename=voice_history.csv"},
+            )
+        else:
+            return Response(
+                json.dumps(items, ensure_ascii=False, indent=2),
+                mimetype="application/json",
+                headers={
+                    "Content-Disposition": "attachment; filename=voice_history.json"
+                },
+            )
+
+    @app.route("/input", methods=["POST"])
+    def handle_input():
+        cfg = app.voice_config
+
+        # 1. IP 白名单验证
+        client_ip = get_client_ip(request)
+        if not is_ip_allowed(client_ip, cfg.allowed_ips):
+            logging.warning(f"IP未授权访问: {client_ip}")
+            return (
+                jsonify(
+                    {
+                        "code": 403,
+                        "message": "IP not allowed",
+                        "error_detail": "Your IP address is not in the whitelist",
+                    }
+                ),
+                403,
+            )
+
+        # 2. JSON 解析
+        try:
+            data = request.get_json(force=True)
+        except Exception as e:
+            logging.error(f"JSON解析失败: {e}")
+            return (
+                jsonify(
+                    {
+                        "code": 400,
+                        "message": "Invalid JSON format",
+                        "error_detail": "Request body must be valid JSON",
+                    }
+                ),
+                400,
+            )
+
+        # 3. Token 校验
+        if not is_token_valid(request, data, cfg.token, cfg.require_token):
+            logging.warning(f"Token校验失败: {client_ip}")
+            return (
+                jsonify(
+                    {
+                        "code": 401,
+                        "message": "Unauthorized",
+                        "error_detail": "Invalid or missing token",
+                    }
+                ),
+                401,
+            )
+
+        # 4. 必需字段
+        if not data or "text" not in data:
+            logging.error("缺少必需字段 'text'")
+            return (
+                jsonify(
+                    {
+                        "code": 400,
+                        "message": "Missing required field: text",
+                        "error_detail": 'The "text" field is required',
+                    }
+                ),
+                400,
+            )
+
+        # 5. 解析字段
+        text = str(data["text"])
+        timestamp = data.get("timestamp", int(time.time() * 1000))
+        device_id = data.get("device_id", "unknown")
+        action = data.get("action", "paste" if cfg.auto_paste else "copy")
+        restore_clipboard = bool(data.get("restore_clipboard", False))
+
+        # 6. 时间戳偏差警告
+        current_time = int(time.time() * 1000)
+        if abs(current_time - timestamp) > 30000:
+            logging.warning(f"时间戳偏差过大: {current_time - timestamp}ms")
+
+        # 7. 执行剪贴板和键盘操作
+        try:
+            import pyclip
+
+            # 仅在需要恢复且不是"仅复制"模式时保存原剪贴板
+            need_restore = restore_clipboard and action != "copy"
+            old_clipboard = _save_clipboard() if need_restore else None
+
+            pyclip.copy(text)
+
+            with app.voice_history_lock:
+                app.voice_history_counter += 1
+                app.voice_history.appendleft(
+                    {
+                        "id": app.voice_history_counter,
+                        "server_time": current_time,
+                        "client_ip": client_ip,
+                        "device_id": device_id,
+                        "action": action,
+                        "text": text,
+                    }
+                )
+
+            logging.info(
+                f"已复制到剪贴板 (长度: {len(text)}, 设备: {device_id}, "
+                f"IP: {client_ip}, action: {action})"
+            )
+
+            if action in ("paste", "paste_terminal", "type"):
+                _do_keyboard_action(action, text)
+
+            # 恢复原有剪贴板内容
+            if need_restore:
+                _restore_clipboard(old_clipboard)
+
+            return jsonify(
+                {
+                    "code": 200,
+                    "message": "success",
+                    "server_time": current_time,
+                    "processed_text_length": len(text),
+                    "action": action,
+                    "device_id": device_id,
+                    "clipboard_restored": need_restore,
+                }
+            )
+
+        except Exception as e:
+            logging.error(f"服务器内部错误: {e}")
+            return (
+                jsonify(
+                    {
+                        "code": 500,
+                        "message": "Internal server error",
+                        "error_detail": str(e),
+                    }
+                ),
+                500,
+            )
+
+    # ==================== 错误处理器 ====================
+
+    @app.errorhandler(413)
+    def request_entity_too_large(error):
+        return (
+            jsonify(
+                {
+                    "code": 413,
+                    "message": "Payload too large",
+                    "error_detail": f"Exceeds {config.max_content_length} bytes",
+                }
+            ),
+            413,
+        )
+
+    return app