dsp-tools 0.9.13__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/commands/get/legacy_models/context.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import regex
+
+from dsp_tools.commands.get.legacy_models.helpers import ContextType
+from dsp_tools.commands.get.legacy_models.helpers import OntoIri
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.utils.data_formats.iri_util import is_iri
+
+
+class ContextIterator:
+    _context: Context
+    _prefixes: list[str]
+    _index: int
+
+    def __init__(self, context: Context):
+        self._context = context
+        self._prefixes = list(self._context.context)
+        self._index = 0
+
+    def __next__(self) -> tuple[Optional[str], Optional[OntoIri]]:
+        if len(self._context.context) == 0 and self._index == 0:
+            return None, None
+        elif self._index < len(self._context.context):
+            tmp = self._prefixes[self._index]
+            self._index += 1
+            return tmp, self._context.context[tmp]
+        else:
+            raise StopIteration
+
+
+class Context:
+    """
+    This class holds a JSON-LD context with the ontology IRI's and the associated prefixes
+    """
+
+    _context: ContextType
+    _rcontext: dict[str, str]
+
+    common_ontologies = ContextType(
+        {
+            "foaf": OntoIri("http://xmlns.com/foaf/0.1/", False),
+            "dc": OntoIri("http://purl.org/dc/elements/1.1/", False),
+            "dcterms": OntoIri("http://purl.org/dc/terms/", False),
+            "dcmi": OntoIri("http://purl.org/dc/dcmitype/", False),
+            "skos": OntoIri("http://www.w3.org/2004/02/skos/core", True),
+            "bibtex": OntoIri("http://purl.org/net/nknouf/ns/bibtex", True),
+            "bibo": OntoIri("http://purl.org/ontology/bibo/", False),
+            "cidoc": OntoIri("http://purl.org/NET/cidoc-crm/core", True),
+            "schema": OntoIri("https://schema.org/", False),
+            "edm": OntoIri("http://www.europeana.eu/schemas/edm/", False),
+            "ebucore": OntoIri("http://www.ebu.ch/metadata/ontologies/ebucore/ebucore", True),
+        }
+    )
+
+    knora_ontologies = ContextType(
+        {
+            "knora-api": OntoIri("http://api.knora.org/ontology/knora-api/v2", True),
+            "salsah-gui": OntoIri("http://api.knora.org/ontology/salsah-gui/v2", True),
+        }
+    )
+
+    base_ontologies = ContextType(
+        {
+            "rdf": OntoIri("http://www.w3.org/1999/02/22-rdf-syntax-ns", True),
+            "rdfs": OntoIri("http://www.w3.org/2000/01/rdf-schema", True),
+            "owl": OntoIri("http://www.w3.org/2002/07/owl", True),
+            "xsd": OntoIri("http://www.w3.org/2001/XMLSchema", True),
+        }
+    )
+
+    def __init__(self, context: Optional[dict[str, str]] = None):
+        """
+        THe Constructor of the Context. It takes one optional parameter which as a dict of
+        prefix - ontology-iri pairs. If the hashtag "#" is used to append element name, the
+        ontology-iri *must* end with "#"!
+        :param context: A dict of prefix - ontology-iri pairs
+        """
+        self._context = ContextType({})
+
+        # add ontologies from context, if any
+        if context:
+            for prefix, onto in context.items():
+                self._context[prefix] = OntoIri(onto.removesuffix("#"), onto.endswith(("#", "/v2")))
+
+        # add standard ontologies (rdf, rdfs, owl, xsl)
+        for k, v in self.base_ontologies.items():
+            if not self._context.get(k):
+                self._context[k] = v
+
+        # add DSP-API internal ontologies (knora-api, salsah-gui)
+        for k, v in self.knora_ontologies.items():
+            if not self._context.get(k):
+                self._context[k] = v
+
+        self._rcontext = {v.iri: k for k, v in self._context.items()}
+
+    def __getitem__(self, key: str) -> OntoIri:
+        return self._context[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self._context
+
+    def __iter__(self) -> ContextIterator:
+        return ContextIterator(self)
+
+    def __str__(self) -> str:
+        output = "Context:\n"
+        for prefix, val in self._context.items():
+            output += "  " + prefix + ": " + val.iri + "\n"
+        return output
+
+    #
+    # now we have a lot of getters/setters
+    #
+    @property
+    def context(self) -> ContextType:
+        return self._context
+
+    @context.setter
+    def context(self, value: ContextType) -> None:
+        """
+        Setter function for the context out of a dict in the form { prefix1 : iri1, prefix2, iri2, …}
+
+        :param value: Dictionary of context
+        :return: None
+        """
+        if value is not None and isinstance(value, dict):
+            self._context = value
+        else:
+            raise BaseError("Error in parameter to context setter")
+
+    def add_context(self, prefix: str, iri: Optional[str] = None) -> None:
+        """
+        Add a new context to a context instance
+
+        :param prefix: The prefix that should be used
+        :param iri: The IRI that belongs to this context prefix
+        :return: None
+        """
+        match iri:
+            case None:
+                if prefix in self.knora_ontologies:
+                    return
+                elif prefix in self.base_ontologies:
+                    return
+                elif prefix in self.common_ontologies:
+                    self._context[prefix] = self.common_ontologies[prefix]
+            case str():
+                if iri.endswith("#"):
+                    iri = iri[:-1]
+                    self._context[prefix] = OntoIri(iri, True)
+                else:
+                    self._context[prefix] = OntoIri(iri, False)
+        self._rcontext[iri] = prefix
+
+    def iri_from_prefix(self, prefix: str) -> Optional[str]:
+        """
+        Returns the full IRI belonging to this prefix, without trailing "#"!
+
+        :param prefix: Prefix of the context entry
+        :return: The full IRI without trailing "#"
+        """
+        # if self.__is_iri(prefix):
+        if is_iri(prefix):
+            return prefix
+        if self._context.get(prefix) is not None:
+            return self._context.get(prefix).iri
+        else:
+            return None
+
+    def prefix_from_iri(self, iri: str) -> Optional[str]:
+        """
+        Get the IRI from a full context that has or has not a trailing "#". It first searches in the normal list
+        of contexted. If the iri is not found there, it looks in the list common (external) ontologies. If the
+        ontology is found there, this ontology is added to the list of known ontology and it's prefix is returned.
+        If nothing is found, None is returns
+
+        :param iri: The full IRI with or without trailing "#", or
+        :return: the prefix of this context element, or None, if not found
+        """
+        # if not self.__is_iri(iri):
+        if not is_iri(iri):
+            raise BaseError("String does not conform to IRI patter: " + iri)
+        if iri.endswith("#"):
+            iri = iri[:-1]
+        result = self._rcontext.get(iri)
+        if result is None:
+            entrylist = list(filter(lambda x: x[1].iri == iri, self.common_ontologies.items()))
+            if len(entrylist) == 1:
+                entry = entrylist[0]
+                self._context[entry[0]] = entry[1]  # add to list of prefixes used
+                self._rcontext[entry[1].iri] = entry[0]
+                result = entry[0]
+            else:
+                tmp = iri.split("/")
+                if tmp[-1] == "v2":
+                    #
+                    # we have a knora ontology name "http://server/ontology/shortcode/shortname/v2"
+                    self._context[tmp[-2]] = OntoIri(iri, True)  # add to list of prefixes used
+                    self._rcontext[iri] = tmp[-2]
+                else:
+                    raise BaseError("Iri cannot be resolved to a well-known prefix!")
+        return result
+
+    def get_qualified_iri(self, val: Optional[str]) -> Optional[str]:
+        """
+        Given an IRI, its fully qualified name is returned.
+
+        Args:
+            val: The input IRI
+
+        Returns:
+            the fully qualified IRI
+        """
+        if not val:
+            return None
+        if is_iri(val):
+            return val
+        tmp = val.split(":")
+        if len(tmp) < 2:
+            raise BaseError("There is no separator to identify the prefix: " + val)
+        iri_info = self._context.get(tmp[0])
+        if iri_info is None:
+            entrylist = list(filter(lambda x: x[1].iri == tmp[0], self.common_ontologies.items()))
+            if len(entrylist) == 1:
+                entry = entrylist[0]
+                self._context[entry[0]] = entry[1]  # add to list of prefixes used
+                self._rcontext[entry[1].iri] = entry[0]
+                iri_info = entry[1]
+            else:
+                raise BaseError("Ontology not known! Cannot generate fully qualified IRI")
+        if iri_info.hashtag:
+            return iri_info.iri + "#" + tmp[1]
+        else:
+            return iri_info.iri + tmp[1]
+
+    def get_prefixed_iri(self, iri: Optional[str]) -> Optional[str]:
+        """
+        We reduce a fully qualified IRI to a short one in the form "prefix:name"
+
+        :param iri: Fully qualified IRI
+        :return: Return short from of IRI ("prefix:name")
+        """
+        if iri is None:
+            return None
+
+        # check if the iri already has the form "prefix:name"
+        m = regex.match("([\\w-]+):([\\w-]+)", iri)
+        if m and m.span()[1] == len(iri):
+            return iri
+
+        if not is_iri(iri):
+            raise BaseError(f"The IRI '{iri}' does not conform to the IRI pattern.")
+
+        split_point = iri.find("#")
+        if split_point == -1:
+            split_point = iri.rfind("/")
+            onto_part = iri[: split_point + 1]
+            element = iri[split_point + 1 :]
+        else:
+            onto_part = iri[:split_point]
+            element = iri[split_point + 1 :]
+
+        prefix = self._rcontext.get(onto_part)
+        if prefix is None:
+            entry_list = list(filter(lambda x: x[1].iri == onto_part, self.common_ontologies.items()))
+            if len(entry_list) == 1:
+                entry = entry_list[0]
+                self._context[entry[0]] = entry[1]  # add to list of prefixes used
+                self._rcontext[entry[1].iri] = entry[0]
+                prefix = entry[0]
+            else:
+                return None
+        return prefix + ":" + element
+
+    def reduce_iri(self, iri_str: str, onto_name: Optional[str] = None) -> str:
+        """
+        Reduces an IRI to the form that is used within the definition JSON file. It expects the context object to have
+        entries (prefixes) for all IRIs:
+        - if it's an external IRI and the ontology can be extracted as prefix it returns: "prefix:name"
+        - if it's in the same ontology, it returns: ":name"
+        - if it's a system ontology ("knora-api" or "salsah-gui") it returns: "name"
+        - if the IRI can't be reduced, it's returned as is
+
+        Args:
+            iri_str: the IRI that should be reduced
+            onto_name: the name of the ontology
+
+        Returns:
+            The reduced IRI if possible otherwise the fully qualified IRI
+        """
+        knora_api = self.prefix_from_iri("http://api.knora.org/ontology/knora-api/v2#")
+        salsah_gui = self.prefix_from_iri("http://api.knora.org/ontology/salsah-gui/v2#")
+
+        if is_iri(iri_str):
+            if self.get_prefixed_iri(iri_str):
+                iri_str = self.get_prefixed_iri(iri_str)
+        tmp = iri_str.split(":")
+        if tmp[0] == knora_api or tmp[0] == salsah_gui:
+            return tmp[1]
+        elif tmp[0] == onto_name:
+            return ":" + tmp[1]
+        else:
+            return iri_str
+
+    def toJsonObj(self) -> dict[str, str]:
+        """
+        Return a python object that can be jsonfied...
+        :return: Object to be jsonfied
+        """
+        return {prefix: oinfo.iri + "#" if oinfo.hashtag else oinfo.iri for prefix, oinfo in self._context.items()}
+
+    def get_externals_used(self) -> dict[str, str]:
+        exclude = ["rdf", "rdfs", "owl", "xsd", "knora-api", "salsah-gui"]
+        return {prefix: onto.iri for prefix, onto in self._context.items() if prefix not in exclude}

dsp_tools/commands/get/legacy_models/group.py

@@ -0,0 +1,241 @@
+"""
+This module implements the handling (CRUD) of DSP groups.
+
+CREATE:
+    * Instantiate a new object of the class Group with all required parameters
+    * Call the ``create``-method on the instance
+
+READ:
+    * Instantiate a new object with ``iri``(IRI of group) given
+    * Call the ``read``-method on the instance
+    * Access the information that has been provided to the instance
+
+UPDATE:
+    * You need an instance of an existing Project by reading an instance
+    * Change the attributes by assigning the new values
+    * Call the ``update```method on the instance
+
+DELETE
+    * Instantiate a new objects with ``iri``(IRI of group) given, or use any instance that has the iri set
+    * Call the ``delete``-method on the instance
+
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from typing import Optional
+from typing import Union
+from urllib.parse import quote_plus
+
+from dsp_tools.clients.connection import Connection
+from dsp_tools.commands.get.legacy_models.model import Model
+from dsp_tools.commands.get.legacy_models.project import Project
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.legacy_models.langstring import LangString
+
+
+class Group(Model):
+    """
+    This class represents a DSP group
+
+    Attributes
+    ----------
+
+    con : Connection
+        A connection instance to a DSP server
+
+    iri : str
+        IRI of the group [get only, cannot be modified after creation of instance]
+
+    name : str
+        Name of the group
+
+    descriptions : LangString
+        Group descriptions in a given language (Languages.EN, Languages.DE, Languages.FR, Languages.IT, Languages.RM).
+
+    project : str | project
+        either the IRI of a project [get only, cannot be modified after creation of instance]
+        or an valid Project instance
+
+    selfjoin : boolean
+        A flag indicating if selfjoin is allowed in this group
+
+    status : boolean
+        A flag indicating if the group is active (True) or inactive/makred deleted (False)
+
+    """
+
+    PROJECT_MEMBER_GROUP: str = "http://www.knora.org/ontology/knora-admin#ProjectMember"
+    PROJECT_ADMIN_GROUP: str = "http://www.knora.org/ontology/knora-admin#ProjectAdmin"
+    ROUTE: str = "/admin/groups"
+    ROUTE_SLASH: str = ROUTE + "/"
+
+    _iri: Optional[str]
+    _name: str | None
+    _descriptions: LangString
+    _project: str
+    _selfjoin: bool
+    _status: bool
+
+    def __init__(
+        self,
+        con: Connection,
+        iri: Optional[str] = None,
+        name: Optional[str] = None,
+        descriptions: Optional[LangString] = None,
+        project: Optional[Union[str, Project]] = None,
+        selfjoin: Optional[bool] = None,
+        status: Optional[bool] = None,
+    ) -> None:
+        super().__init__(con)
+        self._iri = iri
+        self._name = str(name) if name is not None else None
+        self._descriptions = LangString(descriptions)
+        if project is not None and isinstance(project, Project):
+            self._project = project.iri
+        else:
+            self._project = str(project) if project is not None else None
+        self._selfjoin = bool(selfjoin) if selfjoin is not None else None
+        self._status = bool(status) if status is not None else None
+
+    @property
+    def iri(self) -> Optional[str]:
+        return self._iri
+
+    @property
+    def name(self) -> Optional[str]:
+        return self._name
+
+    @name.setter
+    def name(self, value: str) -> None:
+        self._name = value
+        self._changed.add("name")
+
+    @property
+    def descriptions(self) -> LangString:
+        return self._descriptions
+
+    @descriptions.setter
+    def descriptions(self, value: Optional[LangString]) -> None:
+        self._descriptions = LangString(value)
+        self._changed.add("descriptions")
+
+    @property
+    def project(self) -> str:
+        return self._project
+
+    @property
+    def selfjoin(self) -> bool:
+        return self._selfjoin
+
+    @selfjoin.setter
+    def selfjoin(self, value: bool) -> None:
+        self._selfjoin = value
+        self._changed.add("selfjoin")
+
+    @property
+    def status(self) -> bool:
+        return self._status
+
+    @status.setter
+    def status(self, value: bool) -> None:
+        self._status = value
+        self._changed.add("status")
+
+    @classmethod
+    def fromJsonObj(cls, con: Connection, json_obj: Any) -> Group:
+        group_id = json_obj.get("id")
+        if group_id is None:
+            raise BaseError('Group "id" is missing')
+        name = json_obj.get("name")
+        if name is None:
+            raise BaseError('Group "name" is missing')
+        descriptions = LangString.fromJsonObj(json_obj.get("descriptions"))
+        tmp = json_obj.get("project")
+        if tmp is None:
+            raise BaseError('Group "project" is missing')
+        project = tmp.get("id")
+        if project is None:
+            raise BaseError('Group "project" has no "id"')
+        selfjoin = json_obj.get("selfjoin")
+        if selfjoin is None:
+            raise BaseError("selfjoin is missing")
+        status = json_obj.get("status")
+        if status is None:
+            raise BaseError("Status is missing")
+        return cls(
+            con=con,
+            name=name,
+            iri=group_id,
+            descriptions=descriptions,
+            project=project,
+            selfjoin=selfjoin,
+            status=status,
+        )
+
+    def create(self) -> Group:
+        jsonobj = self._toJsonObj_create()
+        result = self._con.post(Group.ROUTE, jsonobj)
+        return Group.fromJsonObj(self._con, result["group"])
+
+    def _toJsonObj_create(self):
+        tmp = {}
+        if self._name is None:
+            raise BaseError("There must be a valid name!")
+        tmp["name"] = self._name
+        if not self._descriptions.isEmpty():
+            tmp["descriptions"] = self._descriptions.toJsonObj()
+        if self._project is None:
+            raise BaseError("There must be a valid project!")
+        tmp["project"] = self._project
+        if self._selfjoin is None:
+            raise BaseError("There must be a valid value for selfjoin!")
+        tmp["selfjoin"] = self._selfjoin
+        if self._status is None:
+            raise BaseError("There must be a valid value for status!")
+        tmp["status"] = self._status
+        return tmp
+
+    def read(self) -> Group:
+        result = self._con.get(Group.ROUTE_SLASH + quote_plus(self._iri))
+        return Group.fromJsonObj(self._con, result["group"])
+
+    def update(self) -> Optional[Group]:
+        updated_group = None
+        jsonobj = self._toJsonObj_update()
+        if jsonobj:
+            result = self._con.put(Group.ROUTE_SLASH + quote_plus(self._iri), jsonobj)
+            updated_group = Group.fromJsonObj(self._con, result["group"])
+        if self._status is not None and "status" in self._changed:
+            jsonobj = {"status": self._status}
+            result = self._con.put(Group.ROUTE_SLASH + quote_plus(self._iri) + "/status", jsonobj)
+            updated_group = Group.fromJsonObj(self._con, result["group"])
+        return updated_group
+
+    def _toJsonObj_update(self) -> dict[str, Any]:
+        tmp = {}
+        if self._name is not None and "name" in self._changed:
+            tmp["name"] = self._name
+        if not self._descriptions.isEmpty() and "descriptions" in self._changed:
+            tmp["descriptions"] = self._descriptions.toJsonObj()
+        if self._selfjoin is not None and "selfjoin" in self._changed:
+            tmp["selfjoin"] = self._selfjoin
+        return tmp
+
+    @staticmethod
+    def getAllGroups(con: Connection) -> list[Group]:
+        result = con.get(Group.ROUTE)
+        return [Group.fromJsonObj(con, group_item) for group_item in result["groups"]]
+
+    @staticmethod
+    def getAllGroupsForProject(con: Connection, proj_iri: str) -> list[Group]:
+        return [g for g in Group.getAllGroups(con) if g.project == proj_iri]
+
+    def createDefinitionFileObj(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "descriptions": self.descriptions.createDefinitionFileObj(),
+            "selfjoin": self.selfjoin,
+            "status": self.status,
+        }

dsp_tools/commands/get/legacy_models/helpers.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from enum import unique
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class OntoIri:
+    """
+    Holds an ontology IRI
+
+    Attributes:
+        iri: the ontology IRI
+        hashtag: True if "#" is used to separate elements, False if element name is appended after "/"
+    """
+
+    iri: str
+    hashtag: bool
+
+
+ContextType = dict[str, OntoIri]
+
+
+@unique
+class Cardinality(Enum):
+    C_1 = "1"
+    C_0_1 = "0-1"
+    C_1_n = "1-n"
+    C_0_n = "0-n"
+
+
+class WithId:
+    """
+    Class helper to get json-ld "@id" thingies
+    """
+
+    _tmp: str = None
+
+    def __init__(self, obj: Optional[dict[str, str]]):
+        if obj is None:
+            return
+        self._tmp = obj.get("@id")
+
+    def to_string(self) -> Optional[str]:
+        return self._tmp