seed2lp 2.0.0__py3-none-any.whl

seed2lp/solver.py

@@ -0,0 +1,333 @@
+# Object Solver constitued of 
+#    - run_mode (str): Running command used (full or target)
+#    - network (Network): Object Network
+#    - time_limit_minute (float): Time limit given by user in minutes 
+#    - time_limit (int): Time limit converted in seconds for resolutions
+#    - number_solution (int): Limit number of solutions to find
+#    - clingo_configuration (str): Configuration for clingo resolution (jumpy or not, or other)
+#    - clingo_strategy (str): Strategy for clingo resolution (usc,oll or not, other)
+#    - enumeration (bool): Enumerate the solutions limited by the number of solutions
+#    - intersection (bool): Find the intersection of all solutions without limitation (give one solution)
+#    - union (bool): Find the union of all solutions without limitation (give one solution)
+#    - minimize (bool): Search the minimal carinality of solutions
+#    - subset_minimal (bool): Search the subset minimal solutions
+#    - clingo_constant (str): Set the value of constant in lp file for search 
+#    - one_model_unsat (bool): Set if the minimze solution is unsatisfiable
+#    - optimum (int): Value of minimal cardinality if not unsatisfiable
+#    - output (dict): List of all solutions
+#    - timer_list (dict): List of all timers to find solution
+#    - verbose (bool): Set debug mode
+
+from os import path
+from .network import  Network
+from .file import write_instance_file
+from dataclasses import dataclass
+from . import logger
+from . import color
+
+
+
+@dataclass
+class ASP_CLINGO:
+    SRC_DIR = path.dirname(path.abspath(__file__))
+    ASP_SRC_SEED_SOLVING = path.join(SRC_DIR, 'asp/seed-solving.lp')
+    ASP_SRC_CONSTRAINTS_TARGET = path.join(SRC_DIR, 'asp/constraints_targets.lp')
+    ASP_SRC_MINIMIZE = path.join(SRC_DIR, 'asp/minimize.lp')
+    ASP_SRC_FLUX = path.join(SRC_DIR, 'asp/flux.lp')
+    ASP_SRC_MAXIMIZE_FLUX = path.join(SRC_DIR, 'asp/maximize_flux.lp')
+    ASP_SRC_MAXIMIZE_PRODUCED_TARGET = path.join(SRC_DIR, 'asp/maximize_produced_target.lp')
+    ASP_SRC_COMMUNITY = path.join(SRC_DIR, 'asp/community_search.lp')
+    ASP_SRC_SHOW_SEEDS = path.join(SRC_DIR, 'asp/show_seeds.lp')
+    ASP_SRC_SHOW_TRANSFERS = path.join(SRC_DIR, 'asp/show_tranfers.lp')
+    ASP_SRC_LIMIT_TRANSFERS = path.join(SRC_DIR, 'asp/limit_transfers.lp')
+    ASP_SRC_ATOM_TRANSF = path.join(SRC_DIR, 'asp/atom_for_transfers.lp')
+    ASP_SRC_ATOMS = path.join(SRC_DIR, 'asp/definition_atoms.lp')
+    ASP_SRC_COM_HEURISTIC = path.join(SRC_DIR, 'asp/community_heuristic.lp')
+    ASP_SRC_SEED_EXTERNAL = path.join(SRC_DIR, 'asp/seed_external.lp')
+    CLINGO_CONFIGURATION = {
+            'minimize-enumeration': ['--project=show', '--opt-mode=enum'],
+            'minimize-union':  ['--enum-mode=brave', '--opt-mode=enum'],
+            'minimize-intersection': ['--enum-mode=cautious', '--opt-mode=enum'],
+            'minimize-one-model': None,
+            'submin-enumeration': ['--heuristic=Domain', '--enum-mode=domRec', '--dom-mod=5,16'], # modifier 5: false / pick 16 : Atoms that are shown
+            'submin-intersection': ['--heuristic=Domain', '--enum-mode=cautious', '--dom-mod=5,16'], # modifier 5: false / pick 16 : Atoms that are shown
+            }
+    ASW_FLAG, OPT_FLAG, OPT_FOUND = 'Answer: ', 'Optimization: ', 'OPTIMUM FOUND'
+
+@dataclass
+class GROUNDING:
+    #TODO: CLEAN GROUND MODE IF NOT USED
+    GROUND = False
+
+###################################################################
+########################## Class  Solver ########################## 
+###################################################################
+class Solver:
+    def __init__(self, run_mode:str, network:Network, 
+                 time_limit_minute:float=None, number_solution:int=None, 
+                 clingo_configuration:str=None, clingo_strategy:str=None,
+                 intersection:bool=False, union:bool=False, 
+                 minimize:bool=False, subset_minimal:bool=False,
+                 temp_dir:str=None, short_option:str=None, run_solve:str=None,
+                 verbose:bool=False, community_mode:str=None):
+        """"Initialize Object Solver
+
+        Args:
+            run_mode (str): Running command used (full or target)
+            network (Network): Network constructed
+            time_limit_minute (float, optional): Time limit given by user in minutes . Defaults to None.
+            number_solution (int, optional): Limit number of solutions to find. Defaults to 100. if -1, no enumeration
+            clingo_configuration (str, optional): Configuration for clingo resolution . Defaults to None.
+            clingo_strategy (str, optional): Strategy for clingo resolution. Defaults to None.
+            intersection (bool, optional):  Find the intersection of all solutions without limitation (give one solution). Defaults to False.
+            union (bool, optional): Find the union of all solutions without limitation (give one solution). Defaults to False.
+            minimize (bool, optional): Search the minimal carinality of solutions. Defaults to False.
+            subset_minimal (bool, optional):  Search the subset minimal solutions. Defaults to False.
+            temp_dir (str, optional): Temporary directory for saving instance file and clingo outputs. Defaults to None.
+            short_option (str, optional): Short way to write option on filename. Defaults to None.
+            run_solve (str, optional): Solving run used (reasoning, filter, guess-check, guess-check-div)
+            verbose (bool, optional): Set debug mode. Defaults to False.
+        """
+
+        self.is_linear:bool
+        self.asp = ASP_CLINGO()
+        self.ground = GROUNDING().GROUND
+        self.run_mode = run_mode
+        self.network = network
+        self.time_limit_minute = time_limit_minute
+        self.set_time_limit()
+        self.number_solution = number_solution
+        self._set_clingo_configuration(clingo_configuration)
+        self._set_clingo_strategy(clingo_strategy)
+        self.enumeration = True
+        if(number_solution == -1):
+            self.enumeration = False
+        self.intersection = intersection
+        self.union = union
+        self.minimize = minimize
+        self.subset_minimal = subset_minimal
+        self.clingo_constant = list()
+        self.one_model_unsat = True
+        self.optimum = tuple()
+        self.optimum_found = False
+        self.opt_prod_tgt = None
+        self.opt_size = None
+        self.output = dict()
+        self.timer_list =  dict()
+        self.verbose = verbose
+        self.messages = list()
+        self.temp_dir = temp_dir
+        self.short_option = short_option
+        self.run_solve = run_solve
+        if self.run_solve == "guess_check_div":
+            self.diversity = True
+        else: 
+            self.diversity = False
+        self.grounded = str()
+        self.temp_result_file = str()
+        self.community_mode = community_mode
+
+        self.asp_files = [self.asp.ASP_SRC_SEED_SOLVING, self.asp.ASP_SRC_CONSTRAINTS_TARGET, self.asp.ASP_SRC_ATOMS]
+        self._set_instance_file()
+
+    
+    ######################## SETTER ########################
+    def set_time_limit(self):
+        """Convert time limit minute into seconds for resolutions
+        """
+        if self.time_limit_minute != 0:
+            self.time_limit=self.time_limit_minute*60
+        else:
+            self.time_limit=None
+
+    
+    def _set_clingo_configuration(self, clingo_configuration:str):
+        """Prepare configuration command option for resolution
+
+        Args:
+            clingo_configuration (str): configuration mode
+        """
+        if clingo_configuration != "none":
+            self.clingo_configuration = f"--configuration={clingo_configuration}"
+        else:
+            self.clingo_configuration = ""
+    
+    def _set_clingo_strategy(self, clingo_strategy:str):
+        """Prepare strategy command option for resolution
+
+        Args:
+            clingo_strategy (str): strategy mode
+        """
+        if clingo_strategy != "none":
+            self.clingo_strategy = f"--opt-strategy={clingo_strategy}"
+        else:
+            self.clingo_strategy = ""
+
+    def _set_instance_file(self):
+        """Prepare ASP instance filename for saving into temporary directory file
+        """
+        filename = f'instance_{self.network.name}_{self.short_option}'
+        self.network.instance_file = path.join(self.temp_dir,f'{filename}.lp')
+        write_instance_file(self.network.instance_file, self.network.facts)
+        self.asp_files.append(self.network.instance_file)
+        logger.log.info(f"Instance file written: {self.network.instance_file}")
+
+    
+    def _set_temp_result_file(self):
+        self.temp_result_file = f'temp_{self.network.name}_{self.short_option}'
+
+    ########################################################
+
+    ######################## METHODS ########################
+
+
+    def get_solutions_infos(self, search_mode:str=""):
+        """Get infos of solving mode for messsages and outputs.
+
+        Args:
+            search_mode (str, optional): Describe the mode of resolution. Defaults to "".
+
+        Returns:
+            str, str, str: mode_message, model_type, output_type
+        """
+        mode_message = ""
+        model_type = ""
+        output_type = ""
+        match search_mode:
+            case "minimize-one-model":
+                mode_message="Minimize optimum"
+                model_type="model_one_solution"
+                output_type = 'MINIMIZE OPTIMUM'
+            case "minimize-intersection":
+                mode_message="Minimize intersection"
+                model_type="model_intersection"
+                output_type = 'MINIMIZE INTERSECTION'
+            case "minimize-union":
+                mode_message="Minimize union"
+                model_type="model_union"
+                output_type = 'MINIMIZE UNION'
+            case "minimize-enumeration":
+                output_type = 'MINIMIZE ENUMERATION'
+            case "submin-enumeration":
+                output_type = 'SUBSET MINIMAL ENUMERATION'
+            case "submin-intersection":
+                mode_message="Subset Minimal intersection"
+                model_type="model_intersection"
+                output_type = 'SUBSET MINIMAL INTERSECTION'
+                
+            
+        full_option=[self.clingo_configuration, self.clingo_strategy]
+        greedy_clingo_option=self.asp.CLINGO_CONFIGURATION[search_mode]
+        if greedy_clingo_option:
+            full_option = [*full_option, *greedy_clingo_option]
+        full_option = list(filter(None, full_option))
+        return full_option, mode_message, model_type, output_type
+
+
+    def init_const(self):
+        """ Inititate ASP constants
+        """
+        self.clingo_constant = ['-c']
+        match self.run_mode:
+            case 'target':
+                logger.print_log("Mode : TARGET", "info")
+                if not self.network.targets_as_seeds:  
+                    logger.print_log('Option: TARGETS ARE FORBIDDEN SEEDS', "info")
+                logger.print_log(f'Search seeds validating the {len(self.network.targets)} targets…','debug')
+                self.clingo_constant.append('run_mode=target')
+            case 'full':
+                logger.print_log("Mode : FULL NETWORK", "info")
+                logger.print_log("Search seeds validating all metabolites as targets…",'debug')
+                self.clingo_constant.append('run_mode=full')
+            case 'fba':
+                logger.print_log("Mode : FBA", "info")
+                if not self.network.targets_as_seeds:  
+                    logger.print_log('Option: TARGETS ARE FORBIDDEN SEEDS', "info")
+                    logger.print_log('Info: Targets are reactant of objective', "info")
+                logger.print_log("Search seeds aleatory…",'debug')
+                self.clingo_constant.append('run_mode=fba')
+            case 'community':
+                match self.community_mode:
+                    case "global":
+                        logger.print_log("Community Mode : Global Subset Minimal", "info")
+                    case "bisteps":
+                        logger.print_log("Community Mode : Bisteps Subset Minimal", "info")
+                    case "delsupset":
+                        logger.print_log("Community Mode : Delete superset of seeds", "info")
+                if not self.network.targets_as_seeds:  
+                    logger.print_log('Option: TARGETS ARE FORBIDDEN SEEDS', "info")
+                logger.print_log(f'Search seeds validating the {len(self.network.targets)} targets…','debug')
+                self.clingo_constant.append('run_mode=target')
+
+        if self.network.accumulation:
+            logger.print_log('ACCUMULATION: Authorized', "info")
+            self.clingo_constant.append('-c')
+            self.clingo_constant.append('accu=1')
+        else:
+            logger.print_log('ACCUMULATION: Forbidden', "info")
+            self.clingo_constant.append('-c')
+            self.clingo_constant.append('accu=0')
+    
+    def get_separate_optimum(self):
+        """This function separate the optimisations if possible: 
+            Maximization of produced target (rank 2)
+            Minimization of set of seeds (rank 1)
+        When using multiple optimization with clingo, the solver gives back
+        a list of optimality found in order of importance in the asp files .
+        A higher rank means a higher importance. 
+        """
+        if len(self.optimum)==1:
+            self.opt_prod_tgt = None
+            self.opt_size = self.optimum[0]
+        else:
+            self.opt_prod_tgt = self.optimum[0]
+            self.opt_size = self.optimum[1]    
+    
+    def get_message(self, mode:str=None):
+        """Get messages to put on terminal
+
+        Args:
+            mode (str, optional): witch kind of messages to chose. Defaults to None.
+        """
+        match mode:
+            case 'subsetmin':
+                logger.print_log("\n____________________________________________","info",color.purple)  
+                logger.print_log("____________________________________________\n", "info",color.purple)
+                logger.print_log(f"Sub Mode: {color.bold}SUBSET MINIMAL{color.reset}".center(55), "info")
+                logger.print_log("____________________________________________", "info",color.purple)
+                logger.print_log("____________________________________________\n", "info",color.purple)
+            case "minimize":
+                logger.print_log("\n____________________________________________","info",color.purple)
+                logger.print_log("____________________________________________\n", "info",color.purple)   
+                logger.print_log(f"Sub Mode: {color.bold}MINIMIZE{color.reset}".center(55), "info")
+                logger.print_log("____________________________________________", "info",color.purple) 
+                logger.print_log("____________________________________________\n", "info",color.purple) 
+            case "one solution":
+                logger.print_log(f"\n~~~~~~~~~~~~~~~ {color.bold}One solution{color.reset} ~~~~~~~~~~~~~~~", "info") 
+            case "intersection":
+                logger.print_log(f"\n~~~~~~~~~~~~~~~ {color.bold}Intersection{color.reset} ~~~~~~~~~~~~~~~", "info") 
+            case "enumeration":
+                logger.print_log(f"\n~~~~~~~~~~~~~~~~ {color.bold}Enumeration{color.reset} ~~~~~~~~~~~~~~~", "info")
+            case "union":
+                logger.print_log(f"\n~~~~~~~~~~~~~~~~~~~ {color.bold}Union{color.reset} ~~~~~~~~~~~~~~~~~~", "info") 
+            case "end":
+                logger.print_log('############################################\n\n', "info", color.cyan_light)
+            case "optimum error":
+                logger.print_log("\n____________________________________________","info") 
+                logger.print_log('ABORTED: No objective funcion found \
+                                    \nPlease correct the SBML file to contain either \
+                                    \n    - a function with "BIOMASS" (not case sensiive) in the name \
+                                    \n    - a function in the objective list', "error")
+            case "command":
+                logger.print_log("                Command", "debug")
+            case "classic":
+                logger.print_log(f"\n················ {color.bold}Classic mode{color.reset} ···············", "info") 
+            case "filter":
+                logger.print_log(f"\n················ {color.bold}Filter mode{color.reset} ···············", "info")  
+            case "guess_check":
+                logger.print_log(f"\n·············· {color.bold}Guess-Check mode{color.reset} ············", "info")  
+            case "guess_check_div":
+                logger.print_log(f"\n····· {color.bold}Guess-Check with diversity mode{color.reset} ······", "info")  
+
+   
+    

seed2lp/temp_flux_com.py

@@ -0,0 +1,74 @@
+import cobra 
+model=cobra.io.read_sbml_model("networks/toys_communities/communities/comex.sbml")
+model=cobra.io.read_sbml_model("networks/toys_communities/sbml/B1.sbml")
+
+for elem in model.boundary:
+    if not elem.reactants and elem.upper_bound > 0:
+        if elem.lower_bound > 0:
+            elem.lower_bound = 0
+        elem.upper_bound = 0.0
+    if not elem.products and elem.lower_bound < 0:
+        if elem.upper_bound < 0:
+            elem.upper_bound = 0
+        elem.lower_bound = 0.0
+
+model.reactions.EX_A.upper_bound = 0
+model.reactions.EX_B.upper_bound = 0
+model.reactions.EX_C.upper_bound = 0
+model.reactions.EX_E.upper_bound = 0
+#model.reactions.EX_A.lower_bound = -1000
+model.reactions.B1_EX_A.lower_bound = -1000
+model.reactions.B2_EX_A.lower_bound = -1000
+model.reactions.B2_EX_B.lower_bound = -1000
+#model.reactions.EX_B.lower_bound = -1000
+model.reactions.EX_C.lower_bound = 0
+model.reactions.EX_E.lower_bound = 0
+
+
+same_flux = model.problem.Constraint(
+                model.reactions.B1_Biom1.flux_expression - model.reactions.B2_Biom2.flux_expression, 
+                lb=0, ub=0)
+model.add_cons_vars(same_flux)
+
+
+#biom_com = cobra.Reaction("Biom_com")
+#biom_com.name = "Biom_com"
+#biom_com.lower_bound = 0
+#biom_com.upper_bound = 1000
+#biom_com.add_metabolites({
+#    model.metabolites.get_by_id("BM1_e"): -1.0,
+#    model.metabolites.get_by_id("BM2_e"): -1.0})
+#
+#model.reactions.add(biom_com)
+
+
+model.objective = "B1_Biom1"
+solution = model.optimize()
+print(solution.fluxes['B1_Biom1'], solution.fluxes['B2_Biom2'], solution.objective_value)
+
+for r in model.reactions:
+    print(f"{r} -- {r.lower_bound} -- {r.upper_bound}")
+
+#######################################################################################################################################################
+
+
+import cobra 
+model=cobra.io.read_sbml_model("networks/toys_communities/communities/comex_2.sbml")
+
+for elem in model.boundary:
+    if not elem.reactants and elem.upper_bound > 0:
+        if elem.lower_bound > 0:
+            elem.lower_bound = 0
+        elem.upper_bound = 0.0
+    if not elem.products and elem.lower_bound < 0:
+        if elem.upper_bound < 0:
+            elem.upper_bound = 0
+        elem.lower_bound = 0.0
+
+model.reactions.EX_A.upper_bound = 0
+model.reactions.EX_B.upper_bound = 0
+model.reactions.EX_A.lower_bound = -1000
+model.reactions.EX_B.lower_bound = 0
+
+#same_flux = model.problem.Constraint(model.reactions.Biom1_B1.flux_expression - model.reactions.Biom2_B2.flux_expression, lb=0, ub=0)
+#model.add_cons_vars(same_flux)

