digitalhub 0.9.1__py3-none-any.whl → 0.10.0b0__py3-none-any.whl

digitalhub/client/dhcore/configurator.py

@@ -0,0 +1,339 @@
+from __future__ import annotations
+
+import typing
+from warnings import warn
+
+from requests import request
+
+from digitalhub.client.dhcore.enums import AuthType, DhcoreEnvVar
+from digitalhub.client.dhcore.models import BasicAuth, OAuth2TokenAuth
+from digitalhub.configurator.configurator import configurator
+from digitalhub.utils.exceptions import ClientError
+from digitalhub.utils.uri_utils import has_remote_scheme
+
+if typing.TYPE_CHECKING:
+    from requests import Response
+
+
+# Default key used to store authentication information
+AUTH_KEY = "_auth"
+
+# API levels that are supported
+MAX_API_LEVEL = 20
+MIN_API_LEVEL = 9
+LIB_VERSION = 9
+
+
+class ClientDHCoreConfigurator:
+    """
+    Configurator object used to configure the client.
+    """
+
+    ##############################
+    # Configuration methods
+    ##############################
+
+    def configure(self, config: dict | None = None) -> None:
+        """
+        Configure the client attributes with config (given or from
+        environment).
+        Regarding authentication parameters, the config parameter
+        takes precedence over the env variables, and the token
+        over the basic auth. Furthermore, the config parameter is
+        validated against the proper pydantic model.
+
+        Parameters
+        ----------
+        config : dict
+            Configuration dictionary.
+
+        Returns
+        -------
+        None
+        """
+        if config is None:
+            self._get_core_endpoint()
+            self._get_auth_vars()
+            return
+
+        # Read passed config
+        # Validate and save credentials
+        if config.get("access_token") is not None:
+            config = OAuth2TokenAuth(**config)
+            for pair in [
+                (AUTH_KEY, AuthType.OAUTH2.value),
+                (DhcoreEnvVar.ENDPOINT.value, config.endpoint),
+                (DhcoreEnvVar.ISSUER.value, config.issuer),
+                (DhcoreEnvVar.ACCESS_TOKEN.value, config.access_token),
+                (DhcoreEnvVar.REFRESH_TOKEN.value, config.refresh_token),
+                (DhcoreEnvVar.CLIENT_ID.value, config.client_id),
+            ]:
+                configurator.set_credential(*pair)
+
+        elif config.get("user") is not None and config.get("password") is not None:
+            config = BasicAuth(**config)
+            for pair in [
+                (AUTH_KEY, AuthType.BASIC.value),
+                (DhcoreEnvVar.ENDPOINT.value, config.endpoint),
+                (DhcoreEnvVar.USER.value, config.user),
+                (DhcoreEnvVar.PASSWORD.value, config.password),
+            ]:
+                configurator.set_credential(*pair)
+
+        else:
+            raise ClientError("Invalid credentials format.")
+
+    def check_core_version(self, response: Response) -> None:
+        """
+        Raise an exception if DHCore API version is not supported.
+
+        Parameters
+        ----------
+        response : Response
+            The response object.
+
+        Returns
+        -------
+        None
+        """
+        if "X-Api-Level" in response.headers:
+            core_api_level = int(response.headers["X-Api-Level"])
+            if not (MIN_API_LEVEL <= core_api_level <= MAX_API_LEVEL):
+                raise ClientError("Backend API level not supported.")
+            if LIB_VERSION < core_api_level:
+                warn("Backend API level is higher than library version. You should consider updating the library.")
+
+    def build_url(self, api: str) -> str:
+        """
+        Build the url.
+
+        Parameters
+        ----------
+        api : str
+            The api to call.
+
+        Returns
+        -------
+        str
+            The url.
+        """
+        api = api.removeprefix("/")
+        return f"{configurator.get_credentials(DhcoreEnvVar.ENDPOINT.value)}/{api}"
+
+    ##############################
+    # Private methods
+    ##############################
+
+    @staticmethod
+    def _sanitize_endpoint(endpoint: str) -> str:
+        """
+        Sanitize the endpoint.
+
+        Returns
+        -------
+        None
+        """
+        if not has_remote_scheme(endpoint):
+            raise ClientError("Invalid endpoint scheme. Must start with http:// or https://.")
+
+        endpoint = endpoint.strip()
+        return endpoint.removesuffix("/")
+
+    def _get_core_endpoint(self) -> None:
+        """
+        Get the DHCore endpoint from env.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        Exception
+            If the endpoint of DHCore is not set in the env variables.
+        """
+        endpoint = configurator.load_var(DhcoreEnvVar.ENDPOINT.value)
+        if endpoint is None:
+            raise ClientError("Endpoint not set as environment variables.")
+        endpoint = self._sanitize_endpoint(endpoint)
+        configurator.set_credential(DhcoreEnvVar.ENDPOINT.value, endpoint)
+
+    def _get_auth_vars(self) -> None:
+        """
+        Get authentication parameters from the env.
+
+        Returns
+        -------
+        None
+        """
+        # Give priority to access token
+        access_token = configurator.load_var(DhcoreEnvVar.ACCESS_TOKEN.value)
+        if access_token is not None:
+            configurator.set_credential(AUTH_KEY, AuthType.OAUTH2.value)
+            configurator.set_credential(DhcoreEnvVar.ACCESS_TOKEN.value, access_token)
+
+        # Fallback to basic
+        else:
+            user = configurator.load_var(DhcoreEnvVar.USER.value)
+            password = configurator.load_var(DhcoreEnvVar.PASSWORD.value)
+            if user is not None and password is not None:
+                configurator.set_credential(AUTH_KEY, AuthType.BASIC.value)
+                configurator.set_credential(DhcoreEnvVar.USER.value, user)
+                configurator.set_credential(DhcoreEnvVar.PASSWORD.value, password)
+
+    ##############################
+    # Auth methods
+    ##############################
+
+    def basic_auth(self) -> bool:
+        """
+        Get basic auth.
+
+        Returns
+        -------
+        bool
+        """
+        auth_type = configurator.get_credentials(AUTH_KEY)
+        return auth_type == AuthType.BASIC.value
+
+    def oauth2_auth(self) -> bool:
+        """
+        Get oauth2 auth.
+
+        Returns
+        -------
+        bool
+        """
+        auth_type = configurator.get_credentials(AUTH_KEY)
+        return auth_type == AuthType.OAUTH2.value
+
+    def set_request_auth(self, kwargs: dict) -> dict:
+        """
+        Get the authentication header.
+
+        Parameters
+        ----------
+        kwargs : dict
+            Keyword arguments to pass to the request.
+
+        Returns
+        -------
+        dict
+            Authentication header.
+        """
+        creds = configurator.get_all_cred()
+        if AUTH_KEY not in creds:
+            return kwargs
+        if self.basic_auth():
+            user = creds[DhcoreEnvVar.USER.value]
+            password = creds[DhcoreEnvVar.PASSWORD.value]
+            kwargs["auth"] = (user, password)
+        elif self.oauth2_auth():
+            if "headers" not in kwargs:
+                kwargs["headers"] = {}
+            access_token = creds[DhcoreEnvVar.ACCESS_TOKEN.value]
+            kwargs["headers"]["Authorization"] = f"Bearer {access_token}"
+        return kwargs
+
+    def get_new_access_token(self) -> None:
+        """
+        Get a new access token.
+
+        Returns
+        -------
+        None
+        """
+        # Call issuer and get endpoint for
+        # refreshing access token
+        url = self._get_refresh_endpoint()
+
+        # Call refresh token endpoint
+        # Try token from env
+        refresh_token = configurator.load_from_env(DhcoreEnvVar.REFRESH_TOKEN.value)
+        response = self._call_refresh_token_endpoint(url, refresh_token)
+
+        # Otherwise try token from file
+        if response.status_code in (400, 401, 403):
+            refresh_token = configurator.load_from_config(DhcoreEnvVar.REFRESH_TOKEN.value)
+            response = self._call_refresh_token_endpoint(url, refresh_token)
+
+        response.raise_for_status()
+        dict_response = response.json()
+
+        # Read new access token and refresh token
+        configurator.set_credential(DhcoreEnvVar.ACCESS_TOKEN.value, dict_response["access_token"])
+        configurator.set_credential(DhcoreEnvVar.REFRESH_TOKEN.value, dict_response["refresh_token"])
+
+        # Propagate new access token to config file
+        self._write_env()
+
+    def _write_env(self) -> None:
+        """
+        Write the env variables to the .dhcore.ini file.
+        It will overwrite any existing env variables.
+
+        Returns
+        -------
+        None
+        """
+        configurator.write_env(
+            [
+                DhcoreEnvVar.ACCESS_TOKEN.value,
+                DhcoreEnvVar.REFRESH_TOKEN.value,
+            ]
+        )
+
+    def _get_refresh_endpoint(self) -> str:
+        """
+        Get the refresh endpoint.
+
+        Returns
+        -------
+        str
+            Refresh endpoint.
+        """
+        # Get issuer endpoint
+        endpoint_issuer = configurator.load_var(DhcoreEnvVar.ISSUER.value)
+        if endpoint_issuer is not None:
+            endpoint_issuer = self._sanitize_endpoint(endpoint_issuer)
+            configurator.set_credential(DhcoreEnvVar.ISSUER.value, endpoint_issuer)
+        else:
+            raise ClientError("Issuer endpoint not set.")
+
+        # Standard issuer endpoint path
+        url = endpoint_issuer + "/.well-known/openid-configuration"
+
+        # Call issuer to get refresh endpoint
+        r = request("GET", url, timeout=60)
+        r.raise_for_status()
+        return r.json().get("token_endpoint")
+
+    def _call_refresh_token_endpoint(self, url: str, refresh_token: str) -> Response:
+        """
+        Call the refresh token endpoint.
+
+        Parameters
+        ----------
+        url : str
+            Refresh token endpoint.
+        refresh_token : str
+            Refresh token.
+
+        Returns
+        -------
+        Response
+            Response object.
+        """
+        # Get client id
+        client_id = configurator.load_var(DhcoreEnvVar.CLIENT_ID.value)
+        if client_id is None:
+            raise ClientError("Client id not set.")
+
+        # Send request to get new access token
+        payload = {
+            "grant_type": "refresh_token",
+            "client_id": client_id,
+            "refresh_token": refresh_token,
+        }
+        headers = {"Content-Type": "application/x-www-form-urlencoded"}
+        return request("POST", url, data=payload, headers=headers, timeout=60)

