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

dsp_tools/commands/get/legacy_models/ontology.py

@@ -0,0 +1,324 @@
+"""
+This model implements the handling of ontologies. It is to note that ResourceClasses, PropertyClasses
+as well as the assignment of PropertyCLasses to the ResourceClasses (with a given cardinality)
+is handled in "cooperation" with the propertyclass.py (PropertyClass) and resourceclass.py (ResourceClass
+and HasProperty) modules.
+
+CREATE:
+    * Instantiate a new object of the Ontology class with all required parameters
+    * Call the ``create``-method on the instance to create the ontology withing the backend
+
+READ:
+    * Instantiate a new object with ``iri``(IRI of ontology) given
+    * Call the ``read``-method on the instance. Reading the ontology also reads all
+      associated PropertyClasses and ResourceClasses as well as the assignments.
+    * Access the information that has been provided to the instance
+
+"""
+
+from __future__ import annotations
+
+import copy
+from typing import Any
+from typing import Optional
+from typing import Union
+from urllib.parse import quote_plus
+
+import regex
+
+from dsp_tools.clients.connection import Connection
+from dsp_tools.commands.get.legacy_models.context import Context
+from dsp_tools.commands.get.legacy_models.helpers import WithId
+from dsp_tools.commands.get.legacy_models.model import Model
+from dsp_tools.commands.get.legacy_models.project import Project
+from dsp_tools.commands.get.legacy_models.propertyclass import PropertyClass
+from dsp_tools.commands.get.legacy_models.resourceclass import ResourceClass
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.legacy_models.datetimestamp import DateTimeStamp
+
+
+class Ontology(Model):
+    ROUTE: str = "/v2/ontologies"
+    METADATA: str = "/metadata/"
+    ALL_LANGUAGES: str = "?allLanguages=true"
+
+    _iri: str
+    _project: str
+    _name: str
+    _label: str
+    _comment: str
+    _lastModificationDate: DateTimeStamp
+    _resource_classes: list[ResourceClass]
+    _property_classes: list[PropertyClass]
+    _context: Context
+    _skiplist: list[str]
+
+    def __init__(
+        self,
+        con: Connection,
+        iri: Optional[str] = None,
+        project: Optional[Union[str, Project]] = None,
+        name: Optional[str] = None,
+        label: Optional[str] = None,
+        comment: Optional[str] = None,
+        lastModificationDate: Optional[Union[str, DateTimeStamp]] = None,
+        resource_classes: Optional[list[ResourceClass]] = None,
+        property_classes: Optional[list[PropertyClass]] = None,
+        context: Context = None,
+    ):
+        super().__init__(con)
+        self._iri = iri
+        if isinstance(project, Project):
+            self._project = project.iri
+        else:
+            self._project = project
+        self._name = name
+        self._label = label
+        self._comment = comment
+        if lastModificationDate is None:
+            self._lastModificationDate = None
+        elif isinstance(lastModificationDate, DateTimeStamp):
+            self._lastModificationDate = lastModificationDate
+        else:
+            self._lastModificationDate = DateTimeStamp(lastModificationDate)
+        self._resource_classes = resource_classes or []
+        self._property_classes = property_classes or []
+        self._context = context if context is not None else Context()
+        self._skiplist = []
+
+    @property
+    def iri(self) -> str:
+        return self._iri
+
+    @property
+    def project(self) -> str:
+        return self._project
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+    @label.setter
+    def label(self, value: str) -> None:
+        self._label = str(value)
+        self._changed.add("label")
+
+    @property
+    def comment(self) -> str:
+        return self._comment
+
+    @comment.setter
+    def comment(self, value: str) -> None:
+        self._comment = str(value)
+        self._changed.add("comment")
+
+    @property
+    def lastModificationDate(self) -> DateTimeStamp:
+        return self._lastModificationDate
+
+    @lastModificationDate.setter
+    def lastModificationDate(self, value: Union[str, DateTimeStamp]) -> None:
+        self._lastModificationDate = DateTimeStamp(value)
+
+    @property
+    def resource_classes(self) -> list[ResourceClass]:
+        return self._resource_classes
+
+    @resource_classes.setter
+    def resource_classes(self, value: list[ResourceClass]) -> None:
+        self._resource_classes = value
+
+    @property
+    def property_classes(self) -> list[PropertyClass]:
+        return self._property_classes
+
+    @property_classes.setter
+    def property_classes(self, value: list[PropertyClass]) -> None:
+        self._property_classes = value
+
+    @property
+    def context(self) -> Context:
+        return self._context
+
+    @classmethod
+    def fromJsonObj(cls, con: Connection, json_obj: Any) -> Ontology:
+        #
+        # First let's get the ID (IRI) of the ontology
+        #
+        iri = json_obj.get("@id")
+        if iri is None:
+            raise BaseError("Ontology iri is missing")
+
+        #
+        # evaluate the JSON-LD context to get the proper prefixes
+        #
+        context = Context(json_obj.get("@context"))
+        onto_name = iri.split("/")[-2]
+        context.add_context(onto_name, iri + "#")
+        rdfs = context.prefix_from_iri("http://www.w3.org/2000/01/rdf-schema#")
+        knora_api = context.prefix_from_iri("http://api.knora.org/ontology/knora-api/v2#")
+        this_onto = context.prefix_from_iri(iri + "#")
+
+        label = json_obj.get(rdfs + ":label")
+        if label is None:
+            raise BaseError("Ontology label is missing")
+        comment = json_obj.get(rdfs + ":comment")
+        if json_obj.get(knora_api + ":attachedToProject") is None:
+            raise BaseError("Ontology not attached to a project")
+        if json_obj[knora_api + ":attachedToProject"].get("@id") is None:
+            raise BaseError("Ontology not attached to a project")
+        project = json_obj[knora_api + ":attachedToProject"]["@id"]
+        tmp = json_obj.get(knora_api + ":lastModificationDate")
+        if tmp is not None:
+            last_modification_date = DateTimeStamp(json_obj.get(knora_api + ":lastModificationDate"))
+        else:
+            last_modification_date = None
+        resource_classes = None
+        property_classes = None
+        if json_obj.get("@graph") is not None:
+            resclasses_obj = list(
+                filter(lambda a: a.get(knora_api + ":isResourceClass") is not None, json_obj.get("@graph"))
+            )
+            resource_classes = list(
+                map(lambda a: ResourceClass.fromJsonObj(con=con, context=context, json_obj=a), resclasses_obj)
+            )
+
+            properties_obj = list(
+                filter(lambda a: a.get(knora_api + ":isResourceProperty") is not None, json_obj.get("@graph"))
+            )
+            property_classes = [
+                PropertyClass.fromJsonObj(con=con, context=context, json_obj=a)
+                for a in properties_obj
+                if WithId(a.get(knora_api + ":objectType")).to_string() != "knora-api:LinkValue"
+            ]
+        return cls(
+            con=con,
+            iri=iri,
+            label=label,
+            project=project,
+            name=this_onto,
+            comment=comment,
+            lastModificationDate=last_modification_date,
+            resource_classes=resource_classes,
+            property_classes=property_classes,
+            context=context,
+        )
+
+    @classmethod
+    def __oneOntologiesFromJsonObj(cls, con: Connection, json_obj: Any, context: Context) -> Ontology:
+        rdfs = context.prefix_from_iri("http://www.w3.org/2000/01/rdf-schema#")
+        owl = context.prefix_from_iri("http://www.w3.org/2002/07/owl#")
+        knora_api = context.prefix_from_iri("http://api.knora.org/ontology/knora-api/v2#")
+        if json_obj.get("@type") != owl + ":Ontology":
+            return None
+        iri = json_obj.get("@id")
+        if iri is None:
+            raise BaseError("Ontology iri is missing")
+        if json_obj.get(knora_api + ":attachedToProject") is None:
+            raise BaseError("Ontology not attached to a project (1)")
+        if json_obj[knora_api + ":attachedToProject"].get("@id") is None:
+            raise BaseError("Ontology not attached to a project (2)")
+        project = json_obj[knora_api + ":attachedToProject"]["@id"]
+        tmp = json_obj.get(knora_api + ":lastModificationDate")
+        if tmp is not None:
+            last_modification_date = DateTimeStamp(json_obj.get(knora_api + ":lastModificationDate"))
+        else:
+            last_modification_date = None
+        label = json_obj.get(rdfs + ":label")
+        if label is None:
+            raise BaseError("Ontology label is missing")
+        comment = json_obj.get(rdfs + ":comment")
+        this_onto = iri.split("/")[-2]
+        context2 = copy.deepcopy(context)
+        context2.add_context(this_onto, iri)
+        return cls(
+            con=con,
+            iri=iri,
+            label=label,
+            project=project,
+            name=this_onto,
+            comment=comment,
+            lastModificationDate=last_modification_date,
+            context=context2,
+        )
+
+    @classmethod
+    def allOntologiesFromJsonObj(cls, con: Connection, json_obj: Any) -> list[Ontology]:
+        context = Context(json_obj.get("@context"))
+        ontos: list[Ontology] = []
+        if json_obj.get("@graph") is not None:
+            for o in json_obj["@graph"]:
+                ontos.append(Ontology.__oneOntologiesFromJsonObj(con, o, context))
+        else:
+            onto = Ontology.__oneOntologiesFromJsonObj(con, json_obj, context)
+            if onto is not None:
+                ontos.append(onto)
+        return ontos
+
+    def create(self) -> Ontology:
+        jsonobj = self._toJsonObj_create()
+        result = self._con.post(Ontology.ROUTE, jsonobj)
+        return Ontology.fromJsonObj(self._con, result)
+
+    def _toJsonObj_create(self):
+        rdfs = self._context.prefix_from_iri("http://www.w3.org/2000/01/rdf-schema#")
+        knora_api = self._context.prefix_from_iri("http://api.knora.org/ontology/knora-api/v2#")
+        if self._name is None:
+            raise BaseError("There must be a valid name given!")
+        if self._label is None:
+            raise BaseError("There must be a valid label given!")
+        if self._project is None:
+            raise BaseError("There must be a valid project given!")
+        tmp = {
+            knora_api + ":ontologyName": self._name,
+            knora_api + ":attachedToProject": {"@id": self._project},
+            rdfs + ":label": self._label,
+            "@context": self._context.toJsonObj(),
+        }
+        if self._comment is not None:
+            tmp[rdfs + ":comment"] = self._comment
+        return tmp
+
+    def read(self) -> Ontology:
+        result = self._con.get(Ontology.ROUTE + "/allentities/" + quote_plus(self._iri) + Ontology.ALL_LANGUAGES)
+        return Ontology.fromJsonObj(self._con, result)
+
+    @staticmethod
+    def getProjectOntologies(con: Connection, project_id: str) -> list[Ontology]:
+        if project_id is None:
+            raise BaseError("Project ID must be defined!")
+        result = con.get(Ontology.ROUTE + Ontology.METADATA + quote_plus(project_id) + Ontology.ALL_LANGUAGES)
+        return Ontology.allOntologiesFromJsonObj(con, result)
+
+    @staticmethod
+    def getOntologyFromServer(con: Connection, shortcode: str, name: str) -> Ontology:
+        if regex.search(r"[0-9A-F]{4}", shortcode):
+            result = con.get("/ontology/" + shortcode + "/" + name + "/v2" + Ontology.ALL_LANGUAGES)
+        else:
+            result = con.get("/ontology/" + name + "/v2" + Ontology.ALL_LANGUAGES)
+        return Ontology.fromJsonObj(con, result)
+
+    def createDefinitionFileObj(self) -> dict[str, Any]:
+        ontology = {
+            "name": self.name,
+            "label": self.label,
+            "comment": self.comment,
+            "properties": [],
+            "resources": [],
+        }
+        if not self.comment:
+            ontology.pop("comment")
+        for prop in self.property_classes:
+            if "knora-api:hasLinkToValue" in prop.superproperties:
+                self._skiplist.append(self.name + ":" + prop.name)
+                continue
+            ontology["properties"].append(prop.createDefinitionFileObj(self.context, self.name))
+
+        for res in self.resource_classes:
+            ontology["resources"].append(res.createDefinitionFileObj(self.context, self.name, self._skiplist))
+
+        return ontology

