pycomo 0.1.0__tar.gz

pycomo-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Michael Predl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pycomo-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: pycomo
+Version: 0.1.0
+Summary: PyCoMo is a software package for generating and analysing compartmentalized community metabolic models
+Home-page: https://github.com/univieCUBE/PyCoMo
+Author: Michael Predl
+Author-email: michael.predl@univie.ac.at
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# PyCoMo
+## What is PyCoMo?
+PyCoMo is a python 3 package for the creation and analysis of community metabolic models. More specifically, PyCoMo generates compartmentalized community metabolic models with a structure allowing simulations under fixed growth rate, but variable abundance profile, or fixed abundance profile and variable community growth rate. The community metabolic models generated by PyCoMo can switch between these two structures and retain the original reaction bounds of the input member models. As also all metabolites, reactions, genes and compartments are directly attributable to their member of origin, PyCoMo community metabolic models are fully reusable.
+
+The community models can be analysed with PyCoMo to predict all feasible exchange metabolites and cross-feeding interactions, for the whole space of growth rate and abundance profiles. The community models are COBRApy models and can therefor be directly used by other COBRA methods. It is also possible to save and load the community models in SBML format, allowing to share and reuse the models built with PyCoMo.
+
+## Installation
+For installing PyCoMo download or clone the repository to your machine.
+```
+git clone https://github.com/univieCUBE/PyCoMo
+```
+Run pip install on the folder containing the PyCoMo repository.
+```
+pip install path/to/PyCoMo
+```
+
+## Usage guide
+PyCoMo can be imported in Python as any other package. Please look through the tutorial for a walkthrough of all the options generating and analysing community metabolic models (available as ipython notebook, python file and pdf).
+
+PyCoMo can also be used via its command line interface. After installation, run ```pycomo -h``` or ```pycomo --help``` to see all options.
+## Citing PyCoMo
+At the present moment we are still working on the final stages of the manuscript. Once it is made public, a citation note will be included at this place.

pycomo-0.1.0/README.md

@@ -0,0 +1,22 @@
+# PyCoMo
+## What is PyCoMo?
+PyCoMo is a python 3 package for the creation and analysis of community metabolic models. More specifically, PyCoMo generates compartmentalized community metabolic models with a structure allowing simulations under fixed growth rate, but variable abundance profile, or fixed abundance profile and variable community growth rate. The community metabolic models generated by PyCoMo can switch between these two structures and retain the original reaction bounds of the input member models. As also all metabolites, reactions, genes and compartments are directly attributable to their member of origin, PyCoMo community metabolic models are fully reusable.
+
+The community models can be analysed with PyCoMo to predict all feasible exchange metabolites and cross-feeding interactions, for the whole space of growth rate and abundance profiles. The community models are COBRApy models and can therefor be directly used by other COBRA methods. It is also possible to save and load the community models in SBML format, allowing to share and reuse the models built with PyCoMo.
+
+## Installation
+For installing PyCoMo download or clone the repository to your machine.
+```
+git clone https://github.com/univieCUBE/PyCoMo
+```
+Run pip install on the folder containing the PyCoMo repository.
+```
+pip install path/to/PyCoMo
+```
+
+## Usage guide
+PyCoMo can be imported in Python as any other package. Please look through the tutorial for a walkthrough of all the options generating and analysing community metabolic models (available as ipython notebook, python file and pdf).
+
+PyCoMo can also be used via its command line interface. After installation, run ```pycomo -h``` or ```pycomo --help``` to see all options.
+## Citing PyCoMo
+At the present moment we are still working on the final stages of the manuscript. Once it is made public, a citation note will be included at this place.

pycomo-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pycomo-0.1.0/setup.py

@@ -0,0 +1,32 @@
+from setuptools import find_packages, setup
+
+with open("README.md", "r") as f:
+    long_description = f.read()
+
+setup(
+    name="pycomo",
+    version="0.1.0",
+    description="PyCoMo is a software package for generating and analysing compartmentalized community metabolic models",
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/univieCUBE/PyCoMo",
+    author="Michael Predl",
+    author_email="michael.predl@univie.ac.at",
+    license="MIT",
+    classifiers=[
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3"
+    ],
+    entry_points={
+        'console_scripts': [
+            'pycomo = pycomo.pycomo_models:main'
+        ]
+    },
+    install_requires=["cobra >= 0.23.0", "pandas >= 1.5.3", "python-libsbml >= 5.20.1", "numpy >= 1.22.4"],
+    extra_require={
+        "dev": ["pytest >= 7.0", "twine >= 4.0.2"],
+    },
+    python_requires=">=3.9",
+)

pycomo-0.1.0/src/pycomo/__init__.py

@@ -0,0 +1,16 @@
+__author__ = "Michael Predl"
+__version__ = "0.1.0"
+
+
+from pycomo.pycomo_models import (
+    SingleOrganismModel,
+    CommunityModel,
+    doall
+)
+from pycomo.helper.utils import (
+    load_named_model,
+    load_named_models_from_dir,
+    read_medium_from_file,
+    read_abundance_from_file,
+    make_string_sbml_id_compatible,
+)

pycomo-0.1.0/src/pycomo/helper/cli.py

@@ -0,0 +1,127 @@
+import os
+import sys
+import argparse
+
+__description__ = ('A package for generating community metabolic models from single species/strain models.')
+__author__ = 'Michael Predl'
+__license__ = "MIT"
+__version__ = "0.1.0"
+
+
+def create_arg_parser():
+    parser = argparse.ArgumentParser(prog="PyCoMo")
+
+    parser.add_argument('-v', '--version', action='version', version=f'%(prog)s {__version__}',
+                        help="display PyCoMo version")
+
+    parser.add_argument('-i', '--input', nargs='+', type=str, required=True,
+                        help="single species/strain models to combine, either as a directory or separate files")
+
+    parser.add_argument('-c', '--is-community', action='store_true',
+                        help="Set this flag if the input model is already a community model.")
+
+    # All parameters regarding the generation and contextualisation of the community model
+    pg_com_model = parser.add_argument_group('Community model parameters')
+
+    pg_com_model.add_argument('-n', '--name', type=str, default='community_model',
+                              help="the name for the new community model")
+
+    pg_com_model.add_argument('-m', '--match-via-annotation', type=str,
+                              help="the metabolite annotation type to use for matching exchange metabolites of "
+                                   "different community members (e.g. metanetx.chemical)")
+
+    pg_linearisation = pg_com_model.add_mutually_exclusive_group()
+
+    pg_linearisation.add_argument('--growth-rate', type=float,
+                                  help="set abundances to be equal for all community members")
+
+    pg_linearisation.add_argument('--equal-abd', action='store_true',
+                                  help="set abundances to be equal for all community members")
+
+    pg_linearisation.add_argument('--abd-file', type=str,
+                                  help="a comma separated file containing the input model file names and their "
+                                       "abundance. No header should be used in the file.")
+
+    pg_com_model.add_argument('--medium', type=str,
+                              help="the medium to be used in the community model, as a comma separated file "
+                                   "containing a column 'compounds' and a column 'maxFlux'.")
+
+    # All parameters regarding outputs to be produced
+    pg_output = parser.add_argument_group('Output parameters')
+
+    pg_output.add_argument('-o', '--output-dir', default=os.getcwd(), type=str,
+                           help="the output directory to store results (default is the current working directory)")
+
+    pg_output.add_argument('--fba-flux', action='store_true',
+                           help="run FBA on the community model and store the flux vector in a file")
+
+    pg_output.add_argument('--fva-flux', type=float,
+                           help="run FVA on the exchange metabolites of the community model and store the flux vector "
+                                "in a file. Set the threshold of the objective that needs to be achieved.")
+
+    pg_output.add_argument('--fba-interaction', action='store_true',
+                           help="run FBA on the community model and store the flux of exchange metabolites and "
+                                "whether they are cross-fed in a file")
+
+    pg_output.add_argument('--fva-interaction', action='store_true',
+                           help="run FVA on the community model and store the flux of exchange metabolites and "
+                                "whether they are cross-fed in a file. Set the threshold of the objective that needs "
+                                "to be achieved.")
+
+    if len(sys.argv) == 1:
+        parser.print_help(sys.stderr)
+        sys.exit(1)
+
+    return parser
+
+
+def check_args(args):
+    if not os.path.isdir(args.output_dir):
+        raise ValueError("The output-dir does not exist or is not a directory.")
+    if args.input is None:
+        raise ValueError("Please provide input to run PyCoMo (-i / --input)")
+    elif not all([os.path.exists(arg_path) for arg_path in args.input]):
+        raise ValueError("Not all input files / directories exist.")
+
+    if args.fva_flux is not None:
+        if not 0. <= args.fva_flux <= 1.:
+            raise ValueError("The fva-flux argument needs to be between 0. and 1. (inclusive).")
+
+    if args.fva_flux is not None:
+        if not 0. <= args.fva_flux <= 1.:
+            raise ValueError("The fva-flux argument needs to be between 0. and 1. (inclusive).")
+
+    if args.abd_file is not None and not os.path.isfile(args.abd_file):
+        raise ValueError("The abundance file is not a file or does not exist")
+
+    if args.growth_rate is not None and args.growth_rate < 0.:
+        raise ValueError(f"The specified growth rate ({args.growth_rate}) is negative.")
+
+    if args.medium is not None and not os.path.isfile(args.medium):
+        raise ValueError("The medium file is not a file or does not exist")
+
+    args.abundance = None
+    if args.equal_abd:
+        args.abundance = "equal"
+    elif args.abd_file is not None:
+        args.abundance = args.abd_file
+
+    args.fba_solution_path = None
+    if args.fba_flux:
+        args.fba_solution_path = os.path.join(args.output_dir, f"{args.name}_fba_flux.csv")
+
+    args.fva_solution_path = None
+    if args.fva_flux is not None:
+        args.fva_solution_path = os.path.join(args.output_dir, f"{args.name}_fva_{args.fva_flux}_flux.csv")
+
+    args.fba_interaction_path = None
+    if args.fba_interaction:
+        args.fba_interaction_path = os.path.join(args.output_dir, f"{args.name}_fba_flux.csv")
+
+    args.fva_interaction_path = None
+    if args.fva_interaction:
+        args.fva_interaction_path = os.path.join(args.output_dir, f"{args.name}_fva_{args.fva_interaction}_flux.csv")
+
+    args.sbml_output_path = os.path.join(args.output_dir, f"{args.name}.xml")
+
+    return args

