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

dsp_tools/commands/xmlupload/ontology_client.py

@@ -1,92 +0,0 @@
-from dataclasses import dataclass
-from dataclasses import field
-from typing import Any
-from typing import Protocol
-
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.models.exceptions import UserError
-from dsp_tools.utils.connection import Connection
-
-
-@dataclass
-class OntologyClient(Protocol):
-    """Interface (protocol) for ontology-related requests to the DSP-API."""
-
-    con: Connection
-    shortcode: str
-    default_ontology: str
-    ontology_names: list[str] = field(default_factory=list)
-
-    def get_all_project_ontologies_from_server(self) -> dict[str, list[dict[str, Any]]]:
-        """Get all the ontologies for a project from the server."""
-
-    def get_knora_api_ontology_from_server(self) -> list[dict[str, Any]]:
-        """Get the knora-api ontology from the server."""
-
-
-@dataclass
-class OntologyClientLive:
-    """Client handling ontology-related requests to the DSP-API."""
-
-    con: Connection
-    shortcode: str
-    default_ontology: str
-    ontology_names: list[str] = field(default_factory=list)
-
-    def get_all_project_ontologies_from_server(self) -> dict[str, list[dict[str, Any]]]:
-        """
-        This function returns all the project ontologies that are on the server.
-
-        Returns:
-            a dictionary with the ontology name as key and the ontology as value.
-        """
-        self._get_ontology_names_from_server()
-        return {onto: self._get_ontology_from_server(onto) for onto in self.ontology_names}
-
-    def _get_ontology_names_from_server(self) -> None:
-        try:
-            url = f"/admin/projects/shortcode/{self.shortcode}"
-            res = self.con.get(url)
-        except BaseError as e:
-            raise UserError(f"A project with shortcode {self.shortcode} could not be found on the DSP server") from e
-        try:
-            onto_iris: list[str] = res["project"]["ontologies"]
-        except KeyError as e:
-            raise BaseError(f"Unexpected response from server: {res}") from e
-        onto_names: list[str] = [iri.split("/")[-2] for iri in onto_iris]
-        self.ontology_names = onto_names
-
-    def _get_ontology_from_server(self, ontology_name: str) -> list[dict[str, Any]]:
-        try:
-            url = f"/ontology/{self.shortcode}/{ontology_name}/v2"
-            res = self.con.get(url)
-        except BaseError:
-            raise BaseError(
-                f"Ontologies for project {self.shortcode} could not be retrieved from the DSP server"
-            ) from None
-        try:
-            onto_graph: list[dict[str, Any]] = res["@graph"]
-        except KeyError as e:
-            raise BaseError(f"Unexpected response from server: {res}") from e
-        return onto_graph
-
-    def get_knora_api_ontology_from_server(self) -> list[dict[str, Any]]:
-        """
-        This function returns the knora-api ontology from the server.
-
-        Returns:
-            knora-api ontology in json format
-
-        Raises:
-            BaseError: if an unexpected response from the server occurred
-        """
-        url = "/ontology/knora-api/v2#"
-        try:
-            res = self.con.get(url)
-        except BaseError:
-            raise BaseError("Knora-api ontology could not be retrieved from the DSP server") from None
-        try:
-            onto_graph: list[dict[str, Any]] = res["@graph"]
-        except KeyError as e:
-            raise BaseError(f"Unexpected response from server when retrieving knora-api ontology: {res}") from e
-        return onto_graph

dsp_tools/commands/xmlupload/project_client.py

