dsp-tools 9.1.0.post11__py3-none-any.whl → 18.3.0.post13__py3-none-any.whl

dsp_tools/commands/create/create_on_server/default_permissions.py

@@ -0,0 +1,134 @@
+from loguru import logger
+
+from dsp_tools.clients.permissions_client import PermissionsClient
+from dsp_tools.utils.ansi_colors import BOLD
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+from dsp_tools.utils.rdf_constants import KNORA_ADMIN_PREFIX
+
+
+def create_default_permissions(
+    perm_client: PermissionsClient,
+    default_permissions: str,
+    default_permissions_overrule: dict[str, str | list[str]] | None,
+    shortcode: str,
+) -> bool:
+    print(BOLD + "Processing default permissions:" + RESET_TO_DEFAULT)
+    logger.info("Processing default permissions:")
+    if not _delete_existing_doaps(perm_client):
+        print("    WARNING: Cannot delete the existing default permissions")
+        logger.warning("Cannot delete the existing default permissions")
+        return False
+    if not _create_new_doap(perm_client, default_permissions):
+        print("    WARNING: Cannot create default permissions")
+        logger.warning("Cannot create default permissions")
+        return False
+    if default_permissions_overrule:
+        if not _create_overrules(perm_client, default_permissions_overrule, shortcode):
+            print("    WARNING: Cannot create default permissions overrules")
+            logger.warning("Cannot create default permissions overrules")
+            return False
+    print("    Default permissions have been set")
+    logger.info("Default permissions have been set")
+    return True
+
+
+def _delete_existing_doaps(perm_client: PermissionsClient) -> bool:
+    if not (doaps := perm_client.get_project_doaps()):
+        return False
+    existing_doap_iris: list[str] = [x["iri"] for x in doaps]
+    for iri in existing_doap_iris:
+        if not perm_client.delete_doap(iri):
+            # don't continue with the others, it's better to stop DOAP handling immediately, to avoid a mess
+            return False
+    return True
+
+
+def _create_new_doap(perm_client: PermissionsClient, default_permissions: str) -> bool:
+    perm = [
+        {"additionalInformation": f"{KNORA_ADMIN_PREFIX}ProjectAdmin", "name": "CR", "permissionCode": None},
+        {"additionalInformation": f"{KNORA_ADMIN_PREFIX}ProjectMember", "name": "D", "permissionCode": None},
+    ]
+    if default_permissions == "public":
+        perm.append({"additionalInformation": f"{KNORA_ADMIN_PREFIX}KnownUser", "name": "V", "permissionCode": None})
+        perm.append({"additionalInformation": f"{KNORA_ADMIN_PREFIX}UnknownUser", "name": "V", "permissionCode": None})
+    payload = {
+        "forGroup": f"{KNORA_ADMIN_PREFIX}ProjectMember",
+        "forProject": perm_client.proj_iri,
+        "hasPermissions": perm,
+    }
+    return perm_client.create_new_doap(payload)
+
+
+def _create_overrules(
+    perm_client: PermissionsClient, default_permissions_overrule: dict[str, str | list[str]], shortcode: str
+) -> bool:
+    overall_success = True
+
+    # Handle private overrules
+    for entity in default_permissions_overrule.get("private", []):
+        first_letter = entity.split(":")[-1][0]
+        is_res = first_letter.upper() == first_letter
+        entity_iri = _get_iri_from_prefixed_name(entity, shortcode, perm_client.auth.server)
+        if is_res:
+            success = _create_one_private_overrule(perm_client=perm_client, res_iri=entity_iri, prop_iri=None)
+        else:
+            success = _create_one_private_overrule(perm_client=perm_client, res_iri=None, prop_iri=entity_iri)
+        if not success:
+            overall_success = False
+
+    # Handle limited_view overrules
+    if not (limited_view := default_permissions_overrule.get("limited_view")):
+        return overall_success
+    if limited_view == "all":
+        success = _create_one_limited_view_overrule(perm_client=perm_client, img_class_iri=None)
+        if not success:
+            overall_success = False
+    else:
+        # limited_view is a list of prefixed class names
+        for prefixed_img_class in limited_view:
+            img_class_iri = _get_iri_from_prefixed_name(prefixed_img_class, shortcode, perm_client.auth.server)
+            success = _create_one_limited_view_overrule(perm_client=perm_client, img_class_iri=img_class_iri)
+            if not success:
+                overall_success = False
+
+    return overall_success
+
+
+def _create_one_private_overrule(perm_client: PermissionsClient, res_iri: str | None, prop_iri: str | None) -> bool:
+    perm = [
+        {"additionalInformation": f"{KNORA_ADMIN_PREFIX}ProjectAdmin", "name": "CR", "permissionCode": None},
+        {"additionalInformation": f"{KNORA_ADMIN_PREFIX}ProjectMember", "name": "D", "permissionCode": None},
+    ]
+    payload = {
+        "forProperty": prop_iri,
+        "forResourceClass": res_iri,
+        "forProject": perm_client.proj_iri,
+        "hasPermissions": perm,
+    }
+    return perm_client.create_new_doap(payload)
+
+
+def _create_one_limited_view_overrule(perm_client: PermissionsClient, img_class_iri: str | None) -> bool:
+    # This makes only sense for the knora-api:hasStillImageFileValue property of image classes
+    # To set it for all image classes, set img_class_iri to None
+    perm = [
+        {"additionalInformation": f"{KNORA_ADMIN_PREFIX}ProjectAdmin", "name": "CR", "permissionCode": None},
+        {"additionalInformation": f"{KNORA_ADMIN_PREFIX}ProjectMember", "name": "D", "permissionCode": None},
+        {"additionalInformation": f"{KNORA_ADMIN_PREFIX}KnownUser", "name": "RV", "permissionCode": None},
+        {"additionalInformation": f"{KNORA_ADMIN_PREFIX}UnknownUser", "name": "RV", "permissionCode": None},
+    ]
+    payload = {
+        "forProperty": "http://api.knora.org/ontology/knora-api/v2#hasStillImageFileValue",
+        "forResourceClass": img_class_iri,
+        "forProject": perm_client.proj_iri,
+        "hasPermissions": perm,
+    }
+    return perm_client.create_new_doap(payload)
+
+
+def _get_iri_from_prefixed_name(prefixed_name: str, proj_shortcode: str, server: str) -> str:
+    onto, name = prefixed_name.split(":")
+    host_iri = server.replace("https://", "http://")
+    if onto == "knora-api":
+        return f"http://api.knora.org/ontology/knora-api/v2#{name}"
+    return f"{host_iri}/ontology/{proj_shortcode}/{onto}/v2#{name}"

dsp_tools/commands/create/create_on_server/group_users.py

@@ -0,0 +1,165 @@
+from typing import Any
+
+from loguru import logger
+from tqdm import tqdm
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.group_user_clients import GroupClient
+from dsp_tools.clients.group_user_clients import UserClient
+from dsp_tools.clients.group_user_clients_live import UserClientLive
+from dsp_tools.commands.create.models.create_problems import CollectedProblems
+from dsp_tools.commands.create.models.create_problems import CreateProblem
+from dsp_tools.commands.create.models.create_problems import UploadProblem
+from dsp_tools.commands.create.models.create_problems import UploadProblemType
+from dsp_tools.commands.create.models.parsed_project import ParsedGroup
+from dsp_tools.commands.create.models.parsed_project import ParsedUser
+from dsp_tools.commands.create.models.parsed_project import ParsedUserMemberShipInfo
+from dsp_tools.commands.create.models.server_project_info import GroupNameToIriLookup
+from dsp_tools.commands.create.models.server_project_info import UserNameToIriLookup
+from dsp_tools.commands.create.serialisation.project import serialise_one_group
+from dsp_tools.commands.create.serialisation.project import serialise_one_user_for_creation
+from dsp_tools.utils.ansi_colors import BOLD
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+
+
+def create_users(
+    users: list[ParsedUser],
+    user_memberships: list[ParsedUserMemberShipInfo],
+    group_lookup: GroupNameToIriLookup,
+    auth: AuthenticationClient,
+    project_iri: str,
+) -> CollectedProblems | None:
+    print(BOLD + "Processing user section:" + RESET_TO_DEFAULT)
+    client = UserClientLive(auth.server, auth)
+    user_to_iri, problems = _create_all_users(users, client)
+    membership_problems = _add_all_memberships(user_memberships, user_to_iri, group_lookup, client, project_iri)
+    problems.extend(membership_problems)
+    if problems:
+        return CollectedProblems("During the creation of the users the following problems occurred:", problems)
+    return None
+
+
+def _create_all_users(users: list[ParsedUser], client: UserClient) -> tuple[UserNameToIriLookup, list[CreateProblem]]:
+    problems: list[CreateProblem] = []
+    user_to_iri = UserNameToIriLookup()
+    progress_bar = tqdm(users, desc="    Creating users", dynamic_ncols=True)
+    logger.debug("Creating users")
+    for usr in progress_bar:
+        result = _create_one_user(usr, client)
+        if result is None:
+            problems.append(UploadProblem(usr.username, UploadProblemType.USER_COULD_NOT_BE_CREATED))
+        else:
+            user_to_iri.add_iri(usr.username, result)
+    return user_to_iri, problems
+
+
+def _create_one_user(user: ParsedUser, client: UserClient) -> str | None:
+    if user_iri := client.get_user_iri_by_username(user.username):
+        return user_iri
+    serialised_user = serialise_one_user_for_creation(user)
+    return client.post_new_user(serialised_user)
+
+
+def _add_all_memberships(
+    memberships: list[ParsedUserMemberShipInfo],
+    user_to_iri: UserNameToIriLookup,
+    group_lookup: GroupNameToIriLookup,
+    client: UserClient,
+    project_iri: str,
+) -> list[CreateProblem]:
+    problems: list[CreateProblem] = []
+    progress_bar = tqdm(memberships, desc="    Updating user information", dynamic_ncols=True)
+    logger.debug("Updating user information")
+    for memb in progress_bar:
+        if usr_iri := user_to_iri.get_iri(memb.username):
+            result = _add_user_to_project_memberships(memb, usr_iri, project_iri, client)
+            problems.extend(result)
+            if memb.groups:
+                result = _add_user_to_custom_groups(memb, usr_iri, client, group_lookup)
+                problems.extend(result)
+        else:
+            logger.debug(f"IRI of user '{memb.username}' could not be found, no project membership added.")
+    return problems
+
+
+def _add_user_to_project_memberships(
+    membership: ParsedUserMemberShipInfo, user_iri: str, project_iri: str, client: UserClient
+) -> list[CreateProblem]:
+    problems: list[CreateProblem] = []
+    membership_good = client.add_user_as_project_member(user_iri, project_iri)
+    if not membership_good:
+        problems.append(UploadProblem(membership.username, UploadProblemType.PROJECT_MEMBERSHIP_COULD_NOT_BE_ADDED))
+    if membership.is_admin:
+        good = client.add_user_as_project_admin(user_iri, project_iri)
+        if not good:
+            problems.append(UploadProblem(membership.username, UploadProblemType.PROJECT_ADMIN_COULD_NOT_BE_ADDED))
+    return problems
+
+
+def _add_user_to_custom_groups(
+    membership: ParsedUserMemberShipInfo, user_iri: str, client: UserClient, group_lookup: GroupNameToIriLookup
+) -> list[CreateProblem]:
+    problems: list[CreateProblem] = []
+    groups_not_found = []
+    groups_iris = []
+    for gr in membership.groups:
+        if found := group_lookup.get_iri(gr):
+            groups_iris.append(found)
+        else:
+            groups_not_found.append(gr)
+    if groups_iris:
+        group_good = client.add_user_to_custom_groups(user_iri, groups_iris)
+        if not group_good:
+            problems.append(UploadProblem(membership.username, UploadProblemType.USER_COULD_NOT_BE_ADDED_TO_GROUP))
+    if groups_not_found:
+        problems.append(UploadProblem(membership.username, UploadProblemType.USER_GROUPS_NOT_FOUND))
+    return problems
+
+
+def create_groups(
+    groups: list[ParsedGroup],
+    group_client: GroupClient,
+    project_iri: str,
+    group_lookup: GroupNameToIriLookup,
+) -> tuple[GroupNameToIriLookup, CollectedProblems | None]:
+    problems: list[CreateProblem] = []
+    print(BOLD + "Processing group section:" + RESET_TO_DEFAULT)
+    progress_bar = tqdm(groups, desc="    Creating groups", dynamic_ncols=True)
+    logger.debug("Creating groups")
+    for gr in progress_bar:
+        if group_lookup.check_exists(gr.name):
+            logger.debug(f"Group with the name '{gr.name}' already exists, skipping.")
+            continue
+        result = _create_one_group(gr, group_client, project_iri)
+        if isinstance(result, UploadProblem):
+            problems.append(result)
+        else:
+            group_lookup.add_iri(gr.name, result)
+    all_problems = None
+    if problems:
+        all_problems = CollectedProblems("During the creation of the groups the following problems happened:", problems)
+    return group_lookup, all_problems
+
+
+def _create_one_group(group: ParsedGroup, group_client: GroupClient, project_iri: str) -> str | UploadProblem:
+    serialised = serialise_one_group(group, project_iri)
+    new_iri = group_client.create_new_group(serialised)
+    if new_iri:
+        return new_iri
+    return UploadProblem(group.name, UploadProblemType.GROUP_COULD_NOT_BE_CREATED)
+
+
+def get_existing_group_to_iri_lookup(
+    group_client: GroupClient, project_iri: str, shortname: str
+) -> GroupNameToIriLookup:
+    all_groups = group_client.get_all_groups()
+    return _construct_group_lookup(all_groups, project_iri, shortname)
+
+
+def _construct_group_lookup(all_groups: list[dict[str, Any]], project_iri: str, shortname: str) -> GroupNameToIriLookup:
+    lookup = GroupNameToIriLookup({}, shortname)
+    for group in all_groups:
+        group_project_iri = group["project"]["id"]
+        if group_project_iri == project_iri:
+            lookup.add_iri(group["name"], group["id"])
+    return lookup

dsp_tools/commands/create/create_on_server/lists.py

@@ -0,0 +1,163 @@
+import warnings
+from typing import Any
+
+from loguru import logger
+from tqdm import tqdm
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.list_client import ListCreateClient
+from dsp_tools.clients.list_client_live import ListCreateClientLive
+from dsp_tools.clients.list_client_live import ListGetClientLive
+from dsp_tools.commands.create.models.create_problems import CollectedProblems
+from dsp_tools.commands.create.models.create_problems import CreateProblem
+from dsp_tools.commands.create.models.create_problems import UploadProblem
+from dsp_tools.commands.create.models.create_problems import UploadProblemType
+from dsp_tools.commands.create.models.create_problems import UserInformation
+from dsp_tools.commands.create.models.create_problems import UserInformationMessage
+from dsp_tools.commands.create.models.parsed_project import ParsedList
+from dsp_tools.commands.create.models.parsed_project import ParsedListNode
+from dsp_tools.commands.create.models.parsed_project import ParsedNodeInfo
+from dsp_tools.commands.create.models.server_project_info import ListNameToIriLookup
+from dsp_tools.error.custom_warnings import DspToolsUnexpectedStatusCodeWarning
+from dsp_tools.error.exceptions import FatalNonOkApiResponseCode
+from dsp_tools.utils.ansi_colors import BOLD
+from dsp_tools.utils.ansi_colors import BOLD_CYAN
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+
+
+def create_lists(
+    parsed_lists: list[ParsedList], shortcode: str, auth: AuthenticationClient, project_iri: str
+) -> tuple[ListNameToIriLookup, CollectedProblems | None]:
+    print(BOLD + "Processing list section:" + RESET_TO_DEFAULT)
+    name2iri = get_existing_lists_on_server(shortcode, auth)
+    if not parsed_lists:
+        return name2iri, None
+    lists_to_create, existing_info = _filter_out_existing_lists(parsed_lists, name2iri)
+    if existing_info:
+        _print_existing_list_info(existing_info)
+    if not lists_to_create:
+        msg = "    All lists defined in the project are already on the server, no list was uploaded."
+        logger.warning(msg)
+        print(BOLD_CYAN + msg + RESET_TO_DEFAULT)
+        return name2iri, None
+
+    create_client = ListCreateClientLive(auth.server, auth, project_iri)
+
+    all_problems: list[CreateProblem] = []
+    progress_bar = tqdm(lists_to_create, desc="    Creating lists", dynamic_ncols=True)
+    for new_lst in progress_bar:
+        list_iri, problems = _create_new_list(new_lst, create_client, project_iri)
+        if list_iri is None:
+            problems.extend(problems)
+        else:
+            name2iri.add_iri(new_lst.list_info.name, list_iri)
+
+    create_problems = None
+    if all_problems:
+        create_problems = CollectedProblems("The following problems occurred during list creation:", all_problems)
+    return name2iri, create_problems
+
+
+def _print_existing_list_info(existing_lists: list[UserInformation]) -> None:
+    lists = ", ".join([x.focus_object for x in existing_lists])
+    msg = f"    The following lists already exist on the server and will be skipped: {lists}"
+    logger.info(msg)
+    print(BOLD_CYAN + msg + RESET_TO_DEFAULT)
+
+
+def get_existing_lists_on_server(shortcode: str, auth: AuthenticationClient) -> ListNameToIriLookup:
+    client = ListGetClientLive(auth.server, shortcode)
+    try:
+        name2iri_dict = client.get_all_list_iris_and_names()
+        return ListNameToIriLookup(name2iri_dict)
+    except FatalNonOkApiResponseCode as e:
+        logger.exception(e)
+        warnings.warn(
+            DspToolsUnexpectedStatusCodeWarning(
+                "Could not retrieve existing lists on server. "
+                "We will not be able to create any properties that require a list that is not defined in the JSON."
+            )
+        )
+        return ListNameToIriLookup({})
+
+
+def _filter_out_existing_lists(
+    parsed_lists: list[ParsedList], name2iri: ListNameToIriLookup
+) -> tuple[list[ParsedList], list[UserInformation]]:
+    lists_to_create: list[ParsedList] = []
+    existing_info: list[UserInformation] = []
+
+    for parsed_list in parsed_lists:
+        if name2iri.check_list_exists(parsed_list.list_info.name):
+            existing_info.append(
+                UserInformation(parsed_list.list_info.name, UserInformationMessage.LIST_EXISTS_ON_SERVER)
+            )
+        else:
+            lists_to_create.append(parsed_list)
+
+    return lists_to_create, existing_info
+
+
+def _create_new_list(
+    parsed_list: ParsedList, create_client: ListCreateClient, project_iri: str
+) -> tuple[str | None, list[UploadProblem]]:
+    serialised = _serialise_list(parsed_list.list_info, project_iri)
+    new_iri = create_client.create_new_list(serialised)
+
+    if new_iri is None:
+        problems: list[UploadProblem] = [
+            UploadProblem(parsed_list.list_info.name, UploadProblemType.LIST_COULD_NOT_BE_CREATED)
+        ]
+        return None, problems
+
+    node_problems = []
+    if parsed_list.children:
+        node_problems = _create_node_tree(parsed_list.children, new_iri, create_client, project_iri)
+
+    return new_iri, node_problems
+
+
+def _serialise_list(parsed_list_info: ParsedNodeInfo, project_iri: str) -> dict[str, Any]:
+    node_dict = {
+        "projectIri": project_iri,
+        "name": parsed_list_info.name,
+        "labels": _convert_to_api_format(parsed_list_info.labels),
+    }
+    if parsed_list_info.comments:
+        node_dict["comments"] = _convert_to_api_format(parsed_list_info.comments)
+    return node_dict
+
+
+def _create_node_tree(
+    nodes: list[ParsedListNode], parent_iri: str, create_client: ListCreateClient, project_iri: str
+) -> list[UploadProblem]:
+    problems: list[UploadProblem] = []
+
+    for node in nodes:
+        serialised = _serialise_node(node.node_info, parent_iri, project_iri)
+        node_iri = create_client.add_list_node(serialised, parent_iri)
+        if node_iri is None:
+            problems.append(UploadProblem(node.node_info.name, UploadProblemType.LIST_NODE_COULD_NOT_BE_CREATED))
+            continue
+
+        if node.children:
+            child_problems = _create_node_tree(node.children, node_iri, create_client, project_iri)
+            problems.extend(child_problems)
+
+    return problems
+
+
+def _serialise_node(node_info: ParsedNodeInfo, parent_iri: str, project_iri: str) -> dict[str, Any]:
+    node_dict = {
+        "parentNodeIri": parent_iri,
+        "projectIri": project_iri,
+        "name": node_info.name,
+        "labels": _convert_to_api_format(node_info.labels),
+    }
+    if node_info.comments:
+        node_dict["comments"] = _convert_to_api_format(node_info.comments)
+    return node_dict
+
+
+def _convert_to_api_format(lang_dict: dict[str, str]) -> list[dict[str, str]]:
+    return [{"value": value, "language": lang} for lang, value in lang_dict.items()]

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/create_on_server/onto_utils.py

@@ -0,0 +1,74 @@
+import time
+from http import HTTPStatus
+
+import regex
+import rustworkx as rx
+from loguru import logger
+from rdflib import OWL
+from rdflib import RDF
+from rdflib import Graph
+from rdflib import URIRef
+
+from dsp_tools.clients.ontology_clients import OntologyCreateClient
+from dsp_tools.clients.ontology_get_client_live import OntologyGetClientLive
+from dsp_tools.commands.create.exceptions import CircularOntologyDependency
+from dsp_tools.commands.create.models.server_project_info import OntoLastModDateLookup
+from dsp_tools.commands.create.models.server_project_info import ProjectIriLookup
+from dsp_tools.error.exceptions import ProjectOntologyNotFound
+from dsp_tools.utils.request_utils import ResponseCodeAndText
+
+
+def should_retry_request(response: ResponseCodeAndText) -> bool:
+    if response.status_code == HTTPStatus.BAD_REQUEST:
+        if regex.search(r"Ontology .+ modified", response.text):
+            return True
+    elif HTTPStatus.INTERNAL_SERVER_ERROR <= response.status_code <= HTTPStatus.NETWORK_AUTHENTICATION_REQUIRED:
+        time.sleep(5)
+        return True
+    return False
+
+
+def sort_for_upload(graph: rx.PyDiGraph, node_to_iri: dict[int, str]) -> list[str]:
+    try:
+        node_sorting_order = rx.topological_sort(graph)
+        return [node_to_iri[x] for x in reversed(node_sorting_order)]
+    except rx.DAGHasCycle as e:
+        logger.error(e)
+        raise CircularOntologyDependency("super-properties") from None
+
+
+def get_modification_date_onto_lookup(
+    project_iri_lookup: ProjectIriLookup,
+    onto_client: OntologyCreateClient,
+) -> OntoLastModDateLookup:
+    lookup = OntoLastModDateLookup(
+        project_iri=project_iri_lookup.project_iri,
+        onto_iris={name: URIRef(iri) for name, iri in project_iri_lookup.onto_iris.items()},
+    )
+    for onto_iri in project_iri_lookup.onto_iris.values():
+        last_mod = onto_client.get_last_modification_date(project_iri_lookup.project_iri, onto_iri)
+        lookup.update_last_mod_date(onto_iri, last_mod)
+    return lookup
+
+
+def get_project_iri_lookup(server: str, shortcode: str, project_iri: str) -> ProjectIriLookup:
+    client = OntologyGetClientLive(server, shortcode)
+    try:
+        ontologies, onto_iris = client.get_ontologies()
+        logger.debug(f"Project ontologies found: {', '.join(onto_iris)}")
+        lookup = _get_name_to_iri_lookup(ontologies)
+        return ProjectIriLookup(project_iri, lookup)
+    except ProjectOntologyNotFound:
+        logger.debug("No project ontologies on server.")
+        return ProjectIriLookup(project_iri)
+
+
+def _get_name_to_iri_lookup(ontologies: list[str]) -> dict[str, str]:
+    lookup = {}
+    for onto in ontologies:
+        g = Graph()
+        g.parse(data=onto, format="ttl")
+        iri = str(next(g.subjects(RDF.type, OWL.Ontology)))
+        name = iri.split("/")[-2]
+        lookup[str(name)] = str(iri)
+    return lookup

dsp_tools/commands/create/create_on_server/ontology.py

@@ -0,0 +1,52 @@
+import time
+
+from loguru import logger
+from tqdm import tqdm
+
+from dsp_tools.clients.ontology_clients import OntologyCreateClient
+from dsp_tools.commands.create.models.create_problems import CollectedProblems
+from dsp_tools.commands.create.models.create_problems import CreateProblem
+from dsp_tools.commands.create.models.create_problems import UploadProblem
+from dsp_tools.commands.create.models.create_problems import UploadProblemType
+from dsp_tools.commands.create.models.parsed_ontology import ParsedOntology
+from dsp_tools.commands.create.models.server_project_info import ProjectIriLookup
+from dsp_tools.commands.create.serialisation.ontology import serialise_ontology_graph_for_request
+from dsp_tools.utils.request_utils import ResponseCodeAndText
+from dsp_tools.utils.request_utils import is_server_error
+
+
+def create_all_ontologies(
+    ontologies: list[ParsedOntology],
+    project_iri_lookup: ProjectIriLookup,
+    client: OntologyCreateClient,
+) -> tuple[ProjectIriLookup, CollectedProblems | None]:
+    logger.debug("Creating ontologies")
+    progress_bar = tqdm(ontologies, "     Creating ontologies", dynamic_ncols=True)
+    problems: list[CreateProblem] = []
+    for o in progress_bar:
+        result = _create_one_ontology(o, project_iri_lookup.project_iri, client)
+        if isinstance(result, UploadProblem):
+            problems.append(result)
+        else:
+            project_iri_lookup.add_onto(o.name, result)
+    if problems:
+        return project_iri_lookup, CollectedProblems(
+            "    While creating ontologies the following problems occurred:", problems
+        )
+    return project_iri_lookup, None
+
+
+def _create_one_ontology(
+    onto: ParsedOntology,
+    project_iri: str,
+    client: OntologyCreateClient,
+) -> UploadProblem | str:
+    serialised = serialise_ontology_graph_for_request(onto, project_iri)
+    result = client.post_new_ontology(serialised)
+    if isinstance(result, ResponseCodeAndText):
+        if is_server_error(result):
+            time.sleep(5)
+            result = client.post_new_ontology(serialised)
+        if isinstance(result, ResponseCodeAndText):
+            return UploadProblem(result.text, UploadProblemType.ONTOLOGY_COULD_NOT_BE_CREATED)
+    return result

