oldaplib 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

oldaplib/src/datamodel.py

@@ -4,7 +4,9 @@ from datetime import datetime
 from typing import Dict, List, Optional, Union, Any, Self
 
 from oldaplib.src.cachesingleton import CacheSingleton, CacheSingletonRedis
+from oldaplib.src.dtypes.namespaceiri import NamespaceIRI
 from oldaplib.src.enums.adminpermissions import AdminPermission
+from oldaplib.src.externalontology import ExternalOntology
 from oldaplib.src.helpers.context import Context
 from oldaplib.src.enums.action import Action
 from oldaplib.src.helpers.irincname import IriOrNCName
@@ -23,6 +25,10 @@ from oldaplib.src.propertyclass import PropertyClass
 from oldaplib.src.resourceclass import ResourceClass
 from oldaplib.src.xsd.xsd_qname import Xsd_QName
 
+@dataclass
+class ExternalOntologyChange:
+    old_value: ExternalOntology | None
+    action: Action
 
 @dataclass
 class ResourceClassChange:
@@ -71,8 +77,10 @@ class DataModel(Model):
     _project: Project
     __context: Context
     __version: SemanticVersion
+    __extontos: dict[Xsd_QName, ExternalOntology]
     __propclasses: dict[Xsd_QName, PropertyClass | None]
     __resclasses: dict[Xsd_QName, ResourceClass | None]
+    __extontos_changeset: dict[Xsd_QName, ExternalOntologyChange]
     __resclasses_changeset: dict[Xsd_QName, ResourceClassChange]
     __propclasses_changeset: dict[Xsd_QName, PropertyClassChange]
 
@@ -83,6 +91,7 @@ class DataModel(Model):
                  contributor: Iri | None = None,
                  modified: Xsd_dateTime | datetime | str | None = None,
                  project: Project | Iri | Xsd_NCName | str,
+                 extontos: list[ExternalOntology] | None = None,
                  propclasses: list[PropertyClass] | None = None,
                  resclasses: list[ResourceClass] | None = None,
                  validate: bool = False) -> None:
@@ -152,6 +161,10 @@ class DataModel(Model):
         self.__context.use(self._project.projectShortName)
         self.__graph = self._project.projectShortName
 
+        self.__extontos = {}
+        if extontos is not None:
+            for e in extontos:
+                self.__extontos[e.extonto_qname] = e
         self.__propclasses = {}
         if propclasses is not None:
             for p in propclasses:
@@ -160,12 +173,14 @@ class DataModel(Model):
         if resclasses is not None:
             for r in resclasses:
                 self.__resclasses[r.owl_class_iri] = r
+        self.__extontos_changeset = {}
         self.__propclasses_changeset = {}
         self.__resclasses_changeset = {}
 
     def _as_dict(self):
         return {x.fragment: y for x, y in self._attributes.items()} | super()._as_dict() | {
             'project': self._project.projectShortName,
+            **({'extontos': [x for x in self.__extontos.values()]} if self.__extontos else {}),
             **({'propclasses': [x for x in self.__propclasses.values()]} if self.__propclasses else {}),
             **({'resclasses': [x for x in self.__resclasses.values()]} if self.__resclasses else {}),
         }
@@ -213,13 +228,16 @@ class DataModel(Model):
         instance.__context = deepcopy(self.__context, memo)
         instance.__version = deepcopy(self.__version, memo)
         instance._project = deepcopy(self._project, memo)
+        instance.__extontos = deepcopy(self.__extontos, memo)
         instance.__propclasses = deepcopy(self.__propclasses, memo)
         instance.__resclasses = deepcopy(self.__resclasses, memo)
         instance.__resclasses_changeset = deepcopy(self.__resclasses_changeset, memo)
         instance.__propclasses_changeset = deepcopy(self.__propclasses_changeset, memo)
         return instance
 
-    def __getitem__(self, key: Xsd_QName) -> PropertyClass | ResourceClass:
+    def __getitem__(self, key: Xsd_QName) -> ExternalOntology | PropertyClass | ResourceClass:
+        if key in self.__extontos:
+            return self.__extontos[key]
         if key in self.__resclasses:
             return self.__resclasses[key]
         if key in self.__propclasses:
@@ -227,8 +245,14 @@ class DataModel(Model):
         else:
             raise KeyError(key)
 
-    def __setitem__(self, key: Xsd_QName, value: PropertyClass | ResourceClass) -> None:
-        if isinstance(value, PropertyClass):
+    def __setitem__(self, key: Xsd_QName, value: ExternalOntology | PropertyClass | ResourceClass) -> None:
+        if isinstance(value, ExternalOntology):
+            if self.__extontos.get(key) is None:
+                self.__extontos_changeset[key] = ExternalOntologyChange(None, Action.CREATE)
+            else:
+                raise OldapErrorAlreadyExists(f'The external ontology "{key}" already exists. It cannot be replaced. Update/delete it.')
+            self.__extontos[key] = value
+        elif isinstance(value, PropertyClass):
             if self.__propclasses.get(key) is None:
                 self.__propclasses_changeset[key] = PropertyClassChange(None, Action.CREATE)
             else:
@@ -246,7 +270,10 @@ class DataModel(Model):
     def __delitem__(self, key: Xsd_QName | str) -> None:
         if not isinstance(key, Xsd_QName):
             key = Xsd_QName(key, validate=True)
-        if key in self.__propclasses:
+        if key in self.__extontos:
+            self.__extontos_changeset[key] = ExternalOntologyChange(self.__extontos[key], Action.DELETE)
+            del self.__extontos[key]
+        elif key in self.__propclasses:
             self.__propclasses_changeset[key] = PropertyClassChange(self.__propclasses[key], Action.DELETE)
             del self.__propclasses[key]
         elif key in self.__resclasses:
@@ -255,7 +282,7 @@ class DataModel(Model):
         else:
             raise OldapErrorValue(f'"{key}" must be either PropertyClass or ResourceClass')
 
-    def get(self, key: Xsd_QName | str) -> PropertyClass | ResourceClass | None:
+    def get(self, key: Xsd_QName | str) -> ExternalOntology | PropertyClass | ResourceClass | None:
         """
         Retrieves an instance of `PropertyClass` or `ResourceClass` associated with the
         specified `key`. The `key` can be either an `Iri` instance or a string. If the
@@ -272,13 +299,27 @@ class DataModel(Model):
         """
         if not isinstance(key, Xsd_QName):
             key = Xsd_QName(key, validate=True)
-        if key in self.__propclasses:
+        if key in self.__extontos:
+            return self.__extontos[key]
+        elif key in self.__propclasses:
             return self.__propclasses[key]
         elif key in self.__resclasses:
             return self.__resclasses[key]
         else:
             return None
 
+    def get_extontos(self) -> list[Xsd_QName]:
+        """
+        Extract and return the list of extended ontologies.
+
+        This method retrieves the extended ontologies by iterating over an internal
+        attribute and returning the values.
+
+        :return: A list containing the extended ontologies.
+        :rtype: list[Xsd_QName]
+        """
+        return [x for x in self.__extontos]
+
     def get_propclasses(self) -> list[Xsd_QName]:
         """
         Get a list of the IRIs of the standalone property classes.
@@ -304,22 +345,43 @@ class DataModel(Model):
         return [x for x in self.__resclasses]
 
     @property
-    def changeset(self) -> dict[Xsd_QName, PropertyClassChange | ResourceClassChange]:
-        return self.__resclasses_changeset | self.__propclasses_changeset
+    def context(self) -> Context:
+        return self.__context
+
+    @property
+    def changeset(self) -> dict[Xsd_QName, ExternalOntologyChange | PropertyClassChange | ResourceClassChange]:
+        return self.__extontos_changeset | self.__resclasses_changeset | self.__propclasses_changeset
+
+    def clear_changeset(self) -> None:
+        """
+        Clears all recorded changes from the current changeset. The function iterates through
+        various internal tracking structures and resets or clears their state as needed. This
+        ensures that the current changeset reflects no modifications and all marked changes
+        are reverted or cleared.
 
