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

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/commands/validate_data/models/api_responses.py

@@ -16,6 +16,7 @@ class SHACLValidationReport:
 class ProjectDataFromApi:
     all_lists: list[OneList]
     enabled_licenses: EnabledLicenseIris
+    resource_iris_in_db: list[InfoForResourceInDB]
 
 
 @dataclass
@@ -50,3 +51,9 @@ class SHACLListInfo:
 @dataclass
 class EnabledLicenseIris:
     enabled_licenses: list[str]
+
+
+@dataclass
+class InfoForResourceInDB:
+    res_iri: str
+    res_type: str

dsp_tools/commands/validate_data/models/validation.py

@@ -23,6 +23,7 @@ class RDFGraphs:
     cardinality_shapes: Graph
     content_shapes: Graph
     knora_api: Graph
+    resources_in_db_graph: Graph
 
 
 @dataclass

dsp_tools/commands/validate_data/prepare_data/make_data_graph.py

@@ -48,7 +48,10 @@ def _make_one_value(val: RdfLikeValue, res_iri: URIRef) -> Graph:
         return g
     if val.knora_type == KnoraValueType.LINK_VALUE:
         link_val = val.user_facing_value if val.user_facing_value else ""
-        triple_object: Literal | URIRef = DATA[link_val]
+        if link_val.startswith("http://rdfh.ch/"):
+            triple_object: Literal | URIRef = URIRef(link_val)
+        else:
+            triple_object = DATA[link_val]
     else:
         triple_object = _make_one_rdflib_object(val.user_facing_value, VALUE_INFO_TRIPLE_OBJECT_TYPE[val.knora_type])
     g.add((val_iri, prop_type_info.knora_prop, triple_object))

dsp_tools/commands/validate_data/prepare_data/prepare_data.py

@@ -2,13 +2,18 @@ import importlib.resources
 from pathlib import Path
 
 from loguru import logger
+from rdflib import RDF
 from rdflib import Graph
+from rdflib import URIRef
 
 from dsp_tools.clients.authentication_client import AuthenticationClient
 from dsp_tools.clients.legal_info_client_live import LegalInfoClientLive
+from dsp_tools.clients.metadata_client import MetadataRetrieval
+from dsp_tools.clients.metadata_client_live import MetadataClientLive
 from dsp_tools.commands.validate_data.api_clients import ListClient
 from dsp_tools.commands.validate_data.api_clients import OntologyClient
 from dsp_tools.commands.validate_data.models.api_responses import EnabledLicenseIris
+from dsp_tools.commands.validate_data.models.api_responses import InfoForResourceInDB
 from dsp_tools.commands.validate_data.models.api_responses import ListLookup
 from dsp_tools.commands.validate_data.models.api_responses import OneList
 from dsp_tools.commands.validate_data.models.api_responses import ProjectDataFromApi
@@ -42,13 +47,13 @@ def prepare_data_for_validation_from_parsed_resource(
     permission_ids: list[str],
     auth: AuthenticationClient,
     shortcode: str,
-) -> tuple[RDFGraphs, set[str]]:
+) -> tuple[RDFGraphs, set[str], MetadataRetrieval]:
     used_iris = {x.res_type for x in parsed_resources}
-    proj_info = _get_project_specific_information_from_api(auth, shortcode)
+    proj_info, metadata_retrieval_success = _get_project_specific_information_from_api(auth, shortcode)
     list_lookup = _make_list_lookup(proj_info.all_lists)
     data_rdf = _make_data_graph_from_parsed_resources(parsed_resources, authorship_lookup, list_lookup)
     rdf_graphs = _create_graphs(data_rdf, shortcode, auth, proj_info, permission_ids)
-    return rdf_graphs, used_iris
+    return rdf_graphs, used_iris, metadata_retrieval_success
 
 
 def _make_list_lookup(project_lists: list[OneList]) -> ListLookup:
@@ -60,11 +65,23 @@ def _make_list_lookup(project_lists: list[OneList]) -> ListLookup:
     return ListLookup(lookup)
 
 
-def _get_project_specific_information_from_api(auth: AuthenticationClient, shortcode: str) -> ProjectDataFromApi:
+def _get_project_specific_information_from_api(
+    auth: AuthenticationClient, shortcode: str
+) -> tuple[ProjectDataFromApi, MetadataRetrieval]:
     list_client = ListClient(auth.server, shortcode)
     all_lists = list_client.get_lists()
     enabled_licenses = _get_license_iris(shortcode, auth)
-    return ProjectDataFromApi(all_lists, enabled_licenses)
+    retrieval_status, formatted_metadata = _get_metadata_info(auth, shortcode)
+    return ProjectDataFromApi(all_lists, enabled_licenses, formatted_metadata), retrieval_status
+
+
+def _get_metadata_info(
+    auth: AuthenticationClient, shortcode: str
+) -> tuple[MetadataRetrieval, list[InfoForResourceInDB]]:
+    metadata_client = MetadataClientLive(auth.server, auth)
+    retrieval_status, metadata = metadata_client.get_resource_metadata(shortcode)
+    formatted_metadata = [InfoForResourceInDB(x["resourceIri"], x["resourceClassIri"]) for x in metadata]
+    return retrieval_status, formatted_metadata
 
 
 def _make_data_graph_from_parsed_resources(
@@ -99,6 +116,8 @@ def _create_graphs(
     api_card_shapes.parse(str(api_card_path))
     content_shapes = shapes.content + api_shapes
     card_shapes = shapes.cardinality + api_card_shapes
+    resources_in_db = _make_resource_in_db_graph(proj_info.resource_iris_in_db)
+    resources_in_db = _bind_prefixes_to_graph(resources_in_db, onto_iris)
     data_rdf = _bind_prefixes_to_graph(data_rdf, onto_iris)
     ontologies = _bind_prefixes_to_graph(ontologies, onto_iris)
     card_shapes = _bind_prefixes_to_graph(card_shapes, onto_iris)
@@ -110,6 +129,7 @@ def _create_graphs(
         cardinality_shapes=card_shapes,
         content_shapes=content_shapes,
         knora_api=knora_api,
+        resources_in_db_graph=resources_in_db,
     )
 
 
@@ -143,3 +163,10 @@ def _get_license_iris(shortcode: str, auth: AuthenticationClient) -> EnabledLice
     license_info = legal_client.get_licenses_of_a_project()
     iris = [x["id"] for x in license_info]
     return EnabledLicenseIris(iris)
+
+
+def _make_resource_in_db_graph(resources_in_db: list[InfoForResourceInDB]) -> Graph:
+    g = Graph()
+    for r in resources_in_db:
+        g.add((URIRef(r.res_iri), RDF.type, URIRef(r.res_type)))
+    return g

dsp_tools/commands/validate_data/validate_data.py

@@ -104,7 +104,7 @@ def validate_parsed_resources(
     config: ValidateDataConfig,
     auth: AuthenticationClient,
 ) -> bool:
-    rdf_graphs, used_iris = prepare_data_for_validation_from_parsed_resource(
+    rdf_graphs, used_iris, _ = prepare_data_for_validation_from_parsed_resource(
         parsed_resources=parsed_resources,
         authorship_lookup=authorship_lookup,
         permission_ids=permission_ids,

dsp_tools/commands/validate_data/validation/get_validation_report.py

@@ -82,10 +82,11 @@ def _create_and_write_graphs(rdf_graphs: RDFGraphs, tmp_path: Path) -> None:
     card_shape_str = rdf_graphs.cardinality_shapes.serialize(format="ttl")
     content_shape_str = rdf_graphs.content_shapes.serialize(format="ttl")
     knora_api_str = rdf_graphs.knora_api.serialize(format="ttl")
+    res_in_db_str = rdf_graphs.resources_in_db_graph.serialize(format="ttl")
     turtle_paths_and_graphs = [
         (tmp_path / CARDINALITY_DATA_TTL, data_str),
         (tmp_path / CARDINALITY_SHACL_TTL, card_shape_str + ontos_str + knora_api_str),
-        (tmp_path / CONTENT_DATA_TTL, data_str + ontos_str + knora_api_str),
+        (tmp_path / CONTENT_DATA_TTL, data_str + ontos_str + knora_api_str + res_in_db_str),
         (tmp_path / CONTENT_SHACL_TTL, content_shape_str + ontos_str + knora_api_str),
     ]
     for f_path, content in turtle_paths_and_graphs:

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.post23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dsp-tools
-Version: 17.0.0.post14
+Version: 17.0.0.post23
 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>