scmcp-shared 0.4.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

scmcp_shared/util.py

@@ -1,17 +1,17 @@
 import inspect
 import os
-from enum import Enum
 from pathlib import Path
 from fastmcp.server.dependencies import get_context
 from fastmcp.exceptions import ToolError
 import asyncio
 import nest_asyncio
+from pydantic import BaseModel
 
 
 def get_env(key):
     return os.environ.get(f"SCMCP_{key.upper()}")
 
- 
+
 def filter_args(request, func, **extra_kwargs):
     kwargs = request.model_dump()
     args = request.model_fields_set
@@ -25,7 +25,7 @@ def filter_args(request, func, **extra_kwargs):
 def add_op_log(adata, func, kwargs, adinfo):
     import hashlib
     import json
-    
+
     if "operation" not in adata.uns:
         adata.uns["operation"] = {}
         adata.uns["operation"]["op"] = {}
@@ -41,26 +41,27 @@ def add_op_log(adata, func, kwargs, adinfo):
     else:
         func_name = str(func)
     new_kwargs = {**adinfo.model_dump()}
-    for k,v in kwargs.items():
+    for k, v in kwargs.items():
         if isinstance(v, tuple):
             new_kwargs[k] = list(v)
         else:
             new_kwargs[k] = v
     try:
         kwargs_str = json.dumps(new_kwargs, sort_keys=True)
-    except:
-        kwargs_str = str(new_kwargs)
+    except Exception as e:
+        print(e)
+        kwargs_str = f"{e}" + str(new_kwargs)
     hash_input = f"{func_name}:{kwargs_str}"
     hash_key = hashlib.md5(hash_input.encode()).hexdigest()
     adata.uns["operation"]["op"][hash_key] = {func_name: new_kwargs}
     adata.uns["operation"]["opid"] = list(adata.uns["operation"]["opid"])
     adata.uns["operation"]["opid"].append(hash_key)
     from .logging_config import setup_logger
+
     logger = setup_logger(log_file=get_env("LOG_FILE"))
     logger.info(f"{func}: {new_kwargs}")
 
 
-
 def save_fig_path(axes, file):
     from matplotlib.axes import Axes
 
@@ -76,12 +77,14 @@ def save_fig_path(axes, file):
                 ax.figure.savefig(file_path)
         elif isinstance(axes, Axes):
             axes.figure.savefig(file_path)
-        elif hasattr(axes, 'savefig'):  # if Figure 
+        elif hasattr(axes, "savefig"):  # if Figure
             axes.savefig(file_path)
-        elif hasattr(axes, 'save'):  # for plotnine.ggplot.ggplot
+        elif hasattr(axes, "save"):  # for plotnine.ggplot.ggplot
             axes.save(file_path)
         else:
-            raise ValueError(f"axes must be a Axes or plotnine object, but got {type(axes)}")
+            raise ValueError(
+                f"axes must be a Axes or plotnine object, but got {type(axes)}"
+            )
         return file_path
     except Exception as e:
         raise e
@@ -102,7 +105,7 @@ def savefig(axes, func=None, **kwargs):
     kwargs.pop("save", None)
     kwargs.pop("show", None)
     args = []
-    for k,v in kwargs.items():
+    for k, v in kwargs.items():
         if isinstance(v, (tuple, list, set)):
             v = v[:3]  ## show first 3 elements
             args.append(f"{k}-{'-'.join([str(i) for i in v])}")
@@ -119,7 +122,7 @@ def savefig(axes, func=None, **kwargs):
         raise PermissionError("You don't have permission to save figure")
     except Exception as e:
         raise e
-    transport = get_env("TRANSPORT") 
+    transport = get_env("TRANSPORT")
     if transport == "stdio":
         return fig_path
     else:
@@ -129,36 +132,41 @@ def savefig(axes, func=None, **kwargs):
         return fig_path
 
 
-
 async def get_figure(request):
     from starlette.responses import FileResponse, Response
 
     figure_name = request.path_params["figure_name"]
     figure_path = f"./figures/{figure_name}"
-    
+
     if not os.path.isfile(figure_path):
