cnks 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

src/server.py

@@ -9,60 +9,16 @@
 
 Exposed Tools:
 - search_keyword: 搜索指定关键词并获取相关引用
-- process_link: 处理特定链接并提取引用信息
-- close_browser: 关闭浏览器实例
 """
 
 import asyncio
 import json
-import logging
 import os
 import sys
 import time
-import traceback
 import uuid
 from typing import Dict, List, Any, Optional
 
-# 配置日志记录
-try:
-    # 尝试使用绝对路径
-    log_dir = os.path.dirname(os.path.abspath(__file__))
-    log_file = os.path.join(os.path.dirname(log_dir), "cnks_server.log")
-    
-    # 创建处理器
-    file_handler = logging.FileHandler(log_file, mode="a")
-    console_handler = logging.StreamHandler()
-    
-    # 设置格式
-    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-    file_handler.setFormatter(formatter)
-    console_handler.setFormatter(formatter)
-    
-    # 获取日志记录器并添加处理器
-    logger = logging.getLogger("cnks.server")
-    logger.setLevel(logging.DEBUG)
-    
-    # 移除现有处理器以避免重复
-    if logger.handlers:
-        for handler in logger.handlers:
-            logger.removeHandler(handler)
-    
-    logger.addHandler(file_handler)
-    logger.addHandler(console_handler)
-    
-    # 打印确认信息
-    print(f"Server logger initialized, logging to: {log_file}")
-    logger.info(f"Server logging to: {log_file}")
-except Exception as e:
-    # 回退到基本控制台日志记录
-    logging.basicConfig(
-        level=logging.DEBUG,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
-    logger = logging.getLogger("cnks.server")
-    logger.error(f"Failed to set up file logging: {str(e)}")
-    print(f"Error setting up server file logging: {str(e)}")
-
 # 导入MCP服务器模块
 try:
     from mcp.server.models import InitializationOptions
@@ -72,14 +28,14 @@ try:
     MCP_AVAILABLE = True
 except ImportError:
     MCP_AVAILABLE = False
-    logger.error("MCP not available. Install with: pip install mcp-py")
+    print("MCP不可用。请安装: pip install mcp-py")
 
 # 尝试导入dotenv支持环境变量
 try:
     from dotenv import load_dotenv
     load_dotenv()
 except ImportError:
-    logger.warning("dotenv not available, environment variables may not be loaded")
+    pass
 
 # 导入Worker模块
 try:
@@ -88,8 +44,8 @@ except ImportError:
     try:
         from worker import Worker
     except ImportError:
-        logger.error("Worker module not available")
-        raise ImportError("Worker module not available")
+        print("Worker模块不可用")
+        raise ImportError("Worker模块不可用")
 
 # 初始化MCP服务器
 server = Server("CNKS Server")
@@ -149,25 +105,6 @@ async def handle_list_tools() -> list[types.Tool]:
                 },
                 "required": ["keyword"]
             }
-        ),
-        types.Tool(
-            name="process_link",
-            description="处理特定链接并提取引用信息",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "link": {"type": "string", "description": "要处理的文章链接"}
-                },
-                "required": ["link"]
-            }
-        ),
-        types.Tool(
-            name="close_browser",
-            description="关闭浏览器资源",
-            inputSchema={
-                "type": "object",
-                "properties": {}
-            }
         )
     ]
 
@@ -189,7 +126,7 @@ class SearchKeywordToolHandler(ToolHandler):
             return [types.TextContent(type="text", text="错误: 关键词不能为空")]
         
         message_id = str(uuid.uuid4())
-        logger.info(f"开始处理关键词: {keyword}")
+        print(f"开始处理关键词: {keyword}")
         
         try:
             # 记录请求
@@ -210,8 +147,7 @@ class SearchKeywordToolHandler(ToolHandler):
             
         except Exception as e:
             error_msg = f"处理关键词 '{keyword}' 时出错: {str(e)}"
-            logger.error(error_msg)
-            logger.error(traceback.format_exc())
+            print(error_msg)
             
             # 更新请求状态
             active_requests[message_id]["status"] = "error"
@@ -219,61 +155,9 @@ class SearchKeywordToolHandler(ToolHandler):
             
             return [types.TextContent(type="text", text=f"错误: {error_msg}")]
 
-class ProcessLinkToolHandler(ToolHandler):
-    async def handle(self, name: str, arguments: dict | None) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
-        link = arguments.get("link", "")
-        
-        if not link:
-            return [types.TextContent(type="text", text="错误: 链接不能为空")]
-        
-        message_id = str(uuid.uuid4())
-        logger.info(f"开始处理链接: {link}")
-        
-        try:
-            # 记录请求
-            active_requests[message_id] = {
-                "link": link,
-                "status": "processing",
-                "timestamp": time.time()
-            }
-            
-            # 调用Worker API处理链接
-            result = await worker_instance.citzer.process_link(link)
-            logger.info(f"链接 '{link}' 处理完成")
-            
-            # 更新请求状态
-            active_requests[message_id]["status"] = "completed"
-            
-            # 返回结果
-            return [types.TextContent(type="text", text=json.dumps(result, ensure_ascii=False, indent=2))]
-            
-        except Exception as e:
-            error_msg = f"处理链接 '{link}' 时出错: {str(e)}"
-            logger.error(error_msg)
-            logger.error(traceback.format_exc())
-            
-            # 更新请求状态
-            active_requests[message_id]["status"] = "error"
-            active_requests[message_id]["error"] = str(e)
-            
-            return [types.TextContent(type="text", text=f"错误: {error_msg}")]
-
-class CloseBrowserToolHandler(ToolHandler):
-    async def handle(self, name: str, arguments: dict | None) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
-        try:
-            await worker_instance.close()
-            logger.info("浏览器资源已关闭")
-            return [types.TextContent(type="text", text="浏览器资源已成功关闭")]
-        except Exception as e:
-            error_msg = f"关闭浏览器失败: {str(e)}"
-            logger.error(error_msg)
-            return [types.TextContent(type="text", text=f"错误: {error_msg}")]
-
 # 工具处理器映射表
 tool_handlers = {
-    "search_keyword": SearchKeywordToolHandler(),
-    "process_link": ProcessLinkToolHandler(),
-    "close_browser": CloseBrowserToolHandler()
+    "search_keyword": SearchKeywordToolHandler()
 }
 
 @server.call_tool()
@@ -290,12 +174,12 @@ async def handle_call_tool(
     Returns:
         list: 包含文本或图像内容的响应
     """
