dsp-tools 17.0.0.post14__py3-none-any.whl → 17.0.0.post21__py3-none-any.whl

dsp_tools/clients/metadata_client.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from enum import Enum
+from enum import auto
+from typing import Protocol
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+
+
+class MetadataRetrieval(Enum):
+    SUCCESS = auto()
+    FAILURE = auto()
+
+
+@dataclass
+class MetadataClient(Protocol):
+    """
+    Protocol class/interface for the metadata endpoint in the API.
+    """
+
+    server: str
+    authentication_client: AuthenticationClient
+
+    def get_resource_metadata(self, shortcode: str) -> tuple[MetadataRetrieval, list[dict[str, str]]]:
+        """Get all resource metadata from one project."""

dsp_tools/clients/metadata_client_live.py

@@ -0,0 +1,42 @@
+from dataclasses import dataclass
+
+import requests
+from loguru import logger
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.metadata_client import MetadataClient
+from dsp_tools.clients.metadata_client import MetadataRetrieval
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_response
+
+TIMEOUT = 120
+
+
+@dataclass
+class MetadataClientLive(MetadataClient):
+    server: str
+    authentication_client: AuthenticationClient
+
+    def get_resource_metadata(self, shortcode: str) -> tuple[MetadataRetrieval, list[dict[str, str]]]:
+        url = f"{self.server}/v2/metadata/projects/{shortcode}/resources?format=JSON"
+        header = {"Authorization": f"Bearer {self.authentication_client.get_token()}"}
+        params = RequestParameters(method="GET", url=url, timeout=TIMEOUT, headers=header)
+        logger.debug("GET Resource Metadata")
+        log_request(params)
+        try:
+            response = requests.get(
+                url=params.url,
+                headers=params.headers,
+                timeout=params.timeout,
+            )
+            if response.ok:
+                # we log the response separately because if it was successful it will be too big
+                log_response(response, include_response_content=False)
+                return MetadataRetrieval.SUCCESS, response.json()
+            # here the response text is important
+            log_response(response)
+            return MetadataRetrieval.FAILURE, []
+        except Exception as err:  # noqa: BLE001 (blind exception)
+            logger.error(err)
+            return MetadataRetrieval.FAILURE, []

dsp_tools/clients/ontology_client.py

@@ -0,0 +1,21 @@
+from typing import Any
+from typing import Protocol
+
+from rdflib import Literal
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+
+
+class OntologyClient(Protocol):
+    """
+    Protocol class/interface for the ontology endpoint in the API.
+    """
+
+    server: str
+    authentication_client: AuthenticationClient
+
+    def get_last_modification_date(self, project_iri: str, onto_iri: str) -> str:
+        """Get the last modification date of an ontology"""
+
+    def post_resource_cardinalities(self, cardinality_graph: dict[str, Any]) -> Literal | None:
+        """Add cardinalities to an existing resource class."""

dsp_tools/clients/ontology_client_live.py

@@ -0,0 +1,139 @@
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Any
+
+import requests
+from loguru import logger
+from rdflib import Graph
+from rdflib import Literal
+from rdflib import URIRef
+from requests import ReadTimeout
+from requests import Response
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.ontology_client import OntologyClient
+from dsp_tools.error.exceptions import BadCredentialsError
+from dsp_tools.error.exceptions import UnexpectedApiResponseError
+from dsp_tools.utils.rdflib_constants import KNORA_API
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_and_raise_timeouts
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_response
+
+TIMEOUT = 60
+
+
+@dataclass
+class OntologyClientLive(OntologyClient):
+    """
+    Client for the ontology endpoint in the API.
+    """
+
+    server: str
+    authentication_client: AuthenticationClient
+
+    def get_last_modification_date(self, project_iri: str, onto_iri: str) -> Literal:
+        url = f"{self.server}/v2/ontologies/metadata"
+        header = {"X-Knora-Accept-Project": project_iri}
+        logger.debug("GET ontology metadata")
+        try:
+            response = self._get_and_log_request(url, header)
+        except (TimeoutError, ReadTimeout) as err:
+            log_and_raise_timeouts(err)
+        if response.ok:
+            date = _parse_last_modification_date(response.text, URIRef(onto_iri))
+            if not date:
+                raise UnexpectedApiResponseError(
+                    f"Could not find the last modification date of the ontology '{onto_iri}' "
+                    f"in the response: {response.text}"
+                )
+            return date
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError("You do not have sufficient credentials to retrieve ontology metadata.")
+        else:
+            raise UnexpectedApiResponseError(
+                f"An unexpected response with the status code {response.status_code} was received from the API. "
+                f"Please consult 'warnings.log' for details."
+            )
+
+    def post_resource_cardinalities(self, cardinality_graph: dict[str, Any]) -> Literal | None:
+        url = f"{self.server}/v2/ontologies/cardinalities"
+
+        logger.debug("POST resource cardinalities to ontology")
+        try:
+            response = self._post_and_log_request(url, cardinality_graph)
+        except (TimeoutError, ReadTimeout) as err:
+            log_and_raise_timeouts(err)
+        if response.ok:
+            date = _parse_last_modification_date(response.text)
+            if not date:
+                raise UnexpectedApiResponseError(
+                    f"Could not find the last modification date in the response: {response.text}"
+                )
+            return date
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError(
+                "Only a project or system administrator can add cardinalities to resource classes. "
+                "Your permissions are insufficient for this action."
+            )
+        else:
+            logger.error(
+                f"During cardinality creation an unexpected response with the status code {response.status_code} "
+                f"was received from the API."
+            )
+            return None
+
+    def _post_and_log_request(
+        self,
+        url: str,
+        data: dict[str, Any] | None,
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        data_dict, generic_headers = self._prepare_request(data, headers)
+        params = RequestParameters("POST", url, TIMEOUT, data_dict, generic_headers)
+        log_request(params)
+        response = requests.post(
+            url=params.url,
+            headers=params.headers,
+            data=params.data_serialized,
+            timeout=params.timeout,
+        )
+        log_response(response)
+        return response
+
+    def _get_and_log_request(
+        self,
+        url: str,
+        headers: dict[str, str] | None = None,
+    ) -> Response:
+        _, generic_headers = self._prepare_request({}, headers)
+        params = RequestParameters(method="GET", url=url, timeout=TIMEOUT, headers=generic_headers)
+        log_request(params)
+        response = requests.get(
+            url=params.url,
+            headers=params.headers,
+            timeout=params.timeout,
+        )
+        log_response(response)
+        return response
+
+    def _prepare_request(
+        self, data: dict[str, Any] | None, headers: dict[str, str] | None
+    ) -> tuple[dict[str, Any] | None, dict[str, str]]:
+        generic_headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.authentication_client.get_token()}",
+        }
+        data_dict = data if data else None
+        if headers:
+            generic_headers.update(headers)
+        return data_dict, generic_headers
+
+
+def _parse_last_modification_date(response_text: str, onto_iri: URIRef | None = None) -> Literal | None:
+    g = Graph()
+    g.parse(data=response_text, format="json-ld")
+    result = next(g.objects(subject=onto_iri, predicate=KNORA_API.lastModificationDate), None)
+    if isinstance(result, Literal):
+        return result
+    return None

dsp_tools/commands/create/communicate_problems.py