dsp_tools/commands/create/create_on_server/project.py

@@ -0,0 +1,68 @@
+import sys
+
+from loguru import logger
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.project_client import ProjectClient
+from dsp_tools.clients.project_client_live import ProjectClientLive
+from dsp_tools.commands.create.exceptions import UnableToCreateProjectError
+from dsp_tools.commands.create.models.parsed_project import ParsedProjectMetadata
+from dsp_tools.commands.create.serialisation.project import serialise_project
+from dsp_tools.error.exceptions import ProjectNotFoundError
+from dsp_tools.utils.ansi_colors import BACKGROUND_BOLD_YELLOW
+from dsp_tools.utils.ansi_colors import BOLD
+from dsp_tools.utils.ansi_colors import BOLD_RED
+from dsp_tools.utils.ansi_colors import RESET_TO_DEFAULT
+from dsp_tools.utils.request_utils import is_server_error
+
+
+def create_project(project: ParsedProjectMetadata, auth: AuthenticationClient, exit_if_exists: bool) -> str:
+    client = ProjectClientLive(auth.server, auth)
+    try:
+        project_iri = client.get_project_iri(project.shortcode)
+        _exit_if_create_should_not_continue(project.shortcode, exit_if_exists)
+        return project_iri
+
+    except ProjectNotFoundError:
+        logger.debug("No project with the shortcode exists. Continuing creating the project.")
+        return _create_project_on_server(project, client)
+
+
+def _exit_if_create_should_not_continue(shortcode: str, exit_if_exists: bool) -> None:
+    if exit_if_exists:
+        msg = (
+            "The project already exists on the server and the flag '--exit-if-exists' was set. "
+            "The process is aborted without further uploads."
+        )
+        logger.info(msg)
+        print(BACKGROUND_BOLD_YELLOW + msg + RESET_TO_DEFAULT)
+        sys.exit(0)
+
+    msg = (
+        f"A project with the shortcode '{shortcode}' already exists on the server. "
+        f"Do you wish to continue uploading additional information? [y/n] "
+    )
+    logger.debug(msg)
+    resp = None
+    while resp not in ["y", "n"]:
+        resp = input(BOLD_RED + msg + RESET_TO_DEFAULT)
+    if resp == "n":
+        logger.debug("Response 'n' abort command.")
+        sys.exit(1)
+
+
+def _create_project_on_server(project: ParsedProjectMetadata, client: ProjectClient) -> str:
+    info_str = f"Creating project '{project.shortname}' ({project.shortcode})"
+    print(BOLD + info_str + RESET_TO_DEFAULT)
+    logger.debug(info_str)
+    serialised = serialise_project(project)
+    result = client.post_new_project(serialised)
+    if isinstance(result, str):
+        return result
+    if is_server_error(result):
+        msg = "Due to a server error it was not possible to create the project. "
+    else:
+        msg = "Unable to create project."
+    raise UnableToCreateProjectError(
+        msg + f"\nOriginal response code: {result.status_code}\nOriginal response message: {result.text}"
+    )