def get_optimal_completions(draft, repairnet, seeds, targets, optimum, nmodels=0):
instance = TermSet(draft.union(repairnet).union(targets).union(seeds))
ireactions = compute_ireactions(instance)
instance = TermSet(instance.union(ireactions))
instance_f = utils.to_file(instance)
prg = [minimal_completion_prg, instance_f]
options = '--configuration=handy --opt-strategy=usc,0 --opt-mode=optN,{0}'.format(
optimum)
models = clyngor.solve(prg, options=options,
nb_model=nmodels).by_arity.discard_quotes
opt_models = clyngor.opt_models_from_clyngor_answers(models)
return opt_models
def get_union_of_optimal_completions(draft, repairnet, seeds, targets, optimum):
instance = TermSet(draft.union(repairnet).union(targets).union(seeds))
ireactions = compute_ireactions(instance)
instance = TermSet(instance.union(ireactions))
instance_f = utils.to_file(instance)
prg = [minimal_completion_prg, instance_f]
options = '--configuration jumpy --opt-strategy=usc,5 --enum-mode=brave --opt-mode=optN,' + \
str(optimum)
models = clyngor.solve(prg, options=options)
for model in models.discard_quotes.by_arity:
best_model = model
os.unlink(instance_f)
return best_model
def get_intersection_of_completions(draft, repairnet, seeds, targets):
instance = TermSet(draft.union(repairnet).union(targets).union(seeds))
ireactions = compute_ireactions(instance)
instance = TermSet(instance.union(ireactions))
instance_f = utils.to_file(instance)
prg = [completion_prg, instance_f]
options = '--enum-mode=cautious --opt-mode=ignore '
best_model = None
models = clyngor.solve(prg, options=options)
for model in models.discard_quotes.by_arity:
best_model = model
os.unlink(instance_f)
return best_model
def get_minimal_completion_size(draft, repairnet, seeds, targets):
instance = TermSet(draft.union(repairnet).union(targets).union(seeds))
ireactions = compute_ireactions(instance)
instance = TermSet(instance.union(ireactions))
instance_f = utils.to_file(instance)
prg = [minimal_completion_prg, instance_f]
co = "--configuration=jumpy --opt-strategy=usc,5"
optimum = None
models = clyngor.solve(prg, options=co)
for model in models.discard_quotes.by_arity:
optimum = model
os.unlink(instance_f)
return optimum
def run_meneco(draft_sbml, seeds_sbml, targets_sbml, repair_sbml, enumeration):
"""Complete metabolic network by selecting reactions from a database
Args:
draft_sbml (str): SBML file name of metabolic network
seeds_sbml (str): SBML file name seeds
targets_sbml (str): SBML file name of targets
repair_sbml (str): SBML file name of repair database
"""
logger.info('Reading draft network from ' + draft_sbml)
draftnet = sbml.readSBMLnetwork(draft_sbml, 'draft')
# draftnet.to_file("draftnet.lp")
logger.info('Reading seeds from ' + seeds_sbml)
seeds = sbml.readSBMLseeds(seeds_sbml)
# seeds.to_file("seeds.lp")
logger.info('Reading targets from ' + targets_sbml)
targets = sbml.readSBMLtargets(targets_sbml)
# targets.to_file("targets.lp")
logger.info('\nChecking draftnet for unproducible targets')
model = query.get_unproducible(draftnet, targets, seeds)
sys.stdout.flush()
unproducible_targets_lst = extract_unprod_traget(model)
logger.info(str(len(unproducible_targets_lst)) + ' unproducible targets:')
logger.info("\n".join(unproducible_targets_lst))
if repair_sbml == None:
return (unproducible_targets_lst)
logger.info('\nReading repair network from ' + repair_sbml)
repairnet = sbml.readSBMLnetwork(repair_sbml, 'repairnet')
# repairnet.to_file("repairnet.lp")
sys.stdout.flush()
logger.info('done')
all_reactions = draftnet
all_reactions = TermSet(all_reactions.union(repairnet))
logger.info('\nChecking draftnet + repairnet for unproducible targets')
model = query.get_unproducible(all_reactions, seeds, targets)
unproducible_targets = extract_unprod_traget(model)
logger.info(' still ' + str(len(unproducible_targets)) +
' unproducible targets:')
logger.info("\n".join(unproducible_targets))
never_producible = extract_unprod_traget(model)
reconstructable_targets = set()
reconstructable_targets_atoms = TermSet()
for t in unproducible_targets_lst:
if not (t in never_producible):
reconstructable_targets.add(t)
reconstructable_targets_atoms.add(Atom('target(\"' + t + '\")'))
logger.info('\n ' + str(len(reconstructable_targets)) +
' targets to reconstruct:')
logger.info("\n".join(reconstructable_targets))
if len(reconstructable_targets) == 0:
utils.clean_up()
quit()
essential_reactions = TermSet()
essential_reactions_to_print = set()
essential_reactions_target = {}
for t in reconstructable_targets:
single_target = TermSet()
single_target.add(Atom('target(\"' + t + '\")'))
logger.info('\nComputing essential reactions for ' + t)
essentials = query.get_intersection_of_completions(
draftnet, repairnet, seeds, single_target)
essentials_to_print, essentials_atoms = extract_xreactions(
essentials, True)
essential_reactions_target[t] = essentials_to_print
logger.info(' ' + str(len(essentials_to_print)) +
' essential reactions found:')
logger.info("\n".join(essentials_to_print))
essential_reactions = TermSet(
essential_reactions.union(essentials_atoms))
essential_reactions_to_print = set(
essential_reactions_to_print.union(essentials_to_print))
logger.info('\nOverall ' + str(len(essential_reactions_to_print)) +
' essential reactions found.')
logger.info("\n".join(essential_reactions_to_print))
logger.info('\nAdding essential reactions to network.')
draftnet = TermSet(draftnet.union(essential_reactions))
utils.clean_up()
# draftnet.to_file("draft.lp")
# repairnet.to_file("repairnet.lp")
# unproducible_targets.to_file("targets.lp")
# seeds.to_file("seeds.lp")
logger.info('\nComputing one minimal completion to produce all targets')
one_min_sol = query.get_minimal_completion_size(
draftnet, repairnet, seeds, reconstructable_targets_atoms)
one_min_sol_lst = extract_xreactions(one_min_sol, False)
optimum = len(one_min_sol_lst)
logger.info("\n".join(one_min_sol_lst))
logger.info('\nComputing common reactions in all completion with size ' +
str(optimum))
intersection_sol = query.get_intersection_of_optimal_completions(
draftnet, repairnet, seeds, reconstructable_targets_atoms, optimum)
intersection_sol_lst = extract_xreactions(intersection_sol, False)
logger.info("\n".join(intersection_sol_lst))
logger.info(
'\nComputing union of reactions from all completion with size ' +
str(optimum))
union_sol = query.get_union_of_optimal_completions(
draftnet, repairnet, seeds, reconstructable_targets_atoms, optimum)
union_sol_lst = extract_xreactions(union_sol, False)
logger.info("\n".join(union_sol_lst))
if enumeration:
logger.info('\nComputing all completions with size ' + str(optimum))
enumeration_sol = query.get_optimal_completions(
draftnet, repairnet, seeds, reconstructable_targets_atoms, optimum)
count = 1
enumeration_sol_lst = []
for model in enumeration_sol:
logger.info('Completion ' + str(count) + ': ')
count += 1
model_lst = extract_xreactions(model, False)
enumeration_sol_lst.append(model_lst)
logger.info("\n".join(model_lst))
#TODO provide clean lists, not list version of terms in what is returned
else:
enumeration_sol_lst = []
return unproducible_targets_lst, reconstructable_targets, essential_reactions_target, one_min_sol_lst, intersection_sol_lst, union_sol_lst, enumeration_sol_lst
def run_meneco(draftnet: str, seeds: str, targets: str, repairnet: str,
enumeration: bool, json: bool):
"""Complete metabolic network by selecting reactions from a database
Args:
draftnet: SBML file name of metabolic network
seeds: SBML file name seeds
targets: SBML file name of targets
repairnet: SBML file name of repair database
"""
result = {}
logger.info('Reading draft network ...')
result['Draft network file'] = draftnet
if not json:
print('Draft network file: {0}'.format(draftnet))
draftnet = sbml.readSBMLnetwork(draftnet, 'draft')
# draftnet.to_file("draftnet.lp")
logger.info('Reading seeds ...')
result['Seeds file'] = seeds
if not json:
print('Seeds file: {0}'.format(seeds))
seeds = sbml.readSBMLseeds(seeds)
# seeds.to_file("seeds.lp")
logger.info('Reading targets ...')
result['Targets file'] = targets
if not json:
print('Targets file: {0}\n'.format(targets))
targets = sbml.readSBMLtargets(targets)
# targets.to_file("targets.lp")
logger.info('Checking draftnet for unproducible targets')
model = query.get_unproducible(draftnet, seeds, targets)
unproducible_targets_lst = extract_unprod_target(model)
result['Unproducible targets'] = list(unproducible_targets_lst)
if not json:
print('{0} unproducible targets:\n\t{1}\n'.format(
len(unproducible_targets_lst),
'\n\t'.join(unproducible_targets_lst)))
if len(unproducible_targets_lst) == 0:
utils.clean_up()
return result
if repairnet == None:
utils.clean_up()
return result
logger.info('Reading repair db ...')
result['Repair db file'] = repairnet
if not json:
print('Repair db file: {0}\n'.format(repairnet))
repairnet = sbml.readSBMLnetwork(repairnet, 'repairnet')
# repairnet.to_file("repairnet.lp")
all_reactions = draftnet
all_reactions = TermSet(all_reactions.union(repairnet))
logger.info('Checking draftnet + repairnet for unproducible targets')
model = query.get_unproducible(all_reactions, seeds, targets)
never_producible = extract_unprod_target(model)
result['Unreconstructable targets'] = list(never_producible)
if not json:
print('Still {0} unreconstructable targets:\n\t{1}\n'.format(
len(never_producible), '\n\t'.join(never_producible)))
reconstructable_targets = set()
reconstructable_targets_atoms = TermSet()
for t in unproducible_targets_lst:
if not (t in never_producible):
reconstructable_targets.add(t)
reconstructable_targets_atoms.add(Atom('target("' + t + '")'))
result['Reconstructable targets'] = list(reconstructable_targets)
if not json:
print('{0} reconstructable targets:\n\t{1}\n'.format(
len(reconstructable_targets),
'\n\t'.join(reconstructable_targets)))
if len(reconstructable_targets) == 0:
utils.clean_up()
return result
essential_reactions = TermSet()
essential_reactions_to_print = set()
essential_reactions_target = {}
for t in reconstructable_targets:
single_target = TermSet()
single_target.add(Atom('target("' + t + '")'))
logger.info('Computing essential reactions for ' + t)
essentials = query.get_intersection_of_completions(
draftnet, repairnet, seeds, single_target)
essentials_to_print, essentials_atoms = extract_xreactions(
essentials, True)
essential_reactions_target[t] = list(essentials_to_print)
if not json:
print('{0} essential reactions for target {1}:\n\t{2}\n'.format(
len(essentials_to_print), t, '\n\t'.join(essentials_to_print)))
essential_reactions = TermSet(
essential_reactions.union(essentials_atoms))
essential_reactions_to_print = set(
essential_reactions_to_print.union(essentials_to_print))
result['Essential reactions'] = essential_reactions_target
if not json:
print('Overall {0} essential reactions found:\n\t{1}\n'.format(
len(essential_reactions_to_print),
'\n\t'.join(essential_reactions_to_print)))
logger.info('Adding essential reactions to network')
draftnet = TermSet(draftnet.union(essential_reactions))
utils.clean_up()
# draftnet.to_file("draft.lp")
# repairnet.to_file("repairnet.lp")
# unproducible_targets.to_file("targets.lp")
# seeds.to_file("seeds.lp")
logger.info('Computing one minimal completion to produce all targets')
one_min_sol = query.get_minimal_completion_size(
draftnet, repairnet, seeds, reconstructable_targets_atoms)
one_min_sol_lst = extract_xreactions(one_min_sol, False)
optimum = len(one_min_sol_lst)
result['One minimal completion'] = list(one_min_sol_lst)
if not json:
print('One minimal completion of size {0}:\n\t{1}\n'.format(
len(one_min_sol_lst), '\n\t'.join(one_min_sol_lst)))
logger.info(
'Computing common reactions in all completion with size {0}'.format(
optimum))
intersection_sol = query.get_intersection_of_optimal_completions(
draftnet, repairnet, seeds, reconstructable_targets_atoms, optimum)
intersection_sol_lst = extract_xreactions(intersection_sol, False)
result['Intersection of cardinality minimal completions'] = list(
intersection_sol_lst)
if not json:
print(
'Intersection of cardinality minimal completions:\n\t{0}\n'.format(
'\n\t'.join(intersection_sol_lst)))
logger.info(
'Computing union of reactions from all completion with size {0}'.
format(optimum))
union_sol = query.get_union_of_optimal_completions(
draftnet, repairnet, seeds, reconstructable_targets_atoms, optimum)
union_sol_lst = extract_xreactions(union_sol, False)
result['Union of cardinality minimal completions'] = list(union_sol_lst)
if not json:
print('Union of cardinality minimal completions:\n\t{0}\n'.format(
'\n\t'.join(union_sol_lst)))
if enumeration:
logger.info('Computing all completions with size {0}'.format(optimum))
enumeration_sol = query.get_optimal_completions(
draftnet, repairnet, seeds, reconstructable_targets_atoms, optimum)
count = 1
enumeration_sol_lst = []
for model in enumeration_sol:
model_lst = extract_xreactions(model, False)
enumeration_sol_lst.append(list(model_lst))
if not json:
print('Completion {0}:\n\t{1}\n'.format(
count, '\n\t'.join(model_lst)))
count += 1
result['All cardinality minimal completions'] = enumeration_sol_lst
return result
