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

dsp_tools/clients/connection_live.py

@@ -0,0 +1,233 @@
+from dataclasses import dataclass
+from dataclasses import field
+from functools import partial
+from importlib.metadata import version
+from typing import Any
+from typing import Literal
+from typing import cast
+
+import regex
+from requests import ReadTimeout
+from requests import RequestException
+from requests import Response
+from requests import Session
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+from dsp_tools.clients.connection import Connection
+from dsp_tools.config.logger_config import WARNINGS_SAVEPATH
+from dsp_tools.error.exceptions import InvalidInputError
+from dsp_tools.error.exceptions import PermanentConnectionError
+from dsp_tools.utils.request_utils import PostFiles
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_and_raise_timeouts
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_request_failure_and_sleep
+from dsp_tools.utils.request_utils import log_response
+from dsp_tools.utils.request_utils import should_retry
+
+HTTP_OK = 200
+
+
+@dataclass
+class ConnectionLive(Connection):
+    """
+    A Connection instance represents a connection to a DSP server.
+
+    Attributes:
+        server: address of the server, e.g https://api.dasch.swiss
+        token: session token received by the server after login
+    """
+
+    server: str
+    authenticationClient: AuthenticationClient | None = None
+    session: Session = field(init=False, default=Session())
+    # downtimes of server-side services -> API still processes request
+    # -> retry too early has side effects (e.g. duplicated resources)
+    timeout_put_post: int = field(init=False, default=30 * 60)
+    timeout_get: int = field(init=False, default=20)
+
+    def __post_init__(self) -> None:
+        self.session.headers["User-Agent"] = f"DSP-TOOLS/{version('dsp-tools')}"
+        if self.server.endswith("/"):
+            self.server = self.server[:-1]
+        if self.authenticationClient and (token := self.authenticationClient.get_token()):
+            self.session.headers["Authorization"] = f"Bearer {token}"
+
+    def post(
+        self,
+        route: str,
+        data: dict[str, Any] | None = None,
+        files: PostFiles | None = None,
+        headers: dict[str, str] | None = None,
+        timeout: int | None = None,
+    ) -> dict[str, Any]:
+        """
+        Make an HTTP POST request to the server to which this connection has been established.
+
+        Args:
+            route: route that will be called on the server
+            data: payload of the HTTP request
+            files: files to be uploaded, if any
+            headers: headers for the HTTP request
+            timeout: timeout of the HTTP request, or None if the default should be used
+
+        Returns:
+            response from server
+
+        Raises:
+            PermanentConnectionError: if all attempts have failed
+            InvalidInputError: if the API responds with a permanent error because of invalid input data
+        """
+        if data:
+            headers = headers or {}
+            if "Content-Type" not in headers:
+                headers["Content-Type"] = "application/json; charset=UTF-8"
+        params = RequestParameters(
+            "POST", self._make_url(route), timeout or self.timeout_put_post, data, headers, files
+        )
+        response = self._try_network_action(params)
+        return cast(dict[str, Any], response.json())
+
+    def get(
+        self,
+        route: str,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Make an HTTP GET request to the server to which this connection has been established.
+
+        Args:
+            route: route that will be called on the server
+            headers: headers for the HTTP request
+
+        Returns:
+            response from server
+
+        Raises:
+            PermanentConnectionError: if all attempts have failed
+            InvalidInputError: if the API responds with a permanent error because of invalid input data
+        """
+        params = RequestParameters("GET", self._make_url(route), self.timeout_get, headers=headers)
+        response = self._try_network_action(params)
+        return cast(dict[str, Any], response.json())
+
+    def put(
+        self,
+        route: str,
+        data: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Make an HTTP GET request to the server to which this connection has been established.
+
+        Args:
+            route: route that will be called on the server
+            data: payload of the HTTP request
+            headers: headers of the HTTP request
+
+        Returns:
+            response from server
+
+        Raises:
+            PermanentConnectionError: if all attempts have failed
+            InvalidInputError: if the API responds with a permanent error because of invalid input data
+        """
+        if data:
+            headers = headers or {}
+            if "Content-Type" not in headers:
+                headers["Content-Type"] = "application/json; charset=UTF-8"
+        params = RequestParameters("PUT", self._make_url(route), self.timeout_put_post, data, headers)
+        response = self._try_network_action(params)
+        return cast(dict[str, Any], response.json())
+
+    def _make_url(self, route: str) -> str:
+        if not route.startswith("/"):
+            route = f"/{route}"
+        return self.server + route
+
+    def _try_network_action(self, params: RequestParameters) -> Response:
+        """
+        Try several times to execute an HTTP request.
+        If a timeout error, a ConnectionError, or a requests.RequestException occur,
+        or if the response indicates that there is a non-permanent server-side problem,
+        this function waits and retries the HTTP request.
+
+        Args:
+            params: keyword arguments for the HTTP request
+
+        Raises:
+            BadCredentialsError: if the server returns a 401 status code on the route /v2/authentication
+            PermanentConnectionError: if all attempts have failed
+            InvalidInputError: if the API responds with a permanent error because of invalid input data
+            unexpected exceptions: if the action fails with an unexpected exception
+
+        Returns:
+            the return value of action
+        """
+        action = partial(self.session.request, **params.as_kwargs())
+        num_of_retries = 24  # xmlupload must handle > 45 min fuseki downtime due to compaction, see DEV-5089
+        for retry_counter in range(num_of_retries):
+            try:
+                log_request(params, dict(self.session.headers))
+                response = action()
+            except (TimeoutError, ReadTimeout) as err:
+                log_and_raise_timeouts(err)
+            except (ConnectionError, RequestException):
+                self._renew_session()
+                log_request_failure_and_sleep(
+                    reason="Connection Error raised", retry_counter=retry_counter, exc_info=True
+                )
+                continue
+
+            log_response(response)
+            if response.status_code == HTTP_OK:
+                return response
+
+            self._handle_non_ok_responses(response, retry_counter)
+
+        # if all attempts have failed, raise error
+        msg = f"Permanently unable to execute the network action. See {WARNINGS_SAVEPATH} for more information."
+        raise PermanentConnectionError(msg)
+
+    def _handle_non_ok_responses(self, response: Response, retry_counter: int) -> None:
+        if should_retry(response):
+            log_request_failure_and_sleep("Transient Error", retry_counter, exc_info=False)
+            return None
+        api_msg = self._extract_original_api_err_msg(str(response.content))
+        blame = self._determine_blame(api_msg)
+        if blame == "client":
+            raise InvalidInputError(api_msg)
+        else:
+            msg = f"Permanently unable to execute the network action.\n{' ' * 37}Original Message: {api_msg}\n"
+            raise PermanentConnectionError(msg)
+
+    def _extract_original_api_err_msg(self, response_content: str) -> str:
+        if found := regex.search(r'{"knora-api:error":"dsp\.errors\.(.*)","@context', response_content):
+            api_msg = found.group(1)
+        if found := regex.search(r'{"message":"(.+)"}', response_content):
+            api_msg = found.group(1)
+        else:
+            api_msg = str(response_content)
+        return api_msg
+
+    def _determine_blame(self, api_msg: str) -> Literal["server", "client"]:
+        api_msg = api_msg.lower()
+        client_markers = [
+            "OntologyConstraintException",
+            "NotFoundException",
+            "One or more resources were not found",
+            "does not allow more than one value for property",
+            "Duplicate values for property",
+            "Text value contains invalid characters",
+        ]
+        blame: Literal["server", "client"] = "server"
+        if any(x.lower() in api_msg for x in client_markers):
+            blame = "client"
+        return blame
+
+    def _renew_session(self) -> None:
+        self.session.close()
+        self.session = Session()
+        self.session.headers["User-Agent"] = f"DSP-TOOLS/{version('dsp-tools')}"
+        if self.authenticationClient and (token := self.authenticationClient.get_token()):
+            self.session.headers["Authorization"] = f"Bearer {token}"

dsp_tools/clients/fuseki_metrics.py

@@ -0,0 +1,60 @@
+import shlex
+import subprocess
+from dataclasses import dataclass
+from enum import Enum
+from enum import auto
+
+from loguru import logger
+
+
+class FusekiBloatingLevel(Enum):
+    OK = auto()
+    WARNING = auto()
+    CRITICAL = auto()
+    CALCULATION_FAILURE = auto()
+
+
+@dataclass
+class FusekiMetrics:
+    container_id: str | None = None
+    start_size: int | None = None
+    end_size: int | None = None
+
+    def try_get_start_size(self) -> None:
+        self.start_size = self._try_get_size()
+
+    def try_get_end_size(self) -> None:
+        self.end_size = self._try_get_size()
+
+    def _try_get_size(self) -> int | None:
+        if not self.container_id:
+            self._try_get_container_id()
+        if not self.container_id:
+            return None
+        if result := self._run_command(["docker", "exec", self.container_id, "du", "-sb", "/fuseki"]):
+            try:
+                size_str = result.split()[0]
+                return int(size_str)
+            except (ValueError, IndexError):
+                logger.error("Could not parse size from du command output.")
+                return None
+        return None
+
+    def _try_get_container_id(self) -> None:
+        if result := self._run_command(["docker", "ps", "--format", "{{.ID}} {{.Image}}"]):
+            for line in result.splitlines():
+                parts = shlex.split(line)
+                if len(parts) == 2 and "daschswiss/apache-jena-fuseki" in parts[1]:
+                    self.container_id = parts[0]
+                    return
+        logger.error("Could not find Fuseki container ID.")
+
+    def _run_command(self, cmd: list[str]) -> str | None:
+        logger.debug(f"Run command: {cmd}")
+        result = subprocess.run(cmd, check=False, capture_output=True, text=True)
+        result_str = f"Result code: {result.returncode}, Message: {result.stdout}"
+        if result.returncode != 0:
+            logger.error(f"Could not run command: {cmd}. {result_str}")
+            return None
+        logger.debug(f"Command output: {result_str}")
+        return result.stdout.strip()

dsp_tools/clients/group_user_clients.py

@@ -0,0 +1,35 @@
+from typing import Any
+from typing import Protocol
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+
+
+class GroupClient(Protocol):
+    api_url: str
+    auth: AuthenticationClient
+
+    def get_all_groups(self) -> list[dict[str, Any]]:
+        """Get all the groups on this DSP-Server."""
+
+    def create_new_group(self, group_dict: dict[str, Any]) -> str | None:
+        """Create a new group."""
+
+
+class UserClient(Protocol):
+    api_url: str
+    auth: AuthenticationClient
+
+    def get_user_iri_by_username(self, username: str) -> str | None:
+        """Get a user by its username."""
+
+    def post_new_user(self, user_dict: dict[str, Any]) -> str | None:
+        """Create a new user."""
+
+    def add_user_as_project_member(self, user_iri: str, project_iri: str) -> bool:
+        """Add an existing user to a project."""
+
+    def add_user_as_project_admin(self, user_iri: str, project_iri: str) -> bool:
+        """Add a user as a project admin."""
+
+    def add_user_to_custom_groups(self, user_iri: str, groups: list[str]) -> bool:
+        """Add a user to a custom group."""

dsp_tools/clients/group_user_clients_live.py

@@ -0,0 +1,181 @@
+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 requests import RequestException
+
+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.error.exceptions import BadCredentialsError
+from dsp_tools.error.exceptions import FatalNonOkApiResponseCode
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_and_raise_request_exception
+from dsp_tools.utils.request_utils import log_and_warn_unexpected_non_ok_response
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_response
+
+TIMEOUT = 30
+
+
+@dataclass
+class UserClientLive(UserClient):
+    api_url: str
+    auth: AuthenticationClient
+
+    def get_user_iri_by_username(self, username: str) -> str | None:
+        url = f"{self.api_url}/admin/users/username/{username}"
+        headers = {"Authorization": f"Bearer {self.auth.get_token()}"}
+        params = RequestParameters("GET", url, TIMEOUT, headers=headers)
+        log_request(params)
+        try:
+            response = requests.get(url=params.url, headers=params.headers, timeout=params.timeout)
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        log_response(response)
+        if response.ok:
+            result = response.json()
+            return cast(str, result["user"]["id"])
+        if response.status_code == HTTPStatus.NOT_FOUND:
+            return None
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError("You do not have sufficient credentials to retrieve user information.")
+        log_and_warn_unexpected_non_ok_response(response.status_code, response.text)
+        return None
+
+    def post_new_user(self, user_dict: dict[str, Any]) -> str | None:
+        url = f"{self.api_url}/admin/users"
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.auth.get_token()}",
+        }
+        params = RequestParameters("POST", url, TIMEOUT, data=user_dict, headers=headers)
+        log_request(params)
+        try:
+            response = requests.post(
+                url=params.url, headers=params.headers, data=params.data_serialized, timeout=params.timeout
+            )
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        log_response(response)
+        if response.ok:
+            result = response.json()
+            return cast(str, result["user"]["id"])
+        if response.status_code == HTTPStatus.BAD_REQUEST:
+            # if the user exists we get a 400, this should never happen through code design
+            raise FatalNonOkApiResponseCode(url, response.status_code, response.text)
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError("You don't have permission to create users.")
+        log_and_warn_unexpected_non_ok_response(response.status_code, response.text)
+        return None
+
+    def add_user_as_project_member(self, user_iri: str, project_iri: str) -> bool:
+        project_iri_encoded = quote_plus(project_iri)
+        user_iri_encoded = quote_plus(user_iri)
+        url = f"{self.api_url}/admin/users/iri/{user_iri_encoded}/project-memberships/{project_iri_encoded}"
+        headers = {"Authorization": f"Bearer {self.auth.get_token()}"}
+        params = RequestParameters("POST", url, TIMEOUT, headers=headers)
+        log_request(params)
+        try:
+            response = requests.post(url=params.url, headers=params.headers, timeout=params.timeout)
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        log_response(response)
+        if response.ok:
+            return True
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError("You don't have permission to add users to projects.")
+        log_and_warn_unexpected_non_ok_response(response.status_code, response.text)
+        return False
+
+    def add_user_as_project_admin(self, user_iri: str, project_iri: str) -> bool:
+        project_iri_encoded = quote_plus(project_iri)
+        user_iri_encoded = quote_plus(user_iri)
+        url = f"{self.api_url}/admin/users/iri/{user_iri_encoded}/project-admin-memberships/{project_iri_encoded}"
+        headers = {"Authorization": f"Bearer {self.auth.get_token()}"}
+        params = RequestParameters("POST", url, TIMEOUT, headers=headers)
+        log_request(params)
+        try:
+            response = requests.post(url=params.url, headers=params.headers, timeout=params.timeout)
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        log_response(response)
+        if response.ok:
+            return True
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError("You don't have permission to add users as project admins.")
+        log_and_warn_unexpected_non_ok_response(response.status_code, response.text)
+        return False
+
+    def add_user_to_custom_groups(self, user_iri: str, groups: list[str]) -> bool:
+        user_iri_encoded = quote_plus(user_iri)
+        successes = []
+        for gr in groups:
+            result = self._add_user_to_one_group(user_iri_encoded, gr)
+            successes.append(result)
+        return all(successes)
+
+    def _add_user_to_one_group(self, user_iri_encoded: str, group_iri: str) -> bool:
+        group_iri_encoded = quote_plus(group_iri)
+        url = f"{self.api_url}/admin/users/iri/{user_iri_encoded}/group-memberships/{group_iri_encoded}"
+        headers = {"Authorization": f"Bearer {self.auth.get_token()}"}
+        params = RequestParameters("POST", url, TIMEOUT, headers=headers)
+        log_request(params)
+        try:
+            response = requests.post(url=params.url, headers=params.headers, timeout=params.timeout)
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        log_response(response)
+        if response.ok:
+            return True
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError("You don't have permission to add users to groups.")
+        log_and_warn_unexpected_non_ok_response(response.status_code, response.text)
+        return False
+
+
+@dataclass
+class GroupClientLive(GroupClient):
+    api_url: str
+    auth: AuthenticationClient
+
+    def get_all_groups(self) -> list[dict[str, Any]]:
+        url = f"{self.api_url}/admin/groups"
+        params = RequestParameters("GET", url, TIMEOUT)
+        log_request(params)
+        try:
+            response = requests.get(params.url, timeout=params.timeout)
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        log_response(response)
+        if response.ok:
+            result = response.json()
+            return cast(list[dict[str, Any]], result["groups"])
+        log_and_warn_unexpected_non_ok_response(response.status_code, response.text)
+        return []
+
+    def create_new_group(self, group_dict: dict[str, Any]) -> str | None:
+        url = f"{self.api_url}/admin/groups"
+        headers = {"Accept": "application/json", "Authorization": f"Bearer {self.auth.get_token()}"}
+        params = RequestParameters("POST", url, TIMEOUT, headers=headers, data=group_dict)
+        log_request(params)
+        try:
+            response = requests.post(
+                params.url, data=params.data_serialized, timeout=params.timeout, headers=params.headers
+            )
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        log_response(response)
+        if response.ok:
+            result = response.json()
+            return cast(str, result["group"]["id"])
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError(
+                "Only a SystemAdmin or ProjectAdmin can create groups. "
+                "Your permissions are insufficient for this action."
+            )
+        log_and_warn_unexpected_non_ok_response(response.status_code, response.text)
+        return None

