Update biopython/mcp_output/mcp_plugin/mcp_service.py

biopython/mcp_output/mcp_plugin/mcp_service.py

@@ -1,5 +1,7 @@
 import os
 import sys
+import ast
+import importlib
 from io import StringIO
 
 # Ensure Biopython source is importable when running the MCP service
@@ -9,29 +11,42 @@ if source_path not in sys.path:
 
 from fastmcp import FastMCP
 
-# Core Biopython utilities from setup.py
-# setup.py expects to be executed from the source root to find Bio/__init__.py
-_orig_cwd = os.getcwd()
-try:
-    os.chdir(source_path)
-    from setup import can_import as biopy_can_import
-    from setup import get_version as biopy_get_version
-finally:
-    os.chdir(_orig_cwd)
-
-# Script entrypoints (aliased to avoid name shadowing)
-from Scripts.query_pubmed import print_usage as query_pubmed_print_usage
-from Scripts.update_ncbi_codon_table import line_wrap as codon_line_wrap
-from Scripts.scop_pdb import main as scop_main
-from Scripts.scop_pdb import open_pdb as scop_open_pdb
-from Scripts.scop_pdb import usage as scop_usage
-from Scripts.xbbtools.nextorf import MissingTable
-from Scripts.xbbtools.nextorf import NextOrf
-from Scripts.xbbtools.nextorf import help as nextorf_help
-from Scripts.xbbtools.nextorf import makeTableX
-from Scripts.xbbtools.xbb_utils import NotePad
-
-# Biopython top-level version
+# Lightweight stand-ins for setup.py utilities to avoid running setup()
+def biopy_can_import(module_name):
+    try:
+        return importlib.import_module(module_name)
+    except ImportError:
+        return None
+
+
+def biopy_get_version():
+    init_path = os.path.join(source_path, "Bio", "__init__.py")
+    try:
+        with open(init_path, "r", encoding="utf-8") as handle:
+            for line in handle:
+                if line.startswith("__version__ = "):
+                    return ast.literal_eval(line.split("=", 1)[1].strip())
+    except FileNotFoundError:
+        return "Unknown"
+    return "Unknown"
+
+# ✅ 延迟导入：只在需要时才导入 Scripts 模块
+# 这样可以避免在服务启动时触发 setuptools
+_scripts_cache = {}
+
+def lazy_import_script(module_path, attr_name):
+    """延迟导入 Scripts 模块中的函数或类"""
+    cache_key = f"{module_path}.{attr_name}"
+    if cache_key not in _scripts_cache:
+        try:
+            module = importlib.import_module(module_path)
+            _scripts_cache[cache_key] = getattr(module, attr_name)
+        except Exception as e:
+            print(f"⚠️ Warning: Could not import {cache_key}: {e}")
+            _scripts_cache[cache_key] = None
+    return _scripts_cache[cache_key]
+
+# Biopython top-level imports (这些是安全的)
 from Bio import __version__ as bio_version
 from Bio import Entrez, SeqIO, pairwise2, Phylo, AlignIO
 from Bio.PDB import PDBParser
@@ -72,7 +87,10 @@ def bio_version_tool(payload: dict | None = None):
 @mcp.tool(name="query_pubmed_print_usage", description="Print usage for query_pubmed script")
 def print_usage_tool(payload: dict | None = None):
     try:
-        result = query_pubmed_print_usage()
+        func = lazy_import_script("Scripts.query_pubmed", "print_usage")
+        if func is None:
+            return {"success": False, "result": None, "error": "Function not available"}
+        result = func()
         return {"success": True, "result": result, "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
@@ -80,7 +98,10 @@ def print_usage_tool(payload: dict | None = None):
 @mcp.tool(name="line_wrap", description="Wrap long strings (from update_ncbi_codon_table.py)")
 def line_wrap_tool(payload: dict):
     try:
-        result = codon_line_wrap(**payload)
+        func = lazy_import_script("Scripts.update_ncbi_codon_table", "line_wrap")
+        if func is None:
+            return {"success": False, "result": None, "error": "Function not available"}
+        result = func(**payload)
         return {"success": True, "result": result, "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
@@ -88,7 +109,10 @@ def line_wrap_tool(payload: dict):
 @mcp.tool(name="scop_main", description="Extract SCOP domain PDB records (Scripts/scop_pdb.py main)")
 def scop_main_tool(payload: dict | None = None):
     try:
-        result = scop_main()
+        func = lazy_import_script("Scripts.scop_pdb", "main")
+        if func is None:
+            return {"success": False, "result": None, "error": "Function not available"}
+        result = func()
         return {"success": True, "result": result, "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
@@ -96,7 +120,10 @@ def scop_main_tool(payload: dict | None = None):
 @mcp.tool(name="scop_open_pdb", description="Download/open a PDB file (Scripts/scop_pdb.py open_pdb)")
 def open_pdb_tool(payload: dict):
     try:
-        result = scop_open_pdb(**payload)
+        func = lazy_import_script("Scripts.scop_pdb", "open_pdb")
+        if func is None:
+            return {"success": False, "result": None, "error": "Function not available"}
+        result = func(**payload)
         return {"success": True, "result": str(result), "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
@@ -104,7 +131,10 @@ def open_pdb_tool(payload: dict):
 @mcp.tool(name="scop_usage", description="Print usage for scop_pdb.py")
 def usage_tool(payload: dict | None = None):
     try:
-        result = scop_usage()
+        func = lazy_import_script("Scripts.scop_pdb", "usage")
+        if func is None:
+            return {"success": False, "result": None, "error": "Function not available"}
+        result = func()
         return {"success": True, "result": result, "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
@@ -113,8 +143,9 @@ def usage_tool(payload: dict | None = None):
 def notepad_tool(*args, **kwargs):
     """NotePad class"""
     try:
+        NotePad = lazy_import_script("Scripts.xbbtools.xbb_utils", "NotePad")
         if NotePad is None:
-            return {"success": False, "result": None, "error": "Class NotePad is not available, path may need adjustment"}
+            return {"success": False, "result": None, "error": "Class NotePad is not available"}
         
         # MCP parameter type conversion
         converted_args = []
@@ -123,7 +154,6 @@ def notepad_tool(*args, **kwargs):
         # Handle position argument type conversion
         for arg in args:
             if isinstance(arg, str):
-                # Try to convert to numeric type
                 try:
                     if '.' in arg:
                         converted_args.append(float(arg))
@@ -153,7 +183,10 @@ def notepad_tool(*args, **kwargs):
 @mcp.tool(name="nextorf_help", description="Help text for NextOrf (Scripts/xbbtools/nextorf.py)")
 def help_tool(payload: dict | None = None):
     try:
-        result = nextorf_help()
+        func = lazy_import_script("Scripts.xbbtools.nextorf", "help")
+        if func is None:
+            return {"success": False, "result": None, "error": "Function not available"}
+        result = func()
         return {"success": True, "result": result, "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
@@ -161,7 +194,10 @@ def help_tool(payload: dict | None = None):
 @mcp.tool(name="makeTableX", description="Generate NextOrf lookup table (Scripts/xbbtools/nextorf.py)")
 def makeTableX_tool(payload: dict):
     try:
-        result = makeTableX(**payload)
+        func = lazy_import_script("Scripts.xbbtools.nextorf", "makeTableX")
+        if func is None:
+            return {"success": False, "result": None, "error": "Function not available"}
+        result = func(**payload)
         return {"success": True, "result": result, "error": None}
     except Exception as e:
         return {"success": False, "result": None, "error": str(e)}
@@ -170,17 +206,16 @@ def makeTableX_tool(payload: dict):
 def missingtable_tool(*args, **kwargs):
     """MissingTable class"""
     try:
+        MissingTable = lazy_import_script("Scripts.xbbtools.nextorf", "MissingTable")
         if MissingTable is None:
-            return {"success": False, "result": None, "error": "Class MissingTable is not available, path may need adjustment"}
+            return {"success": False, "result": None, "error": "Class MissingTable is not available"}
         
         # MCP parameter type conversion
         converted_args = []
         converted_kwargs = kwargs.copy()
         
-        # Handle position argument type conversion
         for arg in args:
             if isinstance(arg, str):
-                # Try to convert to numeric type
                 try:
                     if '.' in arg:
                         converted_args.append(float(arg))
@@ -191,7 +226,6 @@ def missingtable_tool(*args, **kwargs):
             else:
                 converted_args.append(arg)
         
-        # Handle keyword argument type conversion
         for key, value in converted_kwargs.items():
             if isinstance(value, str):
                 try:
@@ -211,17 +245,16 @@ def missingtable_tool(*args, **kwargs):
 def nextorf_tool(*args, **kwargs):
     """NextOrf class"""
     try:
+        NextOrf = lazy_import_script("Scripts.xbbtools.nextorf", "NextOrf")
         if NextOrf is None:
-            return {"success": False, "result": None, "error": "Class NextOrf is not available, path may need adjustment"}
+            return {"success": False, "result": None, "error": "Class NextOrf is not available"}
         
         # MCP parameter type conversion
         converted_args = []
         converted_kwargs = kwargs.copy()
         
-        # Handle position argument type conversion
         for arg in args:
             if isinstance(arg, str):
-                # Try to convert to numeric type
                 try:
                     if '.' in arg:
                         converted_args.append(float(arg))
@@ -232,7 +265,6 @@ def nextorf_tool(*args, **kwargs):
             else:
                 converted_args.append(arg)
         
-        # Handle keyword argument type conversion
         for key, value in converted_kwargs.items():
             if isinstance(value, str):
                 try: