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

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

@@ -1,21 +1,28 @@
-from fastmcp import FastMCP, Context
-import os
-import inspect
-from fastmcp import FastMCP
 import scanpy as sc
 from fastmcp.exceptions import ToolError
 from fastmcp.tools.tool import Tool
-from ..schema.tl import *
-from ..schema import AdataInfo
-from scmcp_shared.util import filter_args, add_op_log, forward_request, get_ads, generate_msg
-from .base import BaseMCP
+from scmcp_shared.schema.preset.tl import *
+from scmcp_shared.schema.preset import AdataInfo
+from scmcp_shared.util import (
+    filter_args,
+    add_op_log,
+    forward_request,
+    get_ads,
+    generate_msg,
+)
+from scmcp_shared.mcp_base import BaseMCP
 
 
 class ScanpyToolsMCP(BaseMCP):
-    def __init__(self, include_tools: list = None, exclude_tools: list = None, AdataInfo: AdataInfo = AdataInfo):
+    def __init__(
+        self,
+        include_tools: list = None,
+        exclude_tools: list = None,
+        AdataInfo: AdataInfo = AdataInfo,
+    ):
         """
         Initialize ScanpyMCP 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.
@@ -24,7 +31,9 @@ class ScanpyToolsMCP(BaseMCP):
         super().__init__("ScanpyMCP-TL-Server", include_tools, exclude_tools, AdataInfo)
 
     def _tool_tsne(self):
-        def _tsne(request: TSNEParams=TSNEParams(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _tsne(
+            request: TSNEParam = TSNEParam(), adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """t-distributed stochastic neighborhood embedding (t-SNE) for visualization"""
             try:
                 result = forward_request("tl_tsne", request, adinfo)
@@ -39,14 +48,17 @@ class ScanpyToolsMCP(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(_tsne, name="tsne")
+
+        return Tool.from_function(_tsne, name="tsne", enabled=True)
 
     def _tool_umap(self):
-        def _umap(request: UMAPParams=UMAPParams(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _umap(
+            request: UMAPParam = UMAPParam(), adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Uniform Manifold Approximation and Projection (UMAP) for visualization"""
             try:
                 result = forward_request("tl_umap", request, adinfo)
