cobrak 0.0.1__py3-none-any.whl

cobrak/__init__.py

@@ -0,0 +1,100 @@
+"""
+COBRAk is a general COBRA/COBRA-k suite written as Python package. For more about it, visit its repository:
+https://github.com/klamt-lab/COBRAk
+
+The __init__ file of COBRAk initializes the rich text output & tracebacks as well as its logger. Furthermore, graceful
+shutdown of user-induced shutdowns is enabled.
+"""
+
+import logging
+import signal
+import sys
+from types import FrameType
+from typing import Any, Optional
+
+from rich.console import Console
+from rich.logging import RichHandler
+from rich.traceback import install
+
+
+# PUBLIC FUNCTIONS SECTION #
+def exit_signal_handler(sig: int, frame: FrameType | None) -> None:
+    """Handles the exit signal by printing a shutdown message and exiting the program.
+
+    Args:
+        sig (int): The signal number.
+        frame (Optional[FrameType]): The current frame.
+    """
+    print(
+        "COBRAk received user signal to terminate (this message may appear multiple times in parallelized contexts). Shutting down..."
+    )
+    sys.exit(0)
+
+
+def setup_rich_tracebacks(show_locals: bool) -> None:
+    """Sets up rich tracebacks with the given options.
+
+    Args:
+        show_locals (bool): Whether to show local variables in the traceback.
+    """
+    install(show_locals=show_locals)
+
+
+def set_logging_level(level: int) -> None:
+    """Sets the logging level.
+
+    E.g. INFO, ERROR, WARNING and CRITICAL from Python's logging module.
+
+    Args:
+        level (int): The logging level.
+    """
+    logger.setLevel(level)
+
+
+def set_logging_handler(
+    show_path: bool = False,
+    show_time: bool = False,
+    show_level: bool = True,
+    keywords: list[str] = [
+        "info",
+        "warning",
+        "error",
+        "critical",
+    ],
+    **args: Any,
+) -> RichHandler:
+    """
+    Sets up the logging handler with the given options.
+
+    Args:
+        show_path (bool, optional): Whether to show the path. Defaults to False.
+        show_time (bool, optional): Whether to show the time. Defaults to False.
+        show_level (bool, optional): Whether to show the level. Defaults to True.
+        keywords (Dict[str, str], optional): The keywords to highlight. Defaults to ["info", "warning", "error", "critical"]
+        **args (Any, optional): Additional Rich handler arguments.
+    """
+    return RichHandler(
+        show_path=show_path,
+        show_time=show_time,
+        show_level=show_level,
+        keywords=keywords,
+        **args,
+    )
+
+
+# ACTIVE SCRIPT SECTION #
+signal.signal(signal.SIGINT, exit_signal_handler)
+signal.signal(signal.SIGTERM, exit_signal_handler)
+
+setup_rich_tracebacks(False)
+
+# Create a logger
+logger = logging.getLogger(__name__)
+
+# Set the logging level
+set_logging_level(logging.INFO)
+
+# Add the handler to the logger
+logger.addHandler(set_logging_handler())
+
+console = Console()

cobrak/_efms.py

@@ -0,0 +1,189 @@
+from copy import deepcopy
+from random import choice
+
+from joblib import Parallel, cpu_count, delayed
+from pyomo.environ import (
+    Binary,
+    ConcreteModel,
+    Constraint,
+    Objective,
+    Reals,
+    SolverFactoryClass,
+    Var,
+    maximize,
+)
+
+from .constants import BIG_M, STANDARD_MIN_MDF
+from .dataclasses import Model, Solver
+from .lps import (
+    get_lp_from_cobrak_model,
+    get_objective,
+)
+from .pyomo_functionality import get_solver
+from .standard_solvers import SCIP
+from .utilities import (
+    delete_orphaned_metabolites_and_enzymes,
+    delete_unused_reactions_in_variability_dict,
+    get_stoichiometrically_coupled_reactions,
+)
+
+STANDARD_EFM_OBJ_NAME = "EFM_STANDARD_OBJECTIVE"
+
+
+def _efm_batch_routine(
+    pyomo_model: ConcreteModel,
+    pyomo_solver: SolverFactoryClass,
+    objective_name: str,
+    cobrak_solver: Solver,
+    objective_sense: int,
+) -> None:
+    getattr(pyomo_model, objective_name).activate()
+
+    # OBJ ACTIVATE
+    pyomo_solver.solve(
+        pyomo_model, tee=True, warmstart=True, **cobrak_solver.solve_extra_options
+    )
+
+    if results.solver.termination_condition == TerminationCondition.maxTimeLimit:
+        result = None
+    else:
+        result = value(getattr(model, target_id))
+
+    getattr(pyomo_model, objective_name).deactivate()
+
+
+def calculate_efms(
+    cobrak_model: Model,
+    with_inhomogenous_constraints: bool = False,
+    with_enzyme_constraints: bool = False,
+    with_thermodynamic_constraints: bool = False,
+    solver: Solver = SCIP,
+    variability_dict: dict[str, tuple[float, float]] = {},
+    max_num_efms: int = 1_000_000_000,
+    min_mdf: float = STANDARD_MIN_MDF,
+    min_efm_flux_bound: float = 1e-5,
+) -> set[tuple[str, ...]]:
+    enforced_reacs = [
+        reac_id
+        for reac_id in variability_dict
+        if variability_dict[reac_id][0] > 0.0 and reac_id in cobrak_model.reactions
+    ]
+    if not with_inhomogenous_constraints:
+        for enforced_reac in enforced_reacs:
+            cobrak_model.reactions[enforced_reac].min_flux = 0.0
+            variability_dict[enforced_reac] = (0.0, variability_dict[enforced_reac][1])
+
+    reduced_model = deepcopy(cobrak_model)
+    if variability_dict != {}:
+        reduced_model = delete_unused_reactions_in_variability_dict(
+            reduced_model, variability_dict
+        )
+    reduced_model = delete_orphaned_metabolites_and_enzymes(reduced_model)
+
+    all_couples = get_stoichiometrically_coupled_reactions(
+        reduced_model,
+    )
+    eligible_couples: list[list[str]] = []
+    for couple in all_couples:
+        eligible = True
+        for enforced_reac in enforced_reacs:
+            if enforced_reac in couple:
+                eligible = False
+                break
+        if eligible:
+            eligible_couples.append(couple)
+
+    pyomo_model = get_lp_from_cobrak_model(
+        cobrak_model=reduced_model,
+        with_enzyme_constraints=with_enzyme_constraints,
+        with_thermodynamic_constraints=with_thermodynamic_constraints,
+        with_loop_constraints=True,
+        min_mdf=min_mdf,
+    )
+    zc_var_sum = 0.0
+    zc_var_ids: list[str] = []
+    objective_names: list[str] = []
+    for eligible_couple in eligible_couples:
+        zc_var_id = "zC_var_" + "_".join(eligible_couple)
+        zc_var_ids.append(zc_var_id)
+
+        setattr(pyomo_model, zc_var_id, Var(within=Binary))
+        setattr(
+            pyomo_model,
+            zc_var_id + "_constraint",
+            Constraint(
+                rule=getattr(pyomo_model, eligible_couple[0])
+                <= BIG_M * getattr(pyomo_model, zc_var_id)
+            ),
+        )
+        setattr(
+            pyomo_model,
+            zc_var_id + "_constraint_2",
+            Constraint(
+                rule=getattr(pyomo_model, eligible_couple[0])
+                >= min_efm_flux_bound * getattr(pyomo_model, zc_var_id)
+            ),
+        )
+        zc_var_sum += getattr(pyomo_model, zc_var_id)
+
+        objective_names.append(f"objective_{eligible_couple[0]}")
+        setattr(
+            pyomo_model,
+            objective_names[-1],
+            Objective(expr=getattr(pyomo_model, eligible_couple[0]), sense=maximize),
+        )
+        getattr(pyomo_model, objective_names[-1]).deactivate()
+
+    objective_names.append(f"objective_{eligible_couple[0]}")
+    setattr(
+        pyomo_model,
+        STANDARD_EFM_OBJ_NAME,
+        Objective(expr=0.0, sense=maximize),
+    )
+    getattr(pyomo_model, STANDARD_EFM_OBJ_NAME).deactivate()
+
+    setattr(pyomo_model, "zc_var_sum", Var(within=Reals, bounds=(1.0, 10_000.0)))
+    setattr(
+        pyomo_model,
+        "zc_var_sum_constraint_1",
+        Constraint(rule=getattr(pyomo_model, "zc_var_sum") == zc_var_sum),
+    )
+    pyomo_model.obj = get_objective(pyomo_model, "zc_var_sum", -1)
+
+    integer_cut_i = 0
+    pyomo_solver = get_solver(solver.name, solver.solver_options, solver.solver_attrs)
+    efms: set[tuple[str, ...]] = set()
+    for i in range(max_num_efms):
+        opt_targets = [STANDARD_EFM_OBJ_NAME] + [
+            choice(objective_names) for _ in range(cpu_count() - 1)
+        ]
+        min_z_results = Parallel(n_jobs=-1, verbose=10)(
+            delayed(_efm_batch_routine)(
+                pyomo_model,
+                pyomo_solver,
+                opt_target,
+                +1,
+            )
+            for opt_target in opt_targets
+        )
+
+        new_efms = min_z_results.difference(efms)
+        if len(new_efms) == 0:
+            break
+        for new_efm in new_efms:
+            new_integer_cut = 0.0
+            new_integer_cut_sum = 0.0
+            for zc_var_id in zc_var_ids:
+                if getattr(pyomo_model, zc_var_id).value <= 0.1:
+                    continue
+                new_integer_cut += getattr(pyomo_model, zc_var_id)
+                new_integer_cut_sum += 1
+            setattr(
+                pyomo_model,
+                f"integer_cut_{integer_cut_i}",
+                Constraint(expr=new_integer_cut <= new_integer_cut_sum - 1),
+            )
+            integer_cut_i += 1
+        efms = efms.union(new_efms)
+
+    return efms

