seed2lp 2.0.0__py3-none-any.whl

seed2lp/resmod.py

@@ -0,0 +1,74 @@
+from . import flux
+from cobra.core import Model
+
+class Resmod:
+    def __init__(self, name:str, objectives:list, solver_type:str, search_mode:str, search_type:str,
+                 size:int, seeds_list:list, flux_lp:dict, flux_cobra:dict=None, run_mode:str=None, 
+                 accu:bool=False, is_community:bool=False, transferred_list:list=None):
+        """Initialize Object Resmod
+
+        Args:
+            name (str): Name of the solution
+            objectives (list): List of objective reaction names
+            solver_type (str): Type of solver (Reasoning / FBA / Hybrid)
+            search_mode (str): search mode type (Minimize / Submin)
+            search_type (str): search type (enumeration / union /intersection)
+            size (int): Size of set of seeds
+            seeds_list (list): List of seeds
+            flux_lp (dict): Dictionnary of all reaction with their LP flux
+            flux_cobra (float, optional): Cobra flux calculated (mode Filter, Guess Check). Defaults to None.
+            run_mode (str, optional): Running command used (full or target). Defaults to None.
+            accu (bool, optional): Is accumulation allowed. Defaults to False.
+        """
+        self.name = name
+        self.objectives = objectives
+        self.solver_type = solver_type
+        self.search_mode = search_mode
+        self.search_type = search_type
+        self.size = size
+        self.seeds_list = seeds_list
+        self.flux_lp = flux_lp
+        self.chosen_lp = None
+        self.tested_objective = None
+        self.objective_flux_seeds = None
+        self.objective_flux_demands = None
+        self.OK_seeds = False
+        self.OK_demands = False
+        self.OK = False
+        self.run_mode = run_mode
+        self.accu = accu
+        self.flux_cobra = flux_cobra
+        self.is_community = is_community
+        self.transferred_list = transferred_list
+
+
+   
+    ######################## METHODS ########################
+    def check_flux(self, model_cobra:Model, try_demands:bool=True, equality_flux:bool=False):
+        """Execute flux calculation usng cobra and store data
+
+        Args:
+            model_cobra (Model): Cobra model
+            show_messages (bool, optional): Option to show the messages on console. 
+                                            Defaults to True. False for hybrid with cobra.
+            try_demands (bool, optional): Option to try to add demands if seeds failed.
+                                         Defaults to True. False for hybrid with cobra.
+            equality_flux (bool, optional): Community mode otpion to force equality of flux 
+                                            between species' biomass
+        """
+        with model_cobra as m:
+            flux_output, objective, lp_flux = \
+                        flux.calculate(m, self.objectives, self.seeds_list, self.flux_lp, try_demands, 
+                                       self.is_community, self.transferred_list, equality_flux)
+        if flux_output:
+            self.tested_objective = objective
+            self.chosen_lp = lp_flux
+            self.objective_flux_seeds = flux_output['objective_flux_seeds']
+            self.objective_flux_demands = flux_output['objective_flux_demands']
+            self.OK_seeds = flux_output['OK_seeds']
+            self.OK_demands = flux_output['OK_demands']
+            self.OK = flux_output['OK']
+            self.infeasible_seeds = flux_output['infeasible_seeds']
+            self.infeasible_demands = flux_output['infeasible_demands']
+
+    ########################################################

seed2lp/sbml.py

