mpt-extension-sdk 4.5.0__py3-none-any.whl → 5.17.2__py3-none-any.whl

mpt_extension_sdk/airtable/wrap_http_error.py

@@ -5,10 +5,12 @@ from requests import HTTPError, JSONDecodeError
 
 
 class AirTableError(Exception):
-    pass
+    """Base class for all AirTable API exceptions."""
 
 
 class AirTableHttpError(AirTableError):
+    """Exception raised for HTTP errors in the AirTable API."""
+
     def __init__(self, status_code: int, content: str):
         self.status_code = status_code
         self.content = content
@@ -16,6 +18,8 @@ class AirTableHttpError(AirTableError):
 
 
 class AirTableAPIError(AirTableHttpError):
+    """Exception raised for errors in the AirTable API."""
+
     def __init__(self, status_code: int, payload) -> None:
         super().__init__(status_code, json.dumps(payload))
         self.payload = payload
@@ -30,16 +34,16 @@ class AirTableAPIError(AirTableHttpError):
 
 
 def wrap_airtable_http_error(func):
+    """Wrap a function to catch AirTable HTTP errors."""
+
     @wraps(func)
     def _wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
-        except HTTPError as e:
+        except HTTPError as err:
             try:
-                raise AirTableAPIError(e.response.status_code, e.response.json())
+                raise AirTableAPIError(err.response.status_code, err.response.json())
             except JSONDecodeError:
-                raise AirTableHttpError(
-                    e.response.status_code, e.response.content.decode()
-                )
+                raise AirTableHttpError(err.response.status_code, err.response.content.decode())
 
     return _wrapper

mpt_extension_sdk/constants.py

@@ -9,3 +9,5 @@ ERR_DJANGO_SETTINGS_MODULE_TEXT = (
     "DJANGO_SETTINGS_MODULE environment variable is not set. "
     "Please set it to your Django settings module before running this command."
 )
+POOL_MAX_SIZE = 36
+GRADIENT_HEX_BASE = 16

mpt_extension_sdk/core/events/dataclasses.py

@@ -11,6 +11,8 @@ EventType = Annotated[Literal[EVENT_TYPES], Doc("Unique identifier of the event
 
 @dataclass
 class Event:
+    """Represents an event."""
+
     id: Annotated[str, Doc("The unique identifier of the event.")]
     type: EventType
     data: Annotated[Mapping | Sequence, Doc("Event data.")]

mpt_extension_sdk/core/events/registry.py

@@ -1,12 +1,14 @@
-from collections.abc import MutableMapping, Sequence
-from typing import Any, Callable
+from collections.abc import Callable, MutableMapping, Sequence
+from typing import Any
 
-from .dataclasses import Event, EventType
+from mpt_extension_sdk.core.events.dataclasses import Event, EventType
 
 EventListener = Callable[[Any, Event], None]
 
 
 class EventsRegistry:
+    """Registry for event listeners."""
+
     def __init__(
         self,
     ) -> None:
@@ -44,13 +46,16 @@ class EventsRegistry:
         self,
         event_type: EventType,
     ) -> EventListener | None:
+        """Get the listener for a specific event type."""
         return self.listeners.get(event_type)
 
     def get_registered_types(self) -> Sequence[str]:
+        """Get a list of all registered event types."""
         return list(self.listeners.keys())
 
     def is_event_supported(
         self,
         event_type: EventType,
     ) -> bool:
+        """Check if an event type is supported."""
         return event_type in self.listeners

mpt_extension_sdk/core/extension.py

@@ -4,6 +4,8 @@ from mpt_extension_sdk.core.events.registry import EventsRegistry
 
 
 class Extension:
+    """Base class for all extensions."""
+
     def __init__(
         self,
         /,

mpt_extension_sdk/core/security.py

@@ -1,6 +1,6 @@
 import logging
-from collections.abc import Mapping
-from typing import Any, Callable
+from collections.abc import Callable, Mapping
+from typing import Any, ClassVar
 
 import jwt
 from django.http import HttpRequest
@@ -13,7 +13,9 @@ logger = logging.getLogger(__name__)
 
 
 class JWTAuth(HttpBearer):
-    JWT_ALGOS = [SECURITY_ALGORITHM]
+    """JWT authentication using JSON Web Tokens."""
+
+    jwt_algos: ClassVar[list[str]] = [SECURITY_ALGORITHM]
 
     def __init__(
         self,
@@ -23,28 +25,34 @@ class JWTAuth(HttpBearer):
         super().__init__()
 
     def authenticate(self, request: HttpRequest, token: str) -> Any | None:
+        """Authenticate the request using the provided JWT token."""
         try:
-            claims = jwt.decode(
-                token,
-                options={
-                    "verify_signature": False,
-                    "verify_aud": False,
-                },
-                algorithms=self.JWT_ALGOS,
-            )
-            secret = self.secret_callback(request.client, claims)
-            if not secret:
-                return
-            jwt.decode(
-                token,
-                secret,
-                options={
-                    "verify_aud": False,
-                },
-                algorithms=self.JWT_ALGOS,
-            )
-            request.jwt_claims = claims
-            return claims
-
-        except jwt.PyJWTError as e:
-            logger.error(f"Call cannot be authenticated: {str(e)}")
+            request.jwt_claims = self.get_claims(request, token)
+        except jwt.PyJWTError as err:
+            logger.exception("Call cannot be authenticated: %r", err)  # noqa: TRY401
+        else:
+            return request.jwt_claims
+
+    def get_claims(self, request, token):
+        """Extract JWT claims from the token."""
+        claims = jwt.decode(
+            token,
+            options={
+                "verify_signature": False,
+                "verify_aud": False,
+            },
+            algorithms=self.jwt_algos,
+        )
+        secret = self.secret_callback(request.client, claims)
+        if not secret:
+            return None
+        jwt.decode(
+            token,
+            secret,
+            options={
+                "verify_aud": False,
+            },
+            algorithms=self.jwt_algos,
+        )
+        request.jwt_claims = claims
+        return claims

mpt_extension_sdk/core/utils.py

@@ -4,6 +4,7 @@ from mpt_extension_sdk.mpt_http.base import MPTClient
 
 
 def setup_client():
+    """Set up the main client."""
     return MPTClient(
         f"{settings.MPT_API_BASE_URL}/v1/",
         settings.MPT_API_TOKEN,
@@ -11,6 +12,7 @@ def setup_client():
 
 
 def setup_operations_client():
+    """Set up the operations client."""
     return MPTClient(
         f"{settings.MPT_API_BASE_URL}/v1/",
         settings.MPT_API_TOKEN_OPERATIONS,

mpt_extension_sdk/flows/context.py

@@ -7,33 +7,44 @@ ORDER_TYPE_TERMINATION = "Termination"
 
 @dataclass
 class Context:
+    """Represents the context for an order."""
+
     order: dict
 
     @property
     def order_id(self):
+        """Return the order ID."""
         return self.order.get("id", None)
 
     @property
     def order_type(self):
+        """Return the order type."""
         return self.order.get("type", None)
 
     @property
     def product_id(self):
+        """Return the product ID."""
         return self.order.get("product", {}).get("id", None)
 
     def is_purchase_order(self):
+        """Check if the order is a purchase order."""
         return self.order["type"] == ORDER_TYPE_PURCHASE
 
     def is_change_order(self):
+        """Check if the order is a change order."""
         return self.order["type"] == ORDER_TYPE_CHANGE
 
     def is_termination_order(self):
+        """Check if the order is a termination order."""
         return self.order["type"] == ORDER_TYPE_TERMINATION
 
     @classmethod
     def from_context(cls, context):
+        """Create a new Context instance from an existing one."""
         base_data = asdict(context)
         return cls(**base_data)
 
     def __str__(self):
-        return f"Context: {self.order.get("id", None)} {self.order.get("type", None)}"
+        order_id = self.order.get("id", None)
+        order_type = self.order.get("type", None)
+        return f"Context: {order_id} {order_type}"

mpt_extension_sdk/flows/pipeline.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Callable
+from collections.abc import Callable
 
 from mpt_extension_sdk.flows.context import Context
 from mpt_extension_sdk.mpt_http.base import MPTClient
@@ -8,6 +8,8 @@ NextStep = Callable[[MPTClient, Context], None]
 
 
 class Step(ABC):
+    """Abstract base class for pipeline steps."""
+
     @abstractmethod
     def __call__(
         self,
@@ -15,7 +17,8 @@ class Step(ABC):
         context: Context,
         next_step: NextStep,
     ) -> None:
-        raise NotImplementedError()  # pragma: no cover
+        """Execute the step."""
+        raise NotImplementedError  # pragma: no cover
 
 
 def _default_error_handler(error: Exception, context: Context, next_step: NextStep):
@@ -23,11 +26,14 @@ def _default_error_handler(error: Exception, context: Context, next_step: NextSt
 
 
 class Cursor:
+    """A cursor for navigating through pipeline steps."""
+
     def __init__(self, steps, error_handler):
         self.queue = steps
         self.error_handler = error_handler
 
     def __call__(self, client: MPTClient, context: Context):
+        """Execute the next step in the pipeline."""
         if not self.queue:
             return
         current_step = self.queue[0]
@@ -40,10 +46,13 @@ class Cursor:
 
 
 class Pipeline:
+    """A pipeline for processing steps."""
+
     def __init__(self, *steps):
         self.queue = steps
 
     def run(self, client: MPTClient, context: Context, error_handler=None):
+        """Run the pipeline."""
         execute = Cursor(self.queue, error_handler or _default_error_handler)
         return execute(client, context)
 

mpt_extension_sdk/key_vault/base.py

@@ -12,6 +12,8 @@ logger = logging.getLogger(__name__)
 
 
 class KeyVault(Session):
+    """A client for interacting with Azure Key Vault."""
+
     def __init__(self, key_vault_name: str):
         """
         Initialize the KeyVault client with the provided Key Vault name.
@@ -34,15 +36,10 @@ class KeyVault(Session):
             str: The value of the secret.
         """
         try:
-            client = self._get_key_vault_client(self.key_vault_name)
-
-            # Retrieve the secret from the Key Vault
-            secret = client.get_secret(secret_name)
-
-            return secret.value
-        except ResourceNotFoundError as e:
-            logger.error(
-                f"Secret '{secret_name}' not found in Key Vault '{self.key_vault_name}': {e}"
+            return self._get_secret_from_key_vault(secret_name)
+        except ResourceNotFoundError:
+            logger.exception(
+                "Secret '%s' not found in Key Vault '%s'", secret_name, self.key_vault_name
             )
             return None
 
@@ -58,21 +55,39 @@ class KeyVault(Session):
         Returns:
             None
         """
-
         # Set the secret in the Key Vault
         try:
-            client = self._get_key_vault_client(self.key_vault_name)
+            return self._set_secret_for_key_vault(secret_name, secret_value)
+        except HttpResponseError as err:
+            logger.exception(
+                "Failed to set secret '%s' in Key Vault '%s': %s",
+                secret_name,
+                self.key_vault_name,
+                err,  # noqa: TRY401
+            )
+            return None
 
-            client.set_secret(secret_name, secret_value)
+    def _get_secret_from_key_vault(self, secret_name: str):
+        """
+        Retrieve a secret from the Azure Key Vault.
 
-            updated_secret = client.get_secret(secret_name)
+        Args:
+            secret_name (str): The name of the secret to retrieve.
 
-            return updated_secret.value
-        except HttpResponseError as e:
-            logger.error(
-                f"Failed to set secret '{secret_name}' in Key Vault '{self.key_vault_name}': {e}"
-            )
-            return None
+        Returns:
+            str: The value of the secret.
+        """
+        client = self._get_key_vault_client(self.key_vault_name)
+
+        # Retrieve the secret from the Key Vault
+        return client.get_secret(secret_name).value
+
+    def _set_secret_for_key_vault(self, secret_name: str, secret_value: str):
+        client = self._get_key_vault_client(self.key_vault_name)
+
+        client.set_secret(secret_name, secret_value)
+
+        return client.get_secret(secret_name).value
 
     def _get_key_vault_url(self, key_vault_name: str):  # pragma: no cover
         """
@@ -84,7 +99,6 @@ class KeyVault(Session):
         Returns:
             str: The URL of the Azure Key Vault.
         """
-
         # Construct the Key Vault URL
         return f"https://{key_vault_name}.vault.azure.net/"
 
@@ -93,18 +107,15 @@ class KeyVault(Session):
         Create a Key Vault client using the provided Key Vault URL and secret name.
 
         Args:
-            key_vault_url (str): The URL of the Azure Key Vault.
+            key_vault_name (str): The name of the Azure Key Vault.
 
         Returns:
             SecretClient: An instance of the SecretClient for the specified Key Vault.
         """
-
         # Get the Key Vault URL
         key_vault_url = self._get_key_vault_url(key_vault_name)
         # Create a credential object using DefaultAzureCredential
         credential = DefaultAzureCredential()
 
         # Create a Key Vault client using the credential
-        client = SecretClient(vault_url=key_vault_url, credential=credential)
-
-        return client
+        return SecretClient(vault_url=key_vault_url, credential=credential)

mpt_extension_sdk/mpt_http/base.py

@@ -3,10 +3,12 @@ from urllib.parse import urljoin
 from requests import Session
 from requests.adapters import HTTPAdapter, Retry
 
-from mpt_extension_sdk.constants import USER_AGENT
+from mpt_extension_sdk.constants import POOL_MAX_SIZE, USER_AGENT
 
 
 class MPTClient(Session):
+    """Client for interacting with the MPT API."""
+
     def __init__(self, base_url, api_token):
         super().__init__()
         retries = Retry(
@@ -18,7 +20,14 @@ class MPTClient(Session):
             "http://",
             HTTPAdapter(
                 max_retries=retries,
-                pool_maxsize=36,
+                pool_maxsize=POOL_MAX_SIZE,
+            ),
+        )
+        self.mount(
+            "https://",
+            HTTPAdapter(
+                max_retries=retries,
+                pool_maxsize=POOL_MAX_SIZE,
             ),
         )
         self.headers.update(
@@ -27,17 +36,20 @@ class MPTClient(Session):
                 "Authorization": f"Bearer {api_token}",
             },
         )
-        self.base_url = f"{base_url}/" if base_url[-1] != "/" else base_url
+        self.base_url = base_url if base_url[-1] == "/" else f"{base_url}/"
         self.api_token = api_token
 
     def request(self, method, url, *args, **kwargs):
+        """Send a request to the API."""
         url = self.join_url(url)
         return super().request(method, url, *args, **kwargs)
 
     def prepare_request(self, request, *args, **kwargs):
+        """Prepare the request by joining the base URL."""
         request.url = self.join_url(request.url)
         return super().prepare_request(request, *args, **kwargs)
 
     def join_url(self, url):
+        """Join the base URL with the given URL."""
         url = url[1:] if url[0] == "/" else url
         return urljoin(self.base_url, url)