def latexify_file(filename, arguments):
""" Converts a file containing Bio-PEPA source into a file containing
LaTeX source to format the same model.
"""
model_file = open(filename, "r")
parse_result = biopepa_parser.parse_model_file_exit_on_error(model_file)
model_file.close()
biopepa_model = parse_result
out_filename = utils.get_output_filename(filename, arguments, ".tex")
if out_filename == "stdout":
translate_biopepa_model(biopepa_model, sys.stdout)
else:
out_file = open(out_filename, "w")
translate_biopepa_model(biopepa_model, out_file)
out_file.close()
def output_to_sbml_file(filename, arguments, document):
"""A utility function for consumers of this module to calculate
the output file for given a set of parsed arguments which includes
the possible argument "--output-file". We then output the given
document to that file. This is basically a suitable place to put
this functionality that is common to nearly all x_to_sbml translators
that we have.
Note that the first argument is the filename of the file from which
we have translated into sbml and not the sbml filename itself.
"""
sbml_filename = utils.get_output_filename(filename, arguments, ".sbml")
if sbml_filename == "stdout":
sbml_file = sys.stdout
else:
sbml_file = open(sbml_filename, "w")
output_to_file(sbml_file, document)
if sbml_filename != "stdout":
sbml_file.close()
def run(arguments_parser, get_new_timecourse, needs_arguments):
"""
The shell of the main method, essentially does all the busy work
and accepts a function which will given a read-in timecourse,
return a new timecourse.
"""
arguments = arguments_parser.parse_args()
if len(arguments.filenames) < 1:
print ("Must provide at least one timeseries to add noise to")
sys.exit(1)
# We should do all this, once for each timecourse file.
timecourse_file = arguments.filenames[0]
timecourse = timeseries.get_timecourse_from_file(timecourse_file)
all_names = timecourse.get_column_names()
used_names = utils.get_non_ignored(all_names,
arguments.column,
arguments.mcolumn)
for name in all_names:
if name not in used_names:
timecourse.remove_column(name)
if needs_arguments:
new_timecourse = get_new_timecourse(arguments, timecourse)
else:
new_timecourse = get_new_timecourse(timecourse)
output_filename = utils.get_output_filename(timecourse_file, arguments,
"_modified.csv")
if output_filename == "stdout":
output_file = sys.stdout
else:
output_file = open(output_filename, "w")
# Write the new time course to the file
new_timecourse.write_to_file(output_file)
if output_filename != "stdout":
output_file.close()
def process_file(filename, arguments):
"""Parse in a Bio-PEPA file and convert to an equivalent Bio-PEPA
file that is flattened in the sense that it uses no compartments
and hence no compartment-related rules.
"""
model_file = open(filename, "r")
parse_result = biopepa_parser.parse_model_file_exit_on_error(model_file)
model_file.close()
output_filename = utils.get_output_filename(filename, arguments,
"_flattened.biopepa")
if output_filename != "stdout":
output_file = open(output_filename, "w")
else:
output_file = sys.stdout
flatten_model(parse_result)
parse_result.output_model(output_file)
if output_filename != "stdout":
output_file.close()
def convert(source, target, models):
# Load the versions graph which has information about possible conversions.
versions_graph = Graph()
directory = dirname(sys.argv[0]) or "."
versions_graph.parse(directory + "/conversions/versions.ttl",
format="turtle")
versions_graph.bind("version",
Namespace("https://brickschema.org/version#"))
# Ask if the conversion is possible
job = versions_graph.query("""ASK{
"%s" version:convertsTo+ "%s"
}""" % (source, target))
# If yes, find the shortest path and convert
for doable in job:
if doable:
print("Conversion available!\n=====================")
# Find the conversions to update the model in minimum number of version upgrades
conversions = find_conversions(source, target, versions_graph)
# Loop through all the input models
for model in models:
print("\n\nUpdating {}...".format(model))
standardize_namespaces(model)
# Execute all conversions
for conversion in conversions:
model_graph = Graph()
model_graph.parse(model, format="turtle")
print("Converting to {}...".format(conversion[1]))
execute_conversions(conversion, model_graph)
output = get_output_filename(model, conversion[1])
model_graph.serialize(output, format="turtle")
print("Output stored: {}".format(output))
else:
print("No conversions available from {} to {}.".format(
source, target))
