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

dsp_tools/cli/call_action.py

@@ -2,6 +2,7 @@ import argparse
 import subprocess
 from pathlib import Path
 
+import requests
 from loguru import logger
 
 from dsp_tools.cli.args import ServerCredentials
@@ -27,9 +28,13 @@ from dsp_tools.commands.start_stack import StackHandler
 from dsp_tools.commands.validate_data.validate_data import validate_data
 from dsp_tools.commands.xmlupload.upload_config import UploadConfig
 from dsp_tools.commands.xmlupload.xmlupload import xmlupload
+from dsp_tools.error.exceptions import DockerNotReachableError
+from dsp_tools.error.exceptions import DspApiNotReachableError
 from dsp_tools.error.exceptions import InputError
 from dsp_tools.utils.xml_parsing.parse_clean_validate_xml import parse_and_validate_xml_file
 
+LOCALHOST_API = "http://0.0.0.0:3333"
+
 
 def call_requested_action(args: argparse.Namespace) -> bool:  # noqa: PLR0912 (too many branches)
     """
@@ -41,20 +46,36 @@ def call_requested_action(args: argparse.Namespace) -> bool:  # noqa: PLR0912 (t
     Raises:
         BaseError: from the called function
         InputError: from the called function
+        DockerNotReachableError: from the called function
+        LocalDspApiNotReachableError: from the called function
         unexpected errors from the called methods and underlying libraries
 
     Returns:
         success status
     """
     match args.action:
+        # commands with Docker / API interactions
+        case "start-stack":
+            result = _call_start_stack(args)
+        case "stop-stack":
+            result = _call_stop_stack()
         case "create":
             result = _call_create(args)
-        case "xmlupload":
-            result = _call_xmlupload(args)
+        case "get":
+            result = _call_get(args)
         case "validate-data":
             result = _call_validate_data(args)
+        case "xmlupload":
+            result = _call_xmlupload(args)
         case "resume-xmlupload":
             result = _call_resume_xmlupload(args)
+        case "upload-files":
+            result = _call_upload_files(args)
+        case "ingest-files":
+            result = _call_ingest_files(args)
+        case "ingest-xmlupload":
+            result = _call_ingest_xmlupload(args)
+        # commands that do not require docker
         case "excel2json":
             result = _call_excel2json(args)
         case "old-excel2json":
@@ -69,18 +90,6 @@ def call_requested_action(args: argparse.Namespace) -> bool:  # noqa: PLR0912 (t
             result = _call_excel2properties(args)
         case "id2iri":
             result = _call_id2iri(args)
-        case "start-stack":
-            result = _call_start_stack(args)
-        case "stop-stack":
-            result = _call_stop_stack()
-        case "get":
-            result = _call_get(args)
-        case "upload-files":
-            result = _call_upload_files(args)
-        case "ingest-files":
-            result = _call_ingest_files(args)
-        case "ingest-xmlupload":
-            result = _call_ingest_xmlupload(args)
         case _:
             print(f"ERROR: Unknown action '{args.action}'")
             logger.error(f"Unknown action '{args.action}'")
@@ -89,6 +98,7 @@ def call_requested_action(args: argparse.Namespace) -> bool:  # noqa: PLR0912 (t
 
 
 def _call_stop_stack() -> bool:
+    _check_docker_health()
     stack_handler = StackHandler(StackConfiguration())
     return stack_handler.stop_stack()
 
@@ -164,7 +174,7 @@ def _call_old_excel2json(args: argparse.Namespace) -> bool:
 
 
 def _call_upload_files(args: argparse.Namespace) -> bool:
-    _check_docker_health_if_on_localhost(args.server)
+    _check_health_with_docker_on_localhost(args.server)
     return upload_files(
         xml_file=Path(args.xml_file),
         creds=_get_creds(args),
@@ -173,12 +183,12 @@ def _call_upload_files(args: argparse.Namespace) -> bool:
 
 
 def _call_ingest_files(args: argparse.Namespace) -> bool:
-    _check_docker_health_if_on_localhost(args.server)
+    _check_health_with_docker_on_localhost(args.server)
     return ingest_files(creds=_get_creds(args), shortcode=args.shortcode)
 
 
 def _call_ingest_xmlupload(args: argparse.Namespace) -> bool:
-    _check_docker_health_if_on_localhost(args.server)
+    _check_health_with_docker(args.server)
     interrupt_after = args.interrupt_after if args.interrupt_after > 0 else None
     return ingest_xmlupload(
         xml_file=Path(args.xml_file),
@@ -191,7 +201,7 @@ def _call_ingest_xmlupload(args: argparse.Namespace) -> bool:
 
 
 def _call_xmlupload(args: argparse.Namespace) -> bool:
-    _check_docker_health_if_on_localhost(args.server)
+    _check_health_with_docker(args.server)
     if args.validate_only:
         success = parse_and_validate_xml_file(Path(args.xmlfile))
         print("The XML file is syntactically correct.")
@@ -227,7 +237,7 @@ def _call_xmlupload(args: argparse.Namespace) -> bool:
 
 
 def _call_validate_data(args: argparse.Namespace) -> bool:
-    _check_docker_health_if_on_localhost(args.server)
+    _check_health_with_docker(args.server)
     return validate_data(
         filepath=Path(args.xmlfile),
         creds=_get_creds(args),
@@ -239,7 +249,8 @@ def _call_validate_data(args: argparse.Namespace) -> bool:
 
 
 def _call_resume_xmlupload(args: argparse.Namespace) -> bool:
-    _check_docker_health_if_on_localhost(args.server)
+    # this does not need docker if not on localhost, as does not need to validate
+    _check_health_with_docker_on_localhost(args.server)
     return resume_xmlupload(
         creds=_get_creds(args),
         skip_first_resource=args.skip_first_resource,
@@ -247,7 +258,7 @@ def _call_resume_xmlupload(args: argparse.Namespace) -> bool:
 
 
 def _call_get(args: argparse.Namespace) -> bool:
-    _check_docker_health_if_on_localhost(args.server)
+    _check_health_with_docker_on_localhost(args.server)
     return get_project(
         project_identifier=args.project,
         outfile_path=args.project_definition,
@@ -257,7 +268,7 @@ def _call_get(args: argparse.Namespace) -> bool:
 
 
 def _call_create(args: argparse.Namespace) -> bool:
-    _check_docker_health_if_on_localhost(args.server)
+    _check_health_with_docker_on_localhost(args.server)
     success = False
     match args.lists_only, args.validate_only:
         case True, True:
@@ -289,11 +300,43 @@ def _get_creds(args: argparse.Namespace) -> ServerCredentials:
     )
 
 
-def _check_docker_health_if_on_localhost(api_url: str) -> None:
-    if api_url == "http://0.0.0.0:3333":
+def _check_health_with_docker_on_localhost(api_url: str) -> None:
+    if api_url == LOCALHOST_API:
         _check_docker_health()
+    _check_api_health(api_url)
+
+
+def _check_health_with_docker(api_url: str) -> None:
+    # validate always needs docker running
+    _check_docker_health()
+    _check_api_health(api_url)
 
 
 def _check_docker_health() -> None:
     if subprocess.run("docker stats --no-stream".split(), check=False, capture_output=True).returncode != 0:
-        raise InputError("Docker is not running properly. Please start Docker and try again.")
+        raise DockerNotReachableError()
+
+
+def _check_api_health(api_url: str) -> None:
+    health_url = f"{api_url}/health"
+    msg = (
+        "The DSP-API could not be reached. Please check if your stack is healthy "
+        "or start a stack with 'dsp-tools start-stack' if none is running."
+    )
+    try:
+        response = requests.get(health_url, timeout=2)
+        if not response.ok:
+            if api_url != LOCALHOST_API:
+                msg = (
+                    f"The DSP-API could not be reached (returned status {response.status_code}). "
+                    f"Please contact the DaSCH engineering team for help."
+                )
+            logger.error(msg)
+            raise DspApiNotReachableError(msg)
+        logger.debug(f"DSP API health check passed: {health_url}")
+    except requests.exceptions.RequestException as e:
+        logger.error(e)
+        if api_url != LOCALHOST_API:
+            msg = "The DSP-API responded with a request exception. Please contact the DaSCH engineering team for help."
+        logger.error(msg)
+        raise DspApiNotReachableError(msg) from None

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

@@ -0,0 +1,7 @@
+from rdflib import Namespace
+
+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

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import StrEnum
+
+
+@dataclass
+class CollectedProblems:
+    header: str
+    problems: list[CreateProblem]
+
+
+@dataclass
+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/parsed_ontology.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from enum import auto
+from typing import Any
+
+
+@dataclass
+class ParsedOntology:
+    name: str
+    label: str
+    comment: str | None
+    classes: list[ParsedClass]
+    properties: list[ParsedProperty]
+    cardinalities: list[ParsedClassCardinalities]
+
+
+@dataclass
+class ParsedClass:
+    name: str
+    info: dict[str, Any]
+
+
+@dataclass
+class ParsedProperty:
+    name: str
+    info: dict[str, Any]
+
+
+@dataclass
+class ParsedClassCardinalities:
+    class_iri: str
+    cards: list[ParsedPropertyCardinality]
+
+
+@dataclass
+class ParsedPropertyCardinality:
+    propname: str
+    cardinality: Cardinality
+    gui_order: int | None
+
+
+class Cardinality(Enum):
+    C_0_1 = auto()
+    C_1 = auto()
+    C_0_N = auto()
+    C_1_N = auto()