@@ -0,0 +1,19 @@
+from loguru import logger
+
+from dsp_tools.commands.create.models.input_problems import CollectedProblems
+from dsp_tools.commands.create.models.input_problems import CreateProblem
+from dsp_tools.utils.ansi_colors import BOLD_RED
+from dsp_tools.utils.ansi_colors import RED
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+
+
+def print_problem_collection(problem_collection: CollectedProblems) -> None:
+    individual_problems = _create_individual_problem_strings(problem_collection.problems)
+    logger.error(problem_collection.header, individual_problems)
+    print(BOLD_RED, problem_collection.header, RESET_TO_DEFAULT)
+    print(RED, individual_problems, RESET_TO_DEFAULT)
+
+
+def _create_individual_problem_strings(problems: list[CreateProblem]) -> str:
+    str_list = [f"{p.problematic_object}: {p.problem!s}" for p in problems]
+    return "   - " + "\n    - ".join(str_list)

dsp_tools/commands/create/constants.py

@@ -1,4 +1,7 @@
-KNORA_API = "http://api.knora.org/ontology/knora-api/v2#"
-SALSAH_GUI = "http://api.knora.org/ontology/salsah-gui/v2#"
+from rdflib import Namespace
 
-UNIVERSAL_PREFIXES = {"knora-api": KNORA_API, "salsah-gui": SALSAH_GUI}
+KNORA_API_STR = "http://api.knora.org/ontology/knora-api/v2#"
+SALSAH_GUI_STR = "http://api.knora.org/ontology/salsah-gui/v2#"
+SALSAH_GUI = Namespace(SALSAH_GUI_STR)
+
+UNIVERSAL_PREFIXES = {"knora-api": KNORA_API_STR, "salsah-gui": SALSAH_GUI_STR}

dsp_tools/commands/create/create_on_server/cardinalities.py

@@ -0,0 +1,121 @@
+from typing import Any
+
+from loguru import logger
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.clients.ontology_client import OntologyClient
+from dsp_tools.clients.ontology_client_live import OntologyClientLive
+from dsp_tools.commands.create.models.input_problems import CollectedProblems
+from dsp_tools.commands.create.models.input_problems import CreateProblem
+from dsp_tools.commands.create.models.input_problems import ProblemType
+from dsp_tools.commands.create.models.input_problems import UploadProblem
+from dsp_tools.commands.create.models.parsed_ontology import ParsedClassCardinalities
+from dsp_tools.commands.create.models.parsed_ontology import ParsedOntology
+from dsp_tools.commands.create.models.parsed_ontology import ParsedPropertyCardinality
+from dsp_tools.commands.create.models.server_project_info import CreatedIriCollection
+from dsp_tools.commands.create.models.server_project_info import ProjectIriLookup
+from dsp_tools.commands.create.serialisation.ontology import _make_one_cardinality_graph
+from dsp_tools.commands.create.serialisation.ontology import make_ontology_base_graph
+from dsp_tools.utils.data_formats.iri_util import from_dsp_iri_to_prefixed_iri
+from dsp_tools.utils.rdflib_utils import serialise_json
+
+
+def add_all_cardinalities(
+    ontologies: list[ParsedOntology],
+    project_iri_lookup: ProjectIriLookup,
+    created_iris: CreatedIriCollection,
+    onto_client: OntologyClientLive,
+) -> CollectedProblems | None:
+    all_problems = []
+    for onto in ontologies:
+        onto_iri = project_iri_lookup.onto_iris.get(onto.name)
+        # we do not inform about onto failures here, as it will have been done upstream
+        if onto_iri:
+            last_mod_date = onto_client.get_last_modification_date(project_iri_lookup.project_iri, onto_iri)
+            problems = _add_all_cardinalities_for_one_onto(
+                cardinalities=onto.cardinalities,
+                onto_iri=URIRef(onto_iri),
+                last_modification_date=last_mod_date,
+                onto_client=onto_client,
+                created_iris=created_iris,
+            )
+            all_problems.extend(problems)
+    if all_problems:
+        return CollectedProblems("During the cardinality creation the following problems occurred:", all_problems)
+    return None
+
+
+def _add_all_cardinalities_for_one_onto(
+    cardinalities: list[ParsedClassCardinalities],
+    onto_iri: URIRef,
+    last_modification_date: Literal,
+    onto_client: OntologyClient,
+    created_iris: CreatedIriCollection,
+) -> list[CreateProblem]:
+    problems: list[CreateProblem] = []
+    for c in cardinalities:
+        # we do not inform about classes failures here, as it will have been done upstream
+        if c.class_iri not in created_iris.classes:
+            logger.warning(f"CARDINALITY: Class '{c.class_iri}' not in successes, no cardinalities added.")
+            continue
+        last_modification_date, creation_problems = _add_cardinalities_for_one_class(
+            resource_card=c,
+            onto_iri=onto_iri,
+            last_modification_date=last_modification_date,
+            onto_client=onto_client,
+            successful_props=created_iris.properties,
+        )
+        problems.extend(creation_problems)
+    return problems
+
+
+def _add_cardinalities_for_one_class(
+    resource_card: ParsedClassCardinalities,
+    onto_iri: URIRef,
+    last_modification_date: Literal,
+    onto_client: OntologyClient,
+    successful_props: set[str],
+) -> tuple[Literal, list[UploadProblem]]:
+    res_iri = URIRef(resource_card.class_iri)
+    problems = []
+    for one_card in resource_card.cards:
+        if one_card.propname not in successful_props:
+            logger.warning(f"CARDINALITY: Property '{one_card.propname}' not in successes, no cardinality added.")
+            continue
+        last_modification_date, problem = _add_one_cardinality(
+            one_card, res_iri, onto_iri, last_modification_date, onto_client
+        )
+        if problem:
+            problems.append(problem)
+    return last_modification_date, problems
+
+
+def _add_one_cardinality(
+    card: ParsedPropertyCardinality,
+    res_iri: URIRef,
+    onto_iri: URIRef,
+    last_modification_date: Literal,
+    onto_client: OntologyClient,
+) -> tuple[Literal, UploadProblem | None]:
+    card_serialised = _serialise_card(card, res_iri, onto_iri, last_modification_date)
+    new_mod_date = onto_client.post_resource_cardinalities(card_serialised)
+    if not new_mod_date:
+        prefixed_cls = from_dsp_iri_to_prefixed_iri(str(res_iri))
+        prefixed_prop = from_dsp_iri_to_prefixed_iri(card.propname)
+        return last_modification_date, UploadProblem(
+            f"{prefixed_cls} / {prefixed_prop}",
+            ProblemType.CARDINALITY_COULD_NOT_BE_ADDED,
+        )
+    return new_mod_date, None
+
+
+def _serialise_card(
+    card: ParsedPropertyCardinality, res_iri: URIRef, onto_iri: URIRef, last_modification_date: Literal
+) -> dict[str, Any]:
+    onto_g = make_ontology_base_graph(onto_iri, last_modification_date)
+    onto_serialised = next(iter(serialise_json(onto_g)))
+    card_g = _make_one_cardinality_graph(card, res_iri)
+    card_serialised = serialise_json(card_g)
+    onto_serialised["@graph"] = card_serialised
+    return onto_serialised

dsp_tools/commands/create/create_on_server/mappers.py

