scmcp-shared 0.3.7__py3-none-any.whl → 0.5.0__py3-none-any.whl

scmcp_shared/server/{util.py → preset/util.py}

@@ -1,21 +1,21 @@
-import os
-import inspect
-from pathlib import Path
-import scanpy as sc
-from fastmcp import FastMCP , Context
 from fastmcp.exceptions import ToolError
 from fastmcp.tools.tool import Tool
-from ..schema.util import *
-from ..schema import AdataInfo
-from ..util import filter_args, forward_request, get_ads, generate_msg,add_op_log
-from .base import BaseMCP
+from scmcp_shared.schema.preset.util import *
+from scmcp_shared.schema.preset import AdataInfo
+from scmcp_shared.util import forward_request, get_ads, add_op_log
+from scmcp_shared.mcp_base import BaseMCP
 
 
 class ScanpyUtilMCP(BaseMCP):
-    def __init__(self, include_tools: list = None, exclude_tools: list = None, AdataInfo = AdataInfo):
+    def __init__(
+        self,
+        include_tools: list = None,
+        exclude_tools: list = None,
+        AdataInfo=AdataInfo,
+    ):
         """
         Initialize ScanpyUtilMCP with optional tool filtering.
-        
+
         Args:
             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.
@@ -23,21 +23,23 @@ class ScanpyUtilMCP(BaseMCP):
         """
         super().__init__("SCMCP-Util-Server", include_tools, exclude_tools, AdataInfo)
 
-
     def _tool_query_op_log(self):