-    def changeset_clear(self) -> None:
+        Raises:
+            No explicit errors are raised by this function
+
+        Returns:
+            None
+        """
+        for onto, change in self.__extontos_changeset.items():
+            if change.action == Action.MODIFY:
+                self.__extontos[onto].clear_changeset()
         for prop, change in self.__propclasses_changeset.items():
             if change.action == Action.MODIFY:
                 self.__propclasses[prop].clear_changeset()
         self.__propclasses_changeset = {}
         for res, change in self.__resclasses_changeset.items():
             if change.action == Action.MODIFY:
-                self.__resclasses[res].changeset_clear()
+                self.__resclasses[res].clear_changeset()
         self.__resclasses_changeset = {}
-        self.clear_changeset()
+        self._changeset = {}
 
     def notifier(self, what: Xsd_QName) -> None:
-        if what in self.__propclasses:
+        if what in self.__extontos:
+            self.__extontos_changeset[what] = ExternalOntologyChange(None, Action.MODIFY)
+        elif what in self.__propclasses:
             self.__propclasses_changeset[what] = PropertyClassChange(None, Action.MODIFY)
         elif what in self.__resclasses:
             self.__resclasses_changeset[what] = ResourceClassChange(None, Action.MODIFY)
@@ -370,9 +432,10 @@ class DataModel(Model):
         query = cls.__context.sparql_context
         query += f"""
         SELECT ?version
