求助: vocotype-fcitx5-backend

[abcabc0330]

使用方法

1. 启动后台服务
   方式 A：手动启动（临时）

vocotype-fcitx5-backend &
方式 B：systemd 自动启动（推荐）

启用并启动服务

systemctl --user enable vocotype-fcitx5-backend.service
systemctl --user start vocotype-fcitx5-backend.service

查看服务状态

systemctl --user status vocotype-fcitx5-backend.service

查看日志

journalctl --user -u vocotype-fcitx5-backend.service -f

vocotype-fcitx5-backend ,这段复制到终端，不能正确运行。
vocotype-fcitx5-backend ，这个不知道怎么来的。 前面的都是没有问题，模型测试也没有问题。

就是在使用的时候，突然出现一个： vocotype-fcitx5-backend 。。 就不知道弄的了

[abcabc0330]

2026-01-09 20:00:20,303 - main - INFO - Fcitx5 Backend 已启动，监听: /tmp/vocotype-fcitx5.sock
2026-01-09 20:02:08,815 - main - ERROR - 处理请求失败: [Errno 32] Broken pipe
Traceback (most recent call last):
File "/home/abc/.local/share/vocotype-fcitx5/backend/fcitx5_server.py", line 180, in handle_client
conn.sendall(response_str.encode('utf-8'))
~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
BrokenPipeError: [Errno 32] Broken pipe
2026-01-09 20:02:08,817 - main - ERROR - 接受连接失败: [Errno 32] Broken pipe
^[[A2026-01-09 20:04:16,166 - main - ERROR - 处理请求失败: [Errno 32] Broken pipe
Traceback (most recent call last):
File "/home/abc/.local/share/vocotype-fcitx5/backend/fcitx5_server.py", line 180, in handle_client
conn.sendall(response_str.encode('utf-8'))
~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
BrokenPipeError: [Errno 32] Broken pipe
2026-01-09 20:04:16,168 - main - ERROR - 接受连接失败: [Errno 32] Broken pipe

[abcabc0330]

#!/usr/bin/env python3
"""Fcitx 5 Python 后端服务（语音 + Rime）

此服务作为独立进程运行，通过 Unix Socket 接收来自 C++ Addon 的请求，
提供语音识别和 Rime 拼音输入功能。
"""
from future import annotations

import sys
import os
import json
import socket
import logging
import signal
from pathlib import Path
import errno

添加项目根目录到 path

PROJECT_ROOT = Path(file).parent.parent
sys.path.insert(0, str(PROJECT_ROOT))

from app.funasr_server import FunASRServer
from backend.rime_handler import RimeHandler

配置日志

logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
handlers=[
logging.StreamHandler(sys.stderr),
]
)
logger = logging.getLogger(name)

SOCKET_PATH = "/tmp/vocotype-fcitx5.sock"

class Fcitx5Backend:
"""Fcitx 5 Python 后端服务

职责：
1. 接收语音识别请求，调用 FunASRServer
2. 接收 Rime 按键请求，调用 RimeHandler
3. 通过 IPC 返回结果给 C++ Addon
"""

def __init__(self):
    # 语音识别服务
    logger.info("正在初始化 FunASR 服务器...")
    self.asr_server = FunASRServer()
    asr_result = self.asr_server.initialize()
    if not asr_result['success']:
        logger.error("FunASR 初始化失败: %s", asr_result.get('error'))
        sys.exit(1)
    logger.info("FunASR 服务器初始化成功")

    # Rime 处理器
    self.rime_handler = RimeHandler()
    if self.rime_handler.available:
        logger.info("Rime 集成已启用")
    else:
        logger.info("Rime 集成未启用（纯语音模式）")

    # 标记运行状态
    self.running = True

    # 注册信号处理
    signal.signal(signal.SIGTERM, self._signal_handler)
    signal.signal(signal.SIGINT, self._signal_handler)

def _signal_handler(self, signum, frame):
    """信号处理器"""
    logger.info("收到信号 %d，准备退出...", signum)
    self.running = False

def _is_connection_alive(self, conn: socket.socket) -> bool:
    """检查连接是否仍然活跃"""
    try:
        # 检查 socket 文件描述符是否有效
        if conn.fileno() == -1:
            return False
        
        # 尝试非阻塞地检查 socket 状态
        conn.setblocking(False)
        try:
            data = conn.recv(1, socket.MSG_PEEK)
            if not data:  # 对端已关闭
                return False
        except BlockingIOError:
            # 没有数据可读，但连接仍然活跃
            pass
        except ConnectionResetError:
            return False
        except OSError as e:
            if e.errno in (errno.EBADF, errno.ENOTCONN, errno.EPIPE):
                return False
        finally:
            conn.setblocking(True)
            
        return True
    except Exception as e:
        logger.debug("检查连接状态时出错: %s", e)
        return False

def run(self):
    """运行 IPC 服务器"""
    # 删除旧的 socket 文件
    if os.path.exists(SOCKET_PATH):
        try:
            os.remove(SOCKET_PATH)
        except OSError as e:
            logger.warning("删除旧 socket 文件失败: %s", e)

    # 创建 Unix Socket
    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    # 设置 SO_REUSEADDR 选项
    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    sock.bind(SOCKET_PATH)
    sock.listen(5)
    sock.settimeout(1.0)  # 设置超时以便处理信号

    logger.info("Fcitx5 Backend 已启动，监听: %s", SOCKET_PATH)

    try:
        while self.running:
            try:
                conn, _ = sock.accept()
                # 设置客户端连接的超时
                conn.settimeout(30.0)  # 30秒超时
                self.handle_client(conn)
            except socket.timeout:
                continue
            except (BrokenPipeError, ConnectionResetError) as e:
                if self.running:
                    logger.warning("连接异常: %s", e)
            except OSError as e:
                if self.running:
                    if e.errno == errno.EINTR:
                        # 被信号中断，继续
                        continue
                    logger.error("接受连接失败: %s", e)
            except Exception as exc:
                if self.running:
                    logger.error("接受连接失败: %s", exc)
    finally:
        sock.close()
        try:
            if os.path.exists(SOCKET_PATH):
                os.remove(SOCKET_PATH)
        except OSError as e:
            logger.warning("清理 socket 文件失败: %s", e)
        logger.info("Fcitx5 Backend 已停止")

def handle_client(self, conn: socket.socket):
    """处理客户端请求

    IPC 协议：
    - 请求格式：JSON 字符串
    - 响应格式：JSON 字符串

    请求类型：
    1. transcribe: 语音识别
       {"type": "transcribe", "audio_path": "/tmp/xxx.wav"}
       -> {"success": true, "text": "识别结果"}

    2. key_event: Rime 按键处理
       {"type": "key_event", "keyval": 97, "mask": 0}
       -> {"handled": true, "commit": "...", "preedit": {...}, ...}

    3. reset: 重置 Rime 状态
       {"type": "reset"}
       -> {"success": true}

    4. ping: 健康检查
       {"type": "ping"}
       -> {"pong": true}
    """
    try:
        # 接收请求（读到 EOF）
        chunks = []
        while True:
            try:
                chunk = conn.recv(8192)
                if not chunk:
                    break
                chunks.append(chunk)
            except socket.timeout:
                logger.warning("接收请求超时")
                return
            except (BrokenPipeError, ConnectionResetError) as e:
                logger.warning("接收数据时连接断开: %s", e)
                return
            except OSError as e:
                if e.errno == errno.EINTR:
                    continue  # 被信号中断，继续接收
                logger.error("接收数据失败: %s", e)
                return

        if not chunks:
            return
        data = b''.join(chunks).decode('utf-8')

        request = json.loads(data)
        req_type = request.get('type')

        logger.debug("收到请求: type=%s", req_type)

        # 处理请求
        if req_type == 'transcribe':
            # 语音识别
            audio_path = request.get('audio_path')
            if not audio_path:
                response = {"success": False, "error": "缺少 audio_path 参数"}
            else:
                result = self.asr_server.transcribe_audio(audio_path)
                response = result

        elif req_type == 'key_event':
            # Rime 按键处理
            keyval = request.get('keyval')
            mask = request.get('mask', 0)
            if keyval is None:
                response = {"handled": False, "error": "缺少 keyval 参数"}
            else:
                result = self.rime_handler.process_key(keyval, mask)
                response = result

        elif req_type == 'reset':
            # 重置 Rime
            self.rime_handler.reset()
            response = {"success": True}

        elif req_type == 'ping':
            # 健康检查
            response = {"pong": True}

        else:
            response = {"error": f"未知的请求类型: {req_type}"}

        # 发送响应 - 增加 BrokenPipeError 处理
        try:
            response_str = json.dumps(response, ensure_ascii=False)
            response_bytes = response_str.encode('utf-8')
            
            # 检查连接是否还活跃
            if not self._is_connection_alive(conn):
                logger.warning("客户端已断开连接，跳过发送响应")
                return
            
            conn.sendall(response_bytes)
            logger.debug("已发送响应: %d 字节", len(response_str))

        except (BrokenPipeError, ConnectionResetError) as e:
            logger.warning("客户端已断开连接，无法发送响应: %s", e)
        except OSError as e:
            if e.errno == errno.EPIPE:
                logger.warning("管道破裂，客户端已断开连接")
            elif e.errno in (errno.EBADF, errno.ENOTCONN):
                logger.warning("无效的 socket 描述符或未连接")
            else:
                logger.error("发送响应失败: %s", e)
                raise

    except json.JSONDecodeError as exc:
        logger.error("JSON 解析失败: %s", exc)
        error_response = json.dumps({"error": "Invalid JSON"})
        self._safe_send(conn, error_response)

    except Exception as exc:
        logger.error("处理请求失败: %s", exc)
        import traceback
        traceback.print_exc()
        error_response = json.dumps({"error": str(exc)})
        self._safe_send(conn, error_response)

    finally:
        try:
            conn.close()
        except OSError as e:
            if e.errno != errno.EBADF:  # 忽略"Bad file descriptor"错误
                logger.debug("关闭连接时出错: %s", e)

def _safe_send(self, conn: socket.socket, data: str):
    """安全地发送数据，处理各种异常"""
    try:
        if not self._is_connection_alive(conn):
            return
        
        conn.sendall(data.encode('utf-8'))
    except (BrokenPipeError, ConnectionResetError, OSError) as e:
        logger.debug("安全发送失败: %s", e)

def cleanup(self):
    """清理资源"""
    logger.info("正在清理资源...")
    try:
        if hasattr(self, 'asr_server') and self.asr_server:
            self.asr_server.cleanup()
        if hasattr(self, 'rime_handler') and self.rime_handler:
            self.rime_handler.cleanup()
    except Exception as exc:
        logger.error("清理资源失败: %s", exc)

def main():
"""主入口"""
global SOCKET_PATH
import argparse

parser = argparse.ArgumentParser(
    description='VoCoType Fcitx5 Backend Server'
)
parser.add_argument(
    '--socket',
    default=SOCKET_PATH,
    help=f'Unix socket path (default: {SOCKET_PATH})'
)
parser.add_argument(
    '--debug',
    action='store_true',
    help='Enable debug logging'
)
parser.add_argument(
    '--verbose',
    action='store_true',
    help='Enable verbose logging'
)
args = parser.parse_args()

if args.debug:
    logging.getLogger().setLevel(logging.DEBUG)
elif args.verbose:
    logging.getLogger().setLevel(logging.INFO)

SOCKET_PATH = args.socket

backend = Fcitx5Backend()
try:
    backend.run()
except KeyboardInterrupt:
    logger.info("收到 Ctrl+C，退出...")
except Exception as e:
    logger.exception("未捕获的异常: %s", e)
finally:
    backend.cleanup()

# 确保进程正常退出
sys.exit(0)

if name == 'main':
main()

[abcabc0330]

用ai修改代码之后。在fcitx 中，依然找不到这个输入法。无法添加。

[LeonardNJU]

您现在还会遇到这个问题吗？试试最新版本(?