def to_functional(self, w: Optional[FunctionalWriter] = None ) -> FunctionalWriter: """ Return a FunctionalWriter instance with the representation of the OntologyDocument in functional syntax """ w = w or FunctionalWriter() self.add_namespaces(w.g) return w.iter([Prefix(ns, uri) for ns, uri in w.g.namespaces()], indent=False).hardbr() +\ (self.ontology or Ontology())
def test_join_functional_outputs(self): class T1(FunOwlRoot): v: IRI def __init__(self, v: str) -> None: self.v = EX[v] def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w + self.v wt = FunctionalWriter() wt.bind('ex', EX) wt + "The values are:" T1("I1").to_functional(wt) T1("I2").to_functional(wt) T1("I3").to_functional(wt) self.assertEqual("The values are: ex:I1 ex:I2 ex:I3", wt.getvalue())
def to_functional(self, w: Optional[FunctionalWriter]) -> FunctionalWriter: """ Return a FunctionalWriter instance with the representation of the ontology in functional syntax """ if self.version and not self.iri: raise ValueError(f"Ontology cannot have a versionIRI ({self.version} without an ontologyIRI") w = w or FunctionalWriter() return w.func(self, lambda: w.opt(self.iri).opt(self.version). br(bool(self.directlyImportsDocuments) or bool(self.annotations) or bool(self.axioms)). iter(self.directlyImportsDocuments, indent=False).iter(self.annotations, indent=False). iter(self.axioms, indent=False), indent=False)
def annots(self, w: FunctionalWriter, f: Callable[[], FunctionalWriter]) -> FunctionalWriter: """ Emit the declaration of an annotatable function :param w: FunctionWriter :param f: function to generate post annotation function content :return: FUnctionWriter instance """ return w.func(self, lambda: self._add_annotations(w, f))
def _add_annotations( self, w: FunctionalWriter, f: Callable[[], FunctionalWriter] = None) -> FunctionalWriter: """ Emit annotations at the beginnng of a functional declaration. On entry, we've emitted "Func(" and need to emit zero or more " Annotation( ... )" entries - one for each annotation :param w: FunctionalWriter to append output to :param f: function to generate everything within "func" after the annotations :return: FunctionalWriter instance """ if self.annotations: w.br() w.iter(self.annotations, indent=False) w.br().indent() f() if self.annotations: w.outdent() return w
This is an example ontology that contains all constructs required for the various versions of the Pizza Tutorial run by Manchester University (see http://owl.cs.manchester.ac.uk/publications/talks-and-tutorials/protg-owl-tutorial).""", lang="en"))) pizza.axioms.append(SubObjectPropertyOf(PIZZA.hasBase, PIZZA.hasIngredient)) pizza.axioms.append(InverseObjectProperties(PIZZA.hasBase, PIZZA.isBaseOf)) pizza.axioms.append(FunctionalObjectProperty(PIZZA.hasBase)) pizza.axioms.append(InverseFunctionalObjectProperty(PIZZA.hasBase)) pizza.axioms.append(ObjectPropertyDomain(PIZZA.hasBase, PIZZA.Pizza)) pizza.axioms.append(ObjectPropertyRange(PIZZA.hasBase, PIZZA.PizzaBase)) print(pizza_doc.to_functional().getvalue()) #%% md ## Ontologies in functional format can be read from files or URL's #%% from funowl.converters.functional_converter import to_python from funowl.writers.FunctionalWriter import FunctionalWriter pizza_doc = to_python( "https://raw.githubusercontent.com/hsolbrig/funowl/master/tests/data/pizza.owl" ) w = FunctionalWriter(g=pizza_doc.add_namespaces(Graph())) for axiom in pizza_doc.ontology.axioms: if isinstance(axiom, SubClassOf) and str( axiom.subClassExpression) == 'pizza:AmericanHot': w.add(axiom) print(str(w))
def to_functional2(self, wr: FunctionalWriter) -> FunctionalWriter: return wr.hardbr().indent().iter(self.v).outdent()
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.func(self, lambda: w.br().indent().concat(self.instnum, ':', sep='').outdent().iter(self.foos))
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.func(self, lambda: w.iter(self.objectPropertyExpressions))
def setUp(self) -> None: self.sw = FunctionalWriter() self.sw.bind(None, SCT)
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: self.list_cardinality(self.dataPropertyExpressions, 'exprs', 2) return self.annots(w, lambda: w.iter(self.dataPropertyExpressions))
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: self.list_cardinality(self.dataRanges, 'dataRange', 2) return w.func(self, lambda: w.iter(self.dataRanges))
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.func(self, lambda: (w + self.datatype).iter(self.restrictions))
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.concat(self.literal, self.language)
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.func(self, lambda: w + self.dataRange)
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.concat(self.literal, '^^', self.datatype)
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.func(self, lambda: w.iter(self.literal))
class ClassAxiomsTestCase(TestBase): def setUp(self) -> None: self.sw = FunctionalWriter() self.sw.bind(None, SCT) def test_subclass_of(self): # print(SubClassOf(Annotation(RDFS.comment, "Just a test"), )) pass def test_equivalentclasses(self): self.assertEqual( """EquivalentClasses( <http://snomed.info/id/303394007> <http://snomed.info/id/45189000> <http://snomed.info/id/609096000> )""", str( EquivalentClasses(SCT['303394007'], SCT['45189000'], SCT['609096000']).to_functional(self.sw))) with self.assertRaises(ValueError, msg="at least 2 arguments are required"): str(EquivalentClasses(SCT['303394007']).to_functional(self.sw)) # Taken from SNOMED CT self.assertEqual( """EquivalentClasses( <http://snomed.info/id/303394007> ObjectIntersectionOf( <http://snomed.info/id/45189000> ObjectSomeValuesFrom( <http://snomed.info/id/609096000> ObjectIntersectionOf( ObjectSomeValuesFrom( <http://snomed.info/id/260686004> <http://snomed.info/id/129397003> ) ObjectSomeValuesFrom( <http://snomed.info/id/363700003> <http://snomed.info/id/52988006> ) ObjectSomeValuesFrom( <http://snomed.info/id/405813007> <http://snomed.info/id/69695003> ) ) ) ) )""", str( EquivalentClasses( SCT['303394007'], ObjectIntersectionOf( SCT['45189000'], ObjectSomeValuesFrom( SCT['609096000'], ObjectIntersectionOf( ObjectSomeValuesFrom(SCT['260686004'], SCT['129397003']), ObjectSomeValuesFrom(SCT['363700003'], SCT['52988006']), ObjectSomeValuesFrom( SCT['405813007'], SCT['69695003']))))).to_functional( self.sw.reset()))) def test_disjointclasses(self): self.assertEqual( """DisjointClasses( <http://snomed.info/id/303394007> <http://snomed.info/id/45189000> <http://snomed.info/id/609096000> )""", str( DisjointClasses(SCT['303394007'], SCT['45189000'], SCT['609096000']).to_functional(self.sw))) def test_disjointunion(self): self.assertEqual( """DisjointUnion( <http://snomed.info/id/12345> <http://snomed.info/id/303394007> <http://snomed.info/id/45189000> <http://snomed.info/id/609096000> )""", str( DisjointUnion(SCT['12345'], SCT['303394007'], SCT['45189000'], SCT['609096000']).to_functional( self.sw.reset()))) with self.assertRaises(ValueError, msg="Have to have at least 2 expressions"): DisjointUnion(SCT['12345'], SCT['303394007']).to_functional(self.sw) def test_haskey(self): self.assertEqual( '''HasKey( <http://snomed.info/id/12345> ( <http://snomed.info/id/23456> <http://snomed.info/id/23457> ) ( <http://snomed.info/id/23458> <http://snomed.info/id/23459> ) )''', str( HasKey(SCT['12345'], ObjectPropertyExpression(SCT['23456']), ObjectPropertyExpression(SCT['23457']), DataPropertyExpression(SCT['23458']), DataPropertyExpression(SCT['23459'])).to_functional( self.sw.reset())))
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.func(self, lambda: w.concat((self.prefixName or '') + ':', '=', URIRef(str(self.fullIRI)).n3(), sep=' '))
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: self.list_cardinality(self.objectPropertyExpressions, 'expressions', 2, 2) return w.func( self, lambda: w + self.objectPropertyExpressions[0] + self. objectPropertyExpressions[1])
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.iter(self.as_prefixes(), indent=False)
def to_functional(self, wr: FunctionalWriter) -> FunctionalWriter: return wr.iter(self.v1)
class ClassAxiomsTestCase(TestBase): def setUp(self) -> None: self.sw = FunctionalWriter() self.sw.bind(None, SCT) def test_equivalentclasses(self): self.assertEqual( """EquivalentClasses( :303394007 :45189000 :609096000 )""", str( EquivalentClasses(SCT['303394007'], SCT['45189000'], SCT['609096000']).to_functional(self.sw))) with self.assertRaises(ValueError, msg="at least 2 arguments are required"): str(EquivalentClasses(SCT['303394007']).to_functional(self.sw)) # Taken from SNOMED CT self.assertEqual( """EquivalentClasses( :303394007 ObjectIntersectionOf( :45189000 ObjectSomeValuesFrom( :609096000 ObjectIntersectionOf( ObjectSomeValuesFrom( :260686004 :129397003 ) ObjectSomeValuesFrom( :363700003 :52988006 ) ObjectSomeValuesFrom( :405813007 :69695003 ) ) ) ) )""", str( EquivalentClasses( SCT['303394007'], ObjectIntersectionOf( SCT['45189000'], ObjectSomeValuesFrom( SCT['609096000'], ObjectIntersectionOf( ObjectSomeValuesFrom(SCT['260686004'], SCT['129397003']), ObjectSomeValuesFrom(SCT['363700003'], SCT['52988006']), ObjectSomeValuesFrom( SCT['405813007'], SCT['69695003']))))).to_functional( self.sw.reset()))) def test_oio(self): """ Bug: ObjectIntersectionOf ends up being a single argument to ObjectSomeValuesOf """ self.assertEqual( """ObjectIntersectionOf( :45189000 ObjectSomeValuesFrom( :609096000 ObjectUnionOf( :1 :2 ) ) )""", str( ObjectIntersectionOf( SCT['45189000'], ObjectSomeValuesFrom(SCT['609096000'], ObjectUnionOf( SCT['1'], SCT['2']))).to_functional( self.sw.reset()))) def test_disjointclasses(self): self.assertEqual( """DisjointClasses( :303394007 :45189000 :609096000 )""", str( DisjointClasses(SCT['303394007'], SCT['45189000'], SCT['609096000']).to_functional(self.sw))) def test_disjointunion(self): self.assertEqual( """DisjointUnion( :12345 :303394007 :45189000 :609096000 )""", str( DisjointUnion(SCT['12345'], SCT['303394007'], SCT['45189000'], SCT['609096000']).to_functional( self.sw.reset()))) with self.assertRaises(ValueError, msg="Have to have at least 2 expressions"): DisjointUnion(SCT['12345'], SCT['303394007']).to_functional(self.sw) def test_haskey(self): self.assertEqual( '''HasKey( :12345 ( :23456 :23457 ) ( :23458 :23459 ) )''', str( HasKey(SCT['12345'], ObjectPropertyExpression(SCT['23456']), ObjectPropertyExpression(SCT['23457']), DataPropertyExpression(SCT['23458']), DataPropertyExpression(SCT['23459'])).to_functional( self.sw.reset())))
def to_functional(self, wr: FunctionalWriter) -> FunctionalWriter: return wr.iter(self.v, f=lambda e: wr.hardbr() + e)
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.func(self, lambda: w.func(self.v, lambda: self.v.to_functional(w), indent=False))
def setUpClass(cls) -> None: cls.w = FunctionalWriter() cls.wa = FunctionalWriter() cls.wa.bind('a', A)
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.concat(str(self), sep='')
def to_functional(self, w: FunctionalWriter) -> FunctionalWriter: return w.func(self, lambda: (w + self.iri))
def test_base_declaration(self): decl = Declaration(Class(PIZZA.American)) w = FunctionalWriter() self.assertEqual( "Declaration( Class( <http://www.co-ode.org/ontologies/pizza/pizza.owl#American> ) )", str(decl.to_functional(w)))