-        FROM {cls.__graph}:shacl
         WHERE {{
-            {cls.__graph}:shapes schema:version ?version .
+            GRAPH {cls.__graph}:shacl {{
+                {cls.__graph}:shapes schema:version ?version .
+            }}
         }}
         """
         jsonobj = con.query(query)
@@ -380,6 +443,7 @@ class DataModel(Model):
         if len(res) == 0:
             raise OldapErrorNotFound(f'Datamodel "{cls.__graph}:shacl" not found')
         cls.__version = SemanticVersion.fromString(res[0]['version'])
+
         #
         # now we read the OWL ontology metadata
         #
@@ -399,6 +463,13 @@ class DataModel(Model):
         if version != cls.__version:
             raise OldapErrorInconsistency(f'Versionnumber of SHACL ({cls.__version}) and OWL ({version}) do not match')
         #
+        # now read the external ontologies that are used in this datamodel
+        #
+        extontos = ExternalOntology.search(con=con, projectShortName=project.projectShortName)
+        for onto in extontos:
+            cls.__context[onto.prefix] = NamespaceIRI(str(onto.namespaceIri))
+
+        #
         # now get the QNames of all standalone properties within the data model
         #
         query = cls.__context.sparql_context
@@ -425,6 +496,7 @@ class DataModel(Model):
             propclass.force_external()
             propclasses.append(propclass)
         sa_props = {x.property_class_iri: x for x in propclasses}
+
         #
         # now get all resources defined in the data model
         #
@@ -456,7 +528,9 @@ class DataModel(Model):
                 print(f'Error reading resource class {resclassiri}: {er}')
 
             resclasses.append(resclass)
-        instance = cls(project=project, con=con, propclasses=propclasses, resclasses=resclasses)
+        instance = cls(project=project, con=con, propclasses=propclasses, resclasses=resclasses, extontos=extontos)
+        for qname in instance.get_extontos():
+            instance[qname].set_notifier(instance.notifier, qname)
         for qname in instance.get_propclasses():
             instance[qname].set_notifier(instance.notifier, qname)
         for qname in instance.get_resclasses():
@@ -464,7 +538,7 @@ class DataModel(Model):
 
         cache.set(Xsd_QName(project.projectShortName, 'shacl'), instance)
 
-        instance.changeset_clear()
+        instance.clear_changeset()
         return instance
 
     def create(self, indent: int = 0, indent_inc: int = 4) -> None:
@@ -511,6 +585,10 @@ class DataModel(Model):
         sparql += f'{blank:{(indent + 2) * indent_inc}}{self.__graph}:shapes schema:version {self.__version.toRdf} .\n'
         sparql += '\n'
 
+        for qname, onto in self.__extontos.items():
+            sparql += onto.create_shacl(timestamp=timestamp, indent=2)
+            sparql += '\n'
+
         for propiri, propclass in self.__propclasses.items():
             if propclass.internal:
                 raise OldapErrorInconsistency(f"Property class {propclass.property_class_iri} is internal and cannot be used here.")
@@ -531,6 +609,8 @@ class DataModel(Model):
         sparql += f'{blank:{(indent + 2) * indent_inc}}owl:versionIRI <http://oldap.org/ontology/{self.__graph}/version/{str(self.__version)}> .\n'
         sparql += '\n'
 
+        # no OWL for ExternalOntologies
+
         for propiri, propclass in self.__propclasses.items():
             sparql += propclass.create_owl_part1(timestamp=timestamp, indent=2)
 
@@ -575,6 +655,15 @@ class DataModel(Model):
         if not result:
             raise OldapErrorNoPermission(message)
 
+        for qname, change in self.__extontos_changeset.items():
+            match(change.action):
+                case Action.CREATE:
+                    self.__extontos[qname].create()
+                case Action.MODIFY:
+                    self.__extontos[qname].update()
+                case Action.DELETE:
+                    change.old_value.delete()
+
         for qname, change in self.__propclasses_changeset.items():
             match(change.action):
                 case Action.CREATE:
@@ -584,6 +673,7 @@ class DataModel(Model):
                 case Action.DELETE:
                     #self.__propclasses[qname].delete()
                     change.old_value.delete()
+
         for qname, change in self.__resclasses_changeset.items():
             match (change.action):
                 case Action.CREATE:
@@ -593,7 +683,7 @@ class DataModel(Model):
                 case Action.DELETE:
                     #self.__resclasses[qname].delete()
                     change.old_value.delete()
-        self.changeset_clear()
+        self.clear_changeset()
         cache = CacheSingletonRedis()
         cache.delete(Xsd_QName(self._project.projectShortName, 'shacl'))
         #cache.set(Xsd_QName(self._project.projectShortName, 'shacl'), self)
@@ -665,6 +755,8 @@ class DataModel(Model):
             f.write(f'\n{blank:{indent * indent_inc}}{self.__graph}:shacl {{\n')
             f.write(f'{blank:{(indent + 2) * indent_inc}}{self.__graph}:shapes schema:version {self.__version.toRdf} .\n')
             f.write('\n')
+            for qname, onto in self.__extontos.items():
+                f.write(onto.create_shacl(timestamp=timestamp, indent=1))
             for iri, prop in self.__propclasses.items():
                 if not prop.internal:
                     f.write(prop.create_shacl(timestamp=timestamp, indent=1))

oldaplib/src/dtypes/namespaceiri.py

@@ -48,7 +48,12 @@ class NamespaceIRI(Xsd_anyURI):
     def __add__(self, other: str) -> Xsd_anyURI:
         return Xsd_anyURI(self._value + other)
 
-    def expand(self, name: Xsd_NCName):
+
+    @property
+    def toRdf(self) -> str:
+        return f'<{self._value}>'
+
+    def expand(self, name: Xsd_NCName | str):
         """
         Expands the current namespace URI by appending a name to it, separated by a '/'
         and followed by a '#'. The expanded URI is then returned as a new NamespaceIRI