@@ -0,0 +1,307 @@
+"""Routines to extract information from SBML files.
+
+"""
+import xml.etree.ElementTree as ET
+from re import sub, match, search
+from . import logger
+
+def register_all_namespaces(file:str):
+    """Get namespaces for rewriting SBML file
+
+    Args:
+        file (str): SBML file path
+    """
+    namespaces = dict([node for _, node in ET.iterparse(file, events=['start-ns'])])
+    for ns in namespaces:
+        #print(ns,  namespaces[ns])
+        ET.register_namespace(ns, namespaces[ns])
+        
+def get_root(file:str):
+    """Get etree root
+
+    Args:
+        file (str): SBML file path
+
+    Returns:
+        sbml (etree Element), first_line (str) : Return an etree elemnt of the network, and the first line of the sbml file
+    """
+    register_all_namespaces(file)
+    with open(file) as f:
+        first_line = f.readline()
+        xmlstring = f.read()
+    f.close()
+    
+    # Remove the default namespace definition (xmlns="http://some/namespace")
+    default_namespace = search(r'\sxmlns="[^"]+"', xmlstring).group()
+    xmlstring = sub(default_namespace, '', xmlstring, count=1)
+
+    sbml = ET.fromstring(xmlstring)  
+    #tree = ET.parse(file)
+    #sbml = tree.getroot()
+    return sbml, first_line, default_namespace
+
+def get_sbml_tag(element:ET.Element) -> str:
+    "Return tag associated with given SBML element"
+    if element.tag[0] == "{":
+        _, tag = element.tag[1:].split("}")  # uri is not used
+    else:
+        tag = element.tag
+    return tag
+
+
+def get_model(sbml:ET.Element) -> ET.Element:
+    """
+    return the model of a SBML
+    """
+    model_element = None
+    for e in sbml:
+        tag = get_sbml_tag(e)
+        if tag == "model":
+            model_element = e
+            break
+    return model_element
+
+def get_listOfSpecies(model:ET.Element) -> list[ET.Element]:
+    """
+    return list of species of a SBML model
+    """
+    listOfSpecies = None
+    for e in model:
+        tag = get_sbml_tag(e)
+        if tag == "listOfSpecies":
+            listOfSpecies = e
+            break
+    return listOfSpecies
+
+
+def get_listOfReactions(model:ET.Element) -> list[ET.Element]:
+    """return list of reactions of a SBML model"""
+    listOfReactions = []
+    for e in model:
+        tag = get_sbml_tag(e)
+        if tag == "listOfReactions":
+            listOfReactions = e
+            break
+    return listOfReactions
+
+
+def get_listOfReactants(reaction:ET.Element, species:str=None, is_community:bool=False) -> list:
+    """return list of reactants of a reaction"""
+    listOfReactants = list()
+    listOfReactantsNames = list()
+    for e in reaction:
+        tag = get_sbml_tag(e)
+        if tag == "listOfReactants":
+            for meta in e:
+                meta_id = meta_name = meta.attrib.get('species')
+                if is_community:
+                    meta_id = sub("^M_", f"M_{species}_",meta_id)
+                listOfReactants.append([meta_id, meta.attrib.get('stoichiometry'), meta_name])
+                
+                # Create a list of only of meta to determine if a reaction will be transport reaction
+                # both list must be the same (same element in reactnats and products)
+                listOfReactantsNames.append(meta_name.rsplit('_', 1)[0])
+            break
+    return listOfReactants, listOfReactantsNames
+
+
+def get_listOfReactants_from_name(model:ET.Element, reaction_name) -> list[ET.Element]:
+    """return list of reactants of a reaction"""
+    reactions_list = get_listOfReactions(model)
+    for reaction in reactions_list:
+        if reaction_name == reaction.attrib['id']:
+            for e in reaction:
+                tag = get_sbml_tag(e)
+                if tag == "listOfReactants":
+                    listOfReactants = e
+                    break
+    return listOfReactants
+
+
+def get_listOfProducts(reaction:ET.Element, species:str=None, is_community:bool=False) -> list:
+    """return list of products of a reaction"""
+    listOfProducts = list()
+    listOfProductsNames = list()
+    for e in reaction:
+        tag = get_sbml_tag(e)
+        if tag == "listOfProducts":
+            for meta in e:
+                meta_id = meta_name  = meta.attrib.get('species')
+                if is_community:
+                    meta_id = sub("^M_", f"M_{species}_",meta_id)
+                listOfProducts.append([meta_id, meta.attrib.get('stoichiometry'), meta_name])
+
+                # Create a list of only of meta to determine if a reaction will be transport reaction
+                # both list must be the same (same element in reactnats and products)
+                listOfProductsNames.append(meta_name.rsplit('_', 1)[0])
+            break
+    return listOfProducts, listOfProductsNames
+
+
+def get_reaction_from_name(model:ET.Element, reaction_name) -> list[ET.Element]:
+    """return list of reactants of a reaction"""
+    reactions_list = get_listOfReactions(model)
+    for reaction in reactions_list:
+        if reaction_name == reaction.attrib['id']:
+            return reaction
+    raise ValueError(f"No reaction {reaction_name} found in list of reactions \n")
+
+
+def get_fbc(sbml:ET.Element):
+    """
+    return the fbc namespace of a SBML
+    """
+    fbc = None 
+    for nss in ET._namespaces(sbml):
+        for key in nss:
+            if key is not None and 'fbc' in key:
+                fbc=key
+                break
+    return fbc
+
+
+def get_listOfParameters(model:ET.Element)-> dict:
+    """return list of reactions of a SBML model"""
+    listOfParameters = dict()
+    for e in model:
+        tag = get_sbml_tag(e)
+        if tag == "listOfParameters":
+            for param in e:
+                listOfParameters[param.get('id')]=param.get('value') 
+            break
+    return listOfParameters
+
+
+def get_parameters(model:ET.Element) -> list[ET.Element]:
+    """
+    return list of parameters of a SBML model
+    """
+    listOfParameters = None
+    for e in model:
+        tag = get_sbml_tag(e)
+        if tag == "listOfParameters":
+            listOfParameters = e
+            break
+    return listOfParameters
+
+
+def get_objectives(model:ET.Element) -> list[ET.Element]:
+    """
+    return list of parameters of a SBML model
+    """
+    listOfObjective = None
+    for e in model:
+        tag = get_sbml_tag(e)
+        if tag == "listOfObjectives":
+            listOfObjective = e
+            break
+    return listOfObjective
+
+
+def get_listOfFluxObjectives(model,fbc)-> list:
+    """return list of objective reactions of a SBML model"""
+    listOfFluxObjectives = list()
+
+    for e in model:
+        tag = get_sbml_tag(e)
+        if tag == "listOfObjectives":
+            for lo in e[0]:
+                if lo:
+                    for o in lo:
+                        name = o.attrib.get('{'+fbc+'}reaction')
+                        coef = o.attrib.get('{'+fbc+'}coefficient')
+                        reaction = get_reaction_from_name(model, name)
+                        listOfFluxObjectives.append([name,coef,reaction])
+            break
+    return listOfFluxObjectives
+
+
+def read_SBML_species(filename)-> dict:
+    """Yield names of species listed in given SBML file"""
+    model_dict = dict()
+    tree = ET.parse(filename)
+    sbml = tree.getroot()
+    model = get_model(sbml)
+    species_list = list()
+    reactions_list = list()
+    
+    for species in get_listOfSpecies(model):
+        species_list.append(species.attrib['id'])
+    for reaction in get_listOfReactions(model):
+        reactions_list.append(f"{reaction.attrib['id']}")
+
+    model_dict['Metabolites'] = species_list
+    model_dict['Reactions'] = reactions_list
+    return model_dict
+
+
+def get_used_metabolites(filename, call_log=False)-> set:
+    """Determine from source file the truly used metabolite (and not the list of species)
+    Necessary for scripts 10_1_scope_analyse.py and 10_3_iCN718_metabolite_analyses.py
+
+    Args:
+        filename (str): Path to thie SBML file
+
+    Returns:
+        used_metabolites (set): Set of used metabolites
+    """
+    tree = ET.parse(filename)
+    sbml = tree.getroot()
+    model = get_model(sbml)
+    # SBML has species that are never used on any reactions 
+    # but are present into species list
+    # Also, there is some reaction that involves species but 
+    # having boundaries to [0,0], so we are not taken into account
+    # the species of the species of these reactions into the used metabolites
+    used_metabolites = set()
+
+    fbc = get_fbc(get_root(filename)[0])
+    parameters = get_listOfParameters(model)
+
+    for reaction in get_listOfReactions(model):
+        ubound =  parameters[reaction.attrib.get('{'+fbc+'}upperFluxBound')]
+        lbound = parameters[reaction.attrib.get('{'+fbc+'}lowerFluxBound')]
+        if float(ubound) == 0 and float(lbound) == 0  and call_log:
+            logger.log.warning(f"Reaction {reaction.attrib['id']} deleted, boudaries [0,0]")
+            continue
+        else:
+            reactants,_ = get_listOfReactants(reaction,"",False)
+            products,_ = get_listOfProducts(reaction,"",False)
+            for reactant in reactants:
+                used_metabolites.add(reactant[0])
+            for product in products:
+                used_metabolites.add(product[0])
+
+    return used_metabolites
+
+
+
+def etree_to_string(model) -> str:
+    return str(ET.tostring(model, encoding='utf-8', method='xml'),'UTF-8')
+
+def create_sub_element(element:ET.Element, sub_element:str):
+    ET.SubElement(element,sub_element)
+
+def remove_sub_elements(element:ET.Element):
+    for metabolite in list(element):
+        element.remove(metabolite)
+
+def add_metabolites(element:ET.Element, metabolites_list):
+    for metabolite in metabolites_list:
+        element.append(metabolite)
+
+def remove_reaction(model:ET.Element, element:ET.Element):
+    for e in model:
+        tag = get_sbml_tag(e)
+        if tag == "listOfReactions":
+            e.remove(element)
+
+def check_remove_objective(model:ET.Element, reaction:ET.Element, fbc):
+    for e in model:
+        tag = get_sbml_tag(e)
+        if tag == "listOfObjectives":
+            for lo in e[0]:
+                if lo:
+                    for o in lo:
+                        if o.attrib.get('{'+fbc+'}reaction') == reaction.attrib['id']:
+                            lo.remove(o)

