napistu 0.2.5.dev7__py3-none-any.whl → 0.3.1__py3-none-any.whl

napistu/mcp/tutorials.py

@@ -7,118 +7,170 @@ import logging
 
 from fastmcp import FastMCP
 
+from napistu.mcp.component_base import ComponentState, MCPComponent
 from napistu.mcp import tutorials_utils
 from napistu.mcp import utils as mcp_utils
-from napistu.mcp.constants import TUTORIALS
 from napistu.mcp.constants import TUTORIAL_URLS
-from napistu.mcp.constants import TOOL_VARS
-
-# Global cache for tutorial content
-_tutorial_cache: Dict[str, Dict[str, str]] = {
-    TUTORIALS.TUTORIALS: {},
-}
 
 logger = logging.getLogger(__name__)
 
 
-async def initialize_components() -> bool:
-    """
-    Initialize tutorial components by preloading all tutorials into the cache.
+class TutorialsState(ComponentState):
+    """State management for tutorials component."""
 
-    Returns
-    -------
-    bool
-        True if initialization is successful.
-    """
-    global _tutorial_cache
-    for k, v in TUTORIAL_URLS.items():
-        _tutorial_cache[TUTORIALS.TUTORIALS][k] = (
-            await tutorials_utils.get_tutorial_markdown(k)
-        )
-    return True
+    def __init__(self):
+        super().__init__()
+        self.tutorials: Dict[str, str] = {}
 
+    def is_healthy(self) -> bool:
+        """Component is healthy if it has loaded tutorials."""
+        return bool(self.tutorials)
 
-def register_components(mcp: FastMCP) -> None:
-    """
-    Register tutorial components with the MCP server.
+    def get_health_details(self) -> Dict[str, Any]:
+        """Provide tutorials-specific health details."""
+        return {
+            "tutorial_count": len(self.tutorials),
+            "tutorial_ids": list(self.tutorials.keys()),
+        }
 
-    Parameters
-    ----------
-    mcp : FastMCP
-        FastMCP server instance.
-    """
 
-    # Register resources
-    @mcp.resource("napistu://tutorials/index")
-    async def get_tutorials_index() -> List[Dict[str, Any]]:
-        """
-        Get the index of all available tutorials.
+class TutorialsComponent(MCPComponent):
+    """MCP component for tutorial management and search."""
 
-        Returns
-        -------
-        List[dict]
-            List of dictionaries with tutorial IDs and URLs.
-        """
-        return [
-            {"id": tutorial_id, "url": url}
-            for tutorial_id, url in TUTORIAL_URLS.items()
-        ]
+    def _create_state(self) -> TutorialsState:
+        """Create tutorials-specific state."""
+        return TutorialsState()
 
-    @mcp.resource("napistu://tutorials/content/{tutorial_id}")
-    async def get_tutorial_content_resource(tutorial_id: str) -> Dict[str, Any]:
+    async def initialize(self) -> bool:
         """
-        Get the content of a specific tutorial as markdown.
-
-        Parameters
-        ----------
-        tutorial_id : str
-            ID of the tutorial.
+        Initialize tutorials component by loading all tutorials.
 
         Returns
         -------
-        dict
-            Dictionary with markdown content and format.
-
-        Raises
-        ------
-        Exception
-            If the tutorial cannot be loaded.
+        bool
+            True if at least one tutorial was loaded successfully
         """
-        content = _tutorial_cache[TUTORIALS.TUTORIALS].get(tutorial_id)
-        if content is None:
+        tutorials_loaded = 0
+
+        for tutorial_id, url in TUTORIAL_URLS.items():
             try:
                 content = await tutorials_utils.get_tutorial_markdown(tutorial_id)
-                _tutorial_cache[TUTORIALS.TUTORIALS][tutorial_id] = content
+                self.state.tutorials[tutorial_id] = content
+                tutorials_loaded += 1
+                logger.debug(f"Loaded tutorial: {tutorial_id}")
             except Exception as e:
-                logger.error(f"Tutorial {tutorial_id} could not be loaded: {e}")
-                raise
-        return {
-            "content": content,
-            "format": "markdown",
-        }
+                logger.warning(f"Failed to load tutorial {tutorial_id}: {e}")
+                # Continue loading other tutorials even if one fails
 
-    @mcp.tool()
-    async def search_tutorials(query: str) -> List[Dict[str, Any]]:
+        logger.info(f"Loaded {tutorials_loaded}/{len(TUTORIAL_URLS)} tutorials")
+
+        # Consider successful if at least one tutorial loaded
+        return tutorials_loaded > 0
+
+    def register(self, mcp: FastMCP) -> None:
         """
-        Search tutorials for a specific query.
+        Register tutorial resources and tools with the MCP server.
 
         Parameters
         ----------
-        query : str
-            Search term.
-
-        Returns
-        -------
-        List[dict]
-            List of matching tutorials with metadata and snippet.
+        mcp : FastMCP
+            FastMCP server instance
         """