pycomo-0.1.0/src/pycomo/helper/utils.py

@@ -0,0 +1,368 @@
+"""
+This module contains some utility function related to cobrapy community models.
+"""
+import pandas as pd
+import cobra
+import libsbml
+import os
+import re
+
+
+def make_string_sbml_id_compatible(string, remove_ascii_escapes=False, remove_trailing_underscore=False):
+    """
+    This function
+    :param string:
+    :return:
+    """
+    alphanum_pattern = re.compile(r'\w')
+
+    for idx, character in enumerate(string):
+        if not alphanum_pattern.match(character):
+            string = string[:idx] + "_" + string[idx+1:]
+
+    if remove_ascii_escapes:
+        string = remove_ascii_escape_from_string(string)
+
+    if remove_trailing_underscore:
+        while string and string[-1] == "_":
+            string = string[:-1]
+
+    if string[0].isdigit():
+        string = "_" + string
+
+    return string
+
+
+def remove_ascii_escape_from_string(text):
+    ascii_pattern = re.compile("__\d+__")
+    while re.search(ascii_pattern, text):
+        text = re.sub(ascii_pattern, remove_dunder_from_ascii_escape, text)
+    return text
+
+
+def remove_dunder_from_ascii_escape(match_obj):
+    if match_obj.group() is not None:
+        print(match_obj.group())
+        return match_obj.group()[1:-1]
+
+
+def read_medium_from_file(file, comp):
+    medium_df = pd.read_csv(file, sep=",")
+    medium_dict = {}
+    for idx, row in medium_df.iterrows():
+        met = row["compounds"]
+        flux = float(row["maxFlux"])
+        rxn = "EX_" + met + comp
+        medium_dict[rxn] = flux
+    return medium_dict
+
+
+def read_abundance_from_file(file):
+    endings = {"sbml", "json", "mat", "yaml", "yml"}
+    abd_df = pd.read_csv(file, sep=",")
+    abd_dict = {}
+    assert len(abd_df.columns) == 2
+    abd_df.columns = ["model", "fraction"]
+    for idx, row in abd_df.iterrows():
+        model = row["model"]
+        if str(os.path.splitext(model)[1]) in endings:
+            model = model.replace(str(os.path.splitext(file)[1]), "")
+        fraction = float(row["fraction"])
+        abd_dict[model] = fraction
+    return abd_dict
+
+
+def load_named_model(file, format="sbml"):
+    name = os.path.split(file)[1].replace(str(os.path.splitext(file)[1]), "")
+    if format == "sbml":
+        model = cobra.io.read_sbml_model(file)
+    elif format == "json":
+        model = cobra.io.load_json_model(file)
+    elif format == "mat":
+        model = cobra.io.load_matlab_model(file)
+    elif format in ["yaml", "yml"]:
+        model = cobra.io.load_yaml_model(file)
+    else:
+        raise ValueError(f"Incorrect format for model. Please use either sbml or json.")
+    return model, name
+
+
+def load_named_models_from_dir(path, format="sbml"):
+    endings = {"sbml": [".xml"], "json": [".json"], "mat": [".mat"], "yaml": [".yaml", ".yml"]}
+    named_models = {}
+    files = os.listdir(path)
+    expected_ending = endings[format]
+    for file in files:
+        if not os.path.isfile(os.path.join(path, file)) or str(os.path.splitext(file)[1]) not in expected_ending:
+            continue
+        else:
+            model, name = load_named_model(os.path.join(path, file), format=format)
+            named_models[name] = model
+    return named_models
+
+
+def close_to_zero(num, t=10**-10):
+    return -t < num < t
+
+
+def get_model_biomass_compound(model, shared_compartment_name, expected_biomass_id="", generate_if_none=False):
+    """This will produce a biomass metabolite with a unique production reaction"""
+    objective = str(model.objective.expression).split("*")[1].split(' ')[0]
+    biomass_rxn = model.reactions.get_by_id(objective)
+    biomass_products = model.reactions.get_by_id(objective).products
+    biomass_met = None
+    if len(expected_biomass_id) > 0:
+        if expected_biomass_id in [met.id for met in biomass_products]:
+            biomass_met = model.metabolites.get_by_id(expected_biomass_id)
+        elif expected_biomass_id in [met.id for met in model.metabolites]:
+            print(f"WARNING: expected biomass id {expected_biomass_id} is not a product of the objective function.")
+            biomass_met = model.metabolites.get_by_id(expected_biomass_id)
+        else:
+            raise AssertionError(f"Expected biomass metabolite {expected_biomass_id} is not found in the model.")
+    elif len(biomass_products) == 0:
+        # No metabolites produced
+        if generate_if_none:
+            print(f"Note: no products in the objective function, adding biomass to it.")
+            biomass_met = cobra.Metabolite(f"cpd11416_{shared_compartment_name}", name='Biomass',
+                                           compartment=shared_compartment_name)
+            model.add_metabolites([biomass_met])
+            biomass_rxn.add_metabolites({biomass_met: 1.})
+        else:
+            raise AssertionError(f"No biomass compound could be found in objective\nObjective id: {objective}")
+    elif len(biomass_products) == 1:
+        biomass_met = biomass_products[0]
+    else:
+        # Multiple products in the objective, making biomass metabolites ambiguous
+        if generate_if_none:
+            print(f"Note: no products in the objective function, adding biomass to it.")
+            biomass_met = cobra.Metabolite(f"cpd11416_{shared_compartment_name}", name='Biomass',
+                                           compartment=shared_compartment_name)
+            model.add_metabolites([biomass_met])
+            biomass_rxn.add_metabolites({biomass_met: 1.})
+        else:
+            raise AssertionError(f"Multiple products in objective, biomass metabolite is ambiguous. Please set it "
+                                 f"manually.\nObjective id: {objective}")
+    return biomass_met
+
+
+def make_model_ids_sbml_conform(model):
+    for met in model.metabolites:
+        if not met.name:
+            met.name = met.id
+        met.id = make_string_sbml_id_compatible(met.id, remove_ascii_escapes=True, remove_trailing_underscore=True)
+        met.compartment = make_string_sbml_id_compatible(met.compartment, remove_ascii_escapes=True, remove_trailing_underscore=True)
+    for rxn in model.reactions:
+        if not rxn.name:
+            rxn.name = rxn.id
+        rxn.id = make_string_sbml_id_compatible(rxn.id, remove_ascii_escapes=True, remove_trailing_underscore=True)
+    for group in model.groups:
+        if not group.name:
+            group.name = group.id
+        group.id = make_string_sbml_id_compatible(group.id, remove_ascii_escapes=True, remove_trailing_underscore=True)
+
+    rename_dict = {}
+    for gene in model.genes:
+        if not gene.name:
+            gene.name = gene.id
+        rename_dict[gene.id] = make_string_sbml_id_compatible(gene.id, remove_ascii_escapes=True, remove_trailing_underscore=True)
+
+    if rename_dict:
+        cobra.manipulation.modify.rename_genes(model, rename_dict)
+
+    model.repair()
+
+    return model
+
+
+def get_metabolite_id_without_compartment(metabolite):
+    compartment_string = "_" + metabolite.compartment
+    if metabolite.id[-len(compartment_string):] == compartment_string:
+        return metabolite.id[:-len(compartment_string)]
+    else:
+        return metabolite.id
+
+
+def list_contains_unique_strings(str_list):
+    return len(str_list) == len(list(set(str_list)))
+
+
+def list_of_strings_is_self_contained(str_list):
+    self_contained = False
+    for idx, string in enumerate(str_list):
+        for other_idx in range(len(str_list)):
+            if idx == other_idx: continue
+            elif string in str_list[other_idx]:
+                self_contained = True
+    return self_contained
+
+
+def list_without_element(list_var, element):
+    list_var = list_var.copy()
+    list_var.remove(element)
+    return list_var
+
+
+def check_metabolite_equal_mass(met1, met2):
+    """
+    This function compares mass and charge of two metabolites. It returns True if the metabolites have equal mass and
+    charge and False if they do not.
+    """
+    test_reaction = cobra.Reaction()
+    test_reaction.add_metabolites({met1: -1., met2: 1.})
+    return not bool(test_reaction.check_mass_balance())
+
+
+def get_exchange_metabolites(model):
+    exchange_metabolites = {}
+    for reaction in model.exchanges:
+        if len(reaction.metabolites) != 1:
+            print(f"Error: exchange reaction {reaction.id} has more than 1 metabolite")
+        exchange_met = list(reaction.metabolites.keys())[0]
+        exchange_metabolites[exchange_met.id] = exchange_met
+    return exchange_metabolites
+
+
+def check_mass_balance_of_metabolites_with_identical_id(model_1, model_2):
+    exchg_mets_1 = get_exchange_metabolites(model_1)
+    exchg_mets_2 = get_exchange_metabolites(model_2)
+
+    unbalanced_metabolites = []
+
+    for met_id in set(exchg_mets_1) & set(exchg_mets_2):
+        equal_mass = check_metabolite_equal_mass(exchg_mets_1[met_id], exchg_mets_2[met_id])
+        if not equal_mass:
+            unbalanced_metabolites.append(met_id)
+
+    return unbalanced_metabolites
+
+
+def create_parameter_in_sbml_model(sbml_model, pid, is_constant, value=None, as_name=False):
+    """
+    Helper function to set a parameter with ID and value to a SBML model.
+    """
+    parameter = sbml_model.createParameter()
+    parameter.setId(pid)
+    if value is not None:
+        if as_name:
+            parameter.setName(value)
+        else:
+            parameter.setValue(value)
+    parameter.setConstant(is_constant)
+
+
+def create_abundance_parameter(sbml_model, member_id, abundance=None):
+    parameter_prefix = "Abundance_"
+    create_parameter_in_sbml_model(sbml_model=sbml_model, pid=parameter_prefix+member_id, is_constant=False, value=abundance)
+
+
+def read_sbml_model_from_file(file_path):
+    sbml_doc = cobra.io.sbml._get_doc_from_filename(file_path)
+    return sbml_doc.getModel()
+
+
+def get_abundance_parameters_from_sbml_doc(sbml_model):
+    parameter_prefix = "Abundance_"
+    abundance_dict = {}
+
+    for parameter in sbml_model.getListOfParameters():
+        parameter_id = parameter.getId()
+        if parameter_prefix in parameter_id[:len(parameter_prefix)]:
+            fraction = None
+            if parameter.isSetValue():
+                fraction = parameter.getValue()
+            abundance_dict[parameter_id[len(parameter_prefix):]] = fraction
+
+    return abundance_dict
+
+
+def get_flags_and_muc_from_sbml_file(sbml_file):
+    sbml_model = read_sbml_model_from_file(sbml_file)
+
+    parameter_dict = {}
+
+    for parameter in sbml_model.getListOfParameters():
+        parameter_id = parameter.getId()
+        if parameter_id == "mu_c":
+            value = 1.
+            if parameter.isSetValue():
+                value = parameter.getValue()
+            parameter_dict["mu_c"] = value
+        if parameter_id == "fixed_abundance_flag":
+            value = 0
+            if parameter.isSetValue():
+                value = parameter.getValue()
+            value = value == 1  # Flags are stored as 1 and 0 for True and False. None is converted to False
+            parameter_dict["fixed_abundance_flag"] = value
+        if parameter_id == "shared_compartment_id":
+            if not parameter.isSetName():
+                raise ValueError("Error: Missing parameter shared_compartment_id (parameter name should contain ID of "
+                                 "the shared compartment)")
+            name = parameter.getName()
+            parameter_dict["shared_compartment_name"] = name
+        if parameter_id == "fixed_growth_rate_flag":
+            value = 0
+            if parameter.isSetValue():
+                value = parameter.getValue()
+            value = value == 1  # Flags are stored as 1 and 0 for True and False. None is converted to False
+            parameter_dict["fixed_growth_rate_flag"] = value
+
+    return parameter_dict
+
+
+def get_abundance_parameters_from_sbml_file(sbml_file):
+    sbml_model = read_sbml_model_from_file(sbml_file)
+    return get_abundance_parameters_from_sbml_doc(sbml_model)
+
+
+def find_matching_annotations(met1, met2):
+    shared_annotation_keys = set(met1.annotation) & set(met2.annotation)
+    matching_annotations = {}
+    for key in shared_annotation_keys:
+        if met1.annotation[key] == met2.annotation[key]:
+            matching_annotations[key] = met1.annotation[key]
+
+    return matching_annotations
+
+
+def check_annotation_overlap_of_metabolites_with_identical_id(model_1, model_2):
+    exchg_mets_1 = get_exchange_metabolites(model_1)
+    exchg_mets_2 = get_exchange_metabolites(model_2)
+
+    metabolites_without_overlap = []
+
+    for met_id in set(exchg_mets_1) & set(exchg_mets_2):
+        matching_annotations = find_matching_annotations(exchg_mets_1[met_id], exchg_mets_2[met_id])
+        if not matching_annotations:
+            metabolites_without_overlap.append(met_id)
+
+    return metabolites_without_overlap
+
+
+def relax_reaction_constraints_for_zero_flux(model):
+    """This function relaxes all constraints of a model to allow a flux of 0 in all reactions."""
+    for reaction in model.reactions:
+        if reaction.lower_bound > 0.:
+            reaction.lower_bound = 0.
+        if reaction.upper_bound < 0.:
+            reaction.upper_bound = 0.
+
+
+def find_loops_in_model(model):
+    """This function finds loops in models. This is accomplished by setting the medium to contain nothing and relax
+    all constraints to allow a flux of 0. Then, FVA is run on all reactions"""
+    loop_model = model.copy()
+    loop_model.medium = {}
+    relax_reaction_constraints_for_zero_flux(loop_model)
+    no_medium = {}
+    max_flux_value = 1000.0
+    loops = []
+    for rxn in loop_model.reactions:
+        loop_model.objective = rxn.id
+        solution = loop_model.optimize("minimize")
+        min_flux = solution.objective_value if not solution.status == "infeasible" else 0.
+        solution = loop_model.optimize("maximize")
+        max_flux = solution.objective_value if not solution.status == "infeasible" else 0.
+        if min_flux != 0. or max_flux != 0.:
+            loops.append({"reaction": rxn.id, "min_flux": min_flux, "max_flux": max_flux})
+    loops_df = pd.DataFrame(loops)
+    return loops_df