digitalhub/client/dhcore/error_parser.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import typing
+
+from requests.exceptions import HTTPError, RequestException
+
+from digitalhub.utils.exceptions import (
+    BackendError,
+    BadRequestError,
+    EntityAlreadyExistsError,
+    EntityNotExistsError,
+    ForbiddenError,
+    MissingSpecError,
+    UnauthorizedError,
+)
+
+if typing.TYPE_CHECKING:
+    from requests import Response
+
+
+class ErrorParser:
+    @staticmethod
+    def parse(response: Response) -> None:
+        """
+        Handle DHCore API errors.
+
+        Parameters
+        ----------
+        response : Response
+            The response object.
+
+        Returns
+        -------
+        None
+        """
+        try:
+            response.raise_for_status()
+
+        # Backend errors
+        except RequestException as e:
+            # Handle timeout
+            if isinstance(e, TimeoutError):
+                msg = "Request to DHCore backend timed out."
+                raise TimeoutError(msg)
+
+            # Handle connection error
+            elif isinstance(e, ConnectionError):
+                msg = "Unable to connect to DHCore backend."
+                raise ConnectionError(msg)
+
+            # Handle HTTP errors
+            elif isinstance(e, HTTPError):
+                txt_resp = f"Response: {response.text}."
+
+                # Bad request
+                if response.status_code == 400:
+                    # Missing spec in backend
+                    if "missing spec" in response.text:
+                        msg = f"Missing spec in backend. {txt_resp}"
+                        raise MissingSpecError(msg)
+
+                    # Duplicated entity
+                    elif "Duplicated entity" in response.text:
+                        msg = f"Entity already exists. {txt_resp}"
+                        raise EntityAlreadyExistsError(msg)
+
+                    # Other errors
+                    else:
+                        msg = f"Bad request. {txt_resp}"
+                        raise BadRequestError(msg)
+
+                # Unauthorized errors
+                elif response.status_code == 401:
+                    msg = f"Unauthorized. {txt_resp}"
+                    raise UnauthorizedError(msg)
+
+                # Forbidden errors
+                elif response.status_code == 403:
+                    msg = f"Forbidden. {txt_resp}"
+                    raise ForbiddenError(msg)
+
+                # Entity not found
+                elif response.status_code == 404:
+                    # Put with entity not found
+                    if "No such EntityName" in response.text:
+                        msg = f"Entity does not exists. {txt_resp}"
+                        raise EntityNotExistsError(msg)
+
+                    # Other cases
+                    else:
+                        msg = f"Not found. {txt_resp}"
+                        raise BackendError(msg)
+
+                # Other errors
+                else:
+                    msg = f"Backend error. {txt_resp}"
+                    raise BackendError(msg) from e
+
+            # Other requests errors
+            else:
+                msg = f"Some error occurred. {e}"
+                raise BackendError(msg) from e
+
+        # Other generic errors
+        except Exception as e:
+            msg = f"Some error occurred: {e}"
+            raise RuntimeError(msg) from e