-        def _query_op_log(request: QueryOpLogParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _query_op_log(
+            request: QueryOpLogParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Query the adata operation log"""
             adata = get_ads().get_adata(adinfo=adinfo)
             op_dic = adata.uns["operation"]["op"]
-            opids = adata.uns["operation"]["opid"][-request.n:]
+            opids = adata.uns["operation"]["opid"][-request.n :]
             op_list = []
             for opid in opids:
                 op_list.append(op_dic[opid])
             return op_list
-        return Tool.from_function(_query_op_log, name="query_op_log")
+
+        return Tool.from_function(_query_op_log, name="query_op_log", enabled=True)
 
     def _tool_mark_var(self):
-        def _mark_var(request: MarkVarParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _mark_var(request: MarkVarParam, adinfo: self.AdataInfo = self.AdataInfo()):
             """
             Determine if each gene meets specific conditions and store results in adata.var as boolean values.
             For example: mitochondrion genes startswith MT-.
@@ -54,14 +56,20 @@ class ScanpyUtilMCP(BaseMCP):
                 patterns = request.patterns
                 if gene_class is not None:
                     if gene_class == "mitochondrion":
-                        adata.var["mt"] = adata.var_names.str.startswith(('MT-', 'Mt','mt-'))
+                        adata.var["mt"] = adata.var_names.str.startswith(
+                            ("MT-", "Mt", "mt-")
+                        )
                         var_name = "mt"
                     elif gene_class == "ribosomal":
-                        adata.var["ribo"] = adata.var_names.str.startswith(("RPS", "RPL", "Rps", "Rpl"))
+                        adata.var["ribo"] = adata.var_names.str.startswith(
+                            ("RPS", "RPL", "Rps", "Rpl")
+                        )
                         var_name = "ribo"
                     elif gene_class == "hemoglobin":
-                        adata.var["hb"] = adata.var_names.str.contains("^HB[^(P)]", case=False)
-                        var_name = "hb"    
+                        adata.var["hb"] = adata.var_names.str.contains(
+                            "^HB[^(P)]", case=False
+                        )
+                        var_name = "hb"
                 elif pattern_type is not None and patterns is not None:
                     if pattern_type == "startswith":
                         adata.var[var_name] = adata.var_names.str.startswith(patterns)
@@ -70,25 +78,39 @@ class ScanpyUtilMCP(BaseMCP):
                     elif pattern_type == "contains":
                         adata.var[var_name] = adata.var_names.str.contains(patterns)
                     else:
-                        raise ValueError(f"Did not support pattern_type: {pattern_type}")
+                        raise ValueError(
+                            f"Did not support pattern_type: {pattern_type}"
+                        )
                 else:
-                    raise ValueError(f"Please provide validated parameter")
-            
-                res = {var_name: adata.var[var_name].value_counts().to_dict(), "msg": f"add '{var_name}' column in adata.var"}
-                func_kwargs = {"var_name": var_name, "gene_class": gene_class, "pattern_type": pattern_type, "patterns": patterns}
+                    raise ValueError("Please provide validated parameter")
+
+                res = {
+                    var_name: adata.var[var_name].value_counts().to_dict(),
+                    "msg": f"add '{var_name}' column in adata.var",
+                }
+                func_kwargs = {
+                    "var_name": var_name,
+                    "gene_class": gene_class,
+                    "pattern_type": pattern_type,
+                    "patterns": patterns,
+                }
                 add_op_log(adata, "mark_var", func_kwargs, adinfo)
                 return res
             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 ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_mark_var, name="mark_var")
+
+        return Tool.from_function(_mark_var, name="mark_var", enabled=True)
 
     def _tool_list_var(self):
-        def _list_var(request: ListVarParams=ListVarParams(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _list_var(
+            request: ListVarParam = ListVarParam(),
+            adinfo: self.AdataInfo = self.AdataInfo(),
+        ):
             """List key columns in adata.var. It should be called for checking when other tools need var key column names as input."""
             try:
                 result = forward_request("ul_list_var", request, adinfo)
@@ -101,19 +123,20 @@ class ScanpyUtilMCP(BaseMCP):
             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 ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_list_var, name="list_var")
+
+        return Tool.from_function(_list_var, name="list_var", enabled=True)
 
     def _tool_list_obs(self):
-        def _list_obs(request: ListObsParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _list_obs(request: ListObsParam, adinfo: self.AdataInfo = self.AdataInfo()):
             """List key columns in adata.obs. It should be called before other tools need obs key column names input."""
             try:
                 result = forward_request("ul_list_obs", request, adinfo)
                 if result is not None:
-                    return result    
+                    return result
                 adata = get_ads().get_adata(adinfo=adinfo)
                 columns = list(adata.obs.columns)
                 add_op_log(adata, "list_obs", {}, adinfo)
@@ -121,19 +144,22 @@ class ScanpyUtilMCP(BaseMCP):
             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 ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_list_obs, name="list_obs")
+
+        return Tool.from_function(_list_obs, name="list_obs", enabled=True)
 
     def _tool_check_var(self):
-        def _check_var(request: VarNamesParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _check_var(
+            request: VarNamesParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Check if genes/variables exist in adata.var_names. This tool should be called before gene expression visualizations or color by genes."""
             try:
                 result = forward_request("ul_check_var", request, adinfo)
                 if result is not None:
-                    return result     
+                    return result
                 adata = get_ads().get_adata(adinfo=adinfo)
                 var_names = request.var_names
                 if adata.raw is not None:
@@ -146,14 +172,17 @@ class ScanpyUtilMCP(BaseMCP):
             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 ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_check_var, name="check_var")
+
+        return Tool.from_function(_check_var, name="check_var", enabled=True)
 
     def _tool_merge_adata(self):
-        def _merge_adata(request: ConcatBaseParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _merge_adata(
+            request: ConcatBaseParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Merge multiple adata objects."""
             try:
                 result = forward_request("ul_merge_adata", request, adinfo)
@@ -161,96 +190,124 @@ class ScanpyUtilMCP(BaseMCP):
                     return result
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
-                kwargs = {k: v for k, v in request.model_dump().items() if v is not None}
+                kwargs = {
+                    k: v for k, v in request.model_dump().items() if v is not None
+                }
                 merged_adata = adata.concat(ads.adata_dic, **kwargs)
                 ads.adata_dic[dtype] = {}
                 ads.active_id = "merged_adata"
                 add_op_log(merged_adata, ad.concat, kwargs, adinfo)
                 ads.adata_dic[ads.active_id] = merged_adata
-                return {"status": "success", "message": "Successfully merged all AnnData objects"}
+                return {
+                    "status": "success",
+                    "message": "Successfully merged all AnnData objects",
+                }
             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 ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_merge_adata, name="merge_adata")
+
+        return Tool.from_function(_merge_adata, name="merge_adata", enabled=True)
 
     def _tool_set_dpt_iroot(self):
-        def _set_dpt_iroot(request: DPTIROOTParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _set_dpt_iroot(
+            request: DPTIROOTParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Set the iroot cell"""
             try:
                 result = forward_request("ul_set_dpt_iroot", request, adinfo)
                 if result is not None:
-                    return result     
+                    return result
                 adata = get_ads().get_adata(adinfo=adinfo)
                 diffmap_key = request.diffmap_key
                 dimension = request.dimension
                 direction = request.direction
                 if diffmap_key not in adata.obsm:
-                    raise ValueError(f"Diffusion map key '{diffmap_key}' not found in adata.obsm")
+                    raise ValueError(
+                        f"Diffusion map key '{diffmap_key}' not found in adata.obsm"
+                    )
                 if direction == "min":
                     adata.uns["iroot"] = adata.obsm[diffmap_key][:, dimension].argmin()
-                else:  
+                else:
                     adata.uns["iroot"] = adata.obsm[diffmap_key][:, dimension].argmax()
-                
-                func_kwargs = {"diffmap_key": diffmap_key, "dimension": dimension, "direction": direction}
+
+                func_kwargs = {
+                    "diffmap_key": diffmap_key,
+                    "dimension": dimension,
+                    "direction": direction,
+                }
                 add_op_log(adata, "set_dpt_iroot", func_kwargs, adinfo)
-                
-                return {"status": "success", "message": f"Successfully set root cell for DPT using {direction} of dimension {dimension}"}
+
+                return {
+                    "status": "success",
+                    "message": f"Successfully set root cell for DPT using {direction} of dimension {dimension}",
+                }
             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 ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_set_dpt_iroot, name="set_dpt_iroot")
+
+        return Tool.from_function(_set_dpt_iroot, name="set_dpt_iroot", enabled=True)
 
     def _tool_add_layer(self):
-        def _add_layer(request: AddLayerParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _add_layer(
+            request: AddLayerParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Add a layer to the AnnData object."""
             try:
                 result = forward_request("ul_add_layer", request, adinfo)
                 if result is not None:
-                    return result         
+                    return result
                 adata = get_ads().get_adata(adinfo=adinfo)
                 layer_name = request.layer_name
-                
+
                 # Check if layer already exists
                 if layer_name in adata.layers:
-                    raise ValueError(f"Layer '{layer_name}' already exists in adata.layers")
+                    raise ValueError(
+                        f"Layer '{layer_name}' already exists in adata.layers"
+                    )
                 # Add the data as a new layer
                 adata.layers[layer_name] = adata.X.copy()
 
                 func_kwargs = {"layer_name": layer_name}
                 add_op_log(adata, "add_layer", func_kwargs, adinfo)
-                
+
                 return {
-                    "status": "success", 
-                    "message": f"Successfully added layer '{layer_name}' to adata.layers"
+                    "status": "success",
+                    "message": f"Successfully added layer '{layer_name}' to adata.layers",
                 }
             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 ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_add_layer, name="add_layer")
+
+        return Tool.from_function(_add_layer, name="add_layer", enabled=True)
 
     def _tool_check_samples(self):
-        def _check_samples(request: None, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _check_samples(request: None, adinfo: self.AdataInfo = self.AdataInfo()):
             """check the stored samples"""
             try:
                 ads = get_ads()
-                return {"sampleid": [list(ads.adata_dic[dk].keys()) for dk in ads.adata_dic.keys()]}
+                return {
+                    "sampleid": [
+                        list(ads.adata_dic[dk].keys()) for dk in ads.adata_dic.keys()
+                    ]
+                }
             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 ToolError(e.__context__)
                 else:
                     raise ToolError(e)
-        return Tool.from_function(_check_samples, name="check_samples")
+
+        return Tool.from_function(_check_samples, name="check_samples", enabled=True)

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