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

dsp_tools/commands/excel2xml/propertyelement.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from typing import Optional
 from typing import Union
 
-from dsp_tools.models.exceptions import BaseError
+from dsp_tools.error.exceptions import BaseError
 
 # ruff: noqa: E501 (line-too-long)
 
@@ -25,20 +25,20 @@ class PropertyElement:
 
         >>> excel2xml.make_text_prop(":testproperty", "first text")
                 <text-prop name=":testproperty">
-                    <text encoding="utf8" permissions="prop-default">
+                    <text encoding="utf8" permissions="public">
                         first text
                     </text>
                 </text-prop>
-        >>> excel2xml.make_text_prop(":testproperty", excel2xml.PropertyElement("first text", permissions="prop-restricted", encoding="xml"))
+        >>> excel2xml.make_text_prop(":testproperty", excel2xml.PropertyElement("first text", permissions="private", encoding="xml"))
                 <text-prop name=":testproperty">
-                    <text encoding="xml" permissions="prop-restricted">
+                    <text encoding="xml" permissions="private">
                         first text
                     </text>
                 </text-prop>
     """
 
     value: Union[str, int, float, bool]
-    permissions: str = "prop-default"
+    permissions: str = "public"
     comment: Optional[str] = None
     encoding: Optional[str] = None
 

dsp_tools/commands/{project → get}/get.py

@@ -5,14 +5,16 @@ from typing import Any
 import regex
 
 from dsp_tools.cli.args import ServerCredentials
-from dsp_tools.commands.project.models.group import Group
-from dsp_tools.commands.project.models.listnode import ListNode
-from dsp_tools.commands.project.models.ontology import Ontology
-from dsp_tools.commands.project.models.project import Project
-from dsp_tools.commands.project.models.user import User
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.utils.connection import Connection
-from dsp_tools.utils.connection_live import ConnectionLive
+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.get.get_permissions import get_default_permissions
+from dsp_tools.commands.get.legacy_models.group import Group
+from dsp_tools.commands.get.legacy_models.listnode import ListNode
+from dsp_tools.commands.get.legacy_models.ontology import Ontology
+from dsp_tools.commands.get.legacy_models.project import Project
+from dsp_tools.commands.get.legacy_models.user import User
+from dsp_tools.error.exceptions import BaseError
 
 
 def get_project(
@@ -36,24 +38,38 @@ def get_project(
     Returns:
         True if the process finishes without errors
     """
-    con = ConnectionLive(creds.server)
+    auth = AuthenticationClientLive(creds.server, creds.user, creds.password)
     try:
-        con.login(creds.user, creds.password)
+        auth.get_token()
+        con = ConnectionLive(creds.server, auth)
+        authenticated = True
     except BaseError:
-        warnings.warn("WARNING: Missing or wrong credentials. You won't get data about the users of this project.")
+        warnings.warn("WARNING: Missing or wrong credentials. You won't get sensitive data of this project.")
+        con = ConnectionLive(creds.server)
+        authenticated = False
 
     project = _create_project(con, project_identifier)
 
     project = project.read()
     project_obj = project.createDefinitionFileObj()
 
+    prefixes, ontos = _get_ontologies(con, str(project.iri), verbose)
+
+    if authenticated:
+        default_permissions, default_permissions_overrule = get_default_permissions(auth, str(project.iri), prefixes)
+        project_obj["default_permissions"] = default_permissions
+        if default_permissions_overrule:
+            project_obj["default_permissions_overrule"] = default_permissions_overrule
+    else:
+        project_obj["default_permissions"] = "Please provide credentials to retrieve the permissions of this project."
+
     project_obj["groups"] = _get_groups(con, str(project.iri), verbose)
 
-    project_obj["users"] = _get_users(con, project, verbose)
+    if users := _get_users(con, project, verbose):
+        project_obj["users"] = users
 
     project_obj["lists"] = _get_lists(con, project, verbose)
 
-    prefixes, ontos = _get_ontologies(con, str(project.iri), verbose)
     project_obj["ontologies"] = ontos
 
     schema = "https://raw.githubusercontent.com/dasch-swiss/dsp-tools/main/src/dsp_tools/resources/schema/project.json"

dsp_tools/commands/get/get_permissions.py

@@ -0,0 +1,257 @@
+from typing import Any
+from typing import Literal
+
+import regex
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.permissions_client import PermissionsClient
+from dsp_tools.commands.get.get_permissions_legacy import parse_legacy_doaps
+from dsp_tools.commands.get.models.permissions_models import DoapCategories
+from dsp_tools.error.exceptions import UnknownDOAPException
+
+
+def get_default_permissions(
+    auth: AuthenticationClient, project_iri: str, prefixes: dict[str, str]
+) -> tuple[str, dict[str, list[str] | Literal["all"]] | None]:
+    """
+    Retrieve the DOAPs of a project from the server,
+    and try to fit them into our system of "default_permissions" and "default_permissions_overrule".
+    If an anomaly is found, return an error message for "default_permissions",
+    and None for "default_permissions_overrule".
+
+    Returns:
+        "default_permissions": "public" or "private" or error message
+        "default_permissions_overrule": {"private": [<classes_or_props>], "limited_view": ["all" or <img_classes>]}
+    """
+    perm_client = PermissionsClient(auth, project_iri)
+    project_doaps = perm_client.get_project_doaps()
+    fallback_text = (
+        "We cannot determine if this project is public or private. "
+        "The DSP-TOOLS devs can assist you in analysing the existing DOAPs, "
+        "and help you decide if the original intent was rather public or rather private."
+    )
+    try:
+        default_permissions = _parse_default_permissions(project_doaps)
+        default_permissions_overrule = _parse_default_permissions_overrule(project_doaps, prefixes)
+    except UnknownDOAPException:
+        default_permissions = fallback_text
+        default_permissions_overrule = None
+    return default_permissions, default_permissions_overrule
+
+
+def _parse_default_permissions(project_doaps: list[dict[str, Any]]) -> str:
+    """
+    First tries to parse legacy DOAPs with multiple groups, then falls back to new-style parsing.
+    New-style parsing: If the DOAPs exactly match our definition of public/private, return public/private.
+    Otherwise, raise an exception.
+    """
+    # First, try to parse legacy DOAPs (multiple groups: ProjectAdmin, ProjectMember)
+    if legacy_result := parse_legacy_doaps(project_doaps):
+        return legacy_result
+
+    # Fall back to new-style parsing (single ProjectMember group)
+    unsupported_groups = ("SystemAdmin", "ProjectAdmin", "Creator", "KnownUser", "UnknownUser")
+    if [x for x in project_doaps if x.get("forGroup", "").endswith(unsupported_groups)]:
+        raise UnknownDOAPException("The only supported target group for DOAPs is ProjectMember.")
+    proj_member_doaps = [x for x in project_doaps if x.get("forGroup", "").endswith("ProjectMember")]
+    if len(proj_member_doaps) != 1:
+        raise UnknownDOAPException("There must be exactly 1 DOAP for ProjectMember.")
+    perms = proj_member_doaps[0]["hasPermissions"]
+    if len(perms) not in [2, 4]:
+        err_msg = "The only allowed permissions are 'private' (with 2 elements), and 'limited_view' (with 4 elements)"
+        raise UnknownDOAPException(err_msg)
+    proj_adm_perms = [x for x in perms if x["additionalInformation"].endswith("ProjectAdmin")]
+    proj_mem_perms = [x for x in perms if x["additionalInformation"].endswith("ProjectMember")]
+    knwn_usr_perms = [x for x in perms if x["additionalInformation"].endswith("KnownUser")]
+    unkn_usr_perms = [x for x in perms if x["additionalInformation"].endswith("UnknownUser")]
+    if not (len(proj_adm_perms) == len(proj_mem_perms) == 1):
+        raise UnknownDOAPException("There must be always 1 permission for ProjectAdmin and 1 for ProjectMember")
+    if proj_adm_perms[0]["name"] != "CR" or proj_mem_perms[0]["name"] != "D":
+        raise UnknownDOAPException("ProjectAdmin must always have CR and ProjectMember must always have D")
+    if len(knwn_usr_perms) == len(unkn_usr_perms) == 0:
+        return "private"
+    if not (len(knwn_usr_perms) == len(unkn_usr_perms) == 1):
+        raise UnknownDOAPException("In case of 'limited_view', there must be 1 for KnownUser and 1 for UnknownUser")
+    if knwn_usr_perms[0]["name"] != "V" or unkn_usr_perms[0]["name"] != "V":
+        raise UnknownDOAPException("In case of 'public', KnownUser and UnknownUser must always have V")
+    return "public"
+
+
+def _parse_default_permissions_overrule(
+    project_doaps: list[dict[str, Any]], prefixes: dict[str, str]
+) -> dict[str, list[str] | Literal["all"]] | None:
+    """
+    The DOAPs retrieved from the server are examined if they fit into our system of the overrules.
+    If yes, an overrule object is returned. Otherwise, an exception is raised.
+
+    Args:
+        project_doaps: DOAPs as retrieved from the server
+        prefixes: dict in the form {"my-onto": "http://0.0.0.0:3333/ontology/1234/my-onto/v2"}
+
+    Returns:
+        an overrule object that can be written into the JSON project definition file, in this form:
+        "default_permissions_overrule": {"private": [<classes_or_props>], "limited_view": ["all" or <img_classes>]}
+
+    Raises:
+        UnknownDOAPException: if there are DOAPs that do not fit into our system
+    """
+    prefixes_knora_base_inverted = _convert_prefixes(prefixes)
+    doap_categories = _categorize_doaps(project_doaps)
+    _validate_doap_categories(doap_categories)
+    return _construct_overrule_object(doap_categories, prefixes_knora_base_inverted)
+
+
+def _convert_prefixes(prefixes: dict[str, str]) -> dict[str, str]:
+    """
+    Convert knora-api form of prefixes into knora-base form (used by DOAPs), and invert it.
+
+    Args:
+        prefixes: dict in the form of {"my-onto": "http://0.0.0.0:3333/ontology/1234/my-onto/v2"}
+
+    Returns:
+        dict in the form of {"http://www.knora.org/ontology/1234/my-onto": "my-onto"}
+    """
+    prefixes_knora_base_inverted = {}
+    for onto_shorthand, knora_api_iri in prefixes.items():
+        if match := regex.search(r"/ontology/([0-9A-Fa-f]{4})/([^/]+)/v2", knora_api_iri):
+            shortcode, onto_name = match.groups()
+            prefixes_knora_base_inverted[f"http://www.knora.org/ontology/{shortcode}/{onto_name}"] = onto_shorthand
+    return prefixes_knora_base_inverted
+
+
+def _categorize_doaps(project_doaps: list[dict[str, Any]]) -> DoapCategories:
+    """
+    The overrule object of the JSON project definition file has 2 categories: private and limited_view.
+    - "private" is a list of classes/properties that are private.
+      The DOAPs for these correspond 1:1 to the classes/properties.
+    - "limited_view" is
+        - a list of image classes that are limited_view:
+          The DOAPs for these are for knora-api:hasStillImageFileValue and the respective class.
+        - or the string "all". The DOAPs for these are only for knora-api:hasStillImageFileValue.
+
+    This function groups the DOAPs into these categories.
+
+    Args:
+        project_doaps: the DOAPs as retrieved from the server
+
+    Raises:
+        UnknownDOAPException: if there are DOAPs that do not fit into our system
+
+    Returns:
+        a DTO with the categories
+    """
+    class_doaps = []
+    prop_doaps = []
+    has_img_all_classes_doaps = []
+    has_img_specific_class_doaps = []
+    other_doaps = []
+    for doap in project_doaps:
+        match (doap.get("forResourceClass"), doap.get("forProperty")):
+            case (for_class, None) if for_class:
+                class_doaps.append(doap)
+            case (None, for_prop) if for_prop and "hasStillImageFileValue" not in for_prop:
+                prop_doaps.append(doap)
+            case (None, for_prop) if for_prop and "hasStillImageFileValue" in for_prop:
+                has_img_all_classes_doaps.append(doap)
+            case (for_class, for_prop) if for_class and for_prop and "hasStillImageFileValue" in for_prop:
+                has_img_specific_class_doaps.append(doap)
+            case _:
+                other_doaps.append(doap)
+    # Only validate other_doaps if there are any
+    if other_doaps:
+        try:
+            _parse_default_permissions(other_doaps)
+        except UnknownDOAPException:
+            raise UnknownDOAPException("Found DOAPs that do not fit into our system") from None
+    return DoapCategories(
+        class_doaps=class_doaps,
+        prop_doaps=prop_doaps,
+        has_img_all_classes_doaps=has_img_all_classes_doaps,
+        has_img_specific_class_doaps=has_img_specific_class_doaps,
+    )
+
+
+def _validate_doap_categories(doap_categories: DoapCategories) -> None:
+    for expected_private_doap in doap_categories.class_doaps + doap_categories.prop_doaps:
+        perm = sorted(expected_private_doap["hasPermissions"], key=lambda x: x["name"])
+        if len(perm) != 2:
+            raise UnknownDOAPException("'private' is defined as CR ProjectAdmin|D ProjectMember")
+        CR, D = perm
+        if CR["name"] != "CR" or not CR["additionalInformation"].endswith("ProjectAdmin"):
+            raise UnknownDOAPException("'private' is defined as CR ProjectAdmin|D ProjectMember")
+        if D["name"] != "D" or not D["additionalInformation"].endswith("ProjectMember"):
+            raise UnknownDOAPException("'private' is defined as CR ProjectAdmin|D ProjectMember")
+
+    for expected_limited_view in (
+        doap_categories.has_img_all_classes_doaps + doap_categories.has_img_specific_class_doaps
+    ):
+        err_msg = "'limited_view' is defined as CR ProjectAdmin|D ProjectMember|RV KnownUser|RV UnknownUser"
+        perm = sorted(expected_limited_view["hasPermissions"], key=lambda x: x["name"])
+        if len(perm) != 4:
+            raise UnknownDOAPException(err_msg)
+        CR, D, RV1, RV2 = perm
+        if CR["name"] != "CR" or not CR["additionalInformation"].endswith("ProjectAdmin"):
+            raise UnknownDOAPException(err_msg)
+        if D["name"] != "D" or not D["additionalInformation"].endswith("ProjectMember"):
+            raise UnknownDOAPException(err_msg)
+        if RV1["name"] != "RV" or not RV2["additionalInformation"].endswith("nownUser"):
+            raise UnknownDOAPException(err_msg)
+        if RV2["name"] != "RV" or not RV2["additionalInformation"].endswith("nownUser"):
+            raise UnknownDOAPException(err_msg)
+
+
+def _construct_overrule_object(
+    doap_categories: DoapCategories, prefixes_knora_base_inverted: dict[str, str]
+) -> dict[str, list[str] | Literal["all"]]:
+    """
+    Construct the final overrules object that can be written into the JSON project definition file.
+    To do so, the fully qualified IRIs of the classes/properties must be converted to prefixed IRIs.
+
+    Args:
+        doap_categories: The categorized DOAPs from the server
+        prefixes_knora_base_inverted: lookup from fully qualified IRIs to prefixed IRIs
+
+    Raises:
+        UnknownDOAPException: if the DOAPs do not fit into our system
+
+    Returns:
+        the final overrules object that can be written into the JSON project definition file
+    """
+    privates: list[str] = []
+    for class_doap in doap_categories.class_doaps:
+        privates.append(_get_prefixed_iri(class_doap["forResourceClass"], prefixes_knora_base_inverted))
+    for prop_doap in doap_categories.prop_doaps:
+        privates.append(_get_prefixed_iri(prop_doap["forProperty"], prefixes_knora_base_inverted))
+
+    limited_views: list[str] | Literal["all"]
+    if len(doap_categories.has_img_all_classes_doaps) > 1:
+        raise UnknownDOAPException("There can only be 1 all-images DOAP for 'hasStillImageFileValue'")
+    if len(doap_categories.has_img_all_classes_doaps) == 1 and len(doap_categories.has_img_specific_class_doaps) > 0:
+        raise UnknownDOAPException("If there is a DOAP for all images, there cannot be DOAPs for specific img classes")
+    if len(doap_categories.has_img_all_classes_doaps) == 1:
+        limited_views = "all"
+    else:
+        limited_views = []
+        for img_doap in doap_categories.has_img_specific_class_doaps:
+            limited_views.append(_get_prefixed_iri(img_doap["forResourceClass"], prefixes_knora_base_inverted))
+
+    result: dict[str, list[str] | Literal["all"]] = {}
+    if privates:
+        result["private"] = privates
+    if limited_views:
+        result["limited_view"] = limited_views
+    return result
+
+
+def _get_prefixed_iri(full_iri: str, prefixes_inverted: dict[str, str]) -> str:
+    # example:
+    #    - full_iri = "http://www.knora.org/ontology/1234/my-onto/v2#MyClass"
+    #    - prefixes_inverted = {"http://www.knora.org/ontology/1234/my-onto": "my-onto"}
+    #    - output = "my-onto:MyClass"
+    if "#" not in full_iri:
+        raise ValueError(f"{full_iri} is not a valid full IRI")
+    before_hashtag, after_hashtag = full_iri.rsplit("#", maxsplit=1)
+    if before_hashtag not in prefixes_inverted:
+        raise ValueError(f"{full_iri} belongs to an unknown ontology. It cannot be found in the prefixes.")
+    prefix = prefixes_inverted[before_hashtag]
+    return f"{prefix}:{after_hashtag}"

