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

scmcp_shared/server/pl.py

@@ -5,6 +5,7 @@ import scanpy as sc
 from fastmcp import FastMCP, Context
 from fastmcp.exceptions import ToolError
 from ..schema.pl import *
+from ..schema import AdataModel
 from pathlib import Path
 from ..logging_config import setup_logger
 from ..util import forward_request, sc_like_plot, get_ads
@@ -17,14 +18,17 @@ pl_mcp = FastMCP("ScanpyMCP-PL-Server")
 
 
 @pl_mcp.tool()
-async def pca(request: PCAModel = PCAModel()):
+async def pca(
+    request: PCAModel = PCAModel(), 
+    adinfo: AdataModel = AdataModel()
+):
     """Scatter plot in PCA coordinates. default figure for PCA plot"""
     try:
-        result = await forward_request("pl_pca", request)
+        result = await forward_request("pl_pca", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.pca, adata, request)
+        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)
@@ -35,14 +39,17 @@ async def pca(request: PCAModel = PCAModel()):
             raise ToolError(e)
 
 @pl_mcp.tool()
-async def diffmap(request: DiffusionMapModel = DiffusionMapModel()):
+async def diffmap(
+    request: DiffusionMapModel = DiffusionMapModel(), 
+    adinfo: AdataModel = AdataModel()
+):
     """Plot diffusion map embedding of cells."""
     try:
-        result = await forward_request("pl_diffmap", request)
+        result = await forward_request("pl_diffmap", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.diffmap, adata, request)
+        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)
@@ -53,17 +60,20 @@ async def diffmap(request: DiffusionMapModel = DiffusionMapModel()):
             raise ToolError(e)
 
 @pl_mcp.tool()
-async def violin(request: ViolinModel,):
+async def violin(
+    request: ViolinModel,
+    adinfo: AdataModel = AdataModel()
+):
     """Plot violin plot of one or more variables."""
     try:
-        result = await forward_request("pl_violin", request)
+        result = await forward_request("pl_violin", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.violin, adata, request)
+        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 {request.adtype}")
+        raise ToolError(f"doest found {e} in current sampleid with adtype {adinfo.adtype}")
     except ToolError as e:
         raise ToolError(e)
     except Exception as e:
@@ -74,14 +84,17 @@ async def violin(request: ViolinModel,):
 
 
 @pl_mcp.tool()
