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

scmcp_shared/server/pl.py

@@ -3,319 +3,313 @@ import inspect
 from functools import partial
 import scanpy as sc
 from fastmcp import FastMCP, Context
+from fastmcp.exceptions import ToolError
 from ..schema.pl import *
+from ..schema import AdataInfo
 from pathlib import Path
-from ..logging_config import setup_logger
 from ..util import forward_request, sc_like_plot, get_ads
+from .base import BaseMCP
 
 
-logger = setup_logger()
+class ScanpyPlottingMCP(BaseMCP):
+    def __init__(self, include_tools: list = None, exclude_tools: list = None, AdataInfo: AdataInfo = AdataInfo):
+        """
+        Initialize ScanpyPreprocessingMCP 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.
+            AdataInfo: The AdataInfo class to use for type annotations.
+        """
+        super().__init__("ScanpyMCP-PL-Server", include_tools, exclude_tools, AdataInfo)
 
-pl_mcp = FastMCP("ScanpyMCP-PL-Server")
+    def _tool_pca(self):
+        def _pca(request: PCAModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Scatter plot in PCA coordinates. default figure for PCA plot"""
+            try:
+                if (res := forward_request("pl_pca", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.pca, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _pca
 
+    def _tool_diffmap(self):
+        def _diffmap(request: DiffusionMapModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot diffusion map embedding of cells."""
+            try:
+                if (res := forward_request("pl_diffmap", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.diffmap, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _diffmap
 
+    def _tool_violin(self):
+        def _violin(request: ViolinModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot violin plot of one or more variables."""
+            try:
+                if (res := forward_request("pl_violin", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.violin, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except KeyError as e:
+                raise ToolError(f"doest found {e} in current sampleid with adtype {adinfo.adtype}")
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _violin
 
-@pl_mcp.tool()
-async def pca(request: PCAModel = PCAModel()):
-    """Scatter plot in PCA coordinates. default figure for PCA plot"""
-    try:
-        result = await forward_request("pl_pca", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.pca, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e 
+    def _tool_stacked_violin(self):
+        def _stacked_violin(request: StackedViolinModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot stacked violin plots. Makes a compact image composed of individual violin plots stacked on top of each other."""
+            try:
+                if (res := forward_request("pl_stacked_violin", request, adinfo)) is not None:
+                    return res           
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.stacked_violin, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _stacked_violin
 
-@pl_mcp.tool()
-async def diffmap(request: DiffusionMapModel = DiffusionMapModel()):
-    """Plot diffusion map embedding of cells."""
-    try:
-        result = await forward_request("pl_diffmap", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.diffmap, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
+    def _tool_heatmap(self):
+        async def _heatmap(request: HeatmapModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Heatmap of the expression values of genes."""
+            try:
+                if (res := forward_request("pl_heatmap", request, adinfo)) is not None:
+                    return res   
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.heatmap, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _heatmap
 
-@pl_mcp.tool()
-async def violin(request: ViolinModel,):
-    """Plot violin plot of one or more variables."""
-    try:
-        result = await forward_request("pl_violin", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.violin, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise f"doest found {e} in current sampleid with adtype {request.adtype}"
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
+    def _tool_dotplot(self):
+        def _dotplot(request: DotplotModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot dot plot of expression values per gene for each group."""
+            try:
+                if (res := forward_request("pl_dotplot", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.dotplot, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _dotplot
 
+    def _tool_matrixplot(self):
+        def _matrixplot(request: MatrixplotModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """matrixplot, Create a heatmap of the mean expression values per group of each var_names."""
+            try:
+                if (res := forward_request("pl_matrixplot", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.matrixplot, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _matrixplot
 
-@pl_mcp.tool()
-async def stacked_violin(request: StackedViolinModel = StackedViolinModel()):
-    """Plot stacked violin plots. Makes a compact image composed of individual violin plots stacked on top of each other."""
-    try:
-        result = await forward_request("pl_stacked_violin", request)
-        if result is not None:
-            return result           
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.stacked_violin, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
+    def _tool_tracksplot(self):
+        def _tracksplot(request: TracksplotModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """tracksplot, compact plot of expression of a list of genes."""
+            try:
+                if (res := forward_request("pl_tracksplot", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.tracksplot, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _tracksplot
 
+    def _tool_scatter(self):
+        def _scatter(request: EnhancedScatterModel, adinfo: self.AdataInfo=self.AdataInfo()):    
+            """Plot a scatter plot of two variables, Scatter plot along observations or variables axes."""
+            try:
+                if (res := forward_request("pl_scatter", request, adinfo)) is not None:
+                    return res   
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.scatter, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _scatter
 
-@pl_mcp.tool()
-async def heatmap(request: HeatmapModel):
-    """Heatmap of the expression values of genes."""
-    try:
-        result = await forward_request("pl_heatmap", request)
-        if result is not None:
-            return result           
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.heatmap, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
+    def _tool_embedding(self):
+        def _embedding(request: EmbeddingModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Scatter plot for user specified embedding basis (e.g. umap, tsne, etc)."""
+            try:
+                if (res := forward_request("pl_embedding", request, adinfo)) is not None:
+                    return res   
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.embedding, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except KeyError as e:
+                raise ToolError(f"doest found {e} in current sampleid with adtype {adinfo.adtype}")
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _embedding
 
+    def _tool_embedding_density(self):
+        def _embedding_density(request: EmbeddingDensityModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot the density of cells in an embedding."""
+            try:
+                if (res := forward_request("pl_embedding_density", request, adinfo)) is not None:
+                    return res   
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.embedding_density, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _embedding_density
 
-@pl_mcp.tool()
-async def dotplot(request: DotplotModel):
-    """Plot dot plot of expression values per gene for each group."""
-    try:
-        result = await forward_request("pl_dotplot", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.dotplot, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
+    def _tool_rank_genes_groups(self):
+        def _rank_genes_groups(request: RankGenesGroupsModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot ranking of genes based on differential expression."""
+            try:
+                if (res := forward_request("pl_rank_genes_groups", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.rank_genes_groups, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _rank_genes_groups
 
-@pl_mcp.tool()
-async def matrixplot(request: MatrixplotModel):
-    """matrixplot, Create a heatmap of the mean expression values per group of each var_names."""
-    try:
-        result = await forward_request("pl_matrixplot", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.matrixplot, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
+    def _tool_rank_genes_groups_dotplot(self):
+        def _rank_genes_groups_dotplot(request: RankGenesGroupsDotplotModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot ranking of genes(DEGs) using dotplot visualization. Defualt plot DEGs for rank_genes_groups tool"""
+            try:
+                if (res := forward_request("pl_rank_genes_groups_dotplot", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.rank_genes_groups_dotplot, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _rank_genes_groups_dotplot
 
+    def _tool_clustermap(self):
+        def _clustermap(request: ClusterMapModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot hierarchical clustering of cells and genes."""
+            try:
+                if (res := forward_request("pl_clustermap", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.clustermap, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _clustermap
 
-@pl_mcp.tool()
-async def tracksplot(request: TracksplotModel):
-    """tracksplot, compact plot of expression of a list of genes."""
-    try:
-        result = await forward_request("pl_tracksplot", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.tracksplot, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
+    def _tool_highly_variable_genes(self):
+        def _highly_variable_genes(request: HighlyVariableGenesModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """plot highly variable genes; Plot dispersions or normalized variance versus means for genes."""
+            try:
+                if (res := forward_request("pl_highly_variable_genes", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.highly_variable_genes, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _highly_variable_genes
 
-@pl_mcp.tool()
-async def scatter(request: EnhancedScatterModel = EnhancedScatterModel()):
-    """Plot a scatter plot of two variables, Scatter plot along observations or variables axes."""
-    try:
-        result = await forward_request("pl_scatter", request)
-        if result is not None:
-            return result    
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.scatter, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
+    def _tool_pca_variance_ratio(self):
+        def _pca_variance_ratio(request: PCAVarianceRatioModel, adinfo: self.AdataInfo=self.AdataInfo()):
+            """Plot the PCA variance ratio to visualize explained variance."""
+            try:
+                if (res := forward_request("pl_pca_variance_ratio", request, adinfo)) is not None:
+                    return res
+                adata = get_ads().get_adata(adinfo=adinfo)
+                fig_path = sc_like_plot(sc.pl.pca_variance_ratio, adata, request, adinfo)
+                return {"figpath": fig_path}
+            except ToolError as e:
+                raise ToolError(e)
+            except Exception as e:
+                if hasattr(e, '__context__') and e.__context__:
+                    raise ToolError(e.__context__)
+                else:
+                    raise ToolError(e)
+        return _pca_variance_ratio
 
-@pl_mcp.tool()
-async def embedding(request: EmbeddingModel):
-    """Scatter plot for user specified embedding basis (e.g. umap, tsne, etc)."""
-    try:
-        result = await forward_request("pl_embedding", request)
-        if result is not None:
-            return result       
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.embedding, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        from fastmcp.exceptions import ToolError
-        raise ToolError(f"doest found {e} in current sampleid with adtype {request.adtype}")
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
-
-
-@pl_mcp.tool()
-async def embedding_density(request: EmbeddingDensityModel):
-    """Plot the density of cells in an embedding."""
-    try:
-        result = await forward_request("pl_embedding_density", request)
-        if result is not None:
-            return result          
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.embedding_density, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
-
-@pl_mcp.tool()
-async def rank_genes_groups(request: RankGenesGroupsModel):
-    """Plot ranking of genes based on differential expression."""
-    try:
-        result = await forward_request("pl_rank_genes_groups", request)
-        if result is not None:
-            return result         
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.rank_genes_groups, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
-
-
-@pl_mcp.tool()
-async def rank_genes_groups_dotplot(
-    request: RankGenesGroupsDotplotModel,
-):
-    """Plot ranking of genes(DEGs) using dotplot visualization. Defualt plot DEGs for rank_genes_groups tool"""
-    try:
-        result = await forward_request("pl_rank_genes_groups_dotplot", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.rank_genes_groups_dotplot, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
-
-
-@pl_mcp.tool()
-async def clustermap(
-    request: ClusterMapModel = ClusterMapModel() 
-):
-    """Plot hierarchical clustering of cells and genes."""
-    try:
-        result = await forward_request("pl_clustermap", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.clustermap, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
-
-@pl_mcp.tool()
-async def highly_variable_genes(
-    request: HighlyVariableGenesModel = HighlyVariableGenesModel() 
-):
-    """plot highly variable genes; Plot dispersions or normalized variance versus means for genes."""
-    try:
-        result = await forward_request("pl_highly_variable_genes", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.highly_variable_genes, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e
-
-
-@pl_mcp.tool()
-async def pca_variance_ratio(
-    request: PCAVarianceRatioModel = PCAVarianceRatioModel() 
-):
-    """Plot the PCA variance ratio to visualize explained variance."""
-    try:
-        result = await forward_request("pl_pca_variance_ratio", request)
-        if result is not None:
-            return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.pca_variance_ratio, adata, request)
-        return {"figpath": fig_path}
-    except KeyError as e:
-        raise e
-    except Exception as e:
-        if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
-        else:
-            raise e