dsp_tools/commands/get/get_permissions_legacy.py

@@ -0,0 +1,89 @@
+from typing import Any
+from typing import Literal
+
+
+def parse_legacy_doaps(project_doaps: list[dict[str, Any]]) -> Literal["public", "private"] | None:
+    """
+    Check if DOAPs match one of the legacy patterns.
+
+    Legacy private:
+    - For group ProjectAdmin: ProjectAdmin CR, ProjectMember CR/M
+    - For group ProjectMember: ProjectAdmin CR, ProjectMember CR/M
+
+    Legacy public:
+    - For group ProjectAdmin: ProjectAdmin CR, (optionally: Creator CR), ProjectMember D/M, KnownUser V, UnknownUser V
+    - For group ProjectMember: ProjectAdmin CR, (optionally: Creator CR), ProjectMember D/M, KnownUser V, UnknownUser V
+    """
+    if len(project_doaps) != 2:
+        return None
+    admin_doaps = [x for x in project_doaps if x.get("forGroup", "").endswith("ProjectAdmin")]
+    member_doaps = [x for x in project_doaps if x.get("forGroup", "").endswith("ProjectMember")]
+    if len(admin_doaps) != 1 or len(member_doaps) != 1:
+        return None
+
+    admin_perms = admin_doaps[0]["hasPermissions"]
+    member_perms = member_doaps[0]["hasPermissions"]
+    if all([_is_legacy_private(admin_perms), _is_legacy_private(member_perms)]):
+        return "private"
+    if all([_is_legacy_public(admin_perms), _is_legacy_public(member_perms)]):
+        return "public"
+
+    return None
+
+
+def _is_legacy_private(perms: list[dict[str, Any]]) -> bool:
+    """
+    Check if permissions match the legacy private pattern: ProjectAdmin CR, ProjectMember M/D
+
+    Args:
+        perms: List of permission objects
+    """
+    if len(perms) != 2:
+        return False
+
+    sorted_perms = sorted(perms, key=lambda x: x.get("name", ""))
+
+    # First should be CR for ProjectAdmin
+    if sorted_perms[0]["name"] != "CR" or not sorted_perms[0]["additionalInformation"].endswith("ProjectAdmin"):
+        return False
+
+    # Second should be D or M for ProjectMember
+    if sorted_perms[1]["name"] not in ["D", "M"] or not sorted_perms[1]["additionalInformation"].endswith(
+        "ProjectMember"
+    ):
+        return False
+
+    return True
+
+
+def _is_legacy_public(perms: list[dict[str, Any]]) -> bool:
+    """
+    Check if permissions match the public pattern:
+    ProjectAdmin CR, (optionally: Creator CR), ProjectMember D/M, KnownUser V, UnknownUser V
+    """
+    # Should have exactly 4 permissions after filtering out Creator
+    filtered_perms = [p for p in perms if not p["additionalInformation"].endswith("Creator")]
+    if len(filtered_perms) != 4:
+        return False
+
+    sorted_perms = sorted(filtered_perms, key=lambda x: x.get("name", ""))
+
+    # First should be CR for ProjectAdmin
+    if sorted_perms[0]["name"] != "CR" or not sorted_perms[0]["additionalInformation"].endswith("ProjectAdmin"):
+        return False
+
+    # Second should be D or M for ProjectMember
+    if sorted_perms[1]["name"] not in ["D", "M"] or not sorted_perms[1]["additionalInformation"].endswith(
+        "ProjectMember"
+    ):
+        return False
+
+    # Third/Fourth should be V for KnownUser
+    if sorted_perms[2]["name"] != "V" or not sorted_perms[2]["additionalInformation"].endswith("nownUser"):
+        return False
+
+    # Third/Fourth should be V for UnknownUser
+    if sorted_perms[3]["name"] != "V" or not sorted_perms[3]["additionalInformation"].endswith("nownUser"):
+        return False
+
+    return True