-    logger.info(f"收到工具调用请求: {name}, 参数: {arguments}")
+    print(f"收到工具调用请求: {name}, 参数: {arguments}")
     
     if name in tool_handlers:
         return await tool_handlers[name].handle(name, arguments)
     else:
-        logger.error(f"未知工具: {name}")
+        print(f"未知工具: {name}")
         return [types.TextContent(type="text", text=f"错误: 未知工具: {name}")]
 
 def cleanup_expired_requests():
@@ -311,7 +195,7 @@ def cleanup_expired_requests():
     # 移除过期请求
     for msg_id in expired_ids:
         active_requests.pop(msg_id, None)
-        logger.info(f"已清理过期请求: {msg_id}")
+        print(f"已清理过期请求: {msg_id}")
 
 async def handle_simple_request(reader, writer):
     """
@@ -323,11 +207,11 @@ async def handle_simple_request(reader, writer):
         # 读取请求
         request_line = await reader.readline()
         if not request_line:
-            logger.error("收到空请求")
+            print("收到空请求")
             return
             
         request_data = json.loads(request_line.decode('utf-8'))
-        logger.info(f"收到请求: {request_data}")
+        print(f"收到请求: {request_data}")
         
         # 处理请求
         if request_data.get("type") == "tool_call":
@@ -363,35 +247,6 @@ async def handle_simple_request(reader, writer):
                             response = {"status": "error", "message": "处理器未返回结果"}
                     else:
                         response = {"status": "error", "message": "找不到工具处理器"}
-            elif tool_name == "process_link":
-                # 获取参数
-                link = params.get("link", "")
-                
-                if not link:
-                    response = {"status": "error", "message": "链接不能为空"}
-                else:
-                    # 调用处理器
-                    handler = tool_handlers.get("process_link")
-                    
-                    if handler:
-                        result_content = await handler.handle("process_link", params)
-                        if result_content and len(result_content) > 0:
-                            # 从TextContent提取JSON字符串并解析
-                            try:
-                                result_data = json.loads(result_content[0].text)
-                                response = {
-                                    "status": "success", 
-                                    "result": result_data
-                                }
-                            except json.JSONDecodeError:
-                                response = {
-                                    "status": "success", 
-                                    "result": {"message": result_content[0].text}
-                                }
-                        else:
-                            response = {"status": "error", "message": "处理器未返回结果"}
-                    else:
-                        response = {"status": "error", "message": "找不到工具处理器"}
             else:
                 response = {"status": "error", "message": f"未知工具: {tool_name}"}
         else:
@@ -402,12 +257,11 @@ async def handle_simple_request(reader, writer):
         await writer.drain()
         
     except json.JSONDecodeError:
-        logger.error("无法解析JSON请求")
+        print("无法解析JSON请求")
         writer.write(json.dumps({"status": "error", "message": "无法解析JSON请求"}).encode('utf-8') + b'\n')
         await writer.drain()
     except Exception as e:
-        logger.error(f"处理请求时出错: {str(e)}")
-        logger.error(traceback.format_exc())
+        print(f"处理请求时出错: {str(e)}")
         writer.write(json.dumps({"status": "error", "message": f"服务器错误: {str(e)}"}).encode('utf-8') + b'\n')
         await writer.drain()
     finally:
@@ -426,7 +280,7 @@ async def run_simple_server():
     )
     
     addr = server.sockets[0].getsockname()
-    logger.info(f'简易服务器运行在 {addr}')
+    print(f'简易服务器运行在 {addr}')
     
     async with server:
         await server.serve_forever()
@@ -437,22 +291,21 @@ async def main():
     """
     try:
         print("正在启动CNKS服务器...")
