scmcp-shared 0.2.0__tar.gz → 0.2.1__tar.gz

{scmcp_shared-0.2.0 → scmcp_shared-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scmcp_shared
-Version: 0.2.0
+Version: 0.2.1
 Summary: A shared function libray for scmcphub
 Author-email: shuang <hsh-me@outlook.com>
 License: BSD 3-Clause License

scmcp_shared-0.2.1/src/scmcp_shared/__init__.py

@@ -0,0 +1,3 @@
+
+__version__ = "0.2.1"
+

{scmcp_shared-0.2.0 → scmcp_shared-0.2.1}/src/scmcp_shared/server/io.py

@@ -3,6 +3,7 @@ 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, get_ads, generate_msg
 
@@ -47,11 +48,13 @@ async def read(request: ReadModel):
         adata.obs_names_make_unique()
         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()
@@ -67,8 +70,10 @@ async def write(request: WriteModel):
         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-0.2.0 → scmcp_shared-0.2.1}/src/scmcp_shared/server/pl.py

@@ -3,6 +3,7 @@ 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
@@ -25,13 +26,13 @@ async def pca(request: PCAModel = PCAModel()):
         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 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)
 
 @pl_mcp.tool()
 async def diffmap(request: DiffusionMapModel = DiffusionMapModel()):
@@ -43,13 +44,13 @@ async def diffmap(request: DiffusionMapModel = DiffusionMapModel()):
         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 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)
 
 @pl_mcp.tool()
 async def violin(request: ViolinModel,):
@@ -62,12 +63,14 @@ async def violin(request: ViolinModel,):
         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}"
+        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 Exception(f"{str(e.__context__)}")
+            raise ToolError(e.__context__)
         else:
-            raise e
+            raise ToolError(e)
 
 
 @pl_mcp.tool()
@@ -80,13 +83,13 @@ async def stacked_violin(request: StackedViolinModel = StackedViolinModel()):
         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 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)
 
 
 @pl_mcp.tool()
@@ -99,13 +102,13 @@ async def heatmap(request: HeatmapModel):
         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 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)
 
 
 @pl_mcp.tool()
@@ -118,13 +121,13 @@ async def dotplot(request: DotplotModel):
         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 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)
 
 @pl_mcp.tool()
 async def matrixplot(request: MatrixplotModel):
@@ -136,13 +139,13 @@ async def matrixplot(request: MatrixplotModel):
         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 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)
 
 
 @pl_mcp.tool()
@@ -155,13 +158,13 @@ async def tracksplot(request: TracksplotModel):
         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 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)
 
 @pl_mcp.tool()
 async def scatter(request: EnhancedScatterModel = EnhancedScatterModel()):
@@ -173,13 +176,13 @@ async def scatter(request: EnhancedScatterModel = EnhancedScatterModel()):
         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 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)
 
 @pl_mcp.tool()
 async def embedding(request: EmbeddingModel):
@@ -192,13 +195,12 @@ async def embedding(request: EmbeddingModel):
         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__)}")
+            raise ToolError(e.__context__)
         else:
-            raise e
+            raise ToolError(e)
 
 
 @pl_mcp.tool()
@@ -211,13 +213,13 @@ async def embedding_density(request: EmbeddingDensityModel):
         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 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)
 
 @pl_mcp.tool()
 async def rank_genes_groups(request: RankGenesGroupsModel):
@@ -229,13 +231,13 @@ async def rank_genes_groups(request: RankGenesGroupsModel):
         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 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)
 
 
 @pl_mcp.tool()
@@ -243,6 +245,7 @@ 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:
@@ -250,13 +253,13 @@ async def rank_genes_groups_dotplot(
         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 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)
 
 
 @pl_mcp.tool()