cobrak/bigg_metabolites_functionality.py

@@ -0,0 +1,76 @@
+"""bigg_parse_metabolites_file.py
+
+This module contains a function which transforms a BIGG metabolites .txt list
+into an machine-readable JSON.
+"""
+
+# IMPORTS SECTION #
+from .io import json_write
+
+
+# PUBLIC FUNCTIONS SECTION #
+def bigg_parse_metabolites_file(
+    bigg_metabolites_txt_path: str,
+    bigg_metabolites_json_path: str,
+) -> None:
+    """Parses a BIGG metabolites text file and returns a dictionary for this file.
+
+    As of Sep 14 2024, a BIGG metabolites list of all BIGG-included metabolites
+    is retrievable under http://bigg.ucsd.edu/data_access
+
+    Arguments
+    ----------
+    * bigg_metabolites_file_path: str ~ The file path to the BIGG metabolites file.
+      The usual file name (which has to be included too in this argument) is
+      bigg_models_metabolites.txt
+    * output_folder: str ~ The folder in which the JSON including the parsed BIGG
+      metabolites file data is stored with the name 'bigg_id_name_mapping.json'
+
+    Output
+    ----------
+    * A JSON file with the name 'bigg_id_name_mapping.json' in the given output folder,
+      with the following structure:
+    <pre>
+     {
+         "$BIGG_ID": "$CHEMICAL_OR_USUAL_NAME",
+         (...),
+         "$BIGG_ID": "$BIGG_ID",
+         (...),
+     }
+    </pre>
+    The BIGG ID <-> BIGG ID mapping is done for models which already use the BIGG IDs.
+    """
+    # Open the BIGG metabolites file as string list, and remove all newlines
+    with open(bigg_metabolites_txt_path, encoding="utf-8") as f:
+        lines = f.readlines()
+    lines = [x.replace("\n", "") for x in lines if len(x) > 0]
+
+    # Mapping variable which will store the BIGG ID<->
+    bigg_id_name_mapping = {}
+    # Go through each BIGG metabolites file line (which is a tab-separated file)
+    # and retrieve the BIGG ID and the name (if there is a name for the given BIGG
+    # ID)
+    for line in lines:
+        bigg_id = line.split("\t")[1]
+        bigg_id_name_mapping[bigg_id] = bigg_id
+
+        # Exception to check if there is no name :O
+        try:
+            name = line.split("\t")[2].lower()
+        except Exception:
+            continue
+        bigg_id_name_mapping[name] = bigg_id
+
+        try:
+            database_links = line.split("\t")[4]
+        except Exception:
+            continue
+        for database_link_part in database_links.split(": "):
+            if "CHEBI:" not in database_link_part:
+                continue
+            subpart = database_link_part.split("CHEBI:")[1].strip()
+            chebi_id = subpart.split("; ")[0] if "; " in subpart else subpart
+            bigg_id_name_mapping[chebi_id] = bigg_id
+
+    # Write the JSON in the given folder :D
+    json_write(bigg_metabolites_json_path, bigg_id_name_mapping)