-        logger.info("正在启动CNKS服务器")
         
         # 检查MCP是否可用
         if not MCP_AVAILABLE:
-            logger.warning("MCP模块不可用，使用简单服务器替代")
+            print("MCP模块不可用，使用简单服务器替代")
             await run_simple_server()
             return
         
         # 检查是否从命令行直接运行或被导入
         if sys.stdin.isatty():
             # 命令行运行，启动简单服务器
-            logger.info("从命令行运行，启动简单服务器")
+            print("从命令行运行，启动简单服务器")
             await run_simple_server()
         else:
             # 标准输入/输出流可用，使用stdio模式运行MCP服务器
-            logger.info("检测到标准输入/输出流，启动MCP标准服务器")
+            print("检测到标准输入/输出流，启动MCP标准服务器")
             async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
                 await server.run(
                     read_stream,
@@ -469,18 +322,15 @@ async def main():
             
     except KeyboardInterrupt:
         print("\n收到中断信号，服务器正在关闭...")
-        logger.info("收到中断信号，服务器正在关闭")
     except Exception as e:
-        logger.error(f"服务器启动失败: {str(e)}")
-        logger.error(traceback.format_exc())
         print(f"服务器启动失败: {str(e)}")
     finally:
         # 关闭Worker资源
         try:
             await worker_instance.close()
-            logger.info("Worker资源已关闭")
+            print("Worker资源已关闭")
         except Exception as e:
-            logger.error(f"关闭Worker资源时出错: {str(e)}")
+            print(f"关闭Worker资源时出错: {str(e)}")
 
 if __name__ == "__main__":
     # 启动主循环

src/worker.py

@@ -16,51 +16,41 @@
 
 import asyncio
 import json
-import logging
 import os
 import traceback
 import time
 from typing import Dict, List, Any, Optional, Union
 
-# 配置日志记录
-try:
-    # 尝试使用绝对路径
-    log_dir = os.path.dirname(os.path.abspath(__file__))
-    log_file = os.path.join(os.path.dirname(log_dir), "cnks_worker.log")
+# 禁用日志记录
+class DummyLogger:
+    """空日志记录器，用于禁用日志输出"""
+    def __init__(self, *args, **kwargs):
+        pass
+    
+    def debug(self, *args, **kwargs):
+        pass
     
-    # 创建处理器
-    file_handler = logging.FileHandler(log_file, mode="a")
-    console_handler = logging.StreamHandler()
+    def info(self, *args, **kwargs):
+        pass
     
-    # 设置格式
-    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-    file_handler.setFormatter(formatter)
-    console_handler.setFormatter(formatter)
+    def warning(self, *args, **kwargs):
+        pass
     
-    # 获取日志记录器并添加处理器
-    logger = logging.getLogger("cnks.worker")
-    logger.setLevel(logging.DEBUG)
+    def error(self, *args, **kwargs):
+        pass
     
-    # 移除现有处理器以避免重复
-    if logger.handlers:
-        for handler in logger.handlers:
-            logger.removeHandler(handler)
+    def critical(self, *args, **kwargs):
+        pass
     
-    logger.addHandler(file_handler)
-    logger.addHandler(console_handler)
+    def addHandler(self, *args, **kwargs):
+        pass
     
-    # 打印确认信息
-    print(f"Worker logger initialized, logging to: {log_file}")
-    logger.info(f"Worker logging to: {log_file}")
-except Exception as e:
-    # 回退到基本控制台日志记录
-    logging.basicConfig(
-        level=logging.DEBUG,
-        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-    )
-    logger = logging.getLogger("cnks.worker")
-    logger.error(f"Failed to set up file logging: {str(e)}")
-    print(f"Error setting up worker file logging: {str(e)}")
+    def setLevel(self, *args, **kwargs):
+        pass
+
+# 使用空日志记录器
+logger = DummyLogger()
+print = lambda *args, **kwargs: None  # 禁用print函数
 
 # 导入其他模块
 try:
@@ -73,7 +63,7 @@ except ImportError:
         from citzer import Citzer
         from cache import Cache
     except ImportError:
-        logger.warning("无法导入searcher、citzer或cache模块，功能将受限")
+        pass
 
 class Worker:
     """
@@ -90,7 +80,6 @@ class Worker:
         self.citzer.browser_started = False
         # 创建Cache实例
         self.cache = Cache()
-        logger.info("Worker初始化完成")
     
     async def process_keyword(self, keyword: str) -> Dict[str, Any]:
         """
@@ -102,29 +91,20 @@ class Worker:
         Returns:
             Dict[str, Any]: 包含处理结果的字典
         """
-        logger.info(f"处理关键词请求: {keyword}")
-        
         try:
             # 检查缓存中是否有该关键词
             if not self.cache.has_keyword(keyword):
-                logger.info(f"缓存中没有关键词 {keyword}，执行搜索")
-                
                 # 使用searcher搜索关键词
                 links = await self.searcher.search_keyword(keyword)
-                logger.info(f"搜索到 {len(links)} 个链接")
                 
                 # 将结果存入缓存
                 self.cache.add_links(keyword, links)
-                logger.info(f"已将关键词 {keyword} 的链接存入缓存")
-            else:
-                logger.info(f"缓存中已有关键词 {keyword}")
             
             # 将Searcher的浏览器实例共享给Citzer
             if self.searcher.browser_started and not self.citzer.browser_started:
                 self.citzer.context = self.searcher.context
                 self.citzer.playwright = self.searcher.playwright
                 self.citzer.browser_started = True
-                logger.info("已将Searcher的浏览器实例共享给Citzer")
             
             # 处理缓存中未处理的链接
             while True:
@@ -132,26 +112,20 @@ class Worker:
                 link = self.cache.get_unprocessed_link(keyword)
                 
                 if not link:
-                    logger.info(f"关键词 {keyword} 的所有链接已处理完毕")
                     break
                 
-                logger.info(f"处理链接: {link}")
-                
                 # 使用citzer处理链接
                 result = await self.citzer.process_link(link)
                 
                 if result:
                     # 将结果存入缓存
                     self.cache.add_result(link, result)
-                    logger.info(f"已将链接 {link} 的处理结果存入缓存")
                 
                 # 标记链接为已处理
                 self.cache.mark_as_processed(link)
-                logger.info(f"已标记链接 {link} 为已处理")
             
             # 获取所有处理结果
             results = self.cache.get_all_results(keyword)
-            logger.info(f"关键词 {keyword} 的处理结果数量: {len(results)}")
             
             return {
                 "success": True,
@@ -160,9 +134,6 @@ class Worker:
             }
             
         except Exception as e:
-            logger.error(f"处理关键词 {keyword} 时出错: {str(e)}")
-            logger.error(traceback.format_exc())
-            
             return {
                 "success": False,
                 "keyword": keyword,
@@ -176,8 +147,8 @@ class Worker:
                 self.citzer.browser_started = False
                 # 关闭Searcher的浏览器
                 await self.searcher.close_browser()
-            except Exception as e:
-                logger.warning(f"关闭浏览器时出错: {str(e)}")
+            except Exception:
+                pass
     
     async def close(self):
         """关闭工作者资源"""
@@ -189,10 +160,8 @@ class Worker:
             
             # 关闭Searcher的浏览器
             await self.searcher.close_browser()
-            logger.info("已关闭工作者资源")
-        except Exception as e:
-            logger.error(f"关闭工作者资源时出错: {str(e)}")
-            logger.error(traceback.format_exc())
+        except Exception:
+            pass
         
 # 如果作为主程序运行，提供测试功能
 async def main():
@@ -202,14 +171,9 @@ async def main():
     try:
         # 测试关键词
         test_keyword = "人工智能"
-        print(f"测试处理关键词: {test_keyword}")
         
         # 处理关键词
         result = await worker.process_keyword(test_keyword)
-        
-        # 打印结果
-        print(f"处理结果:")
-        print(json.dumps(result, ensure_ascii=False, indent=2))
     finally:
         # 关闭资源
         await worker.close()