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

dsp_tools/commands/create/models/parsed_project.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from dsp_tools.commands.create.models.parsed_ontology import ParsedOntology
+
+
+@dataclass
+class ParsedProject:
+    prefixes: dict[str, str]
+    project_metadata: ParsedProjectMetadata
+    permissions: ParsedPermissions
+    groups: list[ParsedGroup]
+    users: list[ParsedUser]
+    lists: list[ParsedList]
+    ontologies: list[ParsedOntology]
+
+
+@dataclass
+class ParsedProjectMetadata:
+    shortcode: str
+    shortname: str
+    longname: str
+    descriptions: dict[str, str]
+    keywords: list[str]
+    enabled_licenses: list[str]
+
+
+@dataclass
+class ParsedPermissions:
+    default_permissions: str
+    default_permissions_overrule: dict[str, Any] | None
+
+
+@dataclass
+class ParsedGroup:
+    info: dict[str, Any]
+
+
+@dataclass
+class ParsedUser:
+    info: dict[str, Any]
+
+
+@dataclass
+class ParsedList:
+    name: str
+    info: dict[str, Any]

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

@@ -0,0 +1,108 @@
+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 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
+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 ParsedProperty
+from dsp_tools.commands.create.models.parsed_ontology import ParsedPropertyCardinality
+from dsp_tools.commands.create.parsing.parsing_utils import resolve_to_absolute_iri
+
+CARDINALITY_MAPPER = {
+    "0-1": Cardinality.C_0_1,
+    "1": Cardinality.C_1,
+    "0-n": Cardinality.C_0_N,
+    "1-n": Cardinality.C_1_N,
+}
+
+
+def parse_ontology(ontology_json: dict[str, Any], prefixes: dict[str, str]) -> ParsedOntology | CollectedProblems:
+    onto_name = ontology_json["name"]
+    current_onto = prefixes[onto_name]
+    fails = []
+    props, prop_fails = _parse_properties(ontology_json["properties"], current_onto)
+    fails.extend(prop_fails)
+    classes, cls_fails = _parse_classes(ontology_json["resources"], current_onto)
+    fails.extend(cls_fails)
+    cards, card_fails = _parse_cardinalities(ontology_json["resources"], current_onto, prefixes)
+    fails.extend(card_fails)
+    if fails:
+        return CollectedProblems(
+            f"During the parsing of the ontology '{onto_name}' the following errors occurred", fails
+        )
+    return ParsedOntology(
+        name=onto_name,
+        label=ontology_json["label"],
+        comment=ontology_json.get("comment"),
+        classes=classes,
+        properties=props,
+        cardinalities=cards,
+    )
+
+
+def _parse_properties(
+    properties_list: list[dict[str, Any]], current_onto_prefix: str
+) -> tuple[list[ParsedProperty], list[CreateProblem]]:
+    parsed = []
+    for prop in properties_list:
+        parsed.append(ParsedProperty(f"{current_onto_prefix}{prop['name']}", prop))
+    return parsed, []
+
+
+def _parse_classes(
+    classes_list: list[dict[str, Any]], current_onto_prefix: str
+) -> tuple[list[ParsedClass], list[CreateProblem]]:
+    parsed = []
+    for cls in classes_list:
+        parsed.append(ParsedClass(f"{current_onto_prefix}{cls['name']}", cls))
+    return parsed, []
+
+
+def _parse_cardinalities(
+    classes_list: list[dict[str, Any]], current_onto_prefix: str, prefixes: dict[str, str]
+) -> tuple[list[ParsedClassCardinalities], list[CreateProblem]]:
+    parsed = []
+    failures = []
+    for c in classes_list:
+        if c.get("cardinalities"):
+            result = _parse_one_class_cardinality(c, current_onto_prefix, prefixes)
+            if isinstance(result, ParsedClassCardinalities):
+                parsed.append(result)
+            else:
+                failures.extend(result)
+    return parsed, failures
+
+
+def _parse_one_class_cardinality(
+    cls_json: dict[str, Any], current_onto_prefix: str, prefixes: dict[str, str]
+) -> ParsedClassCardinalities | list[CreateProblem]:
+    failures = []
+    parsed = []
+    for c in cls_json["cardinalities"]:
+        result = _parse_one_cardinality(c, current_onto_prefix, prefixes)
+        if isinstance(result, ParsedPropertyCardinality):
+            parsed.append(result)
+        else:
+            failures.append(result)
+    if failures:
+        return failures
+    cls_iri = f"{current_onto_prefix}{cls_json['name']}"
+    return ParsedClassCardinalities(cls_iri, parsed)
+
+
+def _parse_one_cardinality(
+    card_json: dict[str, str | int], current_onto_prefix: str, prefixes: dict[str, str]
+) -> ParsedPropertyCardinality | CreateProblem:
+    prp_name = cast(str, card_json["propname"])
+    if not (resolved := resolve_to_absolute_iri(prp_name, current_onto_prefix, prefixes)):
+        return CreateProblem(prp_name, ProblemType.PREFIX_COULD_NOT_BE_RESOLVED)
+    gui = cast(int | None, card_json.get("gui_order"))
+    return ParsedPropertyCardinality(
+        propname=resolved,
+        cardinality=CARDINALITY_MAPPER[cast(str, card_json["cardinality"])],
+        gui_order=gui,
+    )

dsp_tools/commands/create/parsing/parse_project.py

@@ -0,0 +1,99 @@
+from pathlib import Path
+from typing import Any
+
+from loguru import logger
+
+from dsp_tools.commands.create.models.input_problems import CollectedProblems
+from dsp_tools.commands.create.models.parsed_ontology import ParsedOntology
+from dsp_tools.commands.create.models.parsed_project import ParsedGroup
+from dsp_tools.commands.create.models.parsed_project import ParsedList
+from dsp_tools.commands.create.models.parsed_project import ParsedPermissions
+from dsp_tools.commands.create.models.parsed_project import ParsedProject
+from dsp_tools.commands.create.models.parsed_project import ParsedProjectMetadata
+from dsp_tools.commands.create.models.parsed_project import ParsedUser
+from dsp_tools.commands.create.parsing.parse_ontology import parse_ontology
+from dsp_tools.commands.create.parsing.parsing_utils import create_prefix_lookup
+from dsp_tools.commands.project.create.project_validate import validate_project
+from dsp_tools.utils.json_parsing import parse_json_input
+
+
+def parse_project(
+    project_file_as_path_or_parsed: str | Path | dict[str, Any], api_url: str
+) -> ParsedProject | list[CollectedProblems]:
+    complete_json = _parse_and_validate(project_file_as_path_or_parsed)
+    return _parse_project(complete_json, api_url)
+
+
+def _parse_project(complete_json: dict[str, Any], api_url: str) -> ParsedProject | list[CollectedProblems]:
+    prefix_lookup = create_prefix_lookup(complete_json, api_url)
+    project_json = complete_json["project"]
+    ontologies, failures = _parse_all_ontologies(project_json, prefix_lookup)
+    if failures:
+        return failures
+    return ParsedProject(
+        prefixes=prefix_lookup,
+        project_metadata=_parse_metadata(project_json),
+        permissions=_parse_permissions(project_json),
+        groups=_parse_groups(project_json),
+        users=_parse_users(project_json),
+        lists=_parse_lists(project_json),
+        ontologies=ontologies,
+    )
+
+
+def _parse_and_validate(project_file_as_path_or_parsed: str | Path | dict[str, Any]) -> dict[str, Any]:
+    project_json = parse_json_input(project_file_as_path_or_parsed=project_file_as_path_or_parsed)
+    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.")
+    return project_json
+
+
+def _parse_metadata(project_json: dict[str, Any]) -> ParsedProjectMetadata:
+    return ParsedProjectMetadata(
+        shortcode=project_json["shortcode"],
+        shortname=project_json["shortname"],
+        longname=project_json["longname"],
+        descriptions=project_json["descriptions"],
+        keywords=project_json["keywords"],
+        enabled_licenses=project_json.get("enabled_licenses", []),
+    )
+
+
+def _parse_permissions(project_json: dict[str, Any]) -> ParsedPermissions:
+    return ParsedPermissions(
+        default_permissions=project_json["default_permissions"],
+        default_permissions_overrule=project_json.get("default_permissions_overrule"),
+    )
+
+
+def _parse_groups(project_json: dict[str, Any]) -> list[ParsedGroup]:
+    if not (found := project_json.get("groups")):
+        return []
+    return [ParsedGroup(x) for x in found]
+
+
+def _parse_users(project_json: dict[str, Any]) -> list[ParsedUser]:
+    if not (found := project_json.get("users")):
+        return []
+    return [ParsedUser(x) for x in found]
+
+
+def _parse_lists(project_json: dict[str, Any]) -> list[ParsedList]:
+    if not (found := project_json.get("lists")):
+        return []
+    return [ParsedList(x["name"], x) for x in found]
+
+
+def _parse_all_ontologies(
+    project_json: dict[str, Any], prefix_lookup: dict[str, str]
+) -> tuple[list[ParsedOntology], list[CollectedProblems]]:
+    ontos = []
+    failures = []
+    for o in project_json["ontologies"]:
+        result = parse_ontology(o, prefix_lookup)
+        if isinstance(result, ParsedOntology):
+            ontos.append(result)
+        else:
+            failures.append(result)
+    return ontos, failures

dsp_tools/commands/create/parsing/parsing_utils.py

@@ -0,0 +1,43 @@
+from typing import Any
+
+import regex
+
+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
+
+
+def resolve_to_absolute_iri(prefixed: str, current_onto: str, prefix_lookup: dict[str, str]) -> str | None:
+    if is_uri(prefixed):
+        return prefixed
+    if prefixed.startswith(":"):
+        return f"{current_onto}{prefixed.lstrip(':')}"
+    segments = prefixed.split(":", maxsplit=1)
+    if len(segments) == 1:
+        return f"{KNORA_API_STR}{segments[0]}"
+    if not (found := prefix_lookup.get(segments[0])):
+        return None
+    return f"{found}{segments[1]}"
+
+
+def create_prefix_lookup(project_json: dict[str, Any], api_url: str) -> dict[str, str]:
+    defined_prefixes = project_json.get("prefixes", {})
+    defined_prefixes = defined_prefixes | UNIVERSAL_PREFIXES
+    defined_prefixes = _correct_external_prefix(defined_prefixes)
+    shortcode = project_json["project"]["shortcode"]
+    for onto in project_json["project"]["ontologies"]:
+        onto_name = onto["name"]
+        defined_prefixes[onto_name] = _make_dsp_ontology_prefix(api_url, shortcode, onto_name)
+    return defined_prefixes
+
+
+def _correct_external_prefix(prefixes: dict[str, str]) -> dict[str, str]:
+    for prfx, namespace in prefixes.items():
+        if regex.search(r"(#|\/)$", namespace):
+            continue
+        prefixes[prfx] = f"{namespace}/"
+    return prefixes
+
+
+def _make_dsp_ontology_prefix(api_url: str, shortcode: str, onto_name: str) -> str:
+    return f"{api_url}/ontology/{shortcode}/{onto_name}/v2#"

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."
         )