seed2lp/utils.py

@@ -0,0 +1,237 @@
+"""Utilitaries"""
+import os
+import clyngor
+import re
+from re import findall
+from . import logger
+from csv import reader
+
+
+def solve(*args, **kwargs):
+    "Wrapper around clyngor.solve"
+    kwargs.setdefault('use_clingo_module', False)
+    try:
+        return clyngor.solve(*args, **kwargs)
+    except FileNotFoundError as err:
+        if 'clingo' in err.filename:
+            logger.log.error('Binary file clingo is not accessible in the PATH.')
+            exit(1)
+        else:  raise err
+
+
+def get_ids_from_file(fname:str, asp_atome_type:str=None) -> [str]:
+    """Get metabolites id from seeds file, forbidden seeds file or possible seeds file
+
+    Args:
+        fname (str): file path
+        asp_atome_type (str, optional): Type of atome for facts. Defaults to None.
+
+    Raises:
+        NotImplementedError: Target file of extension [ext] not implemented
+
+    Returns:
+        [str]: List of metabolite
+    """
+    "Yield identifiers of seeds/targets/metabolites found in given sbml or text or lp file"
+    metabolit_list = list()
+    ext = os.path.splitext(fname)[1]
+    #if ext in {'.sbml', '.xml'}:  # sbml data
+    #    from .sbml import read_SBML_species
+    #    yield from read_SBML_species(fname)
+    if ext in {'.lp'}:  # ASP data
+        for model in solve(fname).by_arity:
+            for line, in model.get(f'{asp_atome_type}/1', ()):
+                line = unquoted(line)
+                if re.search("^M_*",line):
+                    metabolit_list.append(line) 
+                else:
+                    metabolit_list.append(f'M_{line}') 
+    elif ext in {'.txt', ''}:  # file, one line per metabolite
+        with open(fname) as fd:
+            for line in map(str.strip, fd):
+                if line:
+                    if re.search("^M_*",line):
+                        metabolit_list.append(line) 
+                    else:
+                        metabolit_list.append(f'M_{line}') 
+    else:
+        raise NotImplementedError(f"Target file of ext {ext}: {fname}")
+    return metabolit_list
+    
+    
+def get_targets_from_file(fname:str, is_community:bool):
+    """Get metabolites id or reactions id from target file
+
+    Args:
+        fname (str): Target file path
+        is_community (bool): Community mode
+
+    Raises:
+        ValueError: The element [element] misses prefix M_ or R_"
+        NotImplementedError: The [file name] extension has to be ".txt". 
+        ValueError: Multiple objective reaction found
+
+    Returns:
+        [str],[str]: List of target and list of objective reaction
+    """
+    target_list=dict()
+    objective_reaction_list = list()
+    ext = os.path.splitext(fname)[1]
+    if ext in {'.txt',  ".csv",''}:  # file, one line per metabolite
+        # file = open(fname)
+        # tgts = reader(file, delimiter='\t')
+        with open(fname, "r") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue  # ignore empty line
+                data = re.split(r"[ \t]+", line)
+
+                obj_id=data[0]
+                if is_community:
+                    if len(data)==2:
+                        species=data[1]
+                    else:
+                        raise ValueError(f"invalid data, needs 2 elements (metabolite or reaction / species):\n {line}")
+                else:
+                    if len(data)==1:
+                        species=""
+                    else:
+                        raise ValueError(f"invalid data, needs 1 element (metabolite or reaction):\n {line}")
+
+                if re.search("^M_*",line):
+                    prefixed_id=prefix_id_network(is_community, obj_id, species, "metabolite")
+                    if obj_id in target_list:
+                        target_list[obj_id].append(prefixed_id)
+                    else:
+                        target_list[obj_id]=[prefixed_id]
+                    #target_list.append(line)
+                elif re.search("^R_*",line):
+                    objective_reaction_list.append([species, obj_id])
+                else:
+                    raise ValueError(f"\n{fname} : The element {line} misses prefix M_ or R_")
+    else:
+        raise NotImplementedError(f'\nThe {fname} extension has to be ".txt". Given: {ext}')
+    
+    if len(objective_reaction_list) >1 and not is_community:
+        raise ValueError(f"\nMultiple objective reaction found in {fname}\n")
+    elif is_community:
+        no_duplicates = len({x[0] for x in objective_reaction_list}) == len(objective_reaction_list)
+        if not no_duplicates:
+            raise ValueError(f"\nMultiple objective reaction found in {fname} for same species\n")
+
+
+    
+    return target_list, objective_reaction_list
+
+
+def quoted(string:str) -> str:
+    r"""Return string, double quoted
+
+    >>> quoted('"a').replace('\\', '$')
+    '"$"a"'
+    >>> quoted('"a b"').replace('\\', '$')
+    '"a b"'
+    >>> quoted('a b').replace('\\', '$')
+    '"a b"'
+    >>> quoted('a\\"').replace('\\', '$')
+    '"a$""'
+    >>> quoted('a"').replace('\\', '$')
+    '"a$""'
+    >>> quoted('\\"a"').replace('\\', '$')
+    '"$"a$""'
+    >>> quoted('"').replace('\\', '$')
+    '"$""'
+
+    """
+    if len(string) > 1 and string[0] == '"' and string[-2] != '\\' and string[-1] == '"':
+        return string
+    else:
+        return '"' + string.replace('\\"', '"').replace('"', '\\"') + '"'
+
+
+def unquoted(string:str) -> str:
+    r"""Remove surrounding double quotes if they are acting as such
+
+    >>> unquoted('"a').replace('\\', '$')
+    '$"a'
+    >>> unquoted('"a b"')
+    'a b'
+    >>> unquoted('b"').replace('\\', '$')
+    'b$"'
+    >>> unquoted('"b\\"').replace('\\', '$')
+    '$"b$"'
+
+    """
+    if string[0] == '"' and string[-2] != '\\' and string[-1] == '"':
+        return string[1:-1]
+    else:
+        return string.replace('\\"', '"').replace('"', '\\"')
+
+
+def quoted_data(asp:str) -> str:
+    "Return the same atoms as found in given asp code, but with all arguments quoted"
+    def gen():
+        for model in clyngor.solve(inline=asp):
+            for pred, args in model:
+                yield f'{pred}(' + ','.join(quoted(str(arg)) for arg in args) + ').'
+    return ' '.join(gen())
+
+
+def repair_json(json_str:str, is_clingo_lpx:bool=False):
+    """Function to add closing ] or } to the json after the process has been killed
+    delete also the last element of the json which can be not finished
+
+    Args:
+        proc_output (str): process output
+
+    Returns:
+        str: complete output on json format
+    """
+    close = {'{': '}', 
+             '[': ']'}
+    if is_clingo_lpx:
+        output = json_str.rsplit('{', 1)[0]
+        output = output.rsplit(',', 1)[0]
+    else:
+        output = json_str.rsplit('\"model', 1)[0]
+    # get the list of caracter "{" "[" "]" "}" in the order of apparition 
+    list_open_close=findall("{|\[|\]|}", output)
+    missing_list=list()
+    for car in list_open_close:
+        size=len(missing_list)
+        # delete the opening element when the closing element  appear right after
+        if size!= 0 and ((missing_list[size -1] == "{" and car == "}") 
+            or (missing_list[size -1] == "[" and car == "]")):
+            missing_list.pop(size -1)
+        else:
+            missing_list.append(car)
+    close_str=""
+    for i, open in reversed(list(enumerate(missing_list))):
+        close_str += "\n" + i * "\t" + close[open]
+    logger.log.warning("Output not totally recovered. Json has been repaired but might miss results")
+    return output+close_str
+
+def prefix_id_network(is_community:bool, name:str, species:str="", type_element:str=""):
+        """Prefix Reaction or Metbolite by the network name (filename) if the tool is used for community.
+        For single network, nothing is prefixed.
+
+        Args:
+            name (str): ID of the element
+            species (str, optional): Network name (from filename). Defaults to "".
+            type_element: (str, optional): "reaction" or "metabolite" or no type. Defaults to "".
+
+        Returns:
+            str: The name prfixed by the network if needed
+        """
+        match is_community, type_element:
+            case True,"reaction":
+                return re.sub("^R_", f"R_{species}_",name)
+            case True,"metabolite":
+                return re.sub("^M_", f"M_{species}_",name)
+            case True,"metaid":
+                return re.sub("^meta_R_", f"meta_R_{species}_",name)
+            case True,_:
+                return f"{species}_{name}"
+            case _,_:
+                return name