-        results: List[Dict[str, Any]] = []
-        for tutorial_id, content in _tutorial_cache[TUTORIALS.TUTORIALS].items():
-            if query.lower() in content.lower():
-                results.append(
-                    {
-                        TOOL_VARS.ID: tutorial_id,
-                        TOOL_VARS.SNIPPET: mcp_utils.get_snippet(content, query),
-                    }
-                )
-        return results
+
+        # Register resources
+        @mcp.resource("napistu://tutorials/index")
+        async def get_tutorials_index() -> List[Dict[str, Any]]:
+            """
+            Get the index of all available tutorials.
+
+            Returns
+            -------
+            List[dict]
+                List of dictionaries with tutorial IDs and URLs.
+            """
+            return [
+                {"id": tutorial_id, "url": url}
+                for tutorial_id, url in TUTORIAL_URLS.items()
+            ]
+
+        @mcp.resource("napistu://tutorials/content/{tutorial_id}")
+        async def get_tutorial_content_resource(tutorial_id: str) -> Dict[str, Any]:
+            """
+            Get the content of a specific tutorial as markdown.
+
+            Parameters
+            ----------
+            tutorial_id : str
+                ID of the tutorial.
+
+            Returns
+            -------
+            dict
+                Dictionary with markdown content and format.
+
+            Raises
+            ------
+            Exception
+                If the tutorial cannot be loaded.
+            """
+            # Check local state first
+            content = self.state.tutorials.get(tutorial_id)
+
+            if content is None:
+                # Fallback: try to load on-demand
+                try:
+                    logger.info(f"Loading tutorial {tutorial_id} on-demand")
+                    content = await tutorials_utils.get_tutorial_markdown(tutorial_id)
+                    self.state.tutorials[tutorial_id] = content  # Cache for future use
+                except Exception as e:
+                    logger.error(f"Tutorial {tutorial_id} could not be loaded: {e}")
+                    raise
+
+            return {
+                "content": content,
+                "format": "markdown",
+            }
+
+        @mcp.tool()
+        async def search_tutorials(query: str) -> List[Dict[str, Any]]:
+            """
+            Search tutorials for a specific query.
+
+            Parameters
+            ----------
+            query : str
+                Search term.
+
+            Returns
+            -------
+            List[dict]
+                List of matching tutorials with metadata and snippet.
+            """
+            results: List[Dict[str, Any]] = []
+
+            for tutorial_id, content in self.state.tutorials.items():
+                if query.lower() in content.lower():
+                    results.append(
+                        {
+                            "id": tutorial_id,
+                            "snippet": mcp_utils.get_snippet(content, query),
+                        }
+                    )
+
+            return results
+
+
+# Module-level component instance
+_component = TutorialsComponent()
+
+
+def get_component() -> TutorialsComponent:
+    """
+    Get the tutorials component instance.
+
+    Returns
+    -------
+    TutorialsComponent
+        The tutorials component instance
+    """
+    return _component

napistu/modify/__init__.py

@@ -4,7 +4,7 @@ from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
 
 try:
-    __version__ = version("calicolabs-cpr")
+    __version__ = version("napistu")
 except PackageNotFoundError:
     # package is not installed
     pass

napistu/modify/gaps.py

@@ -462,7 +462,7 @@ def _identify_species_needing_transport_reactions(
     )
 
     # create a directed graph