digitalhub/client/dhcore/models.py

@@ -2,45 +2,35 @@ from __future__ import annotations
 
 from pydantic import BaseModel
 
-from digitalhub.client.dhcore.env import FALLBACK_USER
 
-
-class AuthConfig(BaseModel):
+class ClientConfig(BaseModel):
     """Client configuration model."""
 
-    user: str = FALLBACK_USER
-    """Username."""
+    endpoint: str
+    """API endpoint."""
 
 
-class BasicAuth(AuthConfig):
+class BasicAuth(ClientConfig):
     """Basic authentication model."""
 
+    user: str
+    """Username."""
+
     password: str
     """Basic authentication password."""
 
 
-class ClientParams(AuthConfig):
-    """Client id authentication model."""
-
-    client_id: str = None
-    """OAuth2 client id."""
-
-    client_scecret: str = None
-    """OAuth2 client secret."""
-
-
-class OAuth2TokenAuth(ClientParams):
+class OAuth2TokenAuth(ClientConfig):
     """OAuth2 token authentication model."""
 
     access_token: str
     """OAuth2 token."""
 
-    refresh_token: str = None
+    refresh_token: str
     """OAuth2 refresh token."""
 
+    client_id: str
+    """OAuth2 client id."""
 
-class TokenExchangeAuth(ClientParams):
-    """Token exchange authentication model."""
-
-    exchange_token: str
-    """Exchange token."""
+    issuer_endpoint: str
+    """OAuth2 issuer endpoint."""

digitalhub/client/dhcore/utils.py

@@ -4,7 +4,7 @@ import os
 import typing
 
 from digitalhub.client.api import get_client
-from digitalhub.client.dhcore.enums import AuthType, DhcoreEnvVar
+from digitalhub.client.dhcore.enums import DhcoreEnvVar
 
 if typing.TYPE_CHECKING:
     from digitalhub.client.dhcore.client import ClientDHCore
@@ -21,8 +21,7 @@ def set_dhcore_env(
     """
     Function to set environment variables for DHCore config.
     Note that if the environment variable is already set, it
-    will be overwritten. It also ovverides the remote client
-    configuration.
+    will be overwritten.
 
     Parameters
     ----------
@@ -56,47 +55,8 @@ def set_dhcore_env(
     if client_id is not None:
         os.environ[DhcoreEnvVar.CLIENT_ID.value] = client_id
 
-    update_client_from_env()
-
-
-def update_client_from_env() -> None:
-    """
-    Function to update client from environment variables.
-
-    Returns
-    -------
-    None
-    """
     client: ClientDHCore = get_client(local=False)
-
-    # Update endpoint
-    endpoint = os.getenv(DhcoreEnvVar.ENDPOINT.value)
-    if endpoint is not None:
-        client._endpoint_core = endpoint
-
-    # Update auth
-
-    # If token is set, it will override the other auth options
-    access_token = os.getenv(DhcoreEnvVar.ACCESS_TOKEN.value)
-    refresh_token = os.getenv(DhcoreEnvVar.REFRESH_TOKEN.value)
-    client_id = os.getenv(DhcoreEnvVar.CLIENT_ID.value)
-
-    if access_token is not None:
-        if refresh_token is not None:
-            client._refresh_token = refresh_token
-        if client_id is not None:
-            client._client_id = client_id
-        client._access_token = access_token
-        client._auth_type = AuthType.OAUTH2.value
-        return
-
-    # Otherwise, if user and password are set, basic auth will be used
-    username = os.getenv(DhcoreEnvVar.USER.value)
-    password = os.getenv(DhcoreEnvVar.PASSWORD.value)
-    if username is not None and password is not None:
-        client._user = username
-        client._password = password
-        client._auth_type = AuthType.BASIC.value
+    client._configurator.configure()
 
 
 def refresh_token() -> None:
@@ -108,4 +68,4 @@ def refresh_token() -> None:
     None
     """
     client: ClientDHCore = get_client(local=False)
-    client._get_new_access_token()
+    client._configurator.get_new_access_token()

digitalhub/client/local/api_builder.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from digitalhub.client._base.api_builder import ClientApiBuilder
+from digitalhub.client.local.enums import LocalClientVar
 from digitalhub.entities._commons.enums import ApiCategories, BackendOperations
 from digitalhub.utils.exceptions import BackendError
 
@@ -63,9 +64,7 @@ class ClientLocalApiBuilder(ClientApiBuilder):
             BackendOperations.DELETE.value,
         ):
             return f"{API_BASE}/{entity_type}/{kwargs['entity_name']}"