-async def stacked_violin(request: StackedViolinModel = StackedViolinModel()):
+async def stacked_violin(
+    request: StackedViolinModel = StackedViolinModel(),
+    adinfo: AdataModel = AdataModel()
+):
     """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)
+        result = await forward_request("pl_stacked_violin", request, adinfo)
         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)
+        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)
@@ -93,14 +106,17 @@ async def stacked_violin(request: StackedViolinModel = StackedViolinModel()):
 
 
 @pl_mcp.tool()
-async def heatmap(request: HeatmapModel):
+async def heatmap(
+    request: HeatmapModel,
+    adinfo: AdataModel = AdataModel()
+):
     """Heatmap of the expression values of genes."""
     try:
-        result = await forward_request("pl_heatmap", request)
+        result = await forward_request("pl_heatmap", request, adinfo)
         if result is not None:
             return result           
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.heatmap, adata, request)
+        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)
@@ -112,14 +128,17 @@ async def heatmap(request: HeatmapModel):
 
 
 @pl_mcp.tool()
-async def dotplot(request: DotplotModel):
+async def dotplot(
+    request: DotplotModel,
+    adinfo: AdataModel = AdataModel()
+):
     """Plot dot plot of expression values per gene for each group."""
     try:
-        result = await forward_request("pl_dotplot", request)
+        result = await forward_request("pl_dotplot", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.dotplot, adata, request)
+        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)
@@ -130,14 +149,17 @@ async def dotplot(request: DotplotModel):
             raise ToolError(e)
 
 @pl_mcp.tool()
-async def matrixplot(request: MatrixplotModel):
+async def matrixplot(
+    request: MatrixplotModel,
+    adinfo: AdataModel = AdataModel()
+):
     """matrixplot, Create a heatmap of the mean expression values per group of each var_names."""
     try:
-        result = await forward_request("pl_matrixplot", request)
+        result = await forward_request("pl_matrixplot", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.matrixplot, adata, request)
+        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)
@@ -149,14 +171,17 @@ async def matrixplot(request: MatrixplotModel):
 
 
 @pl_mcp.tool()
-async def tracksplot(request: TracksplotModel):
+async def tracksplot(
+    request: TracksplotModel,
+    adinfo: AdataModel = AdataModel()
+):
     """tracksplot, compact plot of expression of a list of genes."""
     try:
-        result = await forward_request("pl_tracksplot", request)
+        result = await forward_request("pl_tracksplot", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.tracksplot, adata, request)
+        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)
@@ -167,14 +192,17 @@ async def tracksplot(request: TracksplotModel):
             raise ToolError(e)
 
 @pl_mcp.tool()
-async def scatter(request: EnhancedScatterModel = EnhancedScatterModel()):
+async def scatter(
+    request: EnhancedScatterModel = EnhancedScatterModel(),
+    adinfo: AdataModel = AdataModel()
+):
     """Plot a scatter plot of two variables, Scatter plot along observations or variables axes."""
     try:
-        result = await forward_request("pl_scatter", request)
+        result = await forward_request("pl_scatter", request, adinfo)
         if result is not None:
             return result    
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.scatter, adata, request)
+        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)
@@ -185,17 +213,20 @@ async def scatter(request: EnhancedScatterModel = EnhancedScatterModel()):
             raise ToolError(e)
 
 @pl_mcp.tool()
-async def embedding(request: EmbeddingModel):
+async def embedding(
+    request: EmbeddingModel,
+    adinfo: AdataModel = AdataModel()
+):
     """Scatter plot for user specified embedding basis (e.g. umap, tsne, etc)."""
     try:
-        result = await forward_request("pl_embedding", request)
+        result = await forward_request("pl_embedding", request, adinfo)
         if result is not None:
             return result       
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.embedding, adata, request)
+        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 {request.adtype}")
+        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__)
@@ -204,14 +235,17 @@ async def embedding(request: EmbeddingModel):
 
 
 @pl_mcp.tool()
-async def embedding_density(request: EmbeddingDensityModel):
+async def embedding_density(
+    request: EmbeddingDensityModel,
+    adinfo: AdataModel = AdataModel()
+):
     """Plot the density of cells in an embedding."""
     try:
-        result = await forward_request("pl_embedding_density", request)
+        result = await forward_request("pl_embedding_density", request, adinfo)
         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)
+        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)
@@ -222,14 +256,17 @@ async def embedding_density(request: EmbeddingDensityModel):
             raise ToolError(e)
 
 @pl_mcp.tool()
-async def rank_genes_groups(request: RankGenesGroupsModel):
+async def rank_genes_groups(
+    request: RankGenesGroupsModel,
+    adinfo: AdataModel = AdataModel()
+):
     """Plot ranking of genes based on differential expression."""
     try:
-        result = await forward_request("pl_rank_genes_groups", request)
+        result = await forward_request("pl_rank_genes_groups", request, adinfo)
         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)
+        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)
@@ -243,15 +280,16 @@ async def rank_genes_groups(request: RankGenesGroupsModel):
 @pl_mcp.tool()
 async def rank_genes_groups_dotplot(
     request: RankGenesGroupsDotplotModel,
+    adinfo: AdataModel = AdataModel()
 ):
     """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)
+        result = await forward_request("pl_rank_genes_groups_dotplot", request, adinfo)
         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)
+        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)
@@ -264,15 +302,16 @@ async def rank_genes_groups_dotplot(
 
 @pl_mcp.tool()
 async def clustermap(
-    request: ClusterMapModel = ClusterMapModel() 
+    request: ClusterMapModel = ClusterMapModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Plot hierarchical clustering of cells and genes."""
     try:
-        result = await forward_request("pl_clustermap", request)
+        result = await forward_request("pl_clustermap", request, adinfo)
         if result is not None:
             return result
-        adata = get_ads().get_adata(request=request)
-        fig_path = sc_like_plot(sc.pl.clustermap, adata, request)
+        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)
@@ -284,15 +323,16 @@ async def clustermap(
 
 @pl_mcp.tool()
 async def highly_variable_genes(
-    request: HighlyVariableGenesModel = HighlyVariableGenesModel() 
+    request: HighlyVariableGenesModel = HighlyVariableGenesModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """plot highly variable genes; Plot dispersions or normalized variance versus means for genes."""
     try:
-        result = await forward_request("pl_highly_variable_genes", request)
+        result = await forward_request("pl_highly_variable_genes", request, adinfo)
         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)
+        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)
@@ -305,15 +345,17 @@ async def highly_variable_genes(
 
 @pl_mcp.tool()
 async def pca_variance_ratio(
-    request: PCAVarianceRatioModel = PCAVarianceRatioModel() 
+    request: PCAVarianceRatioModel = PCAVarianceRatioModel(),
+    adinfo: AdataModel = AdataModel()
 ):
     """Plot the PCA variance ratio to visualize explained variance."""
+    ### there is some bug, as scanpy.pl.pca_variance_ratio didn't return axis
     try:
-        result = await forward_request("pl_pca_variance_ratio", request)
+        result = await forward_request("pl_pca_variance_ratio", request, adinfo)
         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)
+        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)