-    directed_graph = net_create.create_cpr_graph(
+    directed_graph = net_create.create_napistu_graph(
         sbml_dfs, directed=True, graph_type="bipartite"
     )
 

napistu/network/__init__.py

@@ -4,7 +4,7 @@ from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
 
 try:
-    __version__ = version("calicolabs-cpr")
+    __version__ = version("napistu")
 except PackageNotFoundError:
     # package is not installed
     pass

napistu/network/constants.py

@@ -7,10 +7,28 @@ from types import SimpleNamespace
 from napistu.constants import SBML_DFS
 from napistu.constants import SBOTERM_NAMES
 
-CPR_GRAPH_NODES = SimpleNamespace(NAME="name")
+# Graph types
+NAPISTU_GRAPH_TYPES = SimpleNamespace(
+    BIPARTITE="bipartite", REGULATORY="regulatory", SURROGATE="surrogate"
+)
+
+VALID_NAPISTU_GRAPH_TYPES = [
+    NAPISTU_GRAPH_TYPES.BIPARTITE,
+    NAPISTU_GRAPH_TYPES.REGULATORY,
+    NAPISTU_GRAPH_TYPES.SURROGATE,
+]
+
+NAPISTU_GRAPH = SimpleNamespace(VERTICES="vertices", EDGES="edges", METADATA="metadata")
+
+NAPISTU_GRAPH_DIRECTEDNESS = SimpleNamespace(
+    DIRECTED="directed", UNDIRECTED="undirected"
+)
+
+NAPISTU_GRAPH_NODES = SimpleNamespace(NAME="name")
 
-CPR_GRAPH_EDGES = SimpleNamespace(
+NAPISTU_GRAPH_EDGES = SimpleNamespace(
     DIRECTED="directed",
+    DIRECTION="direction",
     FROM="from",
     R_ID=SBML_DFS.R_ID,
     R_ISREVERSIBLE=SBML_DFS.R_ISREVERSIBLE,
@@ -26,50 +44,76 @@ CPR_GRAPH_EDGES = SimpleNamespace(
     WEIGHTS="weights",
 )
 
-# variables which should be in cpr graph's edges
-CPR_GRAPH_REQUIRED_EDGE_VARS = {
-    CPR_GRAPH_EDGES.FROM,
-    CPR_GRAPH_EDGES.TO,
-    CPR_GRAPH_EDGES.SBO_TERM,
-    CPR_GRAPH_EDGES.STOICHIOMETRY,
-    CPR_GRAPH_EDGES.SC_PARENTS,
-    CPR_GRAPH_EDGES.SC_CHILDREN,
+NAPISTU_GRAPH_REQUIRED_EDGE_VARS = {
+    NAPISTU_GRAPH_EDGES.FROM,
+    NAPISTU_GRAPH_EDGES.TO,
+    NAPISTU_GRAPH_EDGES.DIRECTION,
 }
 
-# nomenclature for individual fields
+NAPISTU_GRAPH_NODE_TYPES = SimpleNamespace(SPECIES="species", REACTION="reaction")
 
-CPR_GRAPH_NODE_TYPES = SimpleNamespace(REACTION="reaction", SPECIES="species")
+VALID_NAPISTU_GRAPH_NODE_TYPES = [
+    NAPISTU_GRAPH_NODE_TYPES.REACTION,
+    NAPISTU_GRAPH_NODE_TYPES.SPECIES,
+]
+
+NAPISTU_WEIGHTING_STRATEGIES = SimpleNamespace(
+    CALIBRATED="calibrated", MIXED="mixed", TOPOLOGY="topology", UNWEIGHTED="unweighted"
+)
 
-VALID_CPR_GRAPH_NODE_TYPES = [
-    CPR_GRAPH_NODE_TYPES.REACTION,
-    CPR_GRAPH_NODE_TYPES.SPECIES,
+VALID_WEIGHTING_STRATEGIES = [
+    NAPISTU_WEIGHTING_STRATEGIES.UNWEIGHTED,
+    NAPISTU_WEIGHTING_STRATEGIES.TOPOLOGY,
+    NAPISTU_WEIGHTING_STRATEGIES.MIXED,
+    NAPISTU_WEIGHTING_STRATEGIES.CALIBRATED,
 ]
 
-CPR_GRAPH_EDGE_DIRECTIONS = SimpleNamespace(
+# edge reversal
+
+NAPISTU_GRAPH_EDGE_DIRECTIONS = SimpleNamespace(
     FORWARD="forward", REVERSE="reverse", UNDIRECTED="undirected"
 )
 
-# network-level nomenclature
+EDGE_REVERSAL_ATTRIBUTE_MAPPING = {
+    NAPISTU_GRAPH_EDGES.FROM: NAPISTU_GRAPH_EDGES.TO,
+    NAPISTU_GRAPH_EDGES.TO: NAPISTU_GRAPH_EDGES.FROM,
+    NAPISTU_GRAPH_EDGES.SC_PARENTS: NAPISTU_GRAPH_EDGES.SC_CHILDREN,
+    NAPISTU_GRAPH_EDGES.SC_CHILDREN: NAPISTU_GRAPH_EDGES.SC_PARENTS,
+    NAPISTU_GRAPH_EDGES.WEIGHTS: NAPISTU_GRAPH_EDGES.UPSTREAM_WEIGHTS,
+    NAPISTU_GRAPH_EDGES.UPSTREAM_WEIGHTS: NAPISTU_GRAPH_EDGES.WEIGHTS,
+    # Note: stoichiometry requires special handling (* -1)
+}
 
-CPR_GRAPH_TYPES = SimpleNamespace(
-    BIPARTITE="bipartite", REGULATORY="regulatory", SURROGATE="surrogate"
+# Direction enum values
+EDGE_DIRECTION_MAPPING = {
+    NAPISTU_GRAPH_EDGE_DIRECTIONS.FORWARD: NAPISTU_GRAPH_EDGE_DIRECTIONS.REVERSE,
+    NAPISTU_GRAPH_EDGE_DIRECTIONS.REVERSE: NAPISTU_GRAPH_EDGE_DIRECTIONS.FORWARD,
+    NAPISTU_GRAPH_EDGE_DIRECTIONS.UNDIRECTED: NAPISTU_GRAPH_EDGE_DIRECTIONS.UNDIRECTED,  # unchanged
+}
+
+# Net edge direction
+NET_POLARITY = SimpleNamespace(
+    LINK_POLARITY="link_polarity",
+    NET_POLARITY="net_polarity",
+    ACTIVATION="activation",
+    INHIBITION="inhibition",
+    AMBIGUOUS="ambiguous",
+    AMBIGUOUS_ACTIVATION="ambiguous activation",
+    AMBIGUOUS_INHIBITION="ambiguous inhibition",
 )
 
-VALID_CPR_GRAPH_TYPES = [
-    CPR_GRAPH_TYPES.BIPARTITE,
-    CPR_GRAPH_TYPES.REGULATORY,
-    CPR_GRAPH_TYPES.SURROGATE,
+VALID_LINK_POLARITIES = [
+    NET_POLARITY.ACTIVATION,
+    NET_POLARITY.INHIBITION,
+    NET_POLARITY.AMBIGUOUS,
 ]
 
-CPR_WEIGHTING_STRATEGIES = SimpleNamespace(
-    CALIBRATED="calibrated", MIXED="mixed", TOPOLOGY="topology", UNWEIGHTED="unweighted"
-)
-
-VALID_WEIGHTING_STRATEGIES = [
-    CPR_WEIGHTING_STRATEGIES.UNWEIGHTED,
-    CPR_WEIGHTING_STRATEGIES.TOPOLOGY,
-    CPR_WEIGHTING_STRATEGIES.MIXED,
-    CPR_WEIGHTING_STRATEGIES.CALIBRATED,
+VALID_NET_POLARITIES = [
+    NET_POLARITY.ACTIVATION,
+    NET_POLARITY.INHIBITION,
+    NET_POLARITY.AMBIGUOUS,
+    NET_POLARITY.AMBIGUOUS_ACTIVATION,
+    NET_POLARITY.AMBIGUOUS_INHIBITION,
 ]
 
 # the regulatory graph defines a hierarchy of upstream and downstream
@@ -80,7 +124,7 @@ REGULATORY_GRAPH_HIERARCHY = [
     [SBOTERM_NAMES.MODIFIER, SBOTERM_NAMES.STIMULATOR, SBOTERM_NAMES.INHIBITOR],
     [SBOTERM_NAMES.CATALYST],
     [SBOTERM_NAMES.REACTANT],
-    [CPR_GRAPH_NODE_TYPES.REACTION],
+    [NAPISTU_GRAPH_NODE_TYPES.REACTION],
     # normally we don't expect interactors to be defined because they are handled by
     # net_create._format_interactors_for_regulatory_graph() but include them here
     # until Issue #102 is solved
@@ -98,7 +142,7 @@ SURROGATE_GRAPH_HIERARCHY = [
     [SBOTERM_NAMES.MODIFIER, SBOTERM_NAMES.STIMULATOR, SBOTERM_NAMES.INHIBITOR],
     [SBOTERM_NAMES.REACTANT],
     [SBOTERM_NAMES.CATALYST],
-    [CPR_GRAPH_NODE_TYPES.REACTION],
+    [NAPISTU_GRAPH_NODE_TYPES.REACTION],
     # normally we don't expect interactors to be defined because they are handled by
     # net_create._format_interactors_for_regulatory_graph() but include them here
     # until Issue #102 is solved
@@ -115,3 +159,26 @@ VALID_NEIGHBORHOOD_NETWORK_TYPES = [
     NEIGHBORHOOD_NETWORK_TYPES.HOURGLASS,
     NEIGHBORHOOD_NETWORK_TYPES.UPSTREAM,
 ]
+
+# weighting networks and transforming attributes
+
+WEIGHTING_SPEC = SimpleNamespace(
+    TABLE="table",
+    VARIABLE="variable",
+    TRANSFORMATION="trans",
+)
+
+DEFAULT_WT_TRANS = "identity"
+
+DEFINED_WEIGHT_TRANSFORMATION = {
+    DEFAULT_WT_TRANS: "_wt_transformation_identity",
+    "string": "_wt_transformation_string",
+    "string_inv": "_wt_transformation_string_inv",
+}
+
+SCORE_CALIBRATION_POINTS_DICT = {
+    "weights": {"strong": 3, "good": 7, "okay": 20, "weak": 40},
+    "string_wt": {"strong": 950, "good": 400, "okay": 230, "weak": 150},
+}
+
+SOURCE_VARS_DICT = {"string_wt": 10}