def test_biolink_shexeval(self) -> None: base_dir = os.path.abspath( os.path.join(os.path.dirname(__file__), '..', 'data')) g = CFGraph() g.load(os.path.join(base_dir, 'validation', 'biolink-model.ttl'), format="turtle") evaluator = ShExEvaluator( g, os.path.join(base_dir, 'schemas', 'meta.shex'), "https://biolink.github.io/biolink-model/ontology/biolink.ttl", "http://bioentity.io/vocab/SchemaDefinition") result = evaluator.evaluate(debug=False) for rslt in result: if not rslt.result: print(f"Error: {rslt.reason}") self.assertTrue(all(r.result for r in result))
def shextest(self, rdf_file: str, shex_file: str, focus: str, cfgraph: bool = False) -> None: base_dir = os.path.abspath( os.path.join(os.path.dirname(__file__), '..')) g = CFGraph() if cfgraph else Graph() g.load(os.path.join(base_dir, 'rdf', rdf_file), format="turtle") evaluator = ShExEvaluator( g, os.path.join(base_dir, 'shex', shex_file), focus, "http://w3id.org/biolink/vocab/SchemaDefinition") result = evaluator.evaluate(debug=False) for rslt in result: if not rslt.result: print(f"Error: {rslt.reason}") self.assertTrue(all(r.result for r in result))
def evaluate_cli(argv: Optional[Union[str, List[str]]] = None, prog: Optional[str] = None) -> int: if isinstance(argv, str): argv = argv.split() opts = genargs(prog).parse_args(argv if argv is not None else sys.argv[1:]) if opts.sparql or opts.gdbslurper: opts.slurper = True if opts.slurper and opts.flattener: print("Error: Cannot combine slurper and flattener graphs", file=sys.stderr) return 2 if not opts.sparql and not opts.slurper and \ (opts.printsparql or opts.printsparqlresults or opts.graphname is not None or opts.persistbnodes): print( "Error: printsparql, pringsparqlresults, graphname and persistbnodes are SPARQL only", file=sys.stderr) if not opts.format: opts.format = guess_format(opts.rdf) if not opts.format: print( 'Error: Cannot determine RDF format from file name - use "--format" option', file=sys.stderr) return 3 if opts.slurper or opts.gdbslurper: g = SlurpyGraphWithAgent(opts.rdf, agent=opts.useragent, gdb_slurper=opts.gdbslurper) if opts.printsparql: g.debug_slurps = True if opts.printsparqlresults: g.debug_slurps = True g.add_result_hook(QueryResultPrinter) if opts.graphname is not None: g.graph_name = opts.graphname if opts.persistbnodes: g.persistent_bnodes = True else: g = CFGraph() if opts.flattener else Graph() if '\n' in opts.rdf or '\r' in opts.rdf: g.parse(data=opts.rdf, format=opts.format) else: g.load(opts.rdf, format=opts.format) if not (opts.focus or opts.allsubjects or opts.sparql): print( 'Error: You must specify one or more graph focus nodes, supply a SPARQL query, or use the "-A" option', file=sys.stderr) return 4 start = [] if opts.start: start.append(opts.start) if opts.usetype: start.append(START_TYPE(RDF.type)) if opts.startpredicate: start.append(START_TYPE(opts.startpredicate)) if not start: start.append(START) if opts.sparql: # TODO: switch to a generator idiom all the way through if opts.focus is None: opts.focus = [] elif not isinstance(opts.focus, list): opts.focus = [opts.focus] opts.focus += list( SPARQLQuery(opts.rdf, opts.sparql, print_query=opts.printsparql, print_results=opts.printsparqlresults, user_agent=opts.useragent).focus_nodes()) def result_sink(rslt: EvaluationResult) -> bool: if not rslt.result: if evaluator.nerrors == 1: print("Errors:") else: print() print( f" Focus: {rslt.focus}\n Start: {rslt.start}\n Reason: {str(rslt.reason)}" ) return not opts.stoponerror and (not opts.stopafter or evaluator.nnodes < opts.stopafter) return not opts.stopafter or evaluator.nnodes < opts.stopafter evaluator = ShExEvaluator(g, opts.shex, opts.focus, start, rdf_format=opts.format, debug=opts.debug, output_sink=result_sink) evaluator.evaluate() return 1 if evaluator.nerrors else 0
def test_subjects(self): g = CFGraph() g.add((EX.foo, RDF.type, Literal("samsonite"))) g.add((EX.foo, EX.carries, EX.dogs)) self.assertEqual(2, len(list(g.subjects())))
def build_graph() -> CFGraph: g = CFGraph() g.parse(data=rdf, format='turtle') return g
def test_notebook(self): rdf = f'<{s1}> <{p1}> ("a" "b" "c" "d" "e" <{o1}> "b").' g = CFGraph() g.parse(data=rdf, format="turtle") self.assertEqual([(s1, p1)], sorted(g.subject_predicates(o1))) self.assertEqual([s1], sorted(g.subjects(p1, o1)))