@@ -271,13 +274,13 @@ async def clustermap(
         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 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)
 
 @pl_mcp.tool()
 async def highly_variable_genes(
@@ -291,13 +294,13 @@ async def highly_variable_genes(
         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 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)
 
 
 @pl_mcp.tool()
@@ -312,10 +315,10 @@ async def pca_variance_ratio(
         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 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-0.2.0 → scmcp_shared-0.2.1}/src/scmcp_shared/server/pp.py

@@ -3,6 +3,7 @@ import os
 import inspect
 import scanpy as sc
 from fastmcp import FastMCP , Context
+from fastmcp.exceptions import ToolError
 from ..schema.pp import *
 from ..util import filter_args, add_op_log, forward_request, get_ads, generate_msg
 from ..logging_config import setup_logger
@@ -51,13 +52,13 @@ async def subset_cells(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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)
 
 
 @pp_mcp.tool()
@@ -96,13 +97,13 @@ async def subset_genes(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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)
 
 @pp_mcp.tool()
 async def calculate_qc_metrics(
@@ -127,11 +128,13 @@ async def calculate_qc_metrics(
         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)
 
 
 @pp_mcp.tool()
@@ -157,13 +160,13 @@ async def log1p(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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)
 
 
 @pp_mcp.tool()
@@ -185,13 +188,13 @@ async def normalize_total(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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)
 
 
 
@@ -217,13 +220,13 @@ async def highly_variable_genes(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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)
 
 
 @pp_mcp.tool()
@@ -246,13 +249,13 @@ async def regress_out(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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)
 
 @pp_mcp.tool()
 async def scale(
@@ -275,13 +278,13 @@ async def scale(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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)
 
 @pp_mcp.tool()
 async def combat(
@@ -304,13 +307,13 @@ async def combat(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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)
 
 @pp_mcp.tool()
 async def scrublet(
@@ -330,11 +333,13 @@ async def scrublet(
         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)
 
 @pp_mcp.tool()
 async def neighbors(
@@ -354,10 +359,10 @@ async def neighbors(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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-0.2.0 → scmcp_shared-0.2.1}/src/scmcp_shared/server/tl.py

@@ -1,6 +1,7 @@
 from fastmcp import FastMCP, Context
 import os
 import scanpy as sc
+from fastmcp.exceptions import ToolError
 from ..schema.tl import *
 from scmcp_shared.util import filter_args, add_op_log, forward_request, get_ads, generate_msg
 from scmcp_shared.logging_config import setup_logger
@@ -25,13 +26,13 @@ async def tsne(
         sc.tl.tsne(adata, **func_kwargs)
         add_op_log(adata, sc.tl.tsne, func_kwargs)
         return generate_msg(request, adata, ads)
-    except KeyError as e:
-        raise e
+    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)
 
 
 @tl_mcp.tool()
@@ -50,13 +51,13 @@ async def umap(
         sc.tl.umap(adata, **func_kwargs)
         add_op_log(adata, sc.tl.umap, func_kwargs)
         return [generate_msg(request, adata, ads)]
-    except KeyError as e:
-        raise e
+    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)
 
 @tl_mcp.tool()
 async def draw_graph(
@@ -74,13 +75,13 @@ async def draw_graph(
         sc.tl.draw_graph(adata, **func_kwargs)
         add_op_log(adata, sc.tl.draw_graph, func_kwargs)
         return [generate_msg(request, adata, ads)]
-    except KeyError as e:
-        raise e
+    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)
 
 @tl_mcp.tool()
 async def diffmap(
@@ -99,11 +100,13 @@ async def diffmap(
         adata.obsm["X_diffmap"] = adata.obsm["X_diffmap"][:,1:]
         add_op_log(adata, sc.tl.diffmap, func_kwargs)
         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)
 
 @tl_mcp.tool()
 async def embedding_density(
@@ -121,11 +124,13 @@ async def embedding_density(
         sc.tl.embedding_density(adata, **func_kwargs)
         add_op_log(adata, sc.tl.embedding_density, func_kwargs)
         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)
 
 
 @tl_mcp.tool()
@@ -144,11 +149,13 @@ async def leiden(
         sc.tl.leiden(adata, **func_kwargs)
         add_op_log(adata, sc.tl.leiden, func_kwargs)
         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)
 
 
 @tl_mcp.tool()
@@ -167,12 +174,13 @@ async def louvain(
         sc.tl.louvain(adata, **func_kwargs)
         add_op_log(adata, sc.tl.louvain, func_kwargs)
         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)
 
 @tl_mcp.tool()
 async def dendrogram(
@@ -190,12 +198,13 @@ async def dendrogram(
         sc.tl.dendrogram(adata, **func_kwargs)
         add_op_log(adata, sc.tl.dendrogram, func_kwargs)
         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)
 
 @tl_mcp.tool()
 async def dpt(
@@ -213,11 +222,13 @@ async def dpt(
         sc.tl.dpt(adata, **func_kwargs)
         add_op_log(adata, sc.tl.dpt, func_kwargs)
         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)
 
 
 @tl_mcp.tool()
@@ -236,11 +247,13 @@ async def paga(
         sc.tl.paga(adata, **func_kwargs)
         add_op_log(adata, sc.tl.paga, func_kwargs)
         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)
 
 
 @tl_mcp.tool()
@@ -259,11 +272,13 @@ async def ingest(
         sc.tl.ingest(adata, **func_kwargs)
         add_op_log(adata, sc.tl.ingest, func_kwargs)
         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)
 
 @tl_mcp.tool()
 async def rank_genes_groups(
@@ -282,11 +297,13 @@ async def rank_genes_groups(
         sc.tl.rank_genes_groups(adata, **func_kwargs)
         add_op_log(adata, sc.tl.rank_genes_groups, func_kwargs)
         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)
 
 
 @tl_mcp.tool()
@@ -305,11 +322,13 @@ async def filter_rank_genes_groups(
         sc.tl.filter_rank_genes_groups(adata, **func_kwargs)
         add_op_log(adata, sc.tl.filter_rank_genes_groups, func_kwargs)
         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)
 
 
 @tl_mcp.tool()
@@ -328,11 +347,13 @@ async def marker_gene_overlap(
         sc.tl.marker_gene_overlap(adata, **func_kwargs)
         add_op_log(adata, sc.tl.marker_gene_overlap, func_kwargs)
         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)
 
 @tl_mcp.tool()
 async def score_genes(
@@ -350,11 +371,13 @@ async def score_genes(
         sc.tl.score_genes(adata, **func_kwargs)
         add_op_log(adata, sc.tl.score_genes, func_kwargs)
         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)
 
 @tl_mcp.tool()
 async def score_genes_cell_cycle(
@@ -373,11 +396,13 @@ async def score_genes_cell_cycle(
         sc.tl.score_genes_cell_cycle(adata, **func_kwargs)
         add_op_log(adata, sc.tl.score_genes_cell_cycle, func_kwargs)
         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)
 
 
 @tl_mcp.tool()
@@ -398,10 +423,10 @@ async def pca(
         return [
             generate_msg(request, adata, ads)
         ]
-    except KeyError as e:
-        raise e
+    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-0.2.0 → scmcp_shared-0.2.1}/src/scmcp_shared/server/util.py

@@ -3,6 +3,7 @@ import inspect
 from pathlib import Path
 import scanpy as sc
 from fastmcp import FastMCP , Context
+from fastmcp.exceptions import ToolError
 from ..schema.util import *
 from ..util import filter_args, forward_request, get_ads, generate_msg,add_op_log
 
@@ -66,13 +67,13 @@ async def mark_var(
         func_kwargs = {"var_name": var_name, "gene_class": gene_class, "pattern_type": pattern_type, "patterns": patterns}
         add_op_log(adata, "mark_var", func_kwargs)
         return res
-    except KeyError as e:
-        raise e
+    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)
 
 
 @ul_mcp.tool()
@@ -88,13 +89,13 @@ async def list_var(
         columns = list(adata.var.columns)
         add_op_log(adata, list_var, {})
         return columns
-    except KeyError as e:
-        raise e
+    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)
 
 @ul_mcp.tool()
 async def list_obs(
@@ -109,13 +110,13 @@ async def list_obs(
         columns = list(adata.obs.columns)
         add_op_log(adata, list_obs, {})
         return columns
-    except KeyError as e:
-        raise e
+    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)
 
 @ul_mcp.tool()
 async def check_var(
@@ -131,13 +132,13 @@ async def check_var(
         result = {v: v in adata.var_names for v in var_names}
         add_op_log(adata, check_var, {"var_names": var_names})
         return result
-    except KeyError as e:
-        raise e
+    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)
 
 @ul_mcp.tool()
 async def merge_adata(
@@ -158,13 +159,13 @@ async def merge_adata(
         add_op_log(merged_adata, ad.concat, kwargs)
         ads.adata_dic[ads.active_id] = merged_adata
         return {"status": "success", "message": "Successfully merged all AnnData objects"}
-    except KeyError as e:
-        raise e
+    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)
 
 
 @ul_mcp.tool()
@@ -192,13 +193,13 @@ async def set_dpt_iroot(
         add_op_log(adata, "set_dpt_iroot", func_kwargs)
         
         return {"status": "success", "message": f"Successfully set root cell for DPT using {direction} of dimension {dimension}"}
-    except KeyError as e:
-        raise e
+    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)
 
 @ul_mcp.tool()
 async def add_layer(
@@ -226,13 +227,13 @@ async def add_layer(
             "status": "success", 
             "message": f"Successfully added layer '{layer_name}' to adata.layers"
         }
-    except KeyError as e:
-        raise e
+    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)
 
 @ul_mcp.tool()
 async def check_samples():
@@ -241,10 +242,10 @@ async def check_samples():
     try:
         ads = get_ads()
         return {"sampleid": [list(ads.adata_dic[dk].keys()) for dk in ads.adata_dic.keys()]}
-    except KeyError as e:
-        raise e
+    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-0.2.0 → scmcp_shared-0.2.1}/src/scmcp_shared/util.py

@@ -2,7 +2,7 @@ import inspect
 import os
 from pathlib import Path
 from fastmcp.server.dependencies import get_context
-
+from fastmcp.exceptions import ToolError
 
 
 def get_env(key):
@@ -50,6 +50,7 @@ def add_op_log(adata, func, kwargs):
     hash_input = f"{func_name}:{kwargs_str}"
     hash_key = hashlib.md5(hash_input.encode()).hexdigest()
     adata.uns["operation"]["op"][hash_key] = {func_name: new_kwargs}
+    adata.uns["operation"]["opid"] = list(adata.uns["operation"]["opid"])
     adata.uns["operation"]["opid"].append(hash_key)
     from .logging_config import setup_logger
     logger = setup_logger(log_file=get_env("LOG_FILE"))
@@ -151,8 +152,14 @@ async def forward_request(func, request, **kwargs):
         try:
             result = await client.call_tool(func, func_kwargs)
             return result
+        except ToolError as e:
+            raise ToolError(e)
         except Exception as e:
-            raise e
+            if hasattr(e, '__context__') and e.__context__:
+                raise Exception(f"{str(e.__context__)}")
+            else:
+                raise e
+
 
 def obsm2adata(adata, obsm_key):
     from anndata import AnnData

scmcp_shared-0.2.0/src/scmcp_shared/__init__.py

@@ -1,3 +0,0 @@
-
-__version__ = "0.2.0"
-