@@ -0,0 +1,12 @@
+from rdflib import OWL
+from rdflib import Literal
+
+from dsp_tools.commands.create.models.parsed_ontology import Cardinality
+from dsp_tools.commands.create.models.rdf_ontology import RdfCardinalityRestriction
+
+PARSED_CARDINALITY_TO_RDF = {
+    Cardinality.C_1: RdfCardinalityRestriction(OWL.cardinality, Literal(1)),
+    Cardinality.C_0_1: RdfCardinalityRestriction(OWL.maxCardinality, Literal(1)),
+    Cardinality.C_1_N: RdfCardinalityRestriction(OWL.minCardinality, Literal(1)),
+    Cardinality.C_0_N: RdfCardinalityRestriction(OWL.minCardinality, Literal(0)),
+}

dsp_tools/commands/create/models/input_problems.py

@@ -7,17 +7,26 @@ from enum import StrEnum
 @dataclass
 class CollectedProblems:
     header: str
-    problems: list[InputProblem]
+    problems: list[CreateProblem]
 
 
 @dataclass
-class InputProblem:
+class CreateProblem:
     problematic_object: str
     problem: ProblemType
 
 
+@dataclass
+class InputProblem(CreateProblem): ...
+
+
+@dataclass
+class UploadProblem(CreateProblem): ...
+
+
 class ProblemType(StrEnum):
     PREFIX_COULD_NOT_BE_RESOLVED = (
         "The prefix used is not defined in the 'prefix' section of the file, "
         "nor does it belong to one of the project ontologies."
     )
+    CARDINALITY_COULD_NOT_BE_ADDED = "The cardinality could not be added."

dsp_tools/commands/create/models/rdf_ontology.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from rdflib import Literal
+from rdflib import URIRef
+
+
+@dataclass
+class RdfResourceCardinality:
+    resource_iri: URIRef
+    on_property: URIRef
+    cardinality: RdfCardinalityRestriction
+
+
+@dataclass
+class RdfCardinalityRestriction:
+    owl_property: URIRef
+    cardinality_value: Literal

dsp_tools/commands/create/models/server_project_info.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from dataclasses import field
+
+from dsp_tools.commands.create.constants import KNORA_API_STR
+
+
+@dataclass
+class ProjectIriLookup:
+    project_iri: str
+    onto_iris: dict[str, str] = field(default_factory=dict)
+
+    def add_onto(self, name: str, iri: str) -> None:
+        self.onto_iris[name] = iri
+
+    def get_onto_iri(self, name: str) -> str | None:
+        return self.onto_iris.get(name)
+
+
+@dataclass
+class CreatedIriCollection:
+    classes: set[str] = field(default_factory=set)
+    properties: set[str] = field(default_factory=set)
+
+    def __post_init__(self) -> None:
+        self.properties.update({f"{KNORA_API_STR}seqnum", f"{KNORA_API_STR}isPartOf"})

dsp_tools/commands/create/parsing/parse_ontology.py

@@ -2,7 +2,7 @@ from typing import Any
 from typing import cast
 
 from dsp_tools.commands.create.models.input_problems import CollectedProblems
-from dsp_tools.commands.create.models.input_problems import InputProblem
+from dsp_tools.commands.create.models.input_problems import CreateProblem
 from dsp_tools.commands.create.models.input_problems import ProblemType
 from dsp_tools.commands.create.models.parsed_ontology import Cardinality
 from dsp_tools.commands.create.models.parsed_ontology import ParsedClass
@@ -46,7 +46,7 @@ def parse_ontology(ontology_json: dict[str, Any], prefixes: dict[str, str]) -> P
 
 def _parse_properties(
     properties_list: list[dict[str, Any]], current_onto_prefix: str
-) -> tuple[list[ParsedProperty], list[InputProblem]]:
+) -> tuple[list[ParsedProperty], list[CreateProblem]]:
     parsed = []
     for prop in properties_list:
         parsed.append(ParsedProperty(f"{current_onto_prefix}{prop['name']}", prop))
@@ -55,7 +55,7 @@ def _parse_properties(
 
 def _parse_classes(
     classes_list: list[dict[str, Any]], current_onto_prefix: str
-) -> tuple[list[ParsedClass], list[InputProblem]]:
+) -> tuple[list[ParsedClass], list[CreateProblem]]:
     parsed = []
     for cls in classes_list:
         parsed.append(ParsedClass(f"{current_onto_prefix}{cls['name']}", cls))
@@ -64,7 +64,7 @@ def _parse_classes(
 
 def _parse_cardinalities(
     classes_list: list[dict[str, Any]], current_onto_prefix: str, prefixes: dict[str, str]
-) -> tuple[list[ParsedClassCardinalities], list[InputProblem]]:
+) -> tuple[list[ParsedClassCardinalities], list[CreateProblem]]:
     parsed = []
     failures = []
     for c in classes_list:
@@ -79,7 +79,7 @@ def _parse_cardinalities(
 
 def _parse_one_class_cardinality(
     cls_json: dict[str, Any], current_onto_prefix: str, prefixes: dict[str, str]
-) -> ParsedClassCardinalities | list[InputProblem]:
+) -> ParsedClassCardinalities | list[CreateProblem]:
     failures = []
     parsed = []
     for c in cls_json["cardinalities"]:
@@ -96,10 +96,10 @@ def _parse_one_class_cardinality(
 
 def _parse_one_cardinality(
     card_json: dict[str, str | int], current_onto_prefix: str, prefixes: dict[str, str]
-) -> ParsedPropertyCardinality | InputProblem:
+) -> ParsedPropertyCardinality | CreateProblem:
     prp_name = cast(str, card_json["propname"])
     if not (resolved := resolve_to_absolute_iri(prp_name, current_onto_prefix, prefixes)):
-        return InputProblem(prp_name, ProblemType.PREFIX_COULD_NOT_BE_RESOLVED)
+        return CreateProblem(prp_name, ProblemType.PREFIX_COULD_NOT_BE_RESOLVED)
     gui = cast(int | None, card_json.get("gui_order"))
     return ParsedPropertyCardinality(
         propname=resolved,

dsp_tools/commands/create/parsing/parse_project.py

@@ -56,7 +56,7 @@ def _parse_metadata(project_json: dict[str, Any]) -> ParsedProjectMetadata:
         longname=project_json["longname"],
         descriptions=project_json["descriptions"],
         keywords=project_json["keywords"],
-        enabled_licenses=project_json["enabled_licenses"],
+        enabled_licenses=project_json.get("enabled_licenses", []),
     )
 
 

dsp_tools/commands/create/parsing/parsing_utils.py

@@ -2,7 +2,7 @@ from typing import Any
 
 import regex
 
-from dsp_tools.commands.create.constants import KNORA_API
+from dsp_tools.commands.create.constants import KNORA_API_STR
 from dsp_tools.commands.create.constants import UNIVERSAL_PREFIXES
 from dsp_tools.utils.data_formats.uri_util import is_uri
 
