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

scmcp_shared/server/pl.py

@@ -0,0 +1,321 @@
+import os
+import inspect
+from functools import partial
+import scanpy as sc
+from fastmcp import FastMCP, Context
+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 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 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
+
+@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
+
+
+@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
+
+
+@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
+
+
+@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
+
+@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
+
+
+@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
+
+@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
+
+@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

scmcp_shared/server/pp.py

@@ -0,0 +1,363 @@
+
+import os
+import inspect
+import scanpy as sc
+from fastmcp import FastMCP , Context
+from ..schema.pp import *
+from ..util import filter_args, add_op_log, forward_request, get_ads, generate_msg
+from ..logging_config import setup_logger
+logger = setup_logger()
+
+
+pp_mcp = FastMCP("ScanpyMCP-PP-Server")
+
+
+@pp_mcp.tool()
+async def subset_cells(
+    request: SubsetCellModel = SubsetCellModel() 
+):
+    """filter or subset cells based on total genes expressed counts and numbers. or values in adata.obs[obs_key]"""
+
+    try:
+        result = await forward_request("subset_cells", request)
+        if result is not None:
+            return result
+
+        ads = get_ads()
+        adata = ads.get_adata(request=request).copy()
+        func_kwargs = filter_args(request, sc.pp.filter_cells)
+        if func_kwargs:
+            sc.pp.filter_cells(adata, **func_kwargs)
+            add_op_log(adata, sc.pp.filter_cells, func_kwargs)
+        # Subset based on obs (cells) criteria
+        if request.obs_key is not None:
+            if request.obs_key not in adata.obs.columns:
+                raise ValueError(f"Key '{request.obs_key}' not found in adata.obs")        
+            mask = True  # Start with all cells selected
+            if request.obs_value is not None:
+                mask = mask & (adata.obs[request.obs_key] == request.obs_value)
+            if request.obs_min is not None:
+                mask = mask & (adata.obs[request.obs_key] >= request.obs_min)        
+            if request.obs_max is not None:
+                mask = mask & (adata.obs[request.obs_key] <= request.obs_max)        
+            adata = adata[mask, :]
+            add_op_log(adata, "subset_cells", 
+                {
+                "obs_key": request.obs_key, "obs_value": request.obs_value, 
+                "obs_min": request.obs_min, "obs_max": request.obs_max
+                }
+            )
+        ads.set_adata(adata, request=request)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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
+
+
+@pp_mcp.tool()
+async def subset_genes(
+    request: SubsetGeneModel = SubsetGeneModel() 
+):
+    """filter or subset genes based on number of cells or counts, or values in adata.var[var_key] or subset highly variable genes""" 
+    try:
+        result = await forward_request("pp_subset_genes", request)
+        if result is not None:
+            return result
+        func_kwargs = filter_args(request, sc.pp.filter_genes)
+        ads = get_ads()
+        adata = ads.get_adata(request=request).copy()
+        if func_kwargs:
+            sc.pp.filter_genes(adata, **func_kwargs)
+            add_op_log(adata, sc.pp.filter_genes, func_kwargs)
+        if request.var_key is not None:
+            if request.var_key not in adata.var.columns:
+                raise ValueError(f"Key '{request.var_key}' not found in adata.var")
+            mask = True  # Start with all genes selected
+            if request.var_min is not None:
+                mask = mask & (adata.var[request.var_key] >= request.var_min)
+            if request.var_max is not None:
+                mask = mask & (adata.var[request.var_key] <= request.var_max)        
+            adata = adata[:, mask]
+            if request.highly_variable is not None:
+                adata = adata[:, adata.var.highly_variable]
+            add_op_log(adata, "subset_genes", 
+                {
+                "var_key": request.var_key, "var_value": request.var_value, 
+                "var_min": request.var_min, "var_max": request.var_max, "hpv":  request.highly_variable
+                }
+            )
+        ads.set_adata(adata, request=request)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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
+
+@pp_mcp.tool()
+async def calculate_qc_metrics(
+    request: CalculateQCMetrics = CalculateQCMetrics() 
+):
+    """Calculate quality control metrics(common metrics: total counts, gene number, percentage of counts in ribosomal and mitochondrial) for AnnData."""
+
+    try:
+        result = await forward_request("pp_calculate_qc_metrics", request)
+        if result is not None:
+            return result
+        logger.info(f"calculate_qc_metrics {request.model_dump()}")
+        func_kwargs = filter_args(request, sc.pp.calculate_qc_metrics)
+        ads = get_ads()
+        adata = ads.get_adata(request=request)
+        func_kwargs["inplace"] = True
+        try:
+            sc.pp.calculate_qc_metrics(adata, **func_kwargs)
+            add_op_log(adata, sc.pp.calculate_qc_metrics, func_kwargs)
+        except KeyError as e:
+            raise KeyError(f"Cound find {e} in adata.var")
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    except Exception as e:
+        if hasattr(e, '__context__') and e.__context__:
+            raise Exception(f"{str(e.__context__)}")
+        else:
+            raise e 
+
+
+@pp_mcp.tool()
+async def log1p(
+    request: Log1PModel = Log1PModel() 
+):
+    """Logarithmize the data matrix"""
+
+    try:
+        result = await forward_request("pp_log1p", request)
+        if result is not None:
+            return result
+        func_kwargs = filter_args(request, sc.pp.log1p)
+        ads = get_ads()
+        adata = ads.get_adata(request=request).copy()
+        try:
+            sc.pp.log1p(adata, **func_kwargs)
+            adata.raw = adata.copy()
+            add_op_log(adata, sc.pp.log1p, func_kwargs)
+        except Exception as e:
+            raise e
+        ads.set_adata(adata, request=request)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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
+
+
+@pp_mcp.tool()
+async def normalize_total(
+    request: NormalizeTotalModel = NormalizeTotalModel() 
+):
+    """Normalize counts per cell to the same total count"""
+
+    try:
+        result = await forward_request("pp_normalize_total", request)
+        if result is not None:
+            return result
+        func_kwargs = filter_args(request, sc.pp.normalize_total)
+        ads = get_ads()
+        adata = ads.get_adata(request=request).copy()
+        sc.pp.normalize_total(adata, **func_kwargs)
+        add_op_log(adata, sc.pp.normalize_total, func_kwargs)
+        ads.set_adata(adata, request=request)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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
+
+
+
+@pp_mcp.tool()
+async def highly_variable_genes(
+    request: HighlyVariableGenesModel = HighlyVariableGenesModel() 
+):
+    """Annotate highly variable genes"""
+
+    try:
+        result = await forward_request("pp_highly_variable_genes", request)
+        if result is not None:
+            return result
+        try:  
+            func_kwargs = filter_args(request, sc.pp.highly_variable_genes)
+            ads = get_ads()
+            adata = ads.get_adata(request=request)
+            sc.pp.highly_variable_genes(adata, **func_kwargs)
+            add_op_log(adata, sc.pp.highly_variable_genes, func_kwargs)
+        except Exception as e:
+            logger.error(f"Error in pp_highly_variable_genes: {str(e)}")
+            raise e
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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
+
+
+@pp_mcp.tool()
+async def regress_out(
+    request: RegressOutModel,
+    
+):
+    """Regress out (mostly) unwanted sources of variation."""
+
+    try:
+        result = await forward_request("pp_regress_out", request)
+        if result is not None:
+            return result        
+        func_kwargs = filter_args(request, sc.pp.regress_out)
+        ads = get_ads()
+        adata = ads.get_adata(request=request).copy()
+        sc.pp.regress_out(adata, **func_kwargs)
+        add_op_log(adata, sc.pp.regress_out, func_kwargs)
+        ads.set_adata(adata, request=request)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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
+
+@pp_mcp.tool()
+async def scale(
+    request: ScaleModel = ScaleModel() 
+):
+    """Scale data to unit variance and zero mean"""
+
+    try:
+        result = await forward_request("pp_scale", request)
+        if result is not None:
+            return result     
+        func_kwargs = filter_args(request, sc.pp.scale)
+        ads = get_ads()
+        adata = ads.get_adata(request=request).copy()
+
+        sc.pp.scale(adata, **func_kwargs)
+        add_op_log(adata, sc.pp.scale, func_kwargs)
+ 
+        ads.set_adata(adata, request=request)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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
+
+@pp_mcp.tool()
+async def combat(
+    request: CombatModel = CombatModel() 
+):
+    """ComBat function for batch effect correction"""
+
+    try:
+        result = await forward_request("pp_combat", request)
+        if result is not None:
+            return result        
+        func_kwargs = filter_args(request, sc.pp.combat)
+        ads = get_ads()
+        adata = ads.get_adata(request=request).copy()
+
+        sc.pp.combat(adata, **func_kwargs)
+        add_op_log(adata, sc.pp.combat, func_kwargs)
+
+        ads.set_adata(adata, request=request)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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
+
+@pp_mcp.tool()
+async def scrublet(
+    request: ScrubletModel = ScrubletModel() 
+):
+    """Predict doublets using Scrublet"""
+
+    try:
+        result = await forward_request("pp_scrublet", request)
+        if result is not None:
+            return result          
+        func_kwargs = filter_args(request, sc.pp.scrublet)
+        ads = get_ads()
+        adata = ads.get_adata(request=request)
+        sc.pp.scrublet(adata, **func_kwargs)
+        add_op_log(adata, sc.pp.scrublet, func_kwargs)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    except Exception as e:
+        if hasattr(e, '__context__') and e.__context__:
+            raise Exception(f"{str(e.__context__)}")
+        else:
+            raise e 
+
+@pp_mcp.tool()
+async def neighbors(
+    request: NeighborsModel = NeighborsModel() 
+):
+    """Compute nearest neighbors distance matrix and neighborhood graph"""
+
+    try:
+        result = await forward_request("pp_neighbors", request)
+        if result is not None:
+            return result
+        func_kwargs = filter_args(request, sc.pp.neighbors)
+        ads = get_ads()
+        adata = ads.get_adata(request=request)
+        sc.pp.neighbors(adata, **func_kwargs)
+        add_op_log(adata, sc.pp.neighbors, func_kwargs)
+        return [
+            generate_msg(request, adata, ads)
+        ]
+    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