-        elif operation == BackendOperations.SHARE.value:
-            raise BackendError("Share API not implemented for Local.")
-        raise BackendError(f"Invalid operation '{operation}' for entity type '{entity_type}' in Local.")
+        raise BackendError(f"API for operation '{operation}' for entity type '{entity_type}' not implemented in Local.")
 
     def build_api_context(self, operation: str, **kwargs) -> str:
         """
@@ -84,17 +83,10 @@ class ClientLocalApiBuilder(ClientApiBuilder):
             BackendOperations.DELETE.value,
         ):
             return f"{API_CONTEXT}/{project}/{entity_type}/{kwargs['entity_id']}"
-        elif operation == BackendOperations.LOGS.value:
-            raise BackendError("Logs run API not implemented for Local.")
-        elif operation == BackendOperations.STOP.value:
-            raise BackendError("Stop run API not implemented for Local.")
-        elif operation == BackendOperations.RESUME.value:
-            raise BackendError("Resume run API not implemented for Local.")
-        elif operation == BackendOperations.DATA.value:
-            raise BackendError("Secret API (read/set value) not implemented for Local.")
-        elif operation == BackendOperations.FILES.value:
-            raise BackendError("Files API not implemented for Local.")
-        elif operation == BackendOperations.SEARCH.value:
-            raise BackendError("Search API not implemented for Local.")
-
-        raise BackendError(f"Invalid operation '{operation}' for entity type '{entity_type}' in Local.")
+        elif operation in (
+            BackendOperations.LOGS.value,
+            BackendOperations.FILES.value,
+            BackendOperations.METRICS.value,
+        ):
+            return LocalClientVar.EMPTY.value
+        raise BackendError(f"API for operation '{operation}' for entity type '{entity_type}' not implemented in Local.")

digitalhub/client/local/client.py

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 from copy import deepcopy
 from datetime import datetime, timezone
+from typing import Any
 
 from digitalhub.client._base.client import Client
 from digitalhub.client.local.api_builder import ClientLocalApiBuilder
+from digitalhub.client.local.enums import LocalClientVar
 from digitalhub.client.local.key_builder import ClientLocalKeyBuilder
 from digitalhub.utils.exceptions import BackendError
 
@@ -32,7 +34,7 @@ class ClientLocal(Client):
     # CRUD
     ##############################
 
-    def create_object(self, api: str, obj: dict, **kwargs) -> dict:
+    def create_object(self, api: str, obj: Any, **kwargs) -> dict:
         """
         Create an object in local.
 
@@ -48,6 +50,9 @@ class ClientLocal(Client):
         dict
             The created object.
         """
+        if not isinstance(obj, dict):
+            raise TypeError("Object must be a dictionary")
+
         entity_type, _, context_api = self._parse_api(api)
         try:
             # Check if entity_type is valid
@@ -114,6 +119,8 @@ class ClientLocal(Client):
         dict
             The read object.
         """
+        if api == LocalClientVar.EMPTY.value:
+            return {}
         entity_type, entity_id, context_api = self._parse_api(api)
         if entity_id is None:
             msg = self._format_msg(4)
@@ -155,7 +162,7 @@ class ClientLocal(Client):
             msg = self._format_msg(3, entity_type=entity_type, entity_id=entity_id)
             raise BackendError(msg)
 
-    def update_object(self, api: str, obj: dict, **kwargs) -> dict:
+    def update_object(self, api: str, obj: Any, **kwargs) -> dict:
         """
         Update an object in local.
 
@@ -171,6 +178,9 @@ class ClientLocal(Client):
         dict
             The updated object.
         """
+        if not isinstance(obj, dict):
+            raise TypeError("Object must be a dictionary")
+
         entity_type, entity_id, context_api = self._parse_api(api)
         try:
             # API example

digitalhub/client/local/enums.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class LocalClientVar(Enum):
+    """
+    Variables for Local.
+    """
+
+    EMPTY = "EMPTY"