scmcp-shared 0.3.0__py3-none-any.whl → 0.3.5__py3-none-any.whl

scmcp_shared/__init__.py

@@ -1,3 +1,3 @@
 
-__version__ = "0.3.0"
+__version__ = "0.3.5"
 

scmcp_shared/cli.py

@@ -1,77 +1,89 @@
-import typer
-from typing import Optional, Union, Type
+import argparse
+from typing import Optional, Union, Type, Dict, Callable
 from enum import Enum
-from .util import add_figure_route, set_env,setup_mcp
-
-
-class TransportEnum(str, Enum):
-    STDIO = "stdio"
-    SSE = "sse"
-    SHTTP = "shttp"
-
-    @property
-    def transport_value(self) -> str:
-        """Get the actual transport value to use."""
-        if self == TransportEnum.SHTTP:
-            return "streamable-http"
-        return self.value
-
-
-class ModuleEnum(str, Enum):
-    """Base class for module types."""
-    ALL = "all"
-
+from .util import add_figure_route, set_env
+import os
 
 
 class MCPCLI:
     """Base class for CLI applications with support for dynamic modules and parameters."""
     
-    def __init__(self, name: str, help_text: str, manager=None, modules=ModuleEnum):
+    def __init__(self, name: str, help_text: str, mcp=None, manager=None):
         self.name = name
-        self.modules = modules
+        self.mcp = mcp
         self.manager = manager
-        self.app = typer.Typer(
-            name=name,
-            help=help_text,
-            add_completion=False,
-            no_args_is_help=True,
+        self.parser = argparse.ArgumentParser(
+            description=help_text,
+            prog=name
         )
+        self.subcommands: Dict[str, tuple[argparse.ArgumentParser, Callable]] = {}
         self._setup_commands()
     
     def _setup_commands(self):
         """Setup the main commands for the CLI."""
-        self.app.command(name="run", help="Start the server with the specified configuration")(self.run_command())
-        self.app.callback()(self._callback)
-
-    def run_command(self):
-        def _run_command(
-            log_file: Optional[str] = typer.Option(None, "--log-file", help="log file path, use stdout if None"),
-            transport: TransportEnum = typer.Option(TransportEnum.STDIO, "-t", "--transport", help="specify transport type", 
-                                        case_sensitive=False),
-            port: int = typer.Option(8000, "-p", "--port", help="transport port"),
-            host: str = typer.Option("127.0.0.1", "--host", help="transport host"),
-            forward: str = typer.Option(None, "-f", "--forward", help="forward request to another server"),
-            module: list[self.modules] = typer.Option(
-                [self.modules.ALL], 
-                "-m", 
-                "--module", 
-                help="specify module to run"
-            ),
-        ):
-            """Start the server with the specified configuration."""
-            if "all" in module:
-                modules = None
-            elif isinstance(module, list) and bool(module):
-                modules = [m.value for m in module]
-            self.mcp =  self.manager(self.name, include_modules=modules).mcp
-
-            self.run_mcp(log_file, forward, transport, host, port)
-        return _run_command
+        subparsers = self.parser.add_subparsers(dest='command', help='Available commands')        
+        run_parser = subparsers.add_parser('run', help='Start the server with the specified configuration')
+        self._setup_run_command(run_parser)
+        self.subcommands['run'] = (run_parser, self._run_command)
         
-
-    def _callback(self):
-        """Liana MCP CLI root command."""
-        pass
+    def _setup_run_command(self, parser: argparse.ArgumentParser):
+        """Setup run command arguments."""
+        parser.add_argument('-t', '--transport', default="stdio",
+                          choices=["stdio", "shttp", "sse"],
+                          help='specify transport type')
+        parser.add_argument('-p', '--port', type=int, default=8000, help='transport port')
+        parser.add_argument('--host', default='127.0.0.1', help='transport host')
+        parser.add_argument('-f', '--forward', help='forward request to another server')
+        parser.add_argument('-wd', '--working-dir', default=".", help='working directory')
+        parser.add_argument('--log-file', help='log file path, use stdout if None')
+    
+    def add_command(self, name: str, help_text: str, handler: Callable) -> argparse.ArgumentParser:
+        """add new subcommand
+        
+        Args:
+            name: subcommand name
+            help_text: help text
+            handler: handler function
+            
+        Returns:
+            ArgumentParser: parser for the subcommand
+        """
+        subparsers = self.parser._subparsers._group_actions[0]
+        parser = subparsers.add_parser(name, help=help_text)
+        self.subcommands[name] = (parser, handler)
+        return parser
+    
+    def get_command_parser(self, name: str) -> Optional[argparse.ArgumentParser]:
+        """get the parser for the subcommand
+        
+        Args:
+            name: subcommand name
+            
+        Returns:
+            ArgumentParser: parser for the subcommand, return None if the subcommand does not exist
+        """
+        if name in self.subcommands:
+            return self.subcommands[name][0]
+        return None
+    
+    def _run_command(self, args):
+        """Start the server with the specified configuration."""
+        os.chdir(args.working_dir)
+        if hasattr(args, 'module'):
+            if "all" in args.module:
+                modules = None
+            elif isinstance(args.module, list) and bool(args.module):
+                modules = args.module
+        else:
+            modules = None
+        if self.manager is not None:
+            self.mcp = self.manager(self.name, include_modules=modules).mcp
+        elif self.mcp is not None:
+            pass
+        else:
+            raise ValueError("No manager or mcp provided")
+        transport = args.transport
+        self.run_mcp(args.log_file, args.forward, transport, args.host, args.port)
 
     def run_mcp(self, log_file, forward, transport, host, port):
         set_env(log_file, forward, transport, host, port)
@@ -80,8 +92,8 @@ class MCPCLI:
         if transport == "stdio":
             self.mcp.run()
         elif transport in ["sse", "shttp"]:
+            transport = "streamable-http" if transport == "shttp" else transport
             add_figure_route(self.mcp)
-            transport = transport.transport_value
             self.mcp.run(
                 transport=transport,
                 host=host, 
@@ -89,8 +101,11 @@ class MCPCLI:
                 log_level="info"
             )
  
-    def run_cli(self, mcp=None, module_dic=None):
+    def run(self):
         """Run the CLI application."""
-        self.mcp = mcp
-        self.module_dic = module_dic
-        self.app()
+        args = self.parser.parse_args()
+        if args.command in self.subcommands:
+            handler = self.subcommands[args.command][1]
+            handler(args)
+        else:
+            self.parser.print_help()

scmcp_shared/schema/tl.py

@@ -938,6 +938,11 @@ class PCAModel(BaseModel):
         gt=0
     )
     
+    key_added: str = Field(
+        default="X_pca",
+        description="PCA embedding stored key in adata.obsm."
+    )
+    
     @field_validator('n_comps', 'chunk_size')
     def validate_positive_integers(cls, v: Optional[int]) -> Optional[int]:
         """Validate positive integers"""

scmcp_shared/server/tl.py

@@ -376,7 +376,7 @@ class ScanpyToolsMCP(BaseMCP):
         return _score_genes_cell_cycle
 
     def _tool_pca(self):
-        def _pca(request: PCAModel, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _pca(request: PCAModel=PCAModel(), adinfo: self.AdataInfo=self.AdataInfo()):
             """Compute PCA (Principal Component Analysis)."""
             try:
                 result = forward_request("tl_pca", request, adinfo)

scmcp_shared/util.py

@@ -260,14 +260,10 @@ def setup_mcp(mcp, sub_mcp_dic, modules=None):
     return mcp
 
 def _update_args(mcp, func, args_dic : dict):
-    defs = mcp._tool_manager._tools[func].parameters['$defs']
-    model_names = list(defs.keys())
-    args_model = model_names[0] if  model_names[0] != "AdataModel" else model_names[1]
     for args, property_dic in args_dic.items():
         for pk, v in property_dic.items():
-            for model in model_names:
-                if args in mcp._tool_manager._tools[func].parameters['$defs'][model]["properties"]:
-                    mcp._tool_manager._tools[func].parameters['$defs'][model]["properties"][args][pk] = v
+            mcp._tool_manager._tools[func].parameters["properties"]["request"].setdefault(pk, {})
+            mcp._tool_manager._tools[func].parameters["properties"]["request"][pk][args] = v
 
 
 def update_mcp_args(mcp, tool_args : dict):

{scmcp_shared-0.3.0.dist-info → scmcp_shared-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scmcp_shared
-Version: 0.3.0
+Version: 0.3.5
 Summary: A shared function libray for scmcphub
 Author-email: shuang <hsh-me@outlook.com>
 License: BSD 3-Clause License
@@ -35,7 +35,7 @@ License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: fastmcp>=2.3.4
 Requires-Dist: mcp>=1.8.0
-Requires-Dist: pydantic
+Requires-Dist: nest-asyncio
 Requires-Dist: scanpy
 Description-Content-Type: text/markdown
 

{scmcp_shared-0.3.0.dist-info → scmcp_shared-0.3.5.dist-info}/RECORD

@@ -1,21 +1,21 @@
-scmcp_shared/__init__.py,sha256=nSn3YFzkE-BAmUSmif33CxdohNxkgmLE9cYFNbjEu_E,24
-scmcp_shared/cli.py,sha256=NU31Vv-xev8yGtl1KHZhVswJNbK18x2AVzhhH9MR03M,3325
+scmcp_shared/__init__.py,sha256=6zWLsZ8g5hYGDsXCmJv2JvlO9aeJZjPXG5UykIoIeEA,24
+scmcp_shared/cli.py,sha256=KYHp5_VE2JVVT4Su57ELzQa1lI2P8Gw0b4ruBP_Dtxk,4396
 scmcp_shared/logging_config.py,sha256=eCuLuyxMmbj8A1E0VqYWoKA5JPTSbo6cmjS4LOyd0RQ,872
-scmcp_shared/util.py,sha256=vxmR6_iOBa5jaBNBWl3QBysJ14kXRrqrENDRl3_TChQ,9339
+scmcp_shared/util.py,sha256=bJmbgYjhY44flRo51XDiH-5w7OztG34XxGL6JSGG9fo,9101
 scmcp_shared/schema/__init__.py,sha256=Kwkc7kPLjExOlxt1sWEy_5qa96MvOS8sNCMlZa6yRg8,737
 scmcp_shared/schema/io.py,sha256=ZKJpKkKazDE3_ZX3GtMIT08kSaiNmy0qVaxivhN7Dx4,4744
 scmcp_shared/schema/pl.py,sha256=rzE09wHMY3JR56HZc-QfIUUM0fGXRKd-7Dh3CrQrFB0,29547
 scmcp_shared/schema/pp.py,sha256=48F6oKf-I8IZuNQDfq_Lpp3fLLKA4PruqRje_ZrtTyw,21664
-scmcp_shared/schema/tl.py,sha256=0HlZ_WQkgnc93LfIYapRCijWBBaFAdM5SV3Ioht_1wI,34281
+scmcp_shared/schema/tl.py,sha256=DaZUce33OW67h-caK9BW4sD9zhlehmj3mCq1P-3vllM,34407
 scmcp_shared/schema/util.py,sha256=x_2GPsmliHabi9V5C6YEv_M8ZHJsinDZJ6ePWrLPmcI,4815
 scmcp_shared/server/__init__.py,sha256=4KE2Y_gDenF0ZyTGicQW0fTgJfMIQYZfpRP4hQ4rFYs,416
 scmcp_shared/server/base.py,sha256=kaOfi4yHLWr_AdBdpKzDrJiwRmbHF2jbsfI5g2qqgRA,6576
 scmcp_shared/server/io.py,sha256=yrQXdkAsPvk_62xQk5-SRmc5-jAvI-d3sE0QqHDXfMM,3424
 scmcp_shared/server/pl.py,sha256=HdhjrZfEx-IzCkZ03IGCW-mjUItfNvKdSOFbJ2_-2XQ,14854
 scmcp_shared/server/pp.py,sha256=neyRV3yEZ2a08eO-COI-t-PFFvntRzNmu19SQ77do_4,15406
-scmcp_shared/server/tl.py,sha256=2vfl5FrWQgQlPTB4-QLFMuMrtCux6ppmFttKOrryhF0,18320
+scmcp_shared/server/tl.py,sha256=nneWj9SHNcZulhn3WRQrsoecHNsG2apDctB8H5OtQNI,18331
 scmcp_shared/server/util.py,sha256=L51fFL7Nb84JCQrFYyZIGsfmNFlA9uGzTV93hvc9mfI,12025
-scmcp_shared-0.3.0.dist-info/METADATA,sha256=M8NokyJHPjAVnN-JYmprlFhAfDq_XvAAU1l-kiH8LOA,2099
-scmcp_shared-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-scmcp_shared-0.3.0.dist-info/licenses/LICENSE,sha256=YNr1hpea195yq-wGtB8j-2dGtt7A5G00WENmxa7JGco,1495
-scmcp_shared-0.3.0.dist-info/RECORD,,
+scmcp_shared-0.3.5.dist-info/METADATA,sha256=SPZehu8YN559S-rEBcNViW5vf1h0TUjlzXhIAVxuQ3w,2103
+scmcp_shared-0.3.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scmcp_shared-0.3.5.dist-info/licenses/LICENSE,sha256=YNr1hpea195yq-wGtB8j-2dGtt7A5G00WENmxa7JGco,1495
+scmcp_shared-0.3.5.dist-info/RECORD,,