-        return Response(content={"error": "figure not found"}, media_type="application/json")
-    
+        return Response(
+            content={"error": "figure not found"}, media_type="application/json"
+        )
+
     return FileResponse(figure_path)
 
 
 def add_figure_route(server):
     from starlette.routing import Route
-    server._additional_http_routes = [Route("/figures/{figure_name}", endpoint=get_figure)]
+
+    server._additional_http_routes = [
+        Route("/figures/{figure_name}", endpoint=get_figure)
+    ]
 
 
 async def async_forward_request(func, request, adinfo, **kwargs):
     from fastmcp import Client
+
     forward_url = get_env("FORWARD")
     request_kwargs = request.model_dump()
     request_args = request.model_fields_set
     func_kwargs = {
         "request": {k: request_kwargs.get(k) for k in request_args},
-        "adinfo": adinfo.model_dump()
+        "adinfo": adinfo.model_dump(),
     }
     if not forward_url:
         return None
-        
+
     client = Client(forward_url)
     async with client:
         tools = await client.list_tools()
@@ -169,13 +177,12 @@ async def async_forward_request(func, request, adinfo, **kwargs):
         except ToolError as e:
             raise ToolError(e)
         except Exception as e:
-            if hasattr(e, '__context__') and e.__context__:
+            if hasattr(e, "__context__") and e.__context__:
                 raise Exception(f"{str(e.__context__)}")
             else:
                 raise e
 
 
-
 def forward_request(func, request, adinfo, **kwargs):
     """Synchronous wrapper for forward_request"""
     try:
@@ -186,12 +193,13 @@ def forward_request(func, request, adinfo, **kwargs):
             # If we're in a running event loop, use create_task
             async def _run():
                 return await async_forward_request(func, request, adinfo, **kwargs)
+
             return loop.run_until_complete(_run())
         else:
             # If no event loop is running, use asyncio.run()
             return asyncio.run(async_forward_request(func, request, adinfo, **kwargs))
     except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
+        if hasattr(e, "__context__") and e.__context__:
             raise Exception(f"{str(e.__context__)}")
         else:
             raise e
@@ -203,7 +211,9 @@ def obsm2adata(adata, obsm_key):
     if obsm_key not in adata.obsm_keys():
         raise ValueError(f"key {obsm_key} not found in adata.obsm")
     else:
-        return AnnData(adata.obsm[obsm_key], obs=adata.obs, obsm=adata.obsm, uns=adata.uns)
+        return AnnData(
+            adata.obsm[obsm_key], obs=adata.obs, obsm=adata.obsm, uns=adata.uns
+        )
 
 
 def get_ads():
@@ -213,7 +223,11 @@ def get_ads():
 
 
 def generate_msg(adinfo, adata, ads):
-    return {"sampleid": adinfo.sampleid or ads.active_id, "adtype": adinfo.adtype, "adata": adata}
+    return {
+        "sampleid": adinfo.sampleid or ads.active_id,
+        "adtype": adinfo.adtype,
+        "adata": adata,
+    }
 
 
 def sc_like_plot(plot_func, adata, request, adinfo, **kwargs):
@@ -231,7 +245,9 @@ def sc_like_plot(plot_func, adata, request, adinfo, **kwargs):
 def filter_tools(mcp, include_tools=None, exclude_tools=None):
     import asyncio
     import copy
+
     mcp = copy.deepcopy(mcp)
+
     async def _filter_tools(mcp, include_tools=None, exclude_tools=None):
         tools = await mcp.get_tools()
         for tool in tools:
@@ -240,43 +256,98 @@ def filter_tools(mcp, include_tools=None, exclude_tools=None):
             if include_tools and tool not in include_tools:
                 mcp.remove_tool(tool)
         return mcp
+
     return asyncio.run(_filter_tools(mcp, include_tools, exclude_tools))
 
 
- 
 def set_env(log_file, forward, transport, host, port):
     if log_file is not None:
-        os.environ['SCMCP_LOG_FILE'] = log_file
+        os.environ["SCMCP_LOG_FILE"] = log_file
     if forward is not None:
-        os.environ['SCMCP_FORWARD'] = forward           
-    os.environ['SCMCP_TRANSPORT'] = transport
-    os.environ['SCMCP_HOST'] = host
-    os.environ['SCMCP_PORT'] = str(port)
-
+        os.environ["SCMCP_FORWARD"] = forward
+    os.environ["SCMCP_TRANSPORT"] = transport
+    os.environ["SCMCP_HOST"] = host
+    os.environ["SCMCP_PORT"] = str(port)
 
 
 def setup_mcp(mcp, sub_mcp_dic, modules=None):
     import asyncio
+
     if modules is None or modules == "all":
         modules = sub_mcp_dic.keys()
     for module in modules:
         asyncio.run(mcp.import_server(module, sub_mcp_dic[module]))
     return mcp
 
-def _update_args(mcp, func, args_dic : dict):
+
+def _update_args(mcp, func, args_dic: dict):
     for args, property_dic in args_dic.items():
         for pk, v in property_dic.items():
-            mcp._tool_manager._tools[func].parameters["properties"]["request"].setdefault(pk, {})
-            mcp._tool_manager._tools[func].parameters["properties"]["request"][pk][args] = 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):
-    tools = mcp._tool_manager._tools.keys()
-    for tool in tool_args: 
+def update_mcp_args(mcp, tool_args: dict):
+    # tools = mcp._tool_manager._tools.keys()
+    for tool in tool_args:
         _update_args(mcp, tool, tool_args[tool])
 
 
 def check_adata(adata, adinfo, ads):
     sampleid = adinfo.sampleid or ads.active_id
     if sampleid != adata.uns["scmcp_sampleid"]:
-        raise ValueError(f"sampleid mismatch: {sampleid} != {adata.uns['scmcp_sampleid']}")
+        raise ValueError(
+            f"sampleid mismatch: {sampleid} != {adata.uns['scmcp_sampleid']}"
+        )
+
+
+def get_nbm():
+    ctx = get_context()
+    nbm = ctx.request_context.lifespan_context
+    return nbm
+
+
+def parse_args(
+    kwargs: BaseModel | dict,
+    positional_args: list[str] | str | None = None,
+    func_args: list[str] | str | None = None,
+) -> str:
+    if isinstance(kwargs, BaseModel):
+        kwargs = kwargs.model_dump()
+    elif isinstance(kwargs, dict):
+        kwargs = kwargs
+    else:
+        raise ValueError(f"Invalid type: {type(kwargs)}")
+
+    if func_args is not None:
+        if isinstance(func_args, str):
+            func_args = [func_args]
+    else:
+        func_args = []
+    kwargs_str_ls = []
+    if positional_args is not None:
+        if isinstance(positional_args, str):
+            kwargs_str_ls.append(kwargs.pop(positional_args))
+        elif isinstance(positional_args, list):
+            for arg in positional_args:
+                kwargs_str_ls.append(kwargs.pop(arg))
+
+    extra_kwargs = kwargs.pop("kwargs", {})
+    for k, v in kwargs.items():
+        if k in func_args:
+            kwargs_str_ls.append(f"{k}={v}")
+            continue
+        if isinstance(v, (list, tuple, dict, int, float, bool)):
+            kwargs_str_ls.append(f"{k}={v}")
+        elif isinstance(v, str):
+            kwargs_str_ls.append(f"{k}='{v}'")
+
+    if extra_kwargs:
+        kwargs_str_ls.append(f"**{extra_kwargs}")
+
+    kwargs_str = ", ".join(kwargs_str_ls)
+    return kwargs_str

