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

dsp_tools/commands/project/create/project_create_lists.py

@@ -1,200 +0,0 @@
-from typing import Any
-from typing import Optional
-from typing import Union
-
-from loguru import logger
-
-from dsp_tools.cli.args import ServerCredentials
-from dsp_tools.clients.authentication_client_live import AuthenticationClientLive
-from dsp_tools.clients.connection import Connection
-from dsp_tools.clients.connection_live import ConnectionLive
-from dsp_tools.commands.project.create.project_validate import validate_project
-from dsp_tools.commands.project.legacy_models.listnode import ListNode
-from dsp_tools.commands.project.legacy_models.project import Project
-from dsp_tools.error.exceptions import BaseError
-from dsp_tools.error.exceptions import InputError
-from dsp_tools.utils.json_parsing import parse_json_input
-
-
-def create_lists_on_server(
-    lists_to_create: list[dict[str, Any]],
-    con: Connection,
-    project_remote: Project,
-) -> tuple[dict[str, Any], bool]:
-    """
-    Creates the "lists" section of a JSON project definition on a DSP server.
-    If a list with the same name is already existing in this project on the DSP server, this list is skipped.
-    If a node or an entire list cannot be created, an error message is printed, but the process continues.
-
-    Args:
-        lists_to_create: "lists" section of a JSON project definition
-        con: connection to the DSP server
-        project_remote: representation of the project on the DSP server
-
-    Raises:
-        BaseError: if one of the lists to be created already exists on the DSP server, but it has no name
-
-    Returns:
-        tuple consisting of the IRIs of the list nodes and the success status (True if everything went well)
-    """
-
-    overall_success = True
-
-    # retrieve existing lists
-    try:
-        existing_lists = ListNode.getAllLists(con=con, project_iri=project_remote.iri)
-    except BaseError:
-        err_msg = "Unable to retrieve existing lists on DSP server. Cannot check if your lists are already existing."
-        print(f"WARNING: {err_msg}")
-        logger.exception(err_msg)
-        existing_lists = []
-        overall_success = False
-
-    current_project_lists: dict[str, Any] = {}
-    for new_lst in lists_to_create:
-        if existing_lst := [x for x in existing_lists if x.project == project_remote.iri and x.name == new_lst["name"]]:
-            existing_list_name = existing_lst[0].name
-            if not existing_list_name:
-                raise BaseError(f"Node {existing_lst[0]} has no name.")
-            current_project_lists[existing_list_name] = {
-                "id": existing_lst[0].iri,
-                "nodes": new_lst["nodes"],
-            }
-            print(f"    WARNING: List '{new_lst['name']}' already exists on the DSP server. Skipping...")
-            overall_success = False
-            continue
-
-        created_list, success = _create_list_node(con=con, project=project_remote, node=new_lst)
-        current_project_lists.update(created_list)
-        if not success:
-            overall_success = False
-        print(f"    Created list '{new_lst['name']}'.")
-
-    return current_project_lists, overall_success
-
-
-def _create_list_node(
-    con: Connection,
-    project: Project,
-    node: dict[str, Any],
-    parent_node: Optional[ListNode] = None,
-) -> tuple[dict[str, Any], bool]:
-    """
-    Creates a list node on the DSP server, recursively scanning through all its subnodes, creating them as well.
-    If a node cannot be created, an error message is printed, but the process continues.
-
-    Args:
-        con: connection to the DSP server
-        project: project that holds the list where this node should be added to
-        node: the node to be created
-        parent_node: parent node of the node to be created (optional)
-
-    Returns:
-        Returns a tuple consisting of a dict and a bool.
-        The dict contains the IRIs of the created list nodes,
-        nested according to their hierarchy structure,
-        i.e. ``{nodename: {"id": IRI, "nodes": {...}}}``.
-        The bool is True if all nodes could be created,
-        False if any node could not be created.
-
-    Raises:
-        BaseError: if the created node has no name
-    """
-    new_node: ListNode = ListNode(
-        con=con,
-        project=project,
-        label=node["labels"],
-        comments=node.get("comments"),
-        name=node["name"],
-        parent=parent_node,
-    )
-    try:
-        new_node = new_node.create()
-    except BaseError:
-        print(f"WARNING: Cannot create list node '{node['name']}'.")
-        logger.exception(f"Cannot create list node '{node['name']}'.")
-        return {}, False
-
-    # if node has child nodes, call the method recursively
-    if node.get("nodes"):
-        overall_success = True
-        subnode_list = []
-        for subnode in node["nodes"]:
-            created_subnode, success = _create_list_node(con=con, project=project, node=subnode, parent_node=new_node)
-            subnode_list.append(created_subnode)
-            if not success:
-                overall_success = False
-        if not new_node.name:
-            raise BaseError(f"Node {new_node} has no name.")
-        return {new_node.name: {"id": new_node.iri, "nodes": subnode_list}}, overall_success
-    else:
-        if not new_node.name:
-            raise BaseError(f"Node {new_node} has no name.")
-        return {new_node.name: {"id": new_node.iri}}, True
-
-
-def create_only_lists(
-    project_file_as_path_or_parsed: Union[str, dict[str, Any]],
-    creds: ServerCredentials,
-) -> tuple[dict[str, Any], bool]:
-    """
-    This function accepts a JSON project definition,
-    connects to a DSP server,
-    and uploads the "lists" section to the server.
-
-    The project must already exist on the DSP server.
-    If a list with the same name is already existing in this project on the DSP server, this list is skipped.
-
-    Args:
-        project_file_as_path_or_parsed: path to the JSON project definition, or parsed JSON object
-        creds: credentials to connect to the DSP server
-
-    Raises:
-        InputError:
-          - if the project cannot be read from the server
-          - if the connection to the DSP server cannot be established
-
-        BaseError:
-          - if the input is invalid
-          - if a problem occurred while trying to expand the Excel files
-          - if the JSON file is invalid according to the schema
-
-    Returns:
-        Returns a tuple consisting of a dict and a bool.
-        The dict contains the IRIs of the created list nodes,
-        nested according to their hierarchy structure,
-        i.e. ``{nodename: {"id": IRI, "nodes": {...}}}``.
-        If there are no lists in the project definition,
-        an empty dictionary is returned.
-        The bool indicates if everything went smoothly during the process.
-        If a warning or error occurred (e.g. one of the lists already exists,
-        or one of the nodes could not be created),
-        it is False.
-    """
-    project_definition = parse_json_input(project_file_as_path_or_parsed=project_file_as_path_or_parsed)
-    if not project_definition.get("project", {}).get("lists"):
-        return {}, True
-    validate_project(project_definition)
-    print("JSON project file is syntactically correct and passed validation.")
-
-    auth = AuthenticationClientLive(creds.server, creds.user, creds.password)
-    con = ConnectionLive(creds.server, auth)
-
-    # retrieve the project
-    shortcode = project_definition["project"]["shortcode"]
-    project_local = Project(con=con, shortcode=shortcode)
-    try:
-        project_remote = project_local.read()
-    except BaseError:
-        err_msg = f"Unable to create the lists: The project {shortcode} cannot be found on the DSP server."
-        logger.exception(err_msg)
-        raise InputError(err_msg) from None
-
-    # create new lists
-    current_project_lists, success = create_lists_on_server(
-        lists_to_create=project_definition["project"]["lists"],
-        con=con,
-        project_remote=project_remote,
-    )
-
-    return current_project_lists, success

dsp_tools/commands/validate_data/api_clients.py

@@ -1,124 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-from typing import cast
-from urllib.parse import quote_plus
-
-import requests
-
-from dsp_tools.commands.validate_data.models.api_responses import OneList
-from dsp_tools.commands.validate_data.models.api_responses import OneNode
-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
-
-
-@dataclass
-class OntologyClient:
-    api_url: str
-    shortcode: str
-
-    def get_knora_api(self) -> str:
-        url = f"{self.api_url}/ontology/knora-api/v2#"
-        headers = {"Accept": "text/turtle"}
-        timeout = 60
-        log_request(RequestParameters("GET", url, timeout=timeout, headers=headers))
-        response = requests.get(url=url, headers=headers, timeout=timeout)
-        log_response(response, include_response_content=False)
-        if not response.ok:
-            raise InternalError(f"Failed Request: {response.status_code} {response.text}")
-        return response.text
-
-    def get_ontologies(self) -> tuple[list[str], list[str]]:
-        """
-        Returns a list of project ontologies as a string in turtle format.
-        And a list of the ontology IRIs
-
-        Returns:
-            list of ontologies and IRIs
-        """
-        ontology_iris = self._get_ontology_iris()
-        ontologies = [self._get_one_ontology(x) for x in ontology_iris]
-        return ontologies, ontology_iris
-
-    def _get_ontology_iris(self) -> list[str]:
-        url = f"{self.api_url}/admin/projects/shortcode/{self.shortcode}"
-        timeout = 10
-        log_request(RequestParameters("GET", url, timeout=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}")
-        response_json = cast(dict[str, Any], response.json())
-        if not (ontos := response_json.get("project", {}).get("ontologies")):
-            raise InternalError(f"The response from the API does not contain any ontologies.\nResponse:{response.text}")
-        output = cast(list[str], ontos)
-        return output
-
-    def _get_one_ontology(self, ontology_iri: str) -> str:
-        url = ontology_iri
-        headers = {"Accept": "text/turtle"}
-        timeout = 30
-        log_request(RequestParameters("GET", url, timeout=timeout, headers=headers))
-        response = requests.get(url=url, headers=headers, timeout=timeout)
-        log_response(response, include_response_content=False)
-        if not response.ok:
-            raise InternalError(f"Failed Request: {response.status_code} {response.text}")
-        return response.text
-
-
-@dataclass
-class ListClient:
-    """Client to request and reformat the lists of a project."""
-
-    api_url: str
-    shortcode: str
-
-    def get_lists(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(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)