@@ -58,5 +63,15 @@ class NamespaceIRI(Xsd_anyURI):
             the current namespace's URI.
         :return: A new NamespaceIRI object with the expanded URI.
         """
+        if not isinstance(name, Xsd_NCName):
+            name = Xsd_NCName(name)
         return NamespaceIRI(self.value[:-1] + '/' + name.value + '#')
 
+
+if __name__ == '__main__':
+    ns = NamespaceIRI('http://example.com/ns/')
+    print(ns)
+    print(ns + 'foo')
+    print(ns.expand('foo'))
+    print(ns.toRdf)
+

oldaplib/src/enums/externalontologyattr.py

@@ -0,0 +1,22 @@
+from enum import unique
+
+from oldaplib.src.dtypes.namespaceiri import NamespaceIRI
+from oldaplib.src.enums.attributeclass import AttributeClass
+from oldaplib.src.helpers.langstring import LangString
+from oldaplib.src.xsd.xsd_ncname import Xsd_NCName
+from oldaplib.src.xsd.iri import Iri
+
+
+@unique
+class ExternalOntologyAttr(AttributeClass):
+    """Enumeration of attributes from external ontologies.
+
+    Attributes are defined as tuples with the following structure:
+    (QName, mandatory, immutable, datatype)
+    """
+    # order: (QName, mandatory, immutable, datatype)
+    PREFIX = ('oldap:prefix', True, False, Xsd_NCName)
+    NAMESPACE_IRI = ('oldap:namespaceIri', True, True, NamespaceIRI)
+    LABEL = ('rdfs:label', False, False, LangString)
+    COMMENT = ('rdfs:comment', False, False, LangString)
+

oldaplib/src/enums/owlpropertytype.py

@@ -13,6 +13,16 @@ class OwlPropertyType(Enum):
     OwlDataProperty = 'owl:DatatypeProperty'
     OwlObjectProperty = 'owl:ObjectProperty'
     StatementProperty = 'rdf:Property'
+    TransitiveProperty = 'owl:TransitiveProperty'
+    SymmetricProperty = 'owl:SymmetricProperty'
+    ReflexiveProperty = 'owl:ReflexiveProperty'
+    IrreflexiveProperty = 'owl:IrreflexiveProperty'
+    FunctionalProperty = 'owl:FunctionalProperty'
+    InverseFunctionalProperty = 'owl:InverseFunctionalProperty'
+    # InverseOfProperty = 'owl:InverseOfProperty'
+    # EquivalentProperty = 'owl:EquivalentProperty'
+    # _owl_inverseOf: Xsd_QName  # :hasParent owl:inverseOf :hasChild .
+    # _owl_equivalent: Xsd_QName  # :hasSpouse owl:equivalentProperty :marriedTo .
 
     @property
     def toRdf(self):

oldaplib/src/enums/projectattr.py

@@ -24,4 +24,3 @@ class ProjectAttr(AttributeClass):
     NAMESPACE_IRI = ('oldap:namespaceIri', True, True, NamespaceIRI)
     PROJECT_START = ('oldap:projectStart', False, False, Xsd_date)
     PROJECT_END = ('oldap:projectEnd', False, False, Xsd_date)
-    USES_EXTERNAL_ONTOLOGY = ('oldap:usesExternalOntology', False, False, ObservableDict)

oldaplib/src/enums/propertyclassattr.py

@@ -8,6 +8,7 @@ from oldaplib.src.enums.xsd_datatypes import XsdDatatypes
 from oldaplib.src.helpers.langstring import LangString
 from oldaplib.src.helpers.numeric import Numeric
 from oldaplib.src.enums.owlpropertytype import OwlPropertyType
+from oldaplib.src.helpers.observable_set import ObservableSet
 from oldaplib.src.xsd.iri import Iri
 from oldaplib.src.xsd.xsd_boolean import Xsd_boolean
 from oldaplib.src.xsd.xsd_integer import Xsd_integer
@@ -36,8 +37,9 @@ class PropClassAttr(AttributeClass):
     """
     # order: (QName, mandatory, immutable, datatype)
     SUBPROPERTY_OF = ('rdfs:subPropertyOf', False, False, Iri)
-    TYPE = ('rdf:type', False, True, OwlPropertyType)
+    TYPE = ('rdf:type', False, False, ObservableSet)
     CLASS = ('sh:class', False, False, Iri)
+    NODEKIND = ('sh:nodeKind', False, False, Iri)
     DATATYPE = ('sh:datatype', False, False, XsdDatatypes)
     NAME = ('sh:name', False, False, LangString)  # needs notifier
     DESCRIPTION = ('sh:description', False, False, LangString)  # needs notifier