Merge pull request #16 from pablormier/dev

add back old functions from graph class

Author: pablormier

corneto/graph/_graph.py

@@ -11,9 +11,13 @@
     Optional,
     Set,
     Tuple,
+    Union,
 )
 
-from corneto._types import Edge
+import numpy as np
+
+from corneto._io import import_cobra_model
+from corneto._types import CobraModel, Edge, NxDiGraph, NxGraph
 
 from ._base import Attr, Attributes, BaseGraph, EdgeType
 
@@ -616,6 +620,27 @@ def from_json(cls, json_str: str) -> "Graph":
         data = json.loads(json_str)
         return cls.from_dict(data)
 
+    @staticmethod
+    def from_networkx(G: Union[NxGraph, NxDiGraph]):
+        """Create graph from NetworkX graph.
+
+        Args:
+            G: NetworkX graph instance
+
+        Returns:
+            Graph instance with equivalent structure
+        """
+        Gc = Graph()
+        is_directed = G.is_directed()
+        for edge in G.edges():
+            e_data = G.get_edge_data(edge[0], edge[1], default=dict())
+            if is_directed:
+                e_data[Attr.EDGE_TYPE.value] = EdgeType.DIRECTED.value
+            else:
+                e_data[Attr.EDGE_TYPE.value] = EdgeType.UNDIRECTED.value
+            Gc.add_edge(edge[0], edge[1], **e_data)
+        return Gc
+
     def save_json(
         self,
         filepath: str,
@@ -686,3 +711,139 @@ def load_json(cls, filepath: str, compression: Optional[str] = "auto") -> "Graph
 
         # Create graph from JSON string
         return cls.from_json(json_str)
+
+    # DEPRECATED
+
+    @staticmethod
+    def from_vertex_incidence(
+        A: np.ndarray,
+        vertex_ids: Union[List[str], np.ndarray],
+        edge_ids: Union[List[str], np.ndarray],
+    ):
+        """Create graph from vertex incidence matrix and labels.
+
+        Args:
+            A: Vertex incidence matrix. Rows are vertices, columns are edges.
+               Non-zero entries indicate edge-vertex connections.
+            vertex_ids: Labels for vertices corresponding to matrix rows
+            edge_ids: Labels for edges corresponding to matrix columns
+
+        Returns:
+            Graph instance constructed from incidence matrix
+
+        Raises:
+            ValueError: If dimensions of inputs don't match
+        """
+        g = Graph()
+        if len(vertex_ids) != A.shape[0]:
+            raise ValueError(
+                """The number of rows in A matrix is different from 
+                the number of vertex ids"""
+            )
+        if len(edge_ids) != A.shape[1]:
+            raise ValueError(
+                """The number of columns in A matrix is different from
+                the number of edge ids"""
+            )
+        for v in vertex_ids:
+            g.add_vertex(v)
+        for j, v in enumerate(edge_ids):
+            values = A[:, j]
+            idx = np.flatnonzero(values)
+            coeffs = values[idx]
+            v_names = [vertex_ids[i] for i in idx]
+            s = {n: val for n, val in zip(v_names, coeffs) if val < 0}
+            t = {n: val for n, val in zip(v_names, coeffs) if val > 0}
+            g.add_edge(s, t, id=v)
+        return g
+
+    @staticmethod
+    def from_sif(
+        sif_file: str,
+        delimiter: str = "\t",
+        has_header: bool = False,
+        discard_self_loops: Optional[bool] = True,
+        column_order: List[int] = [0, 1, 2],
+    ):
+        """Create graph from Simple Interaction Format (SIF) file.
+
+        Args:
+            sif_file: Path to SIF file
+            delimiter: Column delimiter in file
+            has_header: Whether file has a header row
+            discard_self_loops: Whether to ignore self-loops
+            column_order: Order of source, interaction, target columns
+
+        Returns:
+            New Graph loaded from SIF file
+        """
+        from corneto._io import _read_sif_iter
+
+        it = _read_sif_iter(
+            sif_file,
+            delimiter=delimiter,
+            has_header=has_header,
+            discard_self_loops=discard_self_loops,
+            column_order=column_order,
+        )
+        return Graph.from_sif_tuples(it)
+
+    @staticmethod
+    def from_sif_tuples(tuples: Iterable[Tuple]):
+        """Create graph from iterable of SIF tuples.
+
+        Args:
+            tuples: Iterable of (source, interaction, target) tuples
+
+        Returns:
+            New Graph created from SIF data
+        """
+        g = Graph()
+        for s, v, t in tuples:
+            g.add_edge(s, t, interaction=v)
+        return g
+
+    @staticmethod
+    def from_cobra_model(model: CobraModel):
+        """Create graph from COBRA metabolic model.
+
+        Args:
+            model: COBRApy model instance
+
+        Returns:
+            New Graph representing the metabolic network
+        """
+        S, R, M = import_cobra_model(model)
+        G = Graph.from_vertex_incidence(S, M["id"], R["id"])
+        # Add metadata to the graph, such as default lb/ub for reactions
+        for i in range(G.num_edges):
+            attr = G.get_attr_edge(i)
+            attr["default_lb"] = R["lb"][i]
+            attr["default_ub"] = R["ub"][i]
+            attr["GPR"] = R["gpr"][i]
+        return G
+
+    @staticmethod
+    def from_miom_model(model):
+        """Create graph from MIOM metabolic model.
+
+        Args:
+            model: MIOM model instance or path to compressed model file
+
+        Returns:
+            New Graph representing the metabolic network
+        """
+        if isinstance(model, str):
+            from corneto._io import _load_compressed_gem
+
+            S, R, M = _load_compressed_gem(model)
+        else:
+            S = model.S, M = model.M, R = model.R
+        G = Graph.from_vertex_incidence(S, M["id"], R["id"])
+        # Add metadata to the graph, such as default lb/ub for reactions
+        for i in range(G.num_edges):
+            attr = G.get_attr_edge(i)
+            attr["default_lb"] = R["lb"][i]
+            attr["default_ub"] = R["ub"][i]
+            attr["GPR"] = R["gpr"][i]
+        return G

corneto/methods/future/carnival.py

@@ -416,13 +416,25 @@ def create_flow_based_problem(self, flow_problem, graph: BaseGraph, data: Data):
         return problem
 
     @staticmethod
-    def get_citations():
+    def references():
         """Returns citation keys for this method.
 
         Returns:
             A list of citation keys that can be used to lookup BibTeX entries.
         """
         return ["rodriguez2024unified", "liu2019expression"]
+    
+    @staticmethod
+    def description():
+        """Returns a description of the method.
+
+        Returns:
+            A string describing the method.
+        """
+        return (
+            "Method extending the original CARNIVAL for intracellular network inference "
+            "that uses integer linear programming to model signal propagation."
+        )
 
 
 class CarnivalILP(Method):
@@ -676,7 +688,7 @@ def create_problem(self, graph: BaseGraph, data: Data):
         return P
 
     @staticmethod
-    def get_citations():
+    def references():
         """Returns citation keys for this method.
 
         Returns:

corneto/methods/future/fba.py

@@ -279,5 +279,5 @@ def create_flow_based_problem(self, flow_problem, graph: BaseGraph, data: Data):
         return flow_problem
 
     @staticmethod
-    def get_citations():
+    def references():
         return ["savinell1992network", "rodriguez2024unified"]

corneto/methods/future/imat.py

@@ -318,5 +318,5 @@ def create_flow_based_problem(self, flow_problem, graph: BaseGraph, data: Data):
         return flow_problem
 
     @staticmethod
-    def get_citations():
+    def references():
         return ["shlomi2008network", "rodriguez2024unified"]

corneto/methods/future/method.py

@@ -22,6 +22,8 @@ class Method(ABC):
         backend: Optimization backend to use. Defaults to DEFAULT_BACKEND.
     """
 
+    __show_info_on_import__ = False
+
     def __init__(
         self,
         lambda_reg: float = 0.0,
@@ -43,6 +45,93 @@ def __init__(
         self.processed_graph = None
         self.disable_structured_sparsity = disable_structured_sparsity
 
+    def __repr__(self) -> str:
+        """Returns a string representation of the method.
+
+        Includes the method name, description, parameters, and formatted citations (if any).
+
+        Returns:
+            A formatted string representation of the method.
+        """
+        import inspect
+
+        from corneto.utils._citations import format_references_plaintext
+
+        name = self.name()
+        description = self.description()
+        citation_keys = self.references()
+
+        repr_str = f"{name or self.__class__.__name__}"
+
+        if description:
+            repr_str += f": {description})"
+
+        # Add parameters information
+        repr_str += "\n\nParameters:"
+        # Get all instance attributes that don't start with _ (except _backend)
+        params = {}
+        for attr_name, attr_value in self.__dict__.items():
+            if attr_name == "_backend":
+                params["backend"] = attr_value.__class__.__name__
+            elif not attr_name.startswith("_") or attr_name in [
+                "_reg_varname",
+                "_reg_varname_suffix",
+            ]:
+                # For problem, processed_data, etc. that could be None initially, skip them
+                if (
+                    attr_name in ["problem", "processed_data", "processed_graph"]
+                    and attr_value is None
+                ):
+                    continue
+                # Skip complex objects that aren't useful for a summary
+                if (
+                    isinstance(attr_value, (list, dict, tuple))
+                    and len(str(attr_value)) > 100
+                ):
+                    continue
+                # Format the parameter name (remove leading underscore if present)
+                param_name = attr_name[1:] if attr_name.startswith("_") else attr_name
+                params[param_name] = attr_value
+
+        # Get signature to determine default values
+        signature = None
+        try:
+            signature = inspect.signature(self.__class__.__init__)
+        except (ValueError, TypeError):
+            pass
+
+        if params:
+            for name, value in sorted(params.items()):
+                # Check if this is a default value
+                is_default = False
+                if signature and name in signature.parameters:
+                    param = signature.parameters[name]
+                    if param.default is not param.empty:
+                        if param.default == value:
+                            is_default = True
+
+                # Format the parameter value
+                if isinstance(value, (int, float, bool, str)) or value is None:
+                    value_str = str(value)
+                elif hasattr(value, "__class__"):
+                    value_str = f"<{value.__class__.__name__}>"
+                else:
+                    value_str = str(value)
+
+                # Add default indicator if applicable
+                if is_default:
+                    repr_str += f"\n  {name} = {value_str} (default)"
+                else:
+                    repr_str += f"\n  {name} = {value_str}"
+        else:
+            repr_str += "\n  No parameters"
+
+        if citation_keys:
+            repr_str += "\n\nReferences:"
+            repr_str += format_references_plaintext(citation_keys)
+
+        return repr_str
+
     @abstractmethod
     def preprocess(self, graph: BaseGraph, data: Data) -> Tuple[BaseGraph, Data]:
         """Preprocess the input graph and dataset before optimization.
@@ -131,7 +220,24 @@ def build(self, graph: BaseGraph, data: Data) -> ProblemDef:
         return self.problem
 
     @staticmethod
-    def get_citations() -> list:
+    def name() -> str:
+        """Returns the name of the method.
+
+        Returns:
+            The name of the optimization method.
+        """
+        return ""
+
+    def description(self) -> str:
+        """Returns a description of the method.
+
+        Returns:
+            A string describing the optimization method.
+        """
+        return ""
+
+    @staticmethod
+    def references() -> list:
         """Returns citation keys for this method.
 
         Returns:
@@ -140,16 +246,23 @@ def get_citations() -> list:
         return []
 
     @classmethod
-    def show_citations(cls):
+    def show_references(cls):
         """Display formatted citations in a Jupyter notebook."""
-        from corneto.utils._citations import show_citations
-        show_citations(cls.get_citations())
+        from corneto.utils._citations import show_references
+
+        show_references(cls.references())
 
     @classmethod
     def show_bibtex(cls):
         """Display raw BibTeX entries in a formatted block for easy copying."""
         from corneto.utils._citations import show_bibtex
-        show_bibtex(cls.get_citations())
+
+        show_bibtex(cls.references())
+
+    @classmethod
+    def about(cls):
+        """Display information about the method in a Jupyter notebook."""
+        cls.show_references()
 
     @property
     def backend(self):