dsp-tools 17.0.0.post26__py3-none-any.whl → 18.0.0__py3-none-any.whl

dsp_tools/cli/call_action_with_network.py

@@ -0,0 +1,203 @@
+import argparse
+from pathlib import Path
+
+from dsp_tools.cli.args import NetworkRequirements
+from dsp_tools.cli.args import PathDependencies
+from dsp_tools.cli.args import ValidationSeverity
+from dsp_tools.cli.utils import check_docker_health
+from dsp_tools.cli.utils import check_input_dependencies
+from dsp_tools.cli.utils import check_network_health
+from dsp_tools.cli.utils import get_creds
+from dsp_tools.commands.create.lists_only import create_lists_only
+from dsp_tools.commands.excel2json.old_lists import validate_lists_section_with_schema
+from dsp_tools.commands.ingest_xmlupload.create_resources.upload_xml import ingest_xmlupload
+from dsp_tools.commands.ingest_xmlupload.ingest_files.ingest_files import ingest_files
+from dsp_tools.commands.ingest_xmlupload.upload_files.upload_files import upload_files
+from dsp_tools.commands.project.create.project_create_all import create_project
+from dsp_tools.commands.project.create.project_validate import validate_project
+from dsp_tools.commands.project.get.get import get_project
+from dsp_tools.commands.resume_xmlupload.resume_xmlupload import resume_xmlupload
+from dsp_tools.commands.start_stack import StackConfiguration
+from dsp_tools.commands.start_stack import StackHandler
+from dsp_tools.commands.validate_data.validate_data import validate_data
+from dsp_tools.commands.xmlupload.upload_config import UploadConfig
+from dsp_tools.commands.xmlupload.xmlupload import xmlupload
+from dsp_tools.error.exceptions import InputError
+from dsp_tools.utils.xml_parsing.parse_clean_validate_xml import parse_and_validate_xml_file
+
+
+def call_start_stack(args: argparse.Namespace) -> bool:
+    check_docker_health()
+    stack_handler = StackHandler(
+        StackConfiguration(
+            max_file_size=args.max_file_size,
+            enforce_docker_system_prune=args.prune,
+            suppress_docker_system_prune=args.no_prune,
+            latest_dev_version=args.latest,
+            upload_test_data=args.with_test_data,
+            custom_host=args.custom_host,
+        )
+    )
+    return stack_handler.start_stack()
+
+
+def call_stop_stack() -> bool:
+    check_docker_health()
+    stack_handler = StackHandler(StackConfiguration())
+    return stack_handler.stop_stack()
+
+
+def call_upload_files(args: argparse.Namespace) -> bool:
+    xml_path = Path(args.xml_file)
+    image_dir = Path(args.imgdir)
+    network_requirements = NetworkRequirements(api_url=args.server)
+    path_requirements = PathDependencies([xml_path], required_directories=[image_dir])
+    check_input_dependencies(path_requirements, network_requirements)
+
+    return upload_files(
+        xml_file=xml_path,
+        creds=get_creds(args),
+        imgdir=image_dir,
+    )
+
+
+def call_ingest_files(args: argparse.Namespace) -> bool:
+    check_network_health(NetworkRequirements(api_url=args.server))
+    return ingest_files(creds=get_creds(args), shortcode=args.shortcode)
+
+
+def call_ingest_xmlupload(args: argparse.Namespace) -> bool:
+    xml_path = Path(args.xml_file)
+    required_files = [xml_path]
+    id2iri_file = args.id2iri_replacement_with_file
+    if id2iri_file:
+        required_files.append(Path(id2iri_file))
+    network_requirements = NetworkRequirements(args.server, always_requires_docker=True)
+    path_deps = PathDependencies(required_files)
+    check_input_dependencies(path_deps, network_requirements)
+
+    interrupt_after = args.interrupt_after if args.interrupt_after > 0 else None
+    return ingest_xmlupload(
+        xml_file=xml_path,
+        creds=get_creds(args),
+        interrupt_after=interrupt_after,
+        skip_validation=args.skip_validation,
+        skip_ontology_validation=args.skip_ontology_validation,
+        id2iri_replacement_file=id2iri_file,
+        do_not_request_resource_metadata_from_db=args.do_not_request_resource_metadata_from_db,
+    )
+
+
+def call_xmlupload(args: argparse.Namespace) -> bool:
+    xml_path = Path(args.xmlfile)
+    required_files = [xml_path]
+    id2iri_file = args.id2iri_replacement_with_file
+    if id2iri_file:
+        required_files.append(Path(id2iri_file))
+    network_requirements = NetworkRequirements(args.server, always_requires_docker=True)
+    path_deps = PathDependencies(required_files, [Path(args.imgdir)])
+    check_input_dependencies(path_deps, network_requirements)
+
+    if args.validate_only:
+        success = parse_and_validate_xml_file(xml_path)
+        print("The XML file is syntactically correct.")
+        return success
+    else:
+        interrupt_after = args.interrupt_after if args.interrupt_after > 0 else None
+        match args.validation_severity:
+            case "info":
+                severity = ValidationSeverity.INFO
+            case "warning":
+                severity = ValidationSeverity.WARNING
+            case "error":
+                severity = ValidationSeverity.ERROR
+            case _:
+                raise InputError(
+                    f"The entered validation severity '{args.validation_severity}' "
+                    f"is not part of the allowed values: info, warning, error."
+                )
+        return xmlupload(
+            input_file=xml_path,
+            creds=get_creds(args),
+            imgdir=args.imgdir,
+            config=UploadConfig(
+                interrupt_after=interrupt_after,
+                skip_iiif_validation=args.no_iiif_uri_validation,
+                skip_validation=args.skip_validation,
+                ignore_duplicate_files_warning=args.ignore_duplicate_files_warning,
+                validation_severity=severity,
+                skip_ontology_validation=args.skip_ontology_validation,
+                do_not_request_resource_metadata_from_db=args.do_not_request_resource_metadata_from_db,
+                id2iri_replacement_file=id2iri_file,
+            ),
+        )
+
+
+def call_validate_data(args: argparse.Namespace) -> bool:
+    xml_path = Path(args.xmlfile)
+    required_files = [xml_path]
+    id2iri_file = args.id2iri_replacement_with_file
+    if id2iri_file:
+        required_files.append(Path(id2iri_file))
+    network_requirements = NetworkRequirements(args.server, always_requires_docker=True)
+    path_deps = PathDependencies(required_files)
+    check_input_dependencies(path_deps, network_requirements)
+
+    return validate_data(
+        filepath=xml_path,
+        creds=get_creds(args),
+        save_graphs=args.save_graphs,
+        ignore_duplicate_files_warning=args.ignore_duplicate_files_warning,
+        skip_ontology_validation=args.skip_ontology_validation,
+        id2iri_replacement_file=id2iri_file,
+        do_not_request_resource_metadata_from_db=args.do_not_request_resource_metadata_from_db,
+    )
+
+
+def call_resume_xmlupload(args: argparse.Namespace) -> bool:
+    # this does not need docker if not on localhost, as does not need to validate
+    check_network_health(NetworkRequirements(args.server))
+    return resume_xmlupload(
+        creds=get_creds(args),
+        skip_first_resource=args.skip_first_resource,
+    )
+
+
+def call_get(args: argparse.Namespace) -> bool:
+    network_dependencies = NetworkRequirements(args.server)
+    path_dependencies = PathDependencies(required_directories=[Path(args.project_definition).parent])
+    check_input_dependencies(path_dependencies, network_dependencies)
+
+    return get_project(
+        project_identifier=args.project,
+        outfile_path=args.project_definition,
+        creds=get_creds(args),
+        verbose=args.verbose,
+    )
+
+
+def call_create(args: argparse.Namespace) -> bool:
+    network_dependencies = NetworkRequirements(args.server)
+    path_dependencies = PathDependencies([Path(args.project_definition)])
+    check_input_dependencies(path_dependencies, network_dependencies)
+
+    success = False
+    match args.lists_only, args.validate_only:
+        case True, True:
+            success = validate_lists_section_with_schema(args.project_definition)
+            print("'Lists' section of the JSON project file is syntactically correct and passed validation.")
+        case True, False:
+            success = create_lists_only(
+                project_file_as_path_or_parsed=args.project_definition,
+                creds=get_creds(args),
+            )
+        case False, True:
+            success = validate_project(args.project_definition)
+            print("JSON project file is syntactically correct and passed validation.")
+        case False, False:
+            success = create_project(
+                project_file_as_path_or_parsed=args.project_definition,
+                creds=get_creds(args),
+                verbose=args.verbose,
+            )
+    return success

dsp_tools/cli/create_parsers.py

@@ -96,7 +96,7 @@ def _add_start_stack(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     max_file_size_text = "max. multimedia file size allowed for ingest, in MB (default: 2000, max: 100'000)"
     no_prune_text = "don't execute 'docker system prune' (and don't ask)"
     with_test_data_text = "initialise the database with built-in test data"
-    custom_host = "set host to use stack on a server"
+    custom_host = "set a host to an IP or a domain to run the instance on a server"
     subparser = subparsers.add_parser(name="start-stack", help="Run a local instance of DSP-API and DSP-APP")
     subparser.set_defaults(action="start-stack")
     subparser.add_argument("--max_file_size", type=int, help=max_file_size_text)
@@ -237,10 +237,27 @@ def _add_ingest_xmlupload(
     subparser.add_argument("--interrupt-after", type=int, default=-1, help="interrupt after this number of resources")
     subparser.add_argument("xml_file", help="path to XML file containing the data")
     subparser.add_argument("--skip-validation", action="store_true", help="Skip the SHACL schema validation")
-    subparser.add_argument("--skip-ontology-validation", action="store_true", help="skip the ontology validation")
+    subparser.add_argument(
+        "--skip-ontology-validation",
+        action="store_true",
+        help=(
+            "don't validate the ontology itself, only the data. "
+            "This is intended for projects that are already on the production server"
+        ),
+    )
     subparser.add_argument(
         "--id2iri-replacement-with-file",
-        help="replaces internal IDs of an XML file by IRIs provided in this mapping file",
+        help=(
+            "replaces internal IDs of an XML file (links and stand-off links inside richtext) "
+            "by IRIs provided in this mapping file"
+        ),
+    )
+    subparser.add_argument(
+        "--do-not-request-resource-metadata-from-db",
+        action="store_true",
+        help=(
+            "Do not request IRIs of existing resources from the db (references to existing resources won't be checked)"
+        ),
     )
 
 
@@ -261,13 +278,24 @@ def _add_xmlupload(
         "-i", "--imgdir", default=".", help="folder from where the paths in the <bitstream> tags are evaluated"
     )
     subparser.add_argument(
-        "-V", "--validate-only", action="store_true", help="validate the XML file without uploading it"
+        "-V", "--validate-only", action="store_true", help="run the XML Schema validation without uploading the XML"
     )
     subparser.add_argument("--skip-validation", action="store_true", help="Skip the SHACL schema validation")
-    subparser.add_argument("--skip-ontology-validation", action="store_true", help="skip the ontology validation")
+    subparser.add_argument(
+        "--skip-ontology-validation",
+        action="store_true",
+        help=(
+            "don't validate the ontology itself, only the data. "
+            "This is intended for projects that are already on the production server"
+        ),
+    )
     subparser.add_argument("--interrupt-after", type=int, default=-1, help="interrupt after this number of resources")
     subparser.add_argument("xmlfile", help="path to the XML file containing the data")
-    subparser.add_argument("--no-iiif-uri-validation", action="store_true", help="skip the IIIF URI validation")
+    subparser.add_argument(
+        "--no-iiif-uri-validation",
+        action="store_true",
+        help="don't check if the IIIF links are valid URLs that can be reached online",
+    )
     subparser.add_argument(
         "--ignore-duplicate-files-warning",
         action="store_true",
@@ -276,12 +304,25 @@ def _add_xmlupload(
     subparser.add_argument(
         "--validation-severity",
         choices=["error", "warning", "info"],
-        help="Which severity level of validation message should be printed out",
+        help=(
+            "Which severity level of validation message should be printed out. "
+            "Each level of severity includes the higher levels."
+        ),
         default="info",
     )
+    subparser.add_argument(
+        "--do-not-request-resource-metadata-from-db",
+        action="store_true",
+        help=(
+            "Do not request IRIs of existing resources from the db (references to existing resources won't be checked)"
+        ),
+    )
     subparser.add_argument(
         "--id2iri-replacement-with-file",
-        help="replaces internal IDs of an XML file by IRIs provided in this mapping file",
+        help=(
+            "replaces internal IDs of an XML file (links and stand-off links inside richtext) "
+            "by IRIs provided in this mapping file"
+        ),
     )
 
 
@@ -301,16 +342,35 @@ def _add_validate_data(
         action="store_true",
         help="don't check if multimedia files are referenced more than once",
     )
-    subparser.add_argument("--skip-ontology-validation", action="store_true", help="skip the ontology validation")
+    subparser.add_argument(
+        "--skip-ontology-validation",
+        action="store_true",
+        help=(
+            "don't validate the ontology itself, only the data. "
+            "This is intended for projects that are already on the production server"
+        ),
+    )
     subparser.add_argument(
         "-s", "--server", default=default_dsp_api_url, help="URL of the DSP server where DSP-TOOLS sends the data to"
     )
     subparser.add_argument(
         "--id2iri-replacement-with-file",
-        help="replaces internal IDs of an XML file by IRIs provided in this mapping file",
+        help=(
+            "replaces internal IDs of an XML file (links and stand-off links inside richtext) "
+            "by IRIs provided in this mapping file"
+        ),
     )
     subparser.add_argument(
-        "--save-graphs", action="store_true", help="Save the data, onto and shacl graph as ttl files."
+        "--do-not-request-resource-metadata-from-db",
+        action="store_true",
+        help=(
+            "Do not request IRIs of existing resources from the db (references to existing resources won't be checked)"
+        ),
+    )
+    subparser.add_argument(
+        "--save-graphs",
+        action="store_true",
+        help="Save the data, onto and shacl graph as ttl files. This is primarily intended for development use.",
     )
 
 

dsp_tools/cli/utils.py

@@ -0,0 +1,87 @@
+import argparse
+import subprocess
+from pathlib import Path
+
+import requests
+from loguru import logger
+
+from dsp_tools.cli.args import NetworkRequirements
+from dsp_tools.cli.args import PathDependencies
+from dsp_tools.cli.args import ServerCredentials
+from dsp_tools.error.exceptions import DockerNotReachableError
+from dsp_tools.error.exceptions import DspApiNotReachableError
+from dsp_tools.error.exceptions import UserDirectoryNotFoundError
+from dsp_tools.error.exceptions import UserFilepathNotFoundError
+
+LOCALHOST_API = "http://0.0.0.0:3333"
+
+
+def get_creds(args: argparse.Namespace) -> ServerCredentials:
+    return ServerCredentials(
+        server=args.server,
+        user=args.user,
+        password=args.password,
+        dsp_ingest_url=args.dsp_ingest_url,
+    )
+
+
+def check_input_dependencies(
+    paths: PathDependencies | None = None, network_dependencies: NetworkRequirements | None = None
+) -> None:
+    if paths:
+        check_path_dependencies(paths)
+    if network_dependencies:
+        check_network_health(network_dependencies)
+
+
+def check_path_dependencies(paths: PathDependencies) -> None:
+    for f_path in paths.required_files:
+        _check_filepath_exists(f_path)
+    for dir_path in paths.required_directories:
+        _check_directory_exists(dir_path)
+
+
+def _check_filepath_exists(file_path: Path) -> None:
+    if not file_path.exists():
+        raise UserFilepathNotFoundError(file_path)
+
+
+def _check_directory_exists(dir_path: Path) -> None:
+    if not dir_path.is_dir():
+        raise UserDirectoryNotFoundError(dir_path)
+
+
+def check_network_health(network_requirements: NetworkRequirements) -> None:
+    if network_requirements.api_url == LOCALHOST_API or network_requirements.always_requires_docker:
+        check_docker_health()
+    _check_api_health(network_requirements.api_url)
+
+
+def check_docker_health() -> None:
+    if subprocess.run("docker stats --no-stream".split(), check=False, capture_output=True).returncode != 0:
+        raise DockerNotReachableError()
+
+
+def _check_api_health(api_url: str) -> None:
+    health_url = f"{api_url}/health"
+    msg = (
+        "The DSP-API could not be reached. Please check if your stack is healthy "
+        "or start a stack with 'dsp-tools start-stack' if none is running."
+    )
+    try:
+        response = requests.get(health_url, timeout=2)
+        if not response.ok:
+            if api_url != LOCALHOST_API:
+                msg = (
+                    f"The DSP-API could not be reached (returned status {response.status_code}). "
+                    f"Please contact the DaSCH engineering team for help."
+                )
+            logger.error(msg)
+            raise DspApiNotReachableError(msg)
+        logger.debug(f"DSP API health check passed: {health_url}")
+    except requests.exceptions.RequestException as e:
+        logger.error(e)
+        if api_url != LOCALHOST_API:
+            msg = "The DSP-API responded with a request exception. Please contact the DaSCH engineering team for help."
+        logger.error(msg)
+        raise DspApiNotReachableError(msg) from None

dsp_tools/clients/list_client.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from typing import Protocol
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+
+
+@dataclass
+class OneList:
+    list_iri: str
+    list_name: str
+    nodes: list[OneNode]
+
+    def hlist(self) -> str:
+        return f'"hlist=<{self.list_iri}>"'
+
+
+@dataclass
+class OneNode:
+    name: str
+    iri: str
+
+
+@dataclass
+class ListGetClient(Protocol):
+    """Client to request and reformat the lists of a project."""
+
+    api_url: str
+    shortcode: str
+
+    def get_all_lists_and_nodes(self) -> list[OneList]:
+        """Get all lists and its nodes from a project."""
+
+    def get_all_list_iris_and_names(self) -> dict[str, str]:
+        """Get all list names and IRIs"""
+
+
+@dataclass
+class ListCreateClient(Protocol):
+    api_url: str
+    auth: AuthenticationClient
+
+    def create_new_list(self, list_info: dict[str, Any]) -> str | None:
+        """Create a new list."""
+
+    def add_list_node(self, node_info: dict[str, Any], parent_iri: str) -> str | None:
+        """Add a list node to an existing list."""

dsp_tools/clients/list_client_live.py

@@ -0,0 +1,157 @@
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Any
+from typing import cast
+from urllib.parse import quote_plus
+
+import requests
+from loguru import logger
+from requests import RequestException
+from requests import Response
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.list_client import ListCreateClient
+from dsp_tools.clients.list_client import ListGetClient
+from dsp_tools.clients.list_client import OneList
+from dsp_tools.clients.list_client import OneNode
+from dsp_tools.error.exceptions import BadCredentialsError
+from dsp_tools.error.exceptions import InternalError
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_response
+
+TIMEOUT = 60
+
+
+@dataclass
+class ListGetClientLive(ListGetClient):
+    """Client to request and reformat the lists of a project."""
+
+    api_url: str
+    shortcode: str
+
+    def get_all_lists_and_nodes(self) -> list[OneList]:
+        list_json = self._get_all_list_iris()
+        all_iris = self._extract_list_iris(list_json)
+        all_lists = [self._get_one_list(iri) for iri in all_iris]
+        return [self._reformat_one_list(lst) for lst in all_lists]
+
+    def get_all_list_iris_and_names(self) -> dict[str, str]:
+        response_json = self._get_all_list_iris()
+        iris = self._extract_list_iris(response_json)
+        names = [x["name"] for x in response_json["lists"]]
+        return dict(zip(names, iris))
+
+    def _get_all_list_iris(self) -> dict[str, Any]:
+        url = f"{self.api_url}/admin/lists?projectShortcode={self.shortcode}"
+        timeout = 10
+        log_request(RequestParameters("GET", url, timeout))
+        response = requests.get(url=url, timeout=timeout)
+        log_response(response)
+        if not response.ok:
+            raise InternalError(f"Failed Request: {response.status_code} {response.text}")
+        json_response = cast(dict[str, Any], response.json())
+        return json_response
+
+    def _extract_list_iris(self, response_json: dict[str, Any]) -> list[str]:
+        return [x["id"] for x in response_json["lists"]]
+
+    def _get_one_list(self, list_iri: str) -> dict[str, Any]:
+        encoded_list_iri = quote_plus(list_iri)
+        url = f"{self.api_url}/admin/lists/{encoded_list_iri}"
+        timeout = 30
+        log_request(RequestParameters("GET", url, timeout))
+        response = requests.get(url=url, timeout=timeout)
+        log_response(response, include_response_content=False)
+        if not response.ok:
+            raise InternalError(f"Failed Request: {response.status_code} {response.text}")
+        response_json = cast(dict[str, Any], response.json())
+        return response_json
+
+    def _reformat_one_list(self, response_json: dict[str, Any]) -> OneList:
+        list_name = response_json["list"]["listinfo"]["name"]
+        list_id = response_json["list"]["listinfo"]["id"]
+        nodes = response_json["list"]["children"]
+        all_nodes = []
+        for child in nodes:
+            all_nodes.append(OneNode(child["name"], child["id"]))
+            if node_child := child.get("children"):
+                self._reformat_children(node_child, all_nodes)
+        return OneList(list_iri=list_id, list_name=list_name, nodes=all_nodes)
+
+    def _reformat_children(self, list_child: list[dict[str, Any]], current_nodes: list[OneNode]) -> None:
+        for child in list_child:
+            current_nodes.append(OneNode(child["name"], child["id"]))
+            if grand_child := child.get("children"):
+                self._reformat_children(grand_child, current_nodes)
+
+
+@dataclass
+class ListCreateClientLive(ListCreateClient):
+    api_url: str
+    project_iri: str
+    auth: AuthenticationClient
+
+    def create_new_list(self, list_info: dict[str, Any]) -> str | None:
+        url = f"{self.api_url}/admin/lists"
+        try:
+            headers = self._get_request_header()
+            response = _post_and_log_request(url, list_info, headers)
+        except RequestException as err:
+            logger.exception(err)
+            return None
+        if response.ok:
+            result = response.json()
+            list_iri = cast(str, result["list"]["listinfo"]["id"])
+            return list_iri
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError(
+                "Only a project or system administrator can create lists. "
+                "Your permissions are insufficient for this action."
+            )
+        logger.exception(f"Failed to create list: '{list_info['name']}'")
+        return None
+
+    def add_list_node(self, node_info: dict[str, Any], parent_iri: str) -> str | None:
+        encoded_parent_iri = quote_plus(parent_iri)
+        url = f"{self.api_url}/admin/lists/{encoded_parent_iri}"
+        try:
+            headers = self._get_request_header()
+            response = _post_and_log_request(url, node_info, headers)
+        except RequestException as err:
+            logger.error(err)
+            return None
+        if response.ok:
+            result = response.json()
+            node_iri = cast(str, result["nodeinfo"]["id"])
+            return node_iri
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError(
+                "Only a project or system administrator can add nodes to lists. "
+                "Your permissions are insufficient for this action."
+            )
+        logger.error(f"Failed to add node: '{node_info['name']}'")
+        return None
+
+    def _get_request_header(self) -> dict[str, str]:
+        return {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.auth.get_token()}",
+        }
+
+
+def _post_and_log_request(
+    url: str,
+    data: dict[str, Any],
+    headers: dict[str, str] | None = None,
+) -> Response:
+    params = RequestParameters("POST", url, TIMEOUT, data, headers)
+    log_request(params)
+    response = requests.post(
+        url=params.url,
+        headers=params.headers,
+        data=params.data_serialized,
+        timeout=params.timeout,
+    )
+    log_response(response)
+    return response

dsp_tools/clients/metadata_client.py

@@ -6,9 +6,9 @@ from typing import Protocol
 from dsp_tools.clients.authentication_client import AuthenticationClient
 
 
-class MetadataRetrieval(Enum):
-    SUCCESS = auto()
-    FAILURE = auto()
+class ExistingResourcesRetrieved(Enum):
+    TRUE = auto()
+    FALSE = auto()
 
 
 @dataclass
@@ -20,5 +20,5 @@ class MetadataClient(Protocol):
     server: str
     authentication_client: AuthenticationClient
 
-    def get_resource_metadata(self, shortcode: str) -> tuple[MetadataRetrieval, list[dict[str, str]]]:
+    def get_resource_metadata(self, shortcode: str) -> tuple[ExistingResourcesRetrieved, list[dict[str, str]]]:
         """Get all resource metadata from one project."""

dsp_tools/clients/metadata_client_live.py

@@ -4,8 +4,8 @@ import requests
 from loguru import logger
 
 from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.metadata_client import ExistingResourcesRetrieved
 from dsp_tools.clients.metadata_client import MetadataClient
-from dsp_tools.clients.metadata_client import MetadataRetrieval
 from dsp_tools.utils.request_utils import RequestParameters
 from dsp_tools.utils.request_utils import log_request
 from dsp_tools.utils.request_utils import log_response
@@ -18,7 +18,7 @@ class MetadataClientLive(MetadataClient):
     server: str
     authentication_client: AuthenticationClient
 
-    def get_resource_metadata(self, shortcode: str) -> tuple[MetadataRetrieval, list[dict[str, str]]]:
+    def get_resource_metadata(self, shortcode: str) -> tuple[ExistingResourcesRetrieved, list[dict[str, str]]]:
         url = f"{self.server}/v2/metadata/projects/{shortcode}/resources?format=JSON"
         header = {"Authorization": f"Bearer {self.authentication_client.get_token()}"}
         params = RequestParameters(method="GET", url=url, timeout=TIMEOUT, headers=header)
@@ -33,10 +33,11 @@ class MetadataClientLive(MetadataClient):
             if response.ok:
                 # we log the response separately because if it was successful it will be too big
                 log_response(response, include_response_content=False)
-                return MetadataRetrieval.SUCCESS, response.json()
+                logger.debug(f"{len(response.json())} NUMBER OF RESOURCES RETRIEVED")
+                return ExistingResourcesRetrieved.TRUE, response.json()
             # here the response text is important
             log_response(response)
-            return MetadataRetrieval.FAILURE, []
+            return ExistingResourcesRetrieved.FALSE, []
         except Exception as err:  # noqa: BLE001 (blind exception)
             logger.error(err)
-            return MetadataRetrieval.FAILURE, []
+            return ExistingResourcesRetrieved.FALSE, []