{scmcp_shared-0.4.0.dist-info → scmcp_shared-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scmcp_shared
-Version: 0.4.0
+Version: 0.6.0
 Summary: A shared function libray for scmcphub
 Project-URL: Homepage, http://scmcphub.org/
 Project-URL: Repository, https://github.com/scmcphub/scmcp-shared
@@ -37,12 +37,16 @@ License: BSD 3-Clause License
 License-File: LICENSE
 Keywords: AI,agent,bioinformatics,llm,mcp,model context protocol,scRNA-seq,single cell
 Requires-Python: >=3.10
+Requires-Dist: abcoder
+Requires-Dist: agno
 Requires-Dist: fastmcp>=2.7.0
 Requires-Dist: igraph
-Requires-Dist: instructor>=1.8.3
+Requires-Dist: lancedb
 Requires-Dist: leidenalg
 Requires-Dist: mcp>=1.8.0
 Requires-Dist: nest-asyncio
+Requires-Dist: openai
+Requires-Dist: requests
 Requires-Dist: scanpy
 Description-Content-Type: text/markdown
 

scmcp_shared-0.6.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+scmcp_shared/__init__.py,sha256=cID1jLnC_vj48GgMN6Yb1FA3JsQ95zNmCHmRYE8TFhY,22
+scmcp_shared/agent.py,sha256=pC1g09BgUrahxoYN1JlxPi1_kOeuwWAGwMtR4oKUruc,1142
+scmcp_shared/backend.py,sha256=PyxHhg7ThHE5u6XtWwleAiJ3aqdLHbXoXuyw5QeF4Qw,1695
+scmcp_shared/cli.py,sha256=zYz_E3SlZ_mtYOrSdDJhDmHsppkwzEi2rZ6D3a_ga1c,5603
+scmcp_shared/kb.py,sha256=Wy0ib43DdvIXqSUStRQzK-It-fGqZI1lb4mQY6UnJ3o,4491
+scmcp_shared/logging_config.py,sha256=Z5jLgOCfir4UGxM-ZQvYv7Iyl_zF78qqPNQ_aSE77f0,838
+scmcp_shared/mcp_base.py,sha256=v8sBqObTVzLEvoeQe3la2cfnDWZE7DkY07SqEb_1srA,7277
+scmcp_shared/util.py,sha256=LNrpoHBdA4x-Tt16uT_9A72_QZ41SrqZ0zy3Ozwa858,11163
+scmcp_shared/schema/__init__.py,sha256=Kwkc7kPLjExOlxt1sWEy_5qa96MvOS8sNCMlZa6yRg8,737
+scmcp_shared/schema/io.py,sha256=wZxGDJzzeSbI5Nl5IIE9GJDkBynqYFakK21tnECvBNk,6090
+scmcp_shared/schema/pl.py,sha256=vheuv1itA-FkhAb9c7kkCpHWgbmJGhWJf8nAYkfzbBI,28228
+scmcp_shared/schema/pp.py,sha256=PtbgMupJNBWmAx6lIoMy6RflByAasSnFB5PCytijS80,32300
+scmcp_shared/schema/tl.py,sha256=YbeKoaUqJXcn2WIJn0Rzn5rq4qud_ncUdoaliQkZYwI,35358
+scmcp_shared/schema/tool.py,sha256=U-VFrovAEr2FklS8cSJPimfhTSTHmskmLfCO7Ee0s2o,267
+scmcp_shared/schema/util.py,sha256=1twQ9kiaKI6XubJIuYywG7vr-T2cCCblehhYXJQskls,4558
+scmcp_shared/schema/preset/__init__.py,sha256=dw8bPW1LaQKtATc2wmkAkF-fHYGwIGxY3Aq9mHTL9HA,422
+scmcp_shared/schema/preset/io.py,sha256=hP8LVbiZUaGU0mHCxHS3wmA3Q6OPEldvMACnD6gAn9Y,4558
+scmcp_shared/schema/preset/pl.py,sha256=bURWdeJ1CVOyL78Zfof7aJIXiqtKUog5NuVxNm1mGNw,28152
+scmcp_shared/schema/preset/pp.py,sha256=j6cnQlt2YuOIJwjl8x4JNojSVcXW1bVjnt6BZ8QHNzQ,21079
+scmcp_shared/schema/preset/tl.py,sha256=cHne8cIJBFph5MENsgElx1MQUOi7LYc62M0OQppcZ40,33818
+scmcp_shared/schema/preset/util.py,sha256=1twQ9kiaKI6XubJIuYywG7vr-T2cCCblehhYXJQskls,4558
+scmcp_shared/server/__init__.py,sha256=qwJEKZnBjcTi7wXcPpeQ-EP4YY9jJo9BYXkfCyn662c,198
+scmcp_shared/server/auto.py,sha256=FQKbUDuWlgfkcakLGm28lzrJTBm2vynwskHDdVLV2Dk,1966
+scmcp_shared/server/code.py,sha256=_uNIZ7sVfpBAhX1qPJ8f3zquSEgZXA3jWkPaRx3ph9k,56
+scmcp_shared/server/rag.py,sha256=tKENjR9PuzkektduaTYHf0hDDyo4ypAqCJTyulLSZn4,402
+scmcp_shared/server/preset/__init__.py,sha256=2DdRR0MaipsxREZ4dWvnGfNRAaHQY7BGGVNgGQEyfbo,318
+scmcp_shared/server/preset/io.py,sha256=2QigfUHR8HJtVdI4nIfRh0tm8WhVu8Hge1AAos6afZM,4059
+scmcp_shared/server/preset/pl.py,sha256=pQx7yD1-vRSnNky_8tapI6vU1lqcZ5S4zs5y1aamtcc,16774
+scmcp_shared/server/preset/pp.py,sha256=9WtTQ8aHnN_G_7Rm9hZsa7GU3A7xHBoNf8tE-gsDDHY,17114
+scmcp_shared/server/preset/tl.py,sha256=LtrGMNkeTlTqe2Cyw1OwZXpeTbyGqgENYYC76BKXgpg,19716
+scmcp_shared/server/preset/util.py,sha256=vek2SOEfiyAyCUEjwsFf1uqwT9YuzDHVQJ-dprIDWME,13519
+scmcp_shared-0.6.0.dist-info/METADATA,sha256=j--ns9ClsoFmoTvxc-DeQD_N-aeE29cTzFX2A9LBROU,2514
+scmcp_shared-0.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scmcp_shared-0.6.0.dist-info/licenses/LICENSE,sha256=YNr1hpea195yq-wGtB8j-2dGtt7A5G00WENmxa7JGco,1495
+scmcp_shared-0.6.0.dist-info/RECORD,,

scmcp_shared/server/base.py

@@ -1,148 +0,0 @@
-import inspect
-from fastmcp import FastMCP
-from ..schema import AdataInfo
-from ..util import filter_tools
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-import asyncio
-from typing import Optional, List, Any, Iterable
-from .auto import auto_mcp
-
-class BaseMCP:
-    """Base class for all Scanpy MCP classes."""
-    
-    def __init__(self, name: str, include_tools: list = None, exclude_tools: list = None, AdataInfo = AdataInfo):
-        """
-        Initialize BaseMCP with optional tool filtering.
-        
-        Args:
-            name (str): Name of the MCP server
-            include_tools (list, optional): List of tool names to include. If None, all tools are included.
-            exclude_tools (list, optional): List of tool names to exclude. If None, no tools are excluded.
-            AdataInfo: The AdataInfo class to use for type annotations.
-        """
-        self.mcp = FastMCP(name)
-        self.include_tools = include_tools
-        self.exclude_tools = exclude_tools
-        self.AdataInfo = AdataInfo
-        self._register_tools()
-
-    def _register_tools(self):
-        """Register all tool methods with the FastMCP instance based on include/exclude filters"""
-        # Get all methods of the class
-        methods = inspect.getmembers(self, predicate=inspect.ismethod)
-        
-        # Filter methods that start with _tool_
-        tool_methods = [tl_method() for name, tl_method in methods if name.startswith('_tool_')]
-        
-        # Filter tools based on include/exclude lists
-        if self.include_tools is not None:
-            tool_methods = [tl for tl in tool_methods if tl.name in self.include_tools]
-        
-        if self.exclude_tools is not None:
-            tool_methods = [tl for tl in tool_methods if tl.name not in self.exclude_tools]
-
-        # Register filtered tools
-        for tool in tool_methods:
-            # Get the function returned by the tool method
-            if tool is not None:
-                self.mcp.add_tool(tool)
-
-
-class AdataState:
-    def __init__(self, add_adtypes=None):
-        self.adata_dic = {"exp": {}, "activity": {}, "cnv": {}, "splicing": {}}
-        if isinstance(add_adtypes, str):
-            self.adata_dic[add_adtypes] = {}
-        elif isinstance(add_adtypes, Iterable):
-            self.adata_dic.update({adtype: {} for adtype in add_adtypes})
-        self.active_id = None
-        self.metadatWa = {}
-        self.cr_kernel = {}
-        self.cr_estimator = {}
-        
-    def get_adata(self, sampleid=None, adtype="exp", adinfo=None):
-        if adinfo is not None:
-            kwargs = adinfo.model_dump()
-            sampleid = kwargs.get("sampleid", None)
-            adtype = kwargs.get("adtype", "exp")
-        try:
-            if self.active_id is None:
-                return None
-            sampleid = sampleid or self.active_id
-            return self.adata_dic[adtype][sampleid]
-        except KeyError as e:
-            raise KeyError(f"Key {e} not found in adata_dic[{adtype}].Please check the sampleid or adtype.")
-        except Exception as e:
-            raise Exception(f"fuck {e} {type(e)}")
-    
-    def set_adata(self, adata, sampleid=None, sdtype="exp", adinfo=None):
-        if adinfo is not None:
-            kwargs = adinfo.model_dump()
-            sampleid = kwargs.get("sampleid", None)
-            sdtype = kwargs.get("adtype", "exp")
-        sampleid = sampleid or self.active_id
-        if sdtype not in self.adata_dic:
-            self.adata_dic[sdtype] = {}
-        self.adata_dic[sdtype][sampleid] = adata
-
-
-class BaseMCPManager:
-    """Base class for MCP module management."""
-    
-    def __init__(self, 
-        name: str, 
-        include_modules: Optional[List[str]] = None, 
-        exclude_modules: Optional[List[str]] = None,
-        include_tools: Optional[List[str]] = None,
-        exclude_tools: Optional[List[str]] = None,
-    ):
-        """
-        Initialize BaseMCPManager with optional module filtering.
-        
-        Args:
-            name (str): Name of the MCP server
-            include_modules (List[str], optional): List of module names to include. If None, all modules are included.
-            exclude_modules (List[str], optional): List of module names to exclude. If None, no modules are excluded.
-            include_tools (List[str], optional): List of tool names to include. If None, all tools are included.
-            exclude_tools (List[str], optional): List of tool names to exclude. If None, no tools are excluded.
-        """
-        self.ads = AdataState()
-        self.mcp = FastMCP(name, lifespan=self.adata_lifespan)
-        self.include_modules = include_modules
-        self.exclude_modules = exclude_modules
-        self.include_tools = include_tools
-        self.exclude_tools = exclude_tools
-        self.available_modules = {}
-        self._init_modules()
-        self._register_modules()
-
-    def _init_modules(self):
-        """Initialize available modules. To be implemented by subclasses."""
-        raise NotImplementedError("Subclasses must implement _init_modules")
-
-    def _register_modules(self):
-        """Register modules based on include/exclude filters."""
-        # Filter modules based on include/exclude lists
-        if self.include_modules is not None:
-            self.available_modules = {k: v for k, v in self.available_modules.items() if k in self.include_modules}
-        
-        if self.exclude_modules is not None:
-            self.available_modules = {k: v for k, v in self.available_modules.items() if k not in self.exclude_modules}
-
-        # Register each module
-        for module_name, mcpi in self.available_modules.items():
-            if isinstance(mcpi, FastMCP):
-                if self.include_tools is not None and module_name in self.include_tools:
-                    mcpi = filter_tools(mcpi, include_tools= self.include_tools[module_name])
-                if self.exclude_tools is not None and module_name in self.exclude_tools:
-                    mcpi = filter_tools(mcpi, exclude_tools=self.exclude_tools[module_name])
-
-                asyncio.run(self.mcp.import_server(module_name, mcpi))
-            else:
-                asyncio.run(self.mcp.import_server(module_name, mcpi().mcp))
-
-    @asynccontextmanager
-    async def adata_lifespan(self, server: FastMCP) -> AsyncIterator[Any]:
-        """Context manager for AdataState lifecycle."""
-        yield self.ads

scmcp_shared-0.4.0.dist-info/RECORD

@@ -1,24 +0,0 @@
-scmcp_shared/__init__.py,sha256=5DHi9fyCf-CfX64oAsNqmkR27WRUetIg-NfPin0QKBw,24
-scmcp_shared/agent.py,sha256=tWGAyOwdg3oTfYFquGPompUZMHSWqW3VQvEymywaE0o,854
-scmcp_shared/cli.py,sha256=8Am2zdn1z_gle6Jz-JQkvK-6_mOB6BFhfK05A0pNpkc,5032
-scmcp_shared/logging_config.py,sha256=eCuLuyxMmbj8A1E0VqYWoKA5JPTSbo6cmjS4LOyd0RQ,872
-scmcp_shared/util.py,sha256=8_c6WPNpYNoxKpq6tQCC4elCQkWyk3rH-hTe1sqff4A,9535
-scmcp_shared/schema/__init__.py,sha256=Kwkc7kPLjExOlxt1sWEy_5qa96MvOS8sNCMlZa6yRg8,737
-scmcp_shared/schema/io.py,sha256=-wgL2NQBXwAcojid8rF2Y46GsKL7H6JiheKE6frMotw,4638
-scmcp_shared/schema/pl.py,sha256=7AFXgqb2GAlmeXS6m3IdJgThLz6-FTDBmrJqoAi8j98,29612
-scmcp_shared/schema/pp.py,sha256=WtaugFLP9vfusBZQCXGAYPmYu-5yWHC2wJTSZutS1XM,21674
-scmcp_shared/schema/tl.py,sha256=FEZpr218eaQ8rUp5EJzbjyw1ejqCX4Shsf9CumaKs8A,34425
-scmcp_shared/schema/tool.py,sha256=U-VFrovAEr2FklS8cSJPimfhTSTHmskmLfCO7Ee0s2o,267
-scmcp_shared/schema/util.py,sha256=fMZxTNf9Bv_xDzrW7YK08q0tCoC3L7ofqPY0K2ykG8k,4824
-scmcp_shared/server/__init__.py,sha256=4KE2Y_gDenF0ZyTGicQW0fTgJfMIQYZfpRP4hQ4rFYs,416
-scmcp_shared/server/auto.py,sha256=32SC5nC0N7JuPsDSMFRvojaPmUbpybwY1aCOrQMzaL4,1781
-scmcp_shared/server/base.py,sha256=I90L_DNdCv--VOIHDRjdVehq-3iBm9mV0Sc9OU7GAXQ,6426
-scmcp_shared/server/io.py,sha256=kGBbtd3ltj0ypd0kgMy1l2zT2AVf5yXCHAebQR-ZtUA,4033
-scmcp_shared/server/pl.py,sha256=GVu7GQKW67jz3ig43HLX0d2cjGDPJDXdxMSf6b72kAA,15558
-scmcp_shared/server/pp.py,sha256=UCzogVULgSs8JTR8PiybroGlrm2QvNRrbeAYj7ujr3E,16297
-scmcp_shared/server/tl.py,sha256=LeKcR6F4PNRHZomlD3-igrF44YBQW6Kg7h75psGl9c0,19112
-scmcp_shared/server/util.py,sha256=b6gG1dfXe5GdhM4yUtpxBqx1gMRyQVu3dytmzJeD9zs,12590
-scmcp_shared-0.4.0.dist-info/METADATA,sha256=CKca84Vmtqc5h06oOH6lxqYVDCeVNJpGypX03Y-O1iI,2435
-scmcp_shared-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-scmcp_shared-0.4.0.dist-info/licenses/LICENSE,sha256=YNr1hpea195yq-wGtB8j-2dGtt7A5G00WENmxa7JGco,1495
-scmcp_shared-0.4.0.dist-info/RECORD,,