dsp_tools/commands/get/legacy_models/project.py

@@ -0,0 +1,366 @@
+"""
+This module implements the handling (CRUD) of DSP projects.
+
+CREATE:
+    * Instantiate a new object of the class Project with all required parameters
+    * Call the ``create``-method on the instance
+
+READ:
+    * Instantiate a new object with ``iri`` given
+    * Call the ``read``-method on the instance
+    * Access the information that has been provided to 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.error.exceptions import BaseError
+from dsp_tools.legacy_models.langstring import LangString
+
+
+class Project(Model):
+    """
+    This class represents a project in DSP.
+
+    Attributes
+    ----------
+
+    con : Connection
+        A Connection instance to a DSP server
+
+    iri : str
+        IRI of the project [readonly, cannot be modified after creation of instance]
+
+    shortcode : str
+        DSP project shortcode [readonly, cannot be modified after creation of instance]
+
+    shortname : str
+        DSP project shortname [read/write]
+
+    longname : str
+        DSP project longname [read/write]
+
+    description : LangString
+        DSP project description in a given language (Languages.EN, Languages.DE, Languages.FR, Languages.IT).
+
+    keywords : set[str]
+        Set of keywords describing the project.
+
+    ontologies : set[str]
+        Set if IRI's of the ontologies attached to the project [readonly]
+
+    selfjoin : bool
+        Boolean if the project allows selfjoin
+
+
+    Methods
+    -------
+
+    create : DSP project information object
+        Creates a new project and returns the information from the project as it is in DSP
+
+    read : DSP project information object
+        Read project data from an existing project
+
+    getAllprojects [static]: List of all projects
+        Returns a list of all projects available
+
+    print : None
+        Prints the project information to stdout
+
+    """
+
+    ROUTE: str = "/admin/projects"
+    IRI: str = ROUTE + "/iri/"
+
+    _iri: str
+    _shortcode: str
+    _shortname: str
+    _longname: str
+    _description: LangString
+    _keywords: set[str]
+    _ontologies: set[str]
+    _enabled_licenses: set[str]
+    _selfjoin: bool
+    _status: bool
+    _logo: Optional[str]
+
+    def __init__(
+        self,
+        con: Connection,
+        iri: Optional[str] = None,
+        shortcode: Optional[str] = None,
+        shortname: Optional[str] = None,
+        longname: Optional[str] = None,
+        description: LangString = None,
+        keywords: Optional[set[str]] = None,
+        ontologies: Optional[set[str]] = None,
+        enabled_licenses: Optional[set[str]] = None,
+        selfjoin: Optional[bool] = None,
+        status: Optional[bool] = None,
+        logo: Optional[str] = None,
+    ):
+        """
+        Constructor for Project
+
+        :param con: Connection instance
+        :param iri: IRI of the project [required for CREATE, READ]
+        :param shortcode: Shortcode of the project. Four-digit hexadecimal number. [required for CREATE]
+        :param shortname: Shortname of the project [required for CREATE]
+        :param longname: Longname of the project [required for CREATE]
+        :param description: LangString instance containing the description [required for CREATE]
+        :param keywords: Set of keywords [required for CREATE]
+        :param ontologies: Set of ontologies that belong to this project [optional]
+        :param enabled_licenses: Set of enabled licenses [optional]
+        :param selfjoin: Allow selfjoin [required for CREATE]
+        :param status: Status of project (active if True) [required for CREATE]
+        :param logo: Path to logo image file [optional] NOT YET USED
+        """
+        super().__init__(con)
+        self._iri = iri
+        self._shortcode = shortcode
+        self._shortname = shortname
+        self._longname = longname
+        self._description = LangString(description)
+        self._keywords = keywords
+        if not isinstance(ontologies, set) and ontologies is not None:
+            raise BaseError("Ontologies must be a set of strings or None!")
+        self._ontologies = ontologies
+        self._enabled_licenses = enabled_licenses or set()
+        self._selfjoin = selfjoin
+        self._status = status
+        self._logo = logo
+
+    def __str__(self) -> str:
+        tmpstr = self._iri + "\n  " + self._shortcode + "\n  " + self._shortname
+        return tmpstr
+
+    #
+    # Here follows a list of getters/setters
+    #
+    @property
+    def iri(self) -> Optional[str]:
+        return self._iri
+
+    @property
+    def shortcode(self) -> Optional[str]:
+        return self._shortcode
+
+    @property
+    def shortname(self) -> Optional[str]:
+        return self._shortname
+
+    @shortname.setter
+    def shortname(self, value: str) -> None:
+        if self._shortname != str(value):
+            self._shortname = str(value)
+            self._changed.add("shortname")
+
+    @property
+    def longname(self) -> Optional[str]:
+        return self._longname
+
+    @longname.setter
+    def longname(self, value: str) -> None:
+        if self._longname != str(value):
+            self._longname = str(value)
+            self._changed.add("longname")
+
+    @property
+    def description(self) -> LangString:
+        return self._description or LangString({})
+
+    @description.setter
+    def description(self, value: Optional[LangString]) -> None:
+        self._description = LangString(value)
+        self._changed.add("description")
+
+    @property
+    def keywords(self) -> set[str]:
+        return self._keywords
+
+    @keywords.setter
+    def keywords(self, value: Union[list[str], set[str]]) -> None:
+        if isinstance(value, set):
+            self._keywords = value
+            self._changed.add("keywords")
+        elif isinstance(value, list):
+            self._keywords = set(value)
+            self._changed.add("keywords")
+        else:
+            raise BaseError("Must be a set of strings!")
+
+    @property
+    def ontologies(self) -> set[str]:
+        return self._ontologies
+
+    @property
+    def selfjoin(self) -> Optional[bool]:
+        return self._selfjoin
+
+    @selfjoin.setter
+    def selfjoin(self, value: bool) -> None:
+        if self._selfjoin != value:
+            self._changed.add("selfjoin")
+            self._selfjoin = value
+
+    @property
+    def status(self) -> bool:
+        return self._status
+
+    @status.setter
+    def status(self, value: bool) -> None:
+        if self._status != value:
+            self._status = value
+            self._changed.add("status")
+
+    @property
+    def logo(self) -> str:
+        return self._logo
+
+    @logo.setter
+    def logo(self, value: str) -> None:
+        if self._logo != value:
+            self._logo = value
+            self._changed.add("logo")
+
+    @classmethod
+    def fromJsonObj(cls, con: Connection, json_obj: Any) -> Project:
+        """
+        Internal method! Should not be used directly!
+
+        This method is used to create a Project instance from the JSON data returned by DSP
+
+        :param con: Connection instance
+        :param json_obj: JSON data returned by DSP as python3 object
+        :return: Project instance
+        """
+        iri = json_obj.get("id")
+        if iri is None:
+            raise BaseError("Project iri is missing")
+        shortcode = json_obj.get("shortcode")
+        if shortcode is None:
+            raise BaseError("Shortcode is missing")
+        shortname = json_obj.get("shortname")
+        if shortname is None:
+            raise BaseError("Shortname is missing")
+        longname = json_obj.get("longname")
+        if longname is None:
+            raise BaseError("Longname is missing")
+        description = LangString.fromJsonObj(json_obj.get("description"))
+        keywords = set(json_obj.get("keywords"))
+        if keywords is None:
+            raise BaseError("Keywords are missing")
+        ontologies = set(json_obj.get("ontologies"))
+        if ontologies is None:
+            raise BaseError("ontologies are missing")
+        enabled_licenses = json_obj.get("enabledLicenses", set())
+        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")
+        logo = json_obj.get("logo")
+        return cls(
+            con=con,
+            iri=iri,
+            shortcode=shortcode,
+            shortname=shortname,
+            longname=longname,
+            description=description,
+            keywords=keywords,
+            ontologies=ontologies,
+            enabled_licenses=enabled_licenses,
+            selfjoin=selfjoin,
+            status=status,
+            logo=logo,
+        )
+
+    def createDefinitionFileObj(self) -> dict[str, Any]:
+        return {
+            "shortcode": self._shortcode,
+            "shortname": self._shortname,
+            "longname": self._longname,
+            "descriptions": self._description.createDefinitionFileObj(),
+            "keywords": list(self._keywords),
+            "enabled_licenses": list(self._enabled_licenses),
+        }
+
+    def create(self) -> Project:
+        """
+        Create a new project in DSP
+
+        :return: JSON-object from DSP
+        """
+        jsonobj = self._toJsonObj_create()
+        result = self._con.post(Project.ROUTE, jsonobj)
+        return Project.fromJsonObj(self._con, result["project"])
+
+    def _toJsonObj_create(self) -> dict[str, str]:
+        tmp = {}
+        if self._shortcode is None:
+            raise BaseError("There must be a valid project shortcode!")
+        tmp["shortcode"] = self._shortcode
+        if self._shortname is None:
+            raise BaseError("There must be a valid project shortname!")
+        tmp["shortname"] = self._shortname
+        if self._longname is None:
+            raise BaseError("There must be a valid project longname!")
+        tmp["longname"] = self._longname
+        if self._description.isEmpty():
+            raise BaseError("There must be a valid project description!")
+        tmp["description"] = self._description.toJsonObj()
+        if self._keywords is not None and len(self._keywords) > 0:
+            tmp["keywords"] = self._keywords
+        if self._enabled_licenses:
+            tmp["enabledLicenses"] = list(self._enabled_licenses)
+        if self._selfjoin is None:
+            raise BaseError("selfjoin must be defined (True or False!")
+        tmp["selfjoin"] = self._selfjoin
+        if self._status is None:
+            raise BaseError("status must be defined (True or False!")
+        tmp["status"] = self._status
+        return tmp
+
+    def read(self) -> Project:
+        """
+        Read a project from DSP
+
+        :return: JSON-object from DSP
+        """
+        result = None
+        if self._iri is not None:
+            result = self._con.get(Project.IRI + quote_plus(self._iri))
+        elif self._shortcode is not None:
+            result = self._con.get(Project.ROUTE + "/shortcode/" + quote_plus(self._shortcode))
+        elif self._shortname is not None:
+            result = self._con.get(Project.ROUTE + "/shortname/" + quote_plus(self._shortname))
+        if result is not None:
+            return Project.fromJsonObj(self._con, result["project"])
+        else:
+            raise BaseError(
+                f"ERROR: Could not read project '{self.shortname}' ({self.shortcode}) with IRI {self._iri} "
+                f"from DSP server."
+            )
+
+    @staticmethod
+    def getAllProjects(con: Connection) -> list[Project]:
+        """
+        Get all existing projects in DSP
+
+        :param con: Connection instance
+        :return:
+        """
+        try:
+            result = con.get(Project.ROUTE)
+            return [Project.fromJsonObj(con, a) for a in result["projects"]]
+        except BaseError:
+            return []