scmcp-shared 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

scmcp_shared/server/io.py

@@ -3,33 +3,24 @@ import inspect
 from pathlib import Path
 import scanpy as sc
 from fastmcp import FastMCP , Context
+from fastmcp.exceptions import ToolError
 from ..schema.io import *
-from ..util import filter_args, forward_request
+from ..util import filter_args, forward_request, get_ads, generate_msg
 
 
 io_mcp = FastMCP("SCMCP-IO-Server")
 
 
 @io_mcp.tool()
-async def read(
-    request: ReadModel, 
-    ctx: Context,
-    sampleid: str = Field(default=None, description="adata sampleid"),
-    dtype: str = Field(default="exp", description="adata.X data type")
-):
+async def read(request: ReadModel):
     """
-    Read data from various file formats (h5ad, 10x, text files, etc.) or directory path.
+    Read data from 10X directory or various file formats (h5ad, 10x, text files, etc.).
     """
     try:
-        result = await forward_request("io_read", request, sampleid=sampleid, dtype=dtype)
+        result = await forward_request("io_read", request)
         if result is not None:
             return result        
         kwargs = request.model_dump()
-        ads = ctx.request_context.lifespan_context
-        if sampleid is not None:
-            ads.active_id = sampleid
-        else:
-            ads.active_id = f"adata{len(ads.adata_dic[dtype])}"
 
         file = Path(kwargs.get("filename", None))
         if file.is_dir():
@@ -43,38 +34,46 @@ async def read(
                 adata = adata.T
         else:
             raise FileNotFoundError(f"{kwargs['filename']} does not exist")
+
+        sampleid = kwargs.get("sampleid", None)
+        adtype = kwargs.get("adtype", "exp")
+        ads = get_ads()
+        if sampleid is not None:
+            ads.active_id = sampleid
+        else:
+            ads.active_id = f"adata{len(ads.adata_dic[adtype])}"
+            
         adata.layers["counts"] = adata.X
         adata.var_names_make_unique()
         adata.obs_names_make_unique()
-        ads.set_adata(adata, sampleid=sampleid, sdtype=dtype)
-        return {"sampleid": sampleid or ads.active_id, "dtype": dtype, "adata": adata}
+        ads.set_adata(adata, request=request)
+        return generate_msg(request, adata, ads)
+    except ToolError as e:
+        raise ToolError(e)
     except Exception as e:
         if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
+            raise ToolError(e.__context__)
         else:
-            raise e
+            raise ToolError(e)
 
 
 @io_mcp.tool()
-async def write(
-    request: WriteModel, 
-    ctx: Context,
-    sampleid: str = Field(default=None, description="adata sampleid"),
-    dtype: str = Field(default="exp", description="adata.X data type")
-):
+async def write(request: WriteModel):
     """save adata into a file.
     """
     try:
-        result = await forward_request("io_write", request, sampleid=sampleid, dtype=dtype)
+        result = await forward_request("io_write", request)
         if result is not None:
             return result
-        ads = ctx.request_context.lifespan_context
-        adata = ads.get_adata(sampleid=sampleid, dtype=dtype)
+        ads = get_ads()
+        adata = ads.get_adata(request=request)
         kwargs = request.model_dump()
         sc.write(kwargs["filename"], adata)
         return {"filename": kwargs["filename"], "msg": "success to save file"}
+    except ToolError as e:
+        raise ToolError(e)
     except Exception as e:
         if hasattr(e, '__context__') and e.__context__:
-            raise Exception(f"{str(e.__context__)}")
+            raise ToolError(e.__context__)
         else:
-            raise e    
+            raise ToolError(e)

scmcp_shared/server/pl.py

@@ -0,0 +1,324 @@
+import os
+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 pathlib import Path
+from ..logging_config import setup_logger
+from ..util import forward_request, sc_like_plot, get_ads
+
+
+logger = setup_logger()
+
+pl_mcp = FastMCP("ScanpyMCP-PL-Server")
+
+
+
+@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 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)
+
+@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 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)
+
+@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 ToolError(f"doest found {e} in current sampleid with adtype {request.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)
+
+
+@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 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)
+
+
+@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 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)
+
+
+@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 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)
+
+@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 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)
+
+
+@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 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)
+
+@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 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)
+
+@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:
+        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 ToolError(e.__context__)
+        else:
+            raise ToolError(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 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)
+
+@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 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)
+
+
+@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"""
+    from fastmcp.exceptions import ClientError 
+    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 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)
+
+
+@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 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)
+
+@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 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)
+
+
+@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 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)