def produce_tables(version="sbol_2", lib_paths=None):
'''
Method that is independant from the rdf/xml production, simply runs the parsing and evaluation
process on the templates to produce the symbols and template tables.
This process is just the parse_from file method and returns the tables.
'''
if lib_paths is None:
optpaths = [os.path.join(os.getcwd(), "templates")]
else:
optpaths = [lib_paths]
to_run_fn = os.path.join(optpaths[0], "temp.shb")
f = open(to_run_fn, "a")
f.write("use <" + version + ">")
f.close()
parser = Parser(filename=to_run_fn, debug_lvl=1)
with open(to_run_fn, 'r') as in_file:
data = in_file.read()
env = Env(filename=to_run_fn,
serializer="sbolxml",
paths=optpaths,
version=version)
forms = parser.parse(data)
forms = pre_process(forms, version)
env.interpret(forms)
prefixes = [prefix for prefix in env._rdf._g.namespaces()]
os.remove(to_run_fn)
return env._symbol_table, env._template_table, prefixes
def setUp(self):
self.env = Env()
self.v_uri = Uri('http://test.triplepack/#variable')
self.env.assign(self.v_uri, Value(42))
self.template = Template(Name('A'), [Name('x'), Name('y')], [
Property(Name('x'), Value(42)),
Property(Uri('http://example.eg/predicate'), Name('y'))
])
self.expansion = Expansion(Name('e'), Name('A'),
[Value(1), Value(2)], [])
self.template.evaluate(self.env)
def triple_eval(triple):
(s, p, o) = triple
s = s.evaluate(self.env)
p = p.evaluate(self.env)
o = o.evaluate(self.env)
return (s, p, o)
triples = self.expansion.as_triples(self.env)
triples = [triple_eval(triple) for triple in triples]
bindings = self.env._symbol_table
templates = self.env._template_table
self.pack = TriplePack(triples, bindings, templates, [])
def test_importer_test_files(self):
env = Env(paths=["test/test_files/"])
parser = RDFScriptParser()
with open("test/test_files/top.shb", 'r') as f:
script = f.read()
try:
result = parser.parse(script)
env.interpret(result)
except FileNotFoundError as e:
self.fail(e)
self.assertEqual(len(result), 5)
def setUp(self):
self.env = Env()
self.parser = Parser()
self.vuri = self.parser.parse(
'<http://test.triplepack/#variable>')[0].parts[0]
self.env.assign(self.vuri, Value(42))
self.template = self.parser.parse(
('A(x, y)(x = 42 '
'<http://example.eg/predicate> = y)'))[0]
self.expansion = self.parser.parse('e is a A(1, 2)')[0]
self.template.evaluate(self.env)
triples = self.expansion.as_triples(self.env)
triples = [triple_eval(triple, self.env) for triple in triples]
bindings = self.env._symbol_table
templates = self.env._template_table
self.pack = TriplePack(triples, bindings, templates, self.env._paths)
def setUp(self):
self.env = Env()
def setUp(self):
self.env = Env()
self.parser = Parser()
def setUp(self):
self.env = Env()
self.parser = Parser()
self.maxDiff = None
def parse_from_file(filepath,
serializer='sbolxml',
optpaths=[],
out=None,
extensions=[],
debug_lvl=1,
version="sbol_2",
no_validation=None):
if version == "sbol_3" and serializer == "sbolxml":
serializer = "rdfxml"
if len(optpaths) == 0:
optpaths.append("templates")
parser = Parser(filename=filepath, debug_lvl=debug_lvl)
with open(filepath, 'r', encoding="utf8") as in_file:
data = in_file.read()
env = Env(filename=filepath,
serializer=serializer,
paths=optpaths,
extensions=extensions,
version=version)
forms = parser.parse(data)
forms = pre_process(forms, version)
env.interpret(forms)
sbol = str(env)
ret_code = ""
if not no_validation:
if version == "sbol_3":
ret_code = "No Validation Currently for SBOL3"
print(ret_code)
errors = []
else:
errors = []
response = validate_sbol(sbol)
try:
if response['valid']:
print('SBOL validator success.')
ret_code = "SBOL validator success."
else:
print("SBOL validator failure.")
for e in response['errors']:
print(e)
errors = response['errors']
ret_code = "SBOL validator failure."
except TypeError:
errors = ["Unable to Validate output."]
else:
ret_code = "No Validation."
errors = ["No Validation."]
if out is None:
print(sbol)
else:
with open(out, 'w') as o:
o.write(sbol)
return {ret_code: errors}
def setUp(self):
self.env = Env()
self.env.current_self = Uri('')
self.env.bind_prefix('p', Uri('prefix'))
self.env.prefix = 'p'