@@ -61,19 +73,22 @@ class ScanpyToolsMCP(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(_umap, name="umap")
+
+        return Tool.from_function(_umap, name="umap", enabled=True)
 
     def _tool_draw_graph(self):
-        def _draw_graph(request: DrawGraphParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _draw_graph(
+            request: DrawGraphParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Force-directed graph drawing"""
             try:
                 result = forward_request("tl_draw_graph", request, adinfo)
                 if result is not None:
-                    return result    
+                    return result
                 func_kwargs = filter_args(request, sc.tl.draw_graph)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -83,42 +98,46 @@ class ScanpyToolsMCP(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(_draw_graph, name="draw_graph")
+
+        return Tool.from_function(_draw_graph, name="draw_graph", enabled=True)
 
     def _tool_diffmap(self):
-        def _diffmap(request: DiffMapParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _diffmap(request: DiffMapParam, adinfo: self.AdataInfo = self.AdataInfo()):
             """Diffusion Maps for dimensionality reduction"""
             try:
                 result = forward_request("tl_diffmap", request, adinfo)
                 if result is not None:
-                    return result    
+                    return result
                 func_kwargs = filter_args(request, sc.tl.diffmap)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
                 sc.tl.diffmap(adata, **func_kwargs)
-                adata.obsm["X_diffmap"] = adata.obsm["X_diffmap"][:,1:]
+                adata.obsm["X_diffmap"] = adata.obsm["X_diffmap"][:, 1:]
                 add_op_log(adata, sc.tl.diffmap, func_kwargs, adinfo)
                 return [generate_msg(adinfo, adata, ads)]
             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(_diffmap, name="diffmap")
 
-    def _tool_embedding_density(self):  
-        def _embedding_density(request: EmbeddingDensityParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        return Tool.from_function(_diffmap, name="diffmap", enabled=True)
+
+    def _tool_embedding_density(self):
+        def _embedding_density(
+            request: EmbeddingDensityParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Calculate the density of cells in an embedding"""
             try:
                 result = forward_request("tl_embedding_density", request, adinfo)
                 if result is not None:
-                    return result        
+                    return result
                 func_kwargs = filter_args(request, sc.tl.embedding_density)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -128,19 +147,25 @@ class ScanpyToolsMCP(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(_embedding_density, name="embedding_density")
+
+        return Tool.from_function(
+            _embedding_density, name="embedding_density", enabled=True
+        )
 
     def _tool_leiden(self):
-        def _leiden(request: LeidenParams=LeidenParams(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _leiden(
+            request: LeidenParam = LeidenParam(),
+            adinfo: self.AdataInfo = self.AdataInfo(),
+        ):
             """Leiden clustering algorithm for community detection"""
             try:
                 result = forward_request("tl_leiden", request, adinfo)
                 if result is not None:
-                    return result            
+                    return result
                 func_kwargs = filter_args(request, sc.tl.leiden)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -150,19 +175,23 @@ class ScanpyToolsMCP(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(_leiden, name="leiden")
+
+        return Tool.from_function(_leiden, name="leiden", enabled=True)
 
     def _tool_louvain(self):
-        def _louvain(request: LouvainParams=LouvainParams(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _louvain(
+            request: LouvainParam = LouvainParam(),
+            adinfo: self.AdataInfo = self.AdataInfo(),
+        ):
             """Louvain clustering algorithm for community detection"""
             try:
                 result = forward_request("tl_louvain", request, adinfo)
                 if result is not None:
-                    return result          
+                    return result
                 func_kwargs = filter_args(request, sc.tl.louvain)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -172,19 +201,22 @@ class ScanpyToolsMCP(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(_louvain, name="louvain")
+
+        return Tool.from_function(_louvain, name="louvain", enabled=True)
 
     def _tool_dendrogram(self):
-        def _dendrogram(request: DendrogramParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _dendrogram(
+            request: DendrogramParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Hierarchical clustering dendrogram"""
             try:
                 result = forward_request("tl_dendrogram", request, adinfo)
                 if result is not None:
-                    return result        
+                    return result
                 func_kwargs = filter_args(request, sc.tl.dendrogram)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -194,19 +226,20 @@ class ScanpyToolsMCP(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(_dendrogram, name="dendrogram")
+
+        return Tool.from_function(_dendrogram, name="dendrogram", enabled=True)
 
     def _tool_dpt(self):
-        def _dpt(request: DPTParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _dpt(request: DPTParam, adinfo: self.AdataInfo = self.AdataInfo()):
             """Diffusion Pseudotime (DPT) analysis"""
             try:
                 result = forward_request("tl_dpt", request, adinfo)
                 if result is not None:
-                    return result          
+                    return result
                 func_kwargs = filter_args(request, sc.tl.dpt)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -216,63 +249,68 @@ class ScanpyToolsMCP(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(_dpt, name="dpt")
+
+        return Tool.from_function(_dpt, name="dpt", enabled=True)
 
     def _tool_paga(self):
-        def _paga(request: PAGAParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _paga(request: PAGAParam, adinfo: self.AdataInfo = self.AdataInfo()):
             """Partition-based graph abstraction"""
             try:
                 result = forward_request("tl_paga", request, adinfo)
                 if result is not None:
-                    return result         
+                    return result
                 func_kwargs = filter_args(request, sc.tl.paga)
                 ads = get_ads()
-                adata = ads.get_adata(adinfo=adinfo)    
+                adata = ads.get_adata(adinfo=adinfo)
                 sc.tl.paga(adata, **func_kwargs)
                 add_op_log(adata, sc.tl.paga, func_kwargs, adinfo)
                 return [generate_msg(adinfo, adata, ads)]
             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(_paga, name="paga")
+
+        return Tool.from_function(_paga, name="paga", enabled=True)
 
     def _tool_ingest(self):
-        def _ingest(request: IngestParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _ingest(request: IngestParam, adinfo: self.AdataInfo = self.AdataInfo()):
             """Map labels and embeddings from reference data to new data"""
             try:
                 result = forward_request("tl_ingest", request, adinfo)
                 if result is not None:
-                    return result       
+                    return result
                 func_kwargs = filter_args(request, sc.tl.ingest)
                 ads = get_ads()
-                adata = ads.get_adata(adinfo=adinfo)    
+                adata = ads.get_adata(adinfo=adinfo)
                 sc.tl.ingest(adata, **func_kwargs)
                 add_op_log(adata, sc.tl.ingest, func_kwargs, adinfo)
                 return [generate_msg(adinfo, adata, ads)]
             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(_ingest, name="ingest")   
+
+        return Tool.from_function(_ingest, name="ingest", enabled=True)
 
     def _tool_rank_genes_groups(self):
-        def _rank_genes_groups(request: RankGenesGroupsParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _rank_genes_groups(
+            request: RankGenesGroupsParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Rank genes for characterizing groups, for differentially expressison analysis"""
             try:
                 result = forward_request("tl_rank_genes_groups", request, adinfo)
                 if result is not None:
-                    return result         
+                    return result
                 func_kwargs = filter_args(request, sc.tl.rank_genes_groups)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -282,19 +320,25 @@ class ScanpyToolsMCP(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(_rank_genes_groups, name="rank_genes_groups")
+
+        return Tool.from_function(
+            _rank_genes_groups, name="rank_genes_groups", enabled=True
+        )
 
     def _tool_filter_rank_genes_groups(self):
-        def _filter_rank_genes_groups(request: FilterRankGenesGroupsParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _filter_rank_genes_groups(
+            request: FilterRankGenesGroupsParam,
+            adinfo: self.AdataInfo = self.AdataInfo(),
+        ):
             """Filter out genes based on fold change and fraction of genes"""
             try:
                 result = forward_request("tl_filter_rank_genes_groups", request, adinfo)
                 if result is not None:
-                    return result          
+                    return result
                 func_kwargs = filter_args(request, sc.tl.filter_rank_genes_groups)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -304,19 +348,24 @@ class ScanpyToolsMCP(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(_filter_rank_genes_groups, name="filter_rank_genes_groups")
+
+        return Tool.from_function(
+            _filter_rank_genes_groups, name="filter_rank_genes_groups", enabled=True
+        )
 
     def _tool_marker_gene_overlap(self):
-        def _marker_gene_overlap(request: MarkerGeneOverlapParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _marker_gene_overlap(
+            request: MarkerGeneOverlapParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Calculate overlap between data-derived marker genes and reference markers"""
             try:
                 result = forward_request("tl_marker_gene_overlap", request, adinfo)
                 if result is not None:
-                    return result         
+                    return result
                 func_kwargs = filter_args(request, sc.tl.marker_gene_overlap)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -326,19 +375,24 @@ class ScanpyToolsMCP(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(_marker_gene_overlap, name="marker_gene_overlap")
+
+        return Tool.from_function(
+            _marker_gene_overlap, name="marker_gene_overlap", enabled=True
+        )
 
     def _tool_score_genes(self):
-        def _score_genes(request: ScoreGenesParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _score_genes(
+            request: ScoreGenesParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Score a set of genes based on their average expression"""
             try:
                 result = forward_request("tl_score_genes", request, adinfo)
                 if result is not None:
-                    return result       
+                    return result
                 func_kwargs = filter_args(request, sc.tl.score_genes)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -348,19 +402,22 @@ class ScanpyToolsMCP(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(_score_genes, name="score_genes")
+
+        return Tool.from_function(_score_genes, name="score_genes", enabled=True)
 
     def _tool_score_genes_cell_cycle(self):
-        def _score_genes_cell_cycle(request: ScoreGenesCellCycleParams, adinfo: self.AdataInfo=self.AdataInfo()):
+        def _score_genes_cell_cycle(
+            request: ScoreGenesCellCycleParam, adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Score cell cycle genes and assign cell cycle phases"""
             try:
                 result = forward_request("tl_score_genes_cell_cycle", request, adinfo)
                 if result is not None:
-                    return result       
+                    return result
                 func_kwargs = filter_args(request, sc.tl.score_genes_cell_cycle)
                 ads = get_ads()
                 adata = ads.get_adata(adinfo=adinfo)
@@ -370,14 +427,19 @@ class ScanpyToolsMCP(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(_score_genes_cell_cycle, name="score_genes_cell_cycle")
+
+        return Tool.from_function(
+            _score_genes_cell_cycle, name="score_genes_cell_cycle", enabled=True
+        )
 
     def _tool_pca(self):
-        def _pca(request: PCAParams=PCAParams(), adinfo: self.AdataInfo=self.AdataInfo()):
+        def _pca(
+            request: PCAParam = PCAParam(), adinfo: self.AdataInfo = self.AdataInfo()
+        ):
             """Compute PCA (Principal Component Analysis)."""
             try:
                 result = forward_request("tl_pca", request, adinfo)
@@ -392,8 +454,9 @@ class ScanpyToolsMCP(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(_pca, name="pca")
+
+        return Tool.from_function(_pca, name="pca", enabled=True)