@@ -1,91 +0,0 @@
-from dataclasses import dataclass
-from dataclasses import field
-from typing import Protocol
-from urllib.parse import quote_plus
-
-from dsp_tools.models.exceptions import BaseError
-from dsp_tools.models.exceptions import UserError
-from dsp_tools.utils.connection import Connection
-
-
-@dataclass(frozen=True)
-class ProjectInfo:
-    """Information about a project."""
-
-    project_iri: str
-    ontology_iris: list[str]
-
-
-class ProjectClient(Protocol):
-    """Interface (protocol) for project-related requests to the DSP-API."""
-
-    con: Connection
-    shortcode: str
-    project_info: ProjectInfo | None
-
-    def get_project_iri(self) -> str:
-        """Get the IRI of the project to which the data is being uploaded."""
-
-    def get_ontology_name_dict(self) -> dict[str, str]:
-        """Returns a mapping of ontology names to ontology IRIs."""
-
-
-@dataclass()
-class ProjectClientLive:
-    """Client handling project-related requests to the DSP-API."""
-
-    con: Connection
-    shortcode: str
-    project_info: ProjectInfo | None = field(init=False, default=None)
-
-    def get_project_iri(self) -> str:
-        """Get the IRI of the project to which the data is being uploaded."""
-        if not self.project_info:
-            self.project_info = _get_project_info_from_server(self.con, self.shortcode)
-        return self.project_info.project_iri
-
-    def get_ontology_name_dict(self) -> dict[str, str]:
-        """Returns a mapping of ontology names to ontology IRIs."""
-        if not self.project_info:
-            self.project_info = _get_project_info_from_server(self.con, self.shortcode)
-        return {_extract_name_from_onto_iri(iri): iri for iri in self.project_info.ontology_iris}
-
-
-def _get_project_info_from_server(con: Connection, shortcode: str) -> ProjectInfo:
-    project_iri = _get_project_iri_from_server(con, shortcode)
-    ontologies = _get_ontologies_from_server(con, project_iri)
-    return ProjectInfo(project_iri=project_iri, ontology_iris=ontologies)
-
-
-def _get_project_iri_from_server(con: Connection, shortcode: str) -> str:
-    url = f"/admin/projects/shortcode/{shortcode}"
-    try:
-        res = con.get(url)
-    except BaseError as e:
-        raise UserError(f"A project with shortcode {shortcode} could not be found on the DSP server") from e
-
-    iri: str | None = res.get("project", {}).get("id")
-    if not iri:
-        raise BaseError(f"Unexpected response from server: {res}")
-    return iri
-
-
-def _get_ontologies_from_server(con: Connection, project_iri: str) -> list[str]:
-    try:
-        iri = quote_plus(project_iri)
-        url = f"/v2/ontologies/metadata/{iri}"
-        res = con.get(url)
-        body = res.get("@graph", res)
-        match body:
-            case list():
-                return [o["@id"] for o in body]
-            case dict():
-                return [body["@id"]]
-            case _:
-                raise BaseError("Unexpected response from server")
-    except BaseError as e:
-        raise BaseError(f"Ontologies for project {project_iri} could not be retrieved from the DSP server") from e
-
-
-def _extract_name_from_onto_iri(iri: str) -> str:
-    return iri.split("/")[-2]

dsp_tools/commands/xmlupload/read_validate_xml_file.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import regex
-from lxml import etree
-
-from dsp_tools.models.exceptions import UserError
-from dsp_tools.utils.iri_util import is_resource_iri
-from dsp_tools.utils.xml_utils import parse_xml_file
-from dsp_tools.utils.xml_utils import remove_comments_from_element_tree
-from dsp_tools.utils.xml_utils import transform_special_tags_make_localname
-from dsp_tools.utils.xml_validation import validate_xml
-
-
-def validate_and_parse(input_file: Path) -> tuple[etree._Element, str, str]:
-    """Parse and validate an XML file.
-
-    Args:
-        input_file: Path to the XML file
-
-    Returns:
-        The root element of the parsed XML file, the shortcode, and the default ontology
-    """
-    root = parse_xml_file(input_file)
-    root = remove_comments_from_element_tree(root)
-
-    validate_xml(root)
-    root = transform_special_tags_make_localname(root)
-    _check_if_link_targets_exist(root)
-    shortcode = root.attrib["shortcode"]
-    default_ontology = root.attrib["default-ontology"]
-    return root, shortcode, default_ontology
-
-
-def _check_if_link_targets_exist(root: etree._Element) -> None:
-    """
-    Make sure that all targets of links (resptr and salsah-links)
-    are either IRIs or IDs that exist in the present XML file.
-
-    Args:
-        root: parsed XML file
-
-    Raises:
-        UserError: if a link target does not exist in the XML file
-    """
-    resptr_errors = _check_if_resptr_targets_exist(root)
-    salsah_errors = _check_if_salsah_targets_exist(root)
-    if errors := resptr_errors + salsah_errors:
-        sep = "\n - "
-        msg = f"It is not possible to upload the XML file, because it contains invalid links:{sep}{sep.join(errors)}"
-        raise UserError(msg)
-
-
-def _check_if_resptr_targets_exist(root: etree._Element) -> list[str]:
-    link_values = [x for x in root.iter() if x.tag == "resptr"]
-    resource_ids = [x.attrib["id"] for x in root.iter() if x.tag == "resource"]
-    invalid_link_values = [x for x in link_values if x.text not in resource_ids]
-    invalid_link_values = [x for x in invalid_link_values if not is_resource_iri(str(x.text))]
-    errors = []
-    for inv in invalid_link_values:
-        prop_name = next(inv.iterancestors(tag="resptr-prop")).attrib["name"]
-        res_id = next(inv.iterancestors(tag="resource")).attrib["id"]
-        errors.append(f"Resource '{res_id}', property '{prop_name}' has an invalid link target '{inv.text}'")
-    return errors
-
-
-def _check_if_salsah_targets_exist(root: etree._Element) -> list[str]:
-    link_values = [x for x in root.iter() if x.tag == "a"]
-    resource_ids = [x.attrib["id"] for x in root.iter() if x.tag == "resource"]
-    invalid_link_values = [x for x in link_values if regex.sub(r"IRI:|:IRI", "", x.attrib["href"]) not in resource_ids]
-    invalid_link_values = [x for x in invalid_link_values if x.attrib.get("class") == "salsah-link"]
-    invalid_link_values = [x for x in invalid_link_values if not is_resource_iri(x.attrib["href"])]
-    errors = []
-    for inv in invalid_link_values:
-        prop_name = next(inv.iterancestors(tag="text-prop")).attrib["name"]
-        res_id = next(inv.iterancestors(tag="resource")).attrib["id"]
-        errors.append(f"Resource '{res_id}', property '{prop_name}' has an invalid link target '{inv.attrib['href']}'")
-    return errors
-
-
-def check_if_bitstreams_exist(root: etree._Element, imgdir: str) -> None:
-    """
-    Make sure that all bitstreams referenced in the XML file exist in the imgdir.
-
-    Args:
-        root: parsed XML file
-        imgdir: folder where the bitstreams are stored
-
-    Raises:
-        UserError: if a bitstream does not exist in the imgdir
-    """
-    multimedia_resources = [x for x in root if any((y.tag == "bitstream" for y in x.iter()))]
-    for res in multimedia_resources:
-        pth = next(Path(x.text) for x in res.iter() if x.tag == "bitstream" and x.text)
-        if not Path(imgdir / pth).is_file():
-            raise UserError(
-                f"Bitstream '{pth!s}' of resource '{res.attrib['label']}' does not exist in the imgdir '{imgdir}'."
-            )

dsp_tools/models/custom_warnings.py

@@ -1,31 +0,0 @@
-from typing import Protocol
-from typing import runtime_checkable
-
-from termcolor import cprint
-
-
-@runtime_checkable
-class DspToolsWarning(Protocol):
-    """Protocol for warnings that implement a custom showwarnings() function"""
-
-    @classmethod
-    def showwarning(cls, message: str) -> None:
-        """Functionality that should be executed when a warning of this class is emitted"""
-
-
-class DspToolsUserWarning(Warning):
-    """Class for general user-facing warnings"""
-
-    @classmethod
-    def showwarning(cls, message: str) -> None:
-        """Print the warning, without context"""
-        cprint(f"WARNING: {message}", color="red", attrs=["bold"])
-
-
-class DspToolsFutureWarning(FutureWarning):
-    """Class for user-facing deprecation warnings"""
-
-    @classmethod
-    def showwarning(cls, message: str) -> None:
-        """Print the warning, without context"""
-        cprint(f"DEPRECATION WARNING: {message}", color="red", attrs=["bold"])

dsp_tools/models/exceptions.py

@@ -1,90 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-
-
-@dataclass
-class BaseError(Exception):
-    """
-    A basic error class for DSP-TOOLS.
-
-    Attributes:
-        message: A message that describes the error
-    """
-
-    message: str
-
-    def __str__(self) -> str:
-        return self.message
-
-
-@dataclass
-class Excel2JsonListError(BaseError):
-    """
-    Class for errors that are raised in the context of the excel2json ListNode class.
-    """
-
-
-class InternalError(BaseError):
-    """
-    Class for errors that are raised if the user cannot solve the problem themselves.
-    """
-
-    def __init__(self, custom_msg: str | None = None, keep_default_msg: bool = True) -> None:
-        default_msg = (
-            "\n\nAn internal error occurred.\n"
-            "Please contact the dsp-tools development team with the following information:\n"
-            "    - Which command was used.\n"
-            "    - If applicable, any files that were used in conjunction with the command.\n"
-            "    - A file with the terminal output copied into.\n"
-            "    - The log files called 'logging.log', if there are several, include all.\n"
-            f"      They can be found at: {Path.home() / Path('.dsp-tools')}\n"
-        )
-        match keep_default_msg, custom_msg:
-            case False, str():
-                super().__init__(custom_msg)
-            case True, str():
-                default_msg = f"\n\n{custom_msg}\n--------------------------{default_msg}"
-                super().__init__(default_msg)
-            case _:
-                super().__init__(default_msg)
-
-
-class PermissionNotExistsError(BaseError):
-    """Class for errors that are raised when a permission does not exist."""
-
-
-class InputError(BaseError):
-    """Class for errors that is called when the user input is invalid."""
-
-
-class UserError(BaseError):
-    """
-    Class for errors that are intended for user feedback.
-    Typically, a UserError is raised when the execution of a program must be interrupted
-    due to a bad condition in the input data that prevents further processing.
-    The message should be as user-friendly as possible.
-    """
-
-
-class PermanentConnectionError(BaseError):
-    """This error is raised when all attempts to reconnect to DSP have failed."""
-
-
-class InvalidInputError(BaseError):
-    """This error is raised if the API responds with a permanent error because of invalid input data"""
-
-
-class PermanentTimeOutError(BaseError):
-    """This error is raised when python throws a timeout due to no response from the DSP-API."""
-
-
-class BadCredentialsError(PermanentConnectionError):
-    """This error is raised when DSP-API doesn't accept the prodived credentials."""
-
-
-class XmlUploadError(BaseError):
-    """Represents an error raised in the context of the xmlupload."""
-
-
-class XmlUploadInterruptedError(XmlUploadError):
-    """Represents an error raised when the xmlupload was interrupted."""

dsp_tools/resources/0100-template-repo/template.json

@@ -1,45 +0,0 @@
-{
-    "$schema": "https://raw.githubusercontent.com/dasch-swiss/dsp-tools/main/src/dsp_tools/resources/schema/project.json",
-    "project": {
-        "shortcode": "0100",
-        "shortname": "minimal",
-        "longname": "minimal",
-        "descriptions": { "en": "minimal" },
-        "keywords": ["minimal"],
-        "ontologies": [
-            {
-                "name": "minimal",
-                "label": "minimal",
-                "properties": [
-                    {
-                        "name": "hasText",
-                        "super": [
-                            "hasValue"
-                        ],
-                        "object": "TextValue",
-                        "labels": {
-                            "en": "hasText"
-                        },
-                        "gui_element": "SimpleText"
-                    }
-                ],
-                "resources": [
-                    {
-                        "name": "MinimalResource",
-                        "super": "Resource",
-                        "labels": {
-                            "en": "MinimalResource"
-                        },
-                        "cardinalities": [
-                            {
-                                "propname": ":hasText",
-                                "gui_order": 1,
-                                "cardinality": "0-n"
-                            }
-                        ]
-                    }
-                ]
-            }
-        ]
-    }
-}

dsp_tools/resources/0100-template-repo/template.xml

@@ -1,27 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-
-<knora xmlns="https://dasch.swiss/schema"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xsi:schemaLocation="https://dasch.swiss/schema https://raw.githubusercontent.com/dasch-swiss/dsp-tools/main/src/dsp_tools/resources/schema/data.xsd"
-       shortcode="0100"
-       default-ontology="minimal">
-
-    <permissions id="res-default">
-        <allow group="UnknownUser">RV</allow>
-        <allow group="KnownUser">V</allow>
-        <allow group="ProjectMember">M</allow>
-        <allow group="ProjectAdmin">D</allow>
-        <allow group="Creator">CR</allow>
-        <allow group="SystemAdmin">CR</allow>
-    </permissions>
-    <permissions id="prop-default">
-        <allow group="SystemAdmin">CR</allow>
-    </permissions>
-
-    <resource label="res_0" restype=":MinimalResource" id="res_0" permissions="res-default">
-        <text-prop name=":hasText">
-            <text encoding="utf8" permissions="prop-default">Hello!</text>
-        </text-prop>
-    </resource>
-
-</knora>

dsp_tools/resources/start-stack/docker-compose-validation.yml

@@ -1,5 +0,0 @@
----
-
-services:
-  api:
-    image: daschswiss/knora-api:v30.19.0-14-g49b8259

dsp_tools/resources/start-stack/start-stack-config.yml

@@ -1,4 +0,0 @@
----
-
-# take commit hash of latest DSP-API release from https://github.com/dasch-swiss/dsp-api/commits/main
-DSP-API commit: 88b278ebf96a98ddeec5e084745cf31216244368