@@ -14,7 +14,7 @@ def resolve_to_absolute_iri(prefixed: str, current_onto: str, prefix_lookup: dic
         return f"{current_onto}{prefixed.lstrip(':')}"
     segments = prefixed.split(":", maxsplit=1)
     if len(segments) == 1:
-        return f"{KNORA_API}{segments[0]}"
+        return f"{KNORA_API_STR}{segments[0]}"
     if not (found := prefix_lookup.get(segments[0])):
         return None
     return f"{found}{segments[1]}"

dsp_tools/commands/create/serialisation/ontology.py

@@ -0,0 +1,41 @@
+from rdflib import OWL
+from rdflib import RDF
+from rdflib import RDFS
+from rdflib import BNode
+from rdflib import Graph
+from rdflib import Literal
+from rdflib import URIRef
+
+from dsp_tools.commands.create.constants import SALSAH_GUI
+from dsp_tools.commands.create.create_on_server.mappers import PARSED_CARDINALITY_TO_RDF
+from dsp_tools.commands.create.models.parsed_ontology import ParsedPropertyCardinality
+from dsp_tools.utils.rdflib_constants import KNORA_API
+
+
+def make_ontology_base_graph(onto_iri: URIRef, last_modification_date: Literal) -> Graph:
+    g = Graph()
+    g.add((onto_iri, RDF.type, OWL.Ontology))
+    g.add((onto_iri, KNORA_API.lastModificationDate, last_modification_date))
+    return g
+
+
+def make_cardinality_graph_for_request(
+    card: ParsedPropertyCardinality, res_iri: URIRef, onto_iri: URIRef, last_modification_date: Literal
+) -> Graph:
+    g = make_ontology_base_graph(onto_iri, last_modification_date)
+    g += _make_one_cardinality_graph(card, res_iri)
+    return g
+
+
+def _make_one_cardinality_graph(card: ParsedPropertyCardinality, res_iri: URIRef) -> Graph:
+    card_info = PARSED_CARDINALITY_TO_RDF[card.cardinality]
+    g = Graph()
+    bn_card = BNode()
+    g.add((res_iri, RDF.type, OWL.Class))
+    g.add((res_iri, RDFS.subClassOf, bn_card))
+    g.add((bn_card, RDF.type, OWL.Restriction))
+    g.add((bn_card, card_info.owl_property, card_info.cardinality_value))
+    g.add((bn_card, OWL.onProperty, URIRef(card.propname)))
+    if card.gui_order is not None:
+        g.add((bn_card, SALSAH_GUI.guiOrder, Literal(card.gui_order)))
+    return g

dsp_tools/commands/project/create/project_create_all.py

@@ -4,6 +4,7 @@ of the project, the creation of groups, users, lists, resource classes, properti
 import os
 from pathlib import Path
 from typing import Any
+from typing import cast
 from urllib.parse import quote_plus
 
 from dotenv import load_dotenv
@@ -13,11 +14,14 @@ from dsp_tools.cli.args import ServerCredentials
 from dsp_tools.clients.authentication_client_live import AuthenticationClientLive
 from dsp_tools.clients.connection import Connection
 from dsp_tools.clients.connection_live import ConnectionLive
+from dsp_tools.commands.create.communicate_problems import print_problem_collection
+from dsp_tools.commands.create.models.parsed_project import ParsedProject
+from dsp_tools.commands.create.models.server_project_info import ProjectIriLookup
+from dsp_tools.commands.create.parsing.parse_project import parse_project
 from dsp_tools.commands.project.create.parse_project import parse_project_json
 from dsp_tools.commands.project.create.project_create_default_permissions import create_default_permissions
 from dsp_tools.commands.project.create.project_create_lists import create_lists_on_server
 from dsp_tools.commands.project.create.project_create_ontologies import create_ontologies
-from dsp_tools.commands.project.create.project_validate import validate_project
 from dsp_tools.commands.project.legacy_models.context import Context
 from dsp_tools.commands.project.legacy_models.group import Group
 from dsp_tools.commands.project.legacy_models.project import Project
@@ -34,7 +38,7 @@ from dsp_tools.utils.json_parsing import parse_json_input
 load_dotenv()
 
 
-def create_project(  # noqa: PLR0915 (too many statements)
+def create_project(  # noqa: PLR0915,PLR0912 (too many statements & branches)
     project_file_as_path_or_parsed: str | Path | dict[str, Any],
     creds: ServerCredentials,
     verbose: bool = False,
@@ -69,38 +73,41 @@ def create_project(  # noqa: PLR0915 (too many statements)
     knora_api_prefix = "knora-api:"
     overall_success = True
 
-    project_json = parse_json_input(project_file_as_path_or_parsed=project_file_as_path_or_parsed)
+    # includes validation
+    parsed_project = parse_project(project_file_as_path_or_parsed, creds.server)
+    if not isinstance(parsed_project, ParsedProject):
+        for problem in parsed_project:
+            print_problem_collection(problem)
+        return False
 
+    # required for the legacy code
+    project_json = parse_json_input(project_file_as_path_or_parsed=project_file_as_path_or_parsed)
     context = Context(project_json.get("prefixes", {}))
-
-    # validate against JSON schema
-    validate_project(project_json)
-    print("    JSON project file is syntactically correct and passed validation.")
-    logger.info("JSON project file is syntactically correct and passed validation.")
-
-    project = parse_project_json(project_json)
+    legacy_project = parse_project_json(project_json)
 
     auth = AuthenticationClientLive(creds.server, creds.user, creds.password)
     con = ConnectionLive(creds.server, auth)
 
     # create project on DSP server
-    info_str = f"Create project '{project.metadata.shortname}' ({project.metadata.shortcode})..."
+    info_str = f"Create project '{legacy_project.metadata.shortname}' ({legacy_project.metadata.shortcode})..."
     print(info_str)
     logger.info(info_str)
     project_remote, success = _create_project_on_server(
-        project_definition=project.metadata,
+        project_definition=legacy_project.metadata,
         con=con,
     )
+    project_iri = cast(str, project_remote.iri)
+    project_iri_lookup = ProjectIriLookup(project_iri)
     if not success:
         overall_success = False
 
     # create the lists
     names_and_iris_of_list_nodes: dict[str, Any] = {}
-    if project.lists:
+    if legacy_project.lists:
         print("Create lists...")
         logger.info("Create lists...")
         names_and_iris_of_list_nodes, success = create_lists_on_server(
-            lists_to_create=project.lists,
+            lists_to_create=legacy_project.lists,
             con=con,
             project_remote=project_remote,
         )
@@ -109,24 +116,24 @@ def create_project(  # noqa: PLR0915 (too many statements)
 
     # create the groups
     current_project_groups: dict[str, Group] = {}
-    if project.groups:
+    if legacy_project.groups:
         print("Create groups...")
         logger.info("Create groups...")
         current_project_groups, success = _create_groups(
             con=con,
-            groups=project.groups,
+            groups=legacy_project.groups,
             project=project_remote,
         )
         if not success:
             overall_success = False
 
     # create or update the users
-    if project.users:
+    if legacy_project.users:
         print("Create users...")
         logger.info("Create users...")
         success = _create_users(
             con=con,
-            users_section=project.users,
+            users_section=legacy_project.users,
             current_project_groups=current_project_groups,
             current_project=project_remote,
             verbose=verbose,
@@ -140,9 +147,12 @@ def create_project(  # noqa: PLR0915 (too many statements)
         context=context,
         knora_api_prefix=knora_api_prefix,
         names_and_iris_of_list_nodes=names_and_iris_of_list_nodes,
-        ontology_definitions=project.ontologies,
+        ontology_definitions=legacy_project.ontologies,
         project_remote=project_remote,
         verbose=verbose,
+        parsed_ontologies=parsed_project.ontologies,
+        project_iri_lookup=project_iri_lookup,
+        auth=auth,
     )
     if not success:
         overall_success = False
@@ -151,9 +161,9 @@ def create_project(  # noqa: PLR0915 (too many statements)
     perm_client = PermissionsClient(auth, str(project_remote.iri))
     success = create_default_permissions(
         perm_client,
-        project.metadata.default_permissions,
-        project.metadata.default_permissions_overrule,
-        project.metadata.shortcode,
+        legacy_project.metadata.default_permissions,
+        legacy_project.metadata.default_permissions_overrule,
+        legacy_project.metadata.shortcode,
     )
     if not success:
         overall_success = False
@@ -161,15 +171,15 @@ def create_project(  # noqa: PLR0915 (too many statements)
     # final steps
     if overall_success:
         msg = (
-            f"Successfully created project '{project.metadata.shortname}' "
-            f"({project.metadata.shortcode}) with all its ontologies. "
+            f"Successfully created project '{legacy_project.metadata.shortname}' "
+            f"({legacy_project.metadata.shortcode}) with all its ontologies. "
             f"There were no problems during the creation process."
         )
         print(f"========================================================\n{msg}")
         logger.info(msg)
     else:
         msg = (
-            f"The project '{project.metadata.shortname}' ({project.metadata.shortcode}) "
+            f"The project '{legacy_project.metadata.shortname}' ({legacy_project.metadata.shortcode}) "
             f"with its ontologies could be created, "
             f"but during the creation process, some problems occurred. Please carefully check the console output."
         )

dsp_tools/commands/project/create/project_create_ontologies.py

@@ -1,12 +1,19 @@
 from typing import Any
 from typing import Optional
+from typing import cast
 
 import regex
 from loguru import logger
 
+from dsp_tools.clients.authentication_client import AuthenticationClient
 from dsp_tools.clients.connection import Connection
+from dsp_tools.clients.ontology_client_live import OntologyClientLive
+from dsp_tools.commands.create.communicate_problems import print_problem_collection
+from dsp_tools.commands.create.create_on_server.cardinalities import add_all_cardinalities
+from dsp_tools.commands.create.models.parsed_ontology import ParsedOntology
+from dsp_tools.commands.create.models.server_project_info import CreatedIriCollection
+from dsp_tools.commands.create.models.server_project_info import ProjectIriLookup
 from dsp_tools.commands.project.legacy_models.context import Context
-from dsp_tools.commands.project.legacy_models.helpers import Cardinality
 from dsp_tools.commands.project.legacy_models.ontology import Ontology
 from dsp_tools.commands.project.legacy_models.project import Project
 from dsp_tools.commands.project.legacy_models.propertyclass import PropertyClass
@@ -25,6 +32,9 @@ def create_ontologies(
     ontology_definitions: list[dict[str, Any]],
     project_remote: Project,
     verbose: bool,
+    parsed_ontologies: list[ParsedOntology],
+    project_iri_lookup: ProjectIriLookup,
+    auth: AuthenticationClient,
 ) -> bool:
     """
     Iterates over the ontologies in a JSON project file and creates the ontologies that don't exist on the DSP server
@@ -39,6 +49,9 @@ def create_ontologies(
         ontology_definitions: the "ontologies" section of the parsed JSON project file
         project_remote: representation of the project on the DSP server
         verbose: verbose switch
+        parsed_ontologies: parsed ontologies
+        project_iri_lookup: lookup for IRIs
+        auth: Authentication Client
 
     Raises:
         InputError: if an error occurs during the creation of an ontology.
@@ -47,6 +60,8 @@ def create_ontologies(
     Returns:
         True if everything went smoothly, False otherwise
     """
+    success_collection = CreatedIriCollection()
+    onto_client = OntologyClientLive(auth.server, auth)
 
     overall_success = True
 
@@ -60,6 +75,9 @@ def create_ontologies(
         logger.exception(err_msg)
         project_ontologies = []
 
+    for existing_onto in project_ontologies:
+        project_iri_lookup.add_onto(existing_onto.name, existing_onto.iri)
+
     created_ontos: list[tuple[dict[str, Any], Ontology, dict[str, ResourceClass]]] = []
     for ontology_definition in ontology_definitions:
         ontology_remote = _create_ontology(
@@ -75,6 +93,8 @@ def create_ontologies(
         if not ontology_remote:
             overall_success = False
             continue
+        else:
+            project_iri_lookup.add_onto(ontology_remote.name, ontology_remote.iri)
 
         # add the empty resource classes to the remote ontology
         last_modification_date, remote_res_classes, success = _add_resource_classes_to_remote_ontology(
@@ -85,11 +105,12 @@ def create_ontologies(
             last_modification_date=ontology_remote.lastModificationDate,
             verbose=verbose,
         )
+        success_collection.classes.update(set(remote_res_classes.keys()))
         if not success:
             overall_success = False
 
         # add the property classes to the remote ontology
-        last_modification_date, success = _add_property_classes_to_remote_ontology(
+        last_modification_date, success, property_successes = _add_property_classes_to_remote_ontology(
             onto_name=ontology_definition["name"],
             property_definitions=ontology_definition.get("properties", []),
             ontology_remote=ontology_remote,
@@ -99,22 +120,21 @@ def create_ontologies(
             knora_api_prefix=knora_api_prefix,
             verbose=verbose,
         )
+        success_collection.properties.update(property_successes)
         created_ontos.append((ontology_definition, ontology_remote, remote_res_classes))
         if not success:
             overall_success = False
 
     print("Add cardinalities to resource classes...")
-    for ontology_definition, ontology_remote, remote_res_classes in created_ontos:
-        success = _add_cardinalities_to_resource_classes(
-            resclass_definitions=ontology_definition.get("resources", []),
-            ontology_remote=ontology_remote,
-            remote_res_classes=remote_res_classes,
-            knora_api_prefix=knora_api_prefix,
-            context=context,
-            verbose=verbose,
-        )
-        if not success:
-            overall_success = False
+    problems = add_all_cardinalities(
+        ontologies=parsed_ontologies,
+        project_iri_lookup=project_iri_lookup,
+        created_iris=success_collection,
+        onto_client=onto_client,
+    )
+    if problems:
+        overall_success = False
+        print_problem_collection(problems)
 
     return overall_success
 
@@ -297,7 +317,7 @@ def _add_property_classes_to_remote_ontology(
     last_modification_date: DateTimeStamp,
     knora_api_prefix: str,
     verbose: bool,
-) -> tuple[DateTimeStamp, bool]:
+) -> tuple[DateTimeStamp, bool, set[str]]:
     """
     Creates the property classes defined in the "properties" section of an ontology. The
     containing project and the containing ontology must already be existing on the DSP server.
@@ -317,6 +337,7 @@ def _add_property_classes_to_remote_ontology(
     Returns:
         a tuple consisting of the last modification date of the ontology, and the success status
     """
+    property_successes = set()
     overall_success = True
     print("    Create property classes...")
     logger.info("Create property classes...")
@@ -370,11 +391,13 @@ def _add_property_classes_to_remote_ontology(
             comment=LangString(prop_class["comments"]) if prop_class.get("comments") else None,
         )
         try:
-            last_modification_date, _ = prop_class_local.create(last_modification_date)
+            last_modification_date, prop_class_created = prop_class_local.create(last_modification_date)
             ontology_remote.lastModificationDate = last_modification_date
             if verbose:
                 print(f"    Created property class '{prop_class['name']}'")
             logger.info(f"Created property class '{prop_class['name']}'")
+            prop_iri = cast(str, prop_class_created.iri)
+            property_successes.add(prop_iri)
         except BaseError as err:
             err_msg = f"Unable to create property class '{prop_class['name']}'"
             if found := regex.search(
@@ -386,7 +409,7 @@ def _add_property_classes_to_remote_ontology(
             logger.exception(err_msg)
             overall_success = False
 
-    return last_modification_date, overall_success
+    return last_modification_date, overall_success, property_successes
 
 
 def _sort_prop_classes(
@@ -423,76 +446,3 @@ def _sort_prop_classes(
                 ok_propclass_names.append(prop_name)
                 prop_classes_to_sort.remove(prop)
     return sorted_prop_classes
-
-
-def _add_cardinalities_to_resource_classes(
-    resclass_definitions: list[dict[str, Any]],
-    ontology_remote: Ontology,
-    remote_res_classes: dict[str, ResourceClass],
-    knora_api_prefix: str,
-    context: Context,
-    verbose: bool,
-) -> bool:
-    """
-    Iterates over the resource classes of an ontology of a JSON project definition, and adds the cardinalities to each
-    resource class. The resource classes and the properties must already be existing on the DSP server.
-    If an error occurs during creation of a cardinality, it is printed out, the process continues, but the success
-    status will be false.
-
-    Args:
-        resclass_definitions: the part of the parsed JSON project file that contains the resources of the current onto
-        ontology_remote: representation of the current ontology on the DSP server
-        remote_res_classes: representations of the resource classes on the DSP server
-        knora_api_prefix: the prefix that stands for the knora-api ontology
-        context: the context of the current project
-        verbose: verbose switch
-
-    Returns:
-        success status
-    """
-    overall_success = True
-    print(f"    Add cardinalities to resource classes of ontology '{ontology_remote.iri}'...")
-    logger.info(f"Add cardinalities to resource classes of ontology '{ontology_remote.iri}'...")
-    switcher = {
-        "1": Cardinality.C_1,
-        "0-1": Cardinality.C_0_1,
-        "0-n": Cardinality.C_0_n,
-        "1-n": Cardinality.C_1_n,
-    }
-    for res_class in resclass_definitions:
-        res_class_remote = remote_res_classes.get(f"{ontology_remote.iri}#{res_class['name']}")
-        if not res_class_remote:
-            msg = (
-                f"Unable to add cardinalities to resource class '{res_class['name']}': "
-                f"This class doesn't exist on the DSP server."
-            )
-            print(f"WARNINIG: {msg}")
-            logger.exception(msg)
-            overall_success = False
-            continue
-        for card_info in res_class.get("cardinalities", []):
-            if ":" in card_info["propname"]:
-                prefix, prop = card_info["propname"].split(":")
-                qualified_propname = card_info["propname"] if prefix else f"{ontology_remote.name}:{prop}"
-            else:
-                qualified_propname = knora_api_prefix + card_info["propname"]
-
-            try:
-                last_modification_date = res_class_remote.addProperty(
-                    property_id=qualified_propname,
-                    cardinality=switcher[card_info["cardinality"]],
-                    gui_order=card_info.get("gui_order"),
-                    last_modification_date=ontology_remote.lastModificationDate,
-                    context=context,
-                )
-                ontology_remote.lastModificationDate = last_modification_date
-                if verbose:
-                    print(f"    Added cardinality '{card_info['propname']}' to resource class '{res_class['name']}'")
-                logger.info(f"Added cardinality '{card_info['propname']}' to resource class '{res_class['name']}'")
-            except BaseError:
-                err_msg = f"Unable to add cardinality '{qualified_propname}' to resource class {res_class['name']}."
-                print(f"WARNING: {err_msg}")
-                logger.exception(err_msg)
-                overall_success = False
-
-    return overall_success

dsp_tools/commands/project/legacy_models/resourceclass.py

@@ -477,39 +477,6 @@ class ResourceClass(Model):
     def has_properties(self) -> dict[str, HasProperty]:
         return self._has_properties
 
-    def getProperty(self, property_id: str) -> Optional[HasProperty]:
-        if self._has_properties is None:
-            return None
-        else:
-            return self._has_properties.get(self._context.get_prefixed_iri(property_id))
-
-    def addProperty(
-        self,
-        last_modification_date: DateTimeStamp,
-        property_id: str,
-        cardinality: Cardinality,
-        context: Context,
-        gui_order: Optional[int] = None,
-    ) -> DateTimeStamp:
-        self._context.context.update(context.context)
-        if self._has_properties.get(property_id) is None:
-            latest_modification_date, resclass = HasProperty(
-                con=self._con,
-                context=self._context,
-                ontology_id=self._ontology_id,
-                property_id=property_id,
-                resclass_id=self.iri,
-                cardinality=cardinality,
-                gui_order=gui_order,
-            ).create(last_modification_date)
-            hp = resclass.getProperty(property_id)
-            hp.ontology_id = self._context.iri_from_prefix(self._ontology_id)
-            hp.resclass_id = self._iri
-            self._has_properties[hp.property_id] = hp
-            return latest_modification_date
-        else:
-            raise BaseError("Property already has cardinality in this class! " + property_id)
-
     @classmethod
     def fromJsonObj(cls, con: Connection, context: Context, json_obj: Any) -> ResourceClass:
         if isinstance(json_obj, list):

dsp_tools/error/exceptions.py

@@ -65,6 +65,10 @@ class InvalidGuiAttributeError(BaseError):
     """This error is raised when a invalid gui-attribute is used."""
 
 
+class UnexpectedApiResponseError(BaseError):
+    """This error is raised when the API gives an unexpected response, that we cannot anticipate and handle cleanly."""
+
+
 class UserFilepathNotFoundError(InputError):
     """This error is raised if a filepath from the user does not exist."""
 

dsp_tools/utils/data_formats/iri_util.py

@@ -12,3 +12,10 @@ def is_iri(s: str) -> bool:
 def is_resource_iri(s: str) -> bool:
     """Checks whether a string is a valid resource IRI."""
     return regex.fullmatch(_resource_iri_pattern, s) is not None
+
+
+def from_dsp_iri_to_prefixed_iri(iri: str) -> str:
+    dsp_iri_re = r".+\/(.+?)\/v2#(.+)$"
+    if not (found := regex.search(dsp_iri_re, iri)):
+        return iri
+    return f"{found.group(1)}:{found.group(2)}"

dsp_tools/utils/rdflib_utils.py

@@ -0,0 +1,10 @@
+import json
+from typing import Any
+
+from rdflib import Graph
+
+
+def serialise_json(rdf_graph: Graph) -> list[dict[str, Any]]:
+    graph_bytes = rdf_graph.serialize(format="json-ld", encoding="utf-8")
+    json_graph: list[dict[str, Any]] = json.loads(graph_bytes)
+    return json_graph

{dsp_tools-17.0.0.post14.dist-info → dsp_tools-17.0.0.post21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dsp-tools
-Version: 17.0.0.post14
+Version: 17.0.0.post21
 Summary: DSP-TOOLS is a Python package with a command line interface that helps you interact with a DaSCH service platform (DSP) server.
 Author: DaSCH - Swiss National Data and Service Center for the Humanities
 Author-email: DaSCH - Swiss National Data and Service Center for the Humanities <info@dasch.swiss>

{dsp_tools-17.0.0.post14.dist-info → dsp_tools-17.0.0.post21.dist-info}/RECORD

@@ -12,18 +12,29 @@ dsp_tools/clients/connection_live.py,sha256=Y0T-F93FFGnY2Z7qHhG56v3Ajg7U7ATq4QHI
 dsp_tools/clients/fuseki_metrics.py,sha256=Vy_aWOusnzlD0EnbyHZcTtPIpMEfRA_ihtYbysTq7sQ,2059
 dsp_tools/clients/legal_info_client.py,sha256=itDvGQf1VV1WiH2oHVcH1epSUSdJPRDwdRUvmCw8P4s,742
 dsp_tools/clients/legal_info_client_live.py,sha256=9nOe8Y-oQRHh4TkD2-tjdxLNNTonQ0i-P6UjCGgIBGA,5987
+dsp_tools/clients/metadata_client.py,sha256=Ozlnz8-_lgPHHKPXsRyLDx1ccvBPoIYLbAJcfYnKvXY,610
+dsp_tools/clients/metadata_client_live.py,sha256=LKaGCBZTAyJg0JHxrDOkcrb_Z3csNKXHEhKiWlVylis,1739
+dsp_tools/clients/ontology_client.py,sha256=bATGyI8YFFCl0yis9beJjGB1ZlJuO_GqYnlB-2ulv94,638
+dsp_tools/clients/ontology_client_live.py,sha256=8uWoRxwlCvUHQZYQsQ5XojAlpEAqzIhFNYROQfsNWf4,5367
 dsp_tools/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/commands/create/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dsp_tools/commands/create/constants.py,sha256=UHbYEERF8Rss7JINKBaR6z85LpwaH8w892airFKYHcw,191
+dsp_tools/commands/create/communicate_problems.py,sha256=GdAOiUZevrYFhRINyDMhcbXdUqtGDKb2nEelhdfSFR0,885
+dsp_tools/commands/create/constants.py,sha256=ZzWNn_zh-0Oy0SJmGivQbcAnQTmwT0akNchZUppXgh0,276
+dsp_tools/commands/create/create_on_server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsp_tools/commands/create/create_on_server/cardinalities.py,sha256=QW0i6TSNmP-dGS2WSad1np9QHz41-A51ArspuAQZGJg,5260
+dsp_tools/commands/create/create_on_server/mappers.py,sha256=Lu2DJAICOZu7WP_1UDvyvRAi0T9ZGO88kvx0UfI6v5I,564
 dsp_tools/commands/create/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dsp_tools/commands/create/models/input_problems.py,sha256=xU4nzl-DEghXWg7eT5V6Z3V_srzUlM-WmzeitDY3fBE,483
+dsp_tools/commands/create/models/input_problems.py,sha256=Oa8-fQy2FTtmfXzMVdhBE9Cs3PlOgTWga4XmK5QkM7s,665
 dsp_tools/commands/create/models/parsed_ontology.py,sha256=EUuD47SmWXyB74vGdxGwuvRzq1f4_YdciwYmqcEwqWc,815
 dsp_tools/commands/create/models/parsed_project.py,sha256=Gnl9gJEm5sNbccYG24cwT4doS-oqh_cywjbqk1V4wZQ,928
+dsp_tools/commands/create/models/rdf_ontology.py,sha256=TyXHmblr9j5XZFVqjLT516MrVYPgzjXWvTX4TckEPPk,361
+dsp_tools/commands/create/models/server_project_info.py,sha256=k5EVYo8ZJhMMB5XKja9Xl6CFQ_oLRFdRZPjMyj4XmO4,699
 dsp_tools/commands/create/parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dsp_tools/commands/create/parsing/parse_lists.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dsp_tools/commands/create/parsing/parse_ontology.py,sha256=4G_IN7lUdfTmZRTpcsE644MjP9HXe3NQkQ8c48lCiGQ,4261
-dsp_tools/commands/create/parsing/parse_project.py,sha256=yWcBSAmlcML5GsSTFVL69XFuzqyntrANq6XO9Nfh3n8,3997
-dsp_tools/commands/create/parsing/parsing_utils.py,sha256=u_PG8EWnhT1aV5GQSb5eCUbGY0Bd7mo4W49ciIhFzVo,1628
+dsp_tools/commands/create/parsing/parse_ontology.py,sha256=4cqo2wa9wcLBszWXgPrixQgaHYPHfENQbF6dkeBVNiU,4268
+dsp_tools/commands/create/parsing/parse_project.py,sha256=CghB-pJ6RcllOP0jn8Hs50kRcxS2Q0iS8A_QNGbjzZU,4005
+dsp_tools/commands/create/parsing/parsing_utils.py,sha256=-kr9ulha4T6reaQsQ2lImuqKEp2w4tQi66tjm2lDa9w,1636
+dsp_tools/commands/create/serialisation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dsp_tools/commands/create/serialisation/ontology.py,sha256=NK4kjriHs7dt5fXNiIBc1z_mE9szI4YemJ--hkYYeCk,1581
 dsp_tools/commands/excel2json/CLAUDE.md,sha256=y7ZcmrHbewN48sV0wyZhNfXDXdERG4PRvdz02Mqh0gg,3399
 dsp_tools/commands/excel2json/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/commands/excel2json/json_header.py,sha256=3PkhYHloGhuK9_zl7XrqboRksquWzGsdNNNo7-LC2c8,13543
@@ -66,10 +77,10 @@ dsp_tools/commands/ingest_xmlupload/upload_files/upload_files.py,sha256=QXj58UiT
 dsp_tools/commands/project/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/commands/project/create/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/commands/project/create/parse_project.py,sha256=xYcFaUtKLZigxDZpD7O2JNueHmy_-Ar1iE2LJe97gos,4081
-dsp_tools/commands/project/create/project_create_all.py,sha256=aOPk_Bwg6-0VXTDaG3VnhbBRtqZtzcGS87uGcEdqjMg,24201
+dsp_tools/commands/project/create/project_create_all.py,sha256=GM1XjpRvGoT79wGO9VF27c8CBdV42dIOhcT3AdKSwzg,24888
 dsp_tools/commands/project/create/project_create_default_permissions.py,sha256=CygzQ4rFF6SYUCkSvrO6gkjpINWZh4wjq_2V0PExwso,5990
 dsp_tools/commands/project/create/project_create_lists.py,sha256=A9kKe4gVP1Ug869102bRXK5RraZUtGzv5cWyFfK_DEA,7963
-dsp_tools/commands/project/create/project_create_ontologies.py,sha256=Iz38-3ubInEPpvCHpQDiJ9qR7bF4ZFwXJ121E5xEdC8,21647
+dsp_tools/commands/project/create/project_create_ontologies.py,sha256=Ie5WHTKg5S1bRCg3SmmbB1tjem3NwRrX3N32TeAWzyI,19465
 dsp_tools/commands/project/create/project_validate.py,sha256=H5TVvqO5V63roGEde1J0n21twkajy4AkVSDGmZb4Jp8,27443
 dsp_tools/commands/project/get/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/commands/project/get/get.py,sha256=_5LxbSP5Fi0PyXODjvND3ZC9E_x91yk6Xb6tcldG5j0,6447
@@ -84,7 +95,7 @@ dsp_tools/commands/project/legacy_models/model.py,sha256=AzxebBc5Y19kPFvsr4cPLWr
 dsp_tools/commands/project/legacy_models/ontology.py,sha256=uXX0U4FVzx53GIjTyZhCN96oxdSc1Jaq-O818XrsSEc,12557
 dsp_tools/commands/project/legacy_models/project.py,sha256=TlC-DPvaIxCdhnO82s_92lcC8--JzO840cLzrmrG4Fo,12012
 dsp_tools/commands/project/legacy_models/propertyclass.py,sha256=tDr23zwcZptZzBIAQSW27aRtRuSbM6PI_hk2ZXnuLm8,16954
-dsp_tools/commands/project/legacy_models/resourceclass.py,sha256=zE02MvJ6kGI5GA5n71oTFnKJaWHtX94yrsBsTQlS71s,27939
+dsp_tools/commands/project/legacy_models/resourceclass.py,sha256=eMorLi4x3zaeq-zBgf3lniKRpcJnQNpGLkJUPPTPsYY,26599
 dsp_tools/commands/project/legacy_models/user.py,sha256=qJ1vxK_yQbLb7z1i7KmJA3j5wYZKAUHPBGIhIXHhfq4,16057
 dsp_tools/commands/project/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/commands/project/models/permissions_client.py,sha256=v_Y02kTWFi7l9JE18lUxkyjc-vyt8KK7h8MN8MtsgXw,2494
@@ -175,7 +186,7 @@ dsp_tools/config/logger_config.py,sha256=Bw2Gu5F2d8un_KNk0hvNtV7fvN2TlThqo6gSwqe
 dsp_tools/config/warnings_config.py,sha256=15_Lt227HLqhdn6v-zJbi1KG9Fo6Zi1_4fp_a-iY72w,1142
 dsp_tools/error/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/error/custom_warnings.py,sha256=7C2DscIz9k7IfM8uebIsKWPcWcSjwpDqbIRDaPw7bI8,1053
-dsp_tools/error/exceptions.py,sha256=cBhH1bpFnOba6rJAEKvgVRwBg6Ni2gN1MPQLDdElPaQ,4686
+dsp_tools/error/exceptions.py,sha256=giLM6Hx17lMdCjNdlwMr4zqdGcqUHypAxESSAtkvvnU,4853
 dsp_tools/error/problems.py,sha256=DotzVg3MYvMJmernd9tTBmDHoT1MOkHdiWVv8iMoFSk,265
 dsp_tools/error/xmllib_errors.py,sha256=DpYCsBIx_GmsBAUlfk2VMqtzD5IGMRbd2yXTcrJFHR4,549
 dsp_tools/error/xmllib_warnings.py,sha256=sS9jJXGJtQqCiJ9P2zCM5gpIhTpChbujQz_fPvxLm8g,1557
@@ -204,12 +215,13 @@ dsp_tools/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/utils/ansi_colors.py,sha256=p2vq-wzfmE-wdDddvC26UcOA6Z1qhFTdzP0dPoW4sy0,1691
 dsp_tools/utils/data_formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dsp_tools/utils/data_formats/date_util.py,sha256=VLNQnSsUX6NB1IY3Ry5KCxCLgHHYN0TSSBRn8hyXN-4,4714
-dsp_tools/utils/data_formats/iri_util.py,sha256=_PXOdfwIDDe2fT1f8k1FBoKdaw1RNnL2Sw8UJrfO-wE,457
+dsp_tools/utils/data_formats/iri_util.py,sha256=O_TQb104ukjVsaqgkstz54QvjgqFPLSxVvqH6HVNjQc,670
 dsp_tools/utils/data_formats/shared.py,sha256=9AybXCAboojvRULZPud5e6B7UkjQOuN6f5fiVxwuZe8,2618
 dsp_tools/utils/data_formats/uri_util.py,sha256=9UGrbtxHVI0Ka0ttxd39KDhGeeP0xOdVLjt6HyV-Ic8,3257
 dsp_tools/utils/fuseki_bloating.py,sha256=yUCSijVf_Ne9iWUK_IzbPAkOMkN8Xt9ttPcWWRSIgMI,2381
 dsp_tools/utils/json_parsing.py,sha256=KlNvwnZoq-gJqnOVH7tiZMzgdld_3IunuOVvlEVXGXc,1684
 dsp_tools/utils/rdflib_constants.py,sha256=D5HO7oILBRiQI-bJj14pbCx6zhKY4RGqjIjq6S_IawU,652
+dsp_tools/utils/rdflib_utils.py,sha256=M9UCXMe8W3SDQ0DYh4i6lRwYkyWozrWLl19NP5A-RlY,284
 dsp_tools/utils/replace_id_with_iri.py,sha256=5M5vXWJIQ0oO4ELwIt_5QeYBvyGESBc2smuNThHiQUY,2928
 dsp_tools/utils/request_utils.py,sha256=KxiFpQ_IH1ZCIF-SknPjRMP5-ZtLP3wWzwSrEZDB2fk,6902
 dsp_tools/utils/xml_parsing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -248,7 +260,7 @@ dsp_tools/xmllib/models/res.py,sha256=c3edvilYZVDmv2O6Z36sSkHXcuKPAJLfWVpStDTMuJ
 dsp_tools/xmllib/models/root.py,sha256=x8_vrDSJ1pZUJUL8LR460dZe4Cg57G_Hy-Zfr2S29dw,13562
 dsp_tools/xmllib/value_checkers.py,sha256=Yx3r6_WoZ5Lev8Orp8yDzd03JvP2GBmFNSFT2dzrycM,10712
 dsp_tools/xmllib/value_converters.py,sha256=WMYS5hd1VlrLLBXnf6pv9yYoPBsv_2MxOO6xv-QsRW4,29218
-dsp_tools-17.0.0.post14.dist-info/WHEEL,sha256=M6du7VZflc4UPsGphmOXHANdgk8zessdJG0DBUuoA-U,78
-dsp_tools-17.0.0.post14.dist-info/entry_points.txt,sha256=qjRfEbkeAwLU_AE2Q-l4Y9irPNmu4Wna-3bfRp1bqV4,62
-dsp_tools-17.0.0.post14.dist-info/METADATA,sha256=tekPavfqdVzjQmW5uibBjMcpbJe8Ty1URY8MhmFCv_4,4285
-dsp_tools-17.0.0.post14.dist-info/RECORD,,
+dsp_tools-17.0.0.post21.dist-info/WHEEL,sha256=M6du7VZflc4UPsGphmOXHANdgk8zessdJG0DBUuoA-U,78
+dsp_tools-17.0.0.post21.dist-info/entry_points.txt,sha256=qjRfEbkeAwLU_AE2Q-l4Y9irPNmu4Wna-3bfRp1bqV4,62
+dsp_tools-17.0.0.post21.dist-info/METADATA,sha256=c-CiHkhfevQLuSoAyhtEYoAA1CF4nWN8HoR5o7H6e_8,4285
+dsp_tools-17.0.0.post21.dist-info/RECORD,,