seed2lp/scope.py

@@ -0,0 +1,124 @@
+from .network import Network
+from menetools import run_menescope
+from .file import is_valid_dir, save
+from os.path import join
+#from .sbml import get_used_metabolites
+import libsbml
+from padmet.utils.sbmlPlugin import convert_from_coded_id
+from padmet.utils.connection import sbmlGenerator
+import sys
+from . import logger
+
+
+class Scope:
+    def __init__(self, file:str, network:Network, output_dir:str):
+        """Initialize Object Scope
+
+        Args:
+            file (str): SBML File (Needed to detect source used metabolites on the network)
+            network (Network): Corrected Network
+        """
+        self.file = file
+        self.network = network
+        self.output_dir = output_dir
+        self.dir_seeds_sbml = is_valid_dir(join(output_dir,'sbml'))
+        self.dir_scope = is_valid_dir(join(output_dir,'scope'))
+
+    ######################## METHODS ########################
+    def execute(self):
+        """Execute the scope from seeds solution for each solution and save it into file.
+        Creates an intermediate seed sbml file.
+        """
+        # Get global data on the network
+        #set_used_metabolites = get_used_metabolites(self.file, True)
+        set_used_metabolites = set(self.network.used_meta.keys())
+
+
+        # run the scope for each solutions of the result
+        for result in self.network.result_seeds:
+            #TODO : print better in TABLE
+            print(result.run_mode.upper())
+            print(result.solver_type)
+            print(result.search_mode)
+            print(result.name)
+            print("Accumulation:", result.accu)
+
+            if  result.accu == True:
+                accu="accu"
+            else:
+                accu="no_accu"
+
+            run_mode = result.run_mode.lower().replace(" ","_").replace("-", "_")
+            solver = result.solver_type.lower().replace(" ","_").replace("-", "_")
+            search_mode = result.search_mode.lower().replace(" ","_").replace("-", "_")
+            seeds=set(result.seeds_list)
+
+            seeds_sbml_complete_dir_path = is_valid_dir(join(self.dir_seeds_sbml, run_mode, solver, search_mode, accu))
+            seeds_sbml_path=join(seeds_sbml_complete_dir_path, f'{result.name}.sbml')
+            scope_dir_path = is_valid_dir(join(self.dir_scope, run_mode, solver, search_mode, accu))
+
+            # Write the seed into sbl format for each solutions
+            create_species_sbml(seeds, seeds_sbml_path)
+            logger.log.info(f"Seeds sbml file created: {seeds_sbml_path}")
+            
+            # Run menescope from seed to get the scope
+            logger.log.info(f"Scope running for {seeds_sbml_path}...") 
+            scope_model = run_menescope(self.file, seeds_sbml_path)
+            logger.log.info(f"Scope terminated.") 
+            scope_model["size_scope"] = len(scope_model["scope"])
+            scope_model["size_all_metabolites"] = len(set_used_metabolites)
+
+
+            
+            print("size of scope", scope_model["size_scope"])
+            print("size of all metabolites", scope_model["size_all_metabolites"],"\n\n")
+            save(f'{result.name}', scope_dir_path, scope_model, "json")
+            logger.log.info(f"Scope saved in: {scope_dir_path}/{result.name}.json.") 
+
+
+
+def create_species_sbml(metabolites, outputfile):
+    """Create a SBML files with a list of species containing metabolites of the input set.
+    Check if there are forbidden SBML characters in the metabolite IDs/ If yes, exit.
+    
+    Args:
+        metabolites (set): set of metabolites
+        outputfile (str): SBML file to be written
+    """
+    document = libsbml.SBMLDocument(2, 1)
+    model = document.createModel("metabolites")
+    forbidden_charlist = ['-', '|', '/', '(', ')',
+        "'", '=', '#', '*', '.', ':', '!', '+', '[',
+        ']', ',', ' ']
+    forbidden_character_in_metabolites = None
+    issue_trying_to_add_species = None
+    for compound in metabolites:
+        compound = compound.strip('"')
+        _, _, comp = convert_from_coded_id(compound)
+        s = model.createSpecies()
+        sbmlGenerator.check(s, 'create species')
+        forbidden_characters_detacted = [char for char in forbidden_charlist if char in compound]
+        if len(forbidden_characters_detacted) > 0:
+            logger.log.warning("Forbidden character ({0}) in {1}. SBML creation will failed.".format(' '.join(forbidden_characters_detacted), compound))
+            forbidden_character_in_metabolites = True
+        try:
+            sbmlGenerator.check(s.setId(compound), 'set species id')
+        except:
+            issue_trying_to_add_species = True
+            logger.log.warning("Issue when trying to add compound {0}.".format(compound))
+
+        if comp is not None:
+            sbmlGenerator.check(s.setCompartment(comp), 'set species compartment')
+        elif comp is None:
+            logger.log.warning("No compartment for " + compound)
+
+    if issue_trying_to_add_species is True and forbidden_character_in_metabolites is True:
+        logger.log.warning("Forbidden character in compound ID, SBML creation will failed.")
+        logger.log.warning("Modify the metabolic networks SBMl file by renaming these metabolites and removing the forbidden character.")
+        sys.exit(1)
+    if issue_trying_to_add_species is True and forbidden_character_in_metabolites is None:
+        logger.log.warning("Issue when trying to add metabolite into SBML file, potential issue with SBML format.")
+        logger.log.warning("Modify the metabolic networks SBMl file by renaming these metabolites and removing the forbidden character.")
+        sys.exit(1)
+
+    libsbml.writeSBMLToFile(document, outputfile)