dsp_tools/clients/legal_info_client.py

@@ -0,0 +1,23 @@
+from typing import Any
+from typing import Protocol
+
+from dsp_tools.clients.authentication_client import AuthenticationClient
+
+
+class LegalInfoClient(Protocol):
+    """
+    Protocol class/interface for the legal info endpoint of the admin API.
+    """
+
+    server: str
+    project_shortcode: str
+    authentication_client: AuthenticationClient
+
+    def post_copyright_holders(self, copyright_holders: list[str]) -> None:
+        """Send a list of new copyright holders to the API"""
+
+    def get_licenses_of_a_project(self, enabled_only: bool) -> list[dict[str, Any]]:
+        """Get a list of enabled licenses for the project."""
+
+    def enable_unknown_license(self) -> None:
+        """Enable the license http://rdfh.ch/licenses/unknown"""

dsp_tools/clients/legal_info_client_live.py

@@ -0,0 +1,132 @@
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Any
+
+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.legal_info_client import LegalInfoClient
+from dsp_tools.error.exceptions import BadCredentialsError
+from dsp_tools.error.exceptions import FatalNonOkApiResponseCode
+from dsp_tools.utils.request_utils import RequestParameters
+from dsp_tools.utils.request_utils import log_and_raise_request_exception
+from dsp_tools.utils.request_utils import log_request
+from dsp_tools.utils.request_utils import log_response
+
+TIMEOUT = 60
+
+
+@dataclass
+class LegalInfoClientLive(LegalInfoClient):
+    server: str
+    project_shortcode: str
+    authentication_client: AuthenticationClient
+
+    def post_copyright_holders(self, copyright_holders: list[str]) -> None:
+        """Send a list of new copyright holders to the API"""
+        logger.debug(f"POST {len(copyright_holders)} new copyright holders")
+        url = f"{self.server}/admin/projects/shortcode/{self.project_shortcode}/legal-info/copyright-holders"
+        try:
+            response = self._post_and_log_request(url, copyright_holders)
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        if response.ok:
+            return
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError(
+                "Only a SystemAdmin or ProjectAdmin can create new copyright holders. "
+                "Your permissions are insufficient for this action."
+            )
+        raise FatalNonOkApiResponseCode(url, response.status_code, response.text)
+
+    def _post_and_log_request(self, url: str, data: list[str]) -> Response:
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.authentication_client.get_token()}",
+        }
+        params = RequestParameters("POST", url, TIMEOUT, {"data": 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
+
+    def get_licenses_of_a_project(self, enabled_only: bool = True) -> list[dict[str, Any]]:
+        logger.debug("GET enabled licenses of the project.")
+        page_num = 1
+        all_data = []
+        is_last_page = False
+        while not is_last_page:
+            response = self._get_one_license_page(page_num, enabled_only)
+            response_dict = response.json()
+            all_data.extend(response_dict["data"])
+            is_last_page = _is_last_page(response_dict)
+        return all_data
+
+    def _get_one_license_page(self, page_num: int, enabled_only: bool) -> Response:
+        enabled = str(enabled_only).lower()
+        url = (
+            f"{self.server}/admin/projects/shortcode/{self.project_shortcode}/"
+            f"legal-info/licenses?page={page_num}&page-size=25&order=Asc&showOnlyEnabled={enabled}"
+        )
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.authentication_client.get_token()}",
+        }
+        params = RequestParameters(method="GET", url=url, timeout=TIMEOUT, headers=headers)
+        log_request(params)
+        try:
+            response = requests.get(
+                url=params.url,
+                headers=params.headers,
+                timeout=params.timeout,
+            )
+            log_response(response)
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        if response.ok:
+            return response
+        raise FatalNonOkApiResponseCode(url, response.status_code, response.text)
+
+    def enable_unknown_license(self) -> None:
+        escaped_license_iri = "http%3A%2F%2Frdfh.ch%2Flicenses%2Funknown"
+        url = (
+            f"{self.server}/admin/projects/shortcode/{self.project_shortcode}/"
+            f"legal-info/licenses/{escaped_license_iri}/enable"
+        )
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.authentication_client.get_token()}",
+        }
+        params = RequestParameters("POST", url, TIMEOUT, headers=headers)
+        log_request(params)
+        try:
+            response = requests.put(
+                url=params.url,
+                headers=params.headers,
+                timeout=params.timeout,
+            )
+            log_response(response)
+        except RequestException as err:
+            log_and_raise_request_exception(err)
+        if response.ok:
+            return
+        if response.status_code == HTTPStatus.FORBIDDEN:
+            raise BadCredentialsError(
+                "Only a SystemAdmin or ProjectAdmin can enable licenses. "
+                "Your permissions are insufficient for this action."
+            )
+        raise FatalNonOkApiResponseCode(url, response.status_code, response.text)
+
+
+def _is_last_page(response: dict[str, Any]) -> bool:
+    current_page = response["pagination"]["currentPage"]
+    total_page = response["pagination"]["totalPages"]
+    return bool(current_page == total_page)