dsp_tools/commands/{project/models → get/legacy_models}/context.py

@@ -4,10 +4,10 @@ from typing import Optional
 
 import regex
 
-from dsp_tools.commands.project.models.helpers import ContextType
-from dsp_tools.commands.project.models.helpers import OntoIri
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.utils.iri_util import is_iri
+from dsp_tools.commands.get.legacy_models.helpers import ContextType
+from dsp_tools.commands.get.legacy_models.helpers import OntoIri
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.utils.data_formats.iri_util import is_iri
 
 
 class ContextIterator:
@@ -15,7 +15,7 @@ class ContextIterator:
     _prefixes: list[str]
     _index: int
 
-    def __init__(self, context: "Context"):
+    def __init__(self, context: Context):
         self._context = context
         self._prefixes = list(self._context.context)
         self._index = 0
@@ -127,7 +127,7 @@ class Context:
         :param value: Dictionary of context
         :return: None
         """
-        if value is not None and isinstance(value, ContextType):
+        if value is not None and isinstance(value, dict):
             self._context = value
         else:
             raise BaseError("Error in parameter to context setter")

dsp_tools/commands/{project/models → get/legacy_models}/group.py

@@ -28,11 +28,11 @@ from typing import Optional
 from typing import Union
 from urllib.parse import quote_plus
 
-from dsp_tools.commands.project.models.model import Model
-from dsp_tools.commands.project.models.project import Project
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.models.langstring import LangString
-from dsp_tools.utils.connection import Connection
+from dsp_tools.clients.connection import Connection
+from dsp_tools.commands.get.legacy_models.model import Model
+from dsp_tools.commands.get.legacy_models.project import Project
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.legacy_models.langstring import LangString
 
 
 class Group(Model):
@@ -68,7 +68,6 @@ class Group(Model):
 
     PROJECT_MEMBER_GROUP: str = "http://www.knora.org/ontology/knora-admin#ProjectMember"
     PROJECT_ADMIN_GROUP: str = "http://www.knora.org/ontology/knora-admin#ProjectAdmin"
-    PROJECT_SYSTEMADMIN_GROUP: str = "http://www.knora.org/ontology/knora-admin#SystemAdmin"
     ROUTE: str = "/admin/groups"
     ROUTE_SLASH: str = ROUTE + "/"
 
@@ -224,10 +223,6 @@ class Group(Model):
             tmp["selfjoin"] = self._selfjoin
         return tmp
 
-    def delete(self) -> Group:
-        result = self._con.delete(Group.ROUTE_SLASH + quote_plus(self._iri))
-        return Group.fromJsonObj(self._con, result["group"])
-
     @staticmethod
     def getAllGroups(con: Connection) -> list[Group]:
         result = con.get(Group.ROUTE)

dsp_tools/commands/{project/models → get/legacy_models}/listnode.py

@@ -18,11 +18,11 @@ from typing import Optional
 from typing import Union
 from urllib.parse import quote_plus
 
-from dsp_tools.commands.project.models.model import Model
-from dsp_tools.commands.project.models.project import Project
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.models.langstring import LangString
-from dsp_tools.utils.connection import Connection
+from dsp_tools.clients.connection import Connection
+from dsp_tools.commands.get.legacy_models.model import Model
+from dsp_tools.commands.get.legacy_models.project import Project
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.legacy_models.langstring import LangString
 
 
 class ListNode(Model):
@@ -301,36 +301,6 @@ class ListNode(Model):
             rootNodeIri=rootNodeIri,
         )
 
-    def create(self) -> ListNode:
-        """
-        Create a new List
-
-        :return: JSON-object from DSP-API
-        """
-        jsonobj = self._toJsonObj_create()
-        if self._parent:
-            result = self._con.post(ListNode.ROUTE_SLASH + quote_plus(self._parent), jsonobj)
-            return ListNode.fromJsonObj(self._con, result["nodeinfo"])
-        else:
-            result = self._con.post(ListNode.ROUTE, jsonobj)
-            return ListNode.fromJsonObj(self._con, result["list"]["listinfo"])
-
-    def _toJsonObj_create(self):
-        tmp = {}
-        if self._project is None:
-            raise BaseError("There must be a project id given!")
-        tmp["projectIri"] = self._project
-        if self._label.isEmpty():
-            raise BaseError("There must be a valid ListNode label!")
-        tmp["labels"] = self._label.toJsonObj()
-        if self._comments:
-            tmp["comments"] = self._comments.toJsonObj()
-        if self._name:
-            tmp["name"] = self._name
-        if self._parent:
-            tmp["parentNodeIri"] = self._parent
-        return tmp
-
     def read(self) -> Any:
         """
         Read a project from DSP-API

dsp_tools/commands/{project/models → get/legacy_models}/model.py

@@ -1,4 +1,4 @@
-from dsp_tools.utils.connection import Connection
+from dsp_tools.clients.connection import Connection
 
 
 class Model:

dsp_tools/commands/{project/models → get/legacy_models}/ontology.py

@@ -26,15 +26,15 @@ from urllib.parse import quote_plus
 
 import regex
 
-from dsp_tools.commands.project.models.context import Context
-from dsp_tools.commands.project.models.helpers import WithId
-from dsp_tools.commands.project.models.model import Model
-from dsp_tools.commands.project.models.project import Project
-from dsp_tools.commands.project.models.propertyclass import PropertyClass
-from dsp_tools.commands.project.models.resourceclass import ResourceClass
-from dsp_tools.models.datetimestamp import DateTimeStamp
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.utils.connection import Connection
+from dsp_tools.clients.connection import Connection
+from dsp_tools.commands.get.legacy_models.context import Context
+from dsp_tools.commands.get.legacy_models.helpers import WithId
+from dsp_tools.commands.get.legacy_models.model import Model
+from dsp_tools.commands.get.legacy_models.project import Project
+from dsp_tools.commands.get.legacy_models.propertyclass import PropertyClass
+from dsp_tools.commands.get.legacy_models.resourceclass import ResourceClass
+from dsp_tools.error.exceptions import BaseError
+from dsp_tools.legacy_models.datetimestamp import DateTimeStamp
 
 
 class Ontology(Model):
@@ -287,11 +287,6 @@ class Ontology(Model):
         result = self._con.get(Ontology.ROUTE + "/allentities/" + quote_plus(self._iri) + Ontology.ALL_LANGUAGES)
         return Ontology.fromJsonObj(self._con, result)
 
-    @staticmethod
-    def getAllOntologies(con: Connection) -> list[Ontology]:
-        result = con.get(Ontology.ROUTE + Ontology.METADATA)
-        return Ontology.allOntologiesFromJsonObj(con, result)
-
     @staticmethod
     def getProjectOntologies(con: Connection, project_id: str) -> list[Ontology]:
         if project_id is None: