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

mpt_extension_sdk/airtable/wrap_http_error.py

@@ -0,0 +1,45 @@
+import json
+from functools import wraps
+
+from requests import HTTPError, JSONDecodeError
+
+
+class AirTableError(Exception):
+    pass
+
+
+class AirTableHttpError(AirTableError):
+    def __init__(self, status_code: int, content: str):
+        self.status_code = status_code
+        self.content = content
+        super().__init__(f"{self.status_code} - {self.content}")
+
+
+class AirTableAPIError(AirTableHttpError):
+    def __init__(self, status_code: int, payload) -> None:
+        super().__init__(status_code, json.dumps(payload))
+        self.payload = payload
+        self.code = status_code
+        self.message = payload.get("error", {}).get("message", "")
+
+    def __str__(self) -> str:
+        return f"{self.code} - {self.message}"
+
+    def __repr__(self) -> str:
+        return str(self.payload)
+
+
+def wrap_airtable_http_error(func):
+    @wraps(func)
+    def _wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except HTTPError as e:
+            try:
+                raise AirTableAPIError(e.response.status_code, e.response.json())
+            except JSONDecodeError:
+                raise AirTableHttpError(
+                    e.response.status_code, e.response.content.decode()
+                )
+
+    return _wrapper

mpt_extension_sdk/constants.py

@@ -0,0 +1,11 @@
+EVENT_TYPES = "orders"
+SECURITY_ALGORITHM = "HS256"
+USER_AGENT = "swo-extensions/1.0"
+CONSUME_EVENTS_HELP_TEXT = "Consume events from the MPT platform"
+DEFAULT_APP_CONFIG_GROUP = "swo.mpt.ext"
+DEFAULT_APP_CONFIG_NAME = "app_config"
+DJANGO_SETTINGS_MODULE = "mpt_extension_sdk.runtime.djapp.conf.default"
+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."
+)

mpt_extension_sdk/core/events/dataclasses.py

@@ -0,0 +1,16 @@
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Annotated, Literal
+
+from typing_extensions import Doc
+
+from mpt_extension_sdk.constants import EVENT_TYPES
+
+EventType = Annotated[Literal[EVENT_TYPES], Doc("Unique identifier of the event type.")]
+
+
+@dataclass
+class 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

@@ -0,0 +1,56 @@
+from collections.abc import MutableMapping, Sequence
+from typing import Any, Callable
+
+from .dataclasses import Event, EventType
+
+EventListener = Callable[[Any, Event], None]
+
+
+class EventsRegistry:
+    def __init__(
+        self,
+    ) -> None:
+        self.listeners: MutableMapping[str, EventListener] = {}
+
+    def listener(
+        self,
+        event_type: EventType,
+        /,
+    ) -> Callable[[EventListener], EventListener]:
+        """
+        Unique identifier of the event type.
+
+        ## Example
+
+        ```python
+        from mpt_extension_sdk.core import Extension
+
+        ext = Extension()
+
+
+        @ext.events.listener("orders")
+        def process_order(client, event):
+            ...
+        ```
+        """
+
+        def decorator(func: EventListener) -> EventListener:
+            self.listeners[event_type] = func
+            return func
+
+        return decorator
+
+    def get_listener(
+        self,
+        event_type: EventType,
+    ) -> EventListener | None:
+        return self.listeners.get(event_type)
+
+    def get_registered_types(self) -> Sequence[str]:
+        return list(self.listeners.keys())
+
+    def is_event_supported(
+        self,
+        event_type: EventType,
+    ) -> bool:
+        return event_type in self.listeners

mpt_extension_sdk/core/extension.py

@@ -0,0 +1,12 @@
+from ninja import NinjaAPI
+
+from mpt_extension_sdk.core.events.registry import EventsRegistry
+
+
+class Extension:
+    def __init__(
+        self,
+        /,
+    ) -> None:
+        self.events: EventsRegistry = EventsRegistry()
+        self.api: NinjaAPI = NinjaAPI()

mpt_extension_sdk/core/security.py

@@ -0,0 +1,50 @@
+import logging
+from collections.abc import Mapping
+from typing import Any, Callable
+
+import jwt
+from django.http import HttpRequest
+from ninja.security import HttpBearer
+
+from mpt_extension_sdk.constants import SECURITY_ALGORITHM
+from mpt_extension_sdk.mpt_http.base import MPTClient
+
+logger = logging.getLogger(__name__)
+
+
+class JWTAuth(HttpBearer):
+    JWT_ALGOS = [SECURITY_ALGORITHM]
+
+    def __init__(
+        self,
+        secret_callback: Callable[[MPTClient, Mapping[str, Any]], str],
+    ) -> None:
+        self.secret_callback = secret_callback
+        super().__init__()
+
+    def authenticate(self, request: HttpRequest, token: str) -> Any | None:
+        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)}")

mpt_extension_sdk/core/utils.py

@@ -0,0 +1,17 @@
+from django.conf import settings
+
+from mpt_extension_sdk.mpt_http.base import MPTClient
+
+
+def setup_client():
+    return MPTClient(
+        f"{settings.MPT_API_BASE_URL}/v1/",
+        settings.MPT_API_TOKEN,
+    )
+
+
+def setup_operations_client():
+    return MPTClient(
+        f"{settings.MPT_API_BASE_URL}/v1/",
+        settings.MPT_API_TOKEN_OPERATIONS,
+    )

mpt_extension_sdk/flows/context.py

@@ -0,0 +1,39 @@
+from dataclasses import asdict, dataclass
+
+ORDER_TYPE_PURCHASE = "Purchase"
+ORDER_TYPE_CHANGE = "Change"
+ORDER_TYPE_TERMINATION = "Termination"
+
+
+@dataclass
+class Context:
+    order: dict
+
+    @property
+    def order_id(self):
+        return self.order.get("id", None)
+
+    @property
+    def order_type(self):
+        return self.order.get("type", None)
+
+    @property
+    def product_id(self):
+        return self.order.get("product", {}).get("id", None)
+
+    def is_purchase_order(self):
+        return self.order["type"] == ORDER_TYPE_PURCHASE
+
+    def is_change_order(self):
+        return self.order["type"] == ORDER_TYPE_CHANGE
+
+    def is_termination_order(self):
+        return self.order["type"] == ORDER_TYPE_TERMINATION
+
+    @classmethod
+    def from_context(cls, context):
+        base_data = asdict(context)
+        return cls(**base_data)
+
+    def __str__(self):
+        return f"Context: {self.order.get("id", None)} {self.order.get("type", None)}"

mpt_extension_sdk/flows/pipeline.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from typing import Callable
+
+from mpt_extension_sdk.flows.context import Context
+from mpt_extension_sdk.mpt_http.base import MPTClient
+
+NextStep = Callable[[MPTClient, Context], None]
+
+
+class Step(ABC):
+    @abstractmethod
+    def __call__(
+        self,
+        client: MPTClient,
+        context: Context,
+        next_step: NextStep,
+    ) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+
+def _default_error_handler(error: Exception, context: Context, next_step: NextStep):
+    raise error
+
+
+class Cursor:
+    def __init__(self, steps, error_handler):
+        self.queue = steps
+        self.error_handler = error_handler
+
+    def __call__(self, client: MPTClient, context: Context):
+        if not self.queue:
+            return
+        current_step = self.queue[0]
+        next_step = Cursor(self.queue[1:], self.error_handler)
+
+        try:
+            current_step(client, context, next_step)
+        except Exception as error:
+            self.error_handler(error, context, next_step)
+
+
+class Pipeline:
+    def __init__(self, *steps):
+        self.queue = steps
+
+    def run(self, client: MPTClient, context: Context, error_handler=None):
+        execute = Cursor(self.queue, error_handler or _default_error_handler)
+        return execute(client, context)
+
+    def __len__(self):
+        return len(self.queue)

mpt_extension_sdk/key_vault/base.py

@@ -0,0 +1,110 @@
+import logging
+
+from azure.core.exceptions import (
+    HttpResponseError,
+    ResourceNotFoundError,
+)
+from azure.identity import DefaultAzureCredential
+from azure.keyvault.secrets import SecretClient
+from requests import Session
+
+logger = logging.getLogger(__name__)
+
+
+class KeyVault(Session):
+    def __init__(self, key_vault_name: str):
+        """
+        Initialize the KeyVault client with the provided Key Vault name.
+
+        Args:
+            key_vault_name (str): The name of the Azure Key Vault.
+        """
+        super().__init__()
+        self.key_vault_name = key_vault_name
+
+    def get_secret(self, secret_name: str):
+        """
+        Retrieve a secret from the Azure Key Vault.
+
+        Args:
+            key_vault_url (str): The URL of the Azure Key Vault.
+            secret_name (str): The name of the secret to retrieve.
+
+        Returns:
+            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 None
+
+    def set_secret(self, secret_name: str, secret_value: str):
+        """
+        Set a secret in the Azure Key Vault.
+
+        Args:
+            key_vault_url (str): The URL of the Azure Key Vault.
+            secret_name (str): The name of the secret to set.
+            secret_value (str): The value of the secret to set.
+
+        Returns:
+            None
+        """
+
+        # Set the secret in the Key Vault
+        try:
+            client = self._get_key_vault_client(self.key_vault_name)
+
+            client.set_secret(secret_name, secret_value)
+
+            updated_secret = client.get_secret(secret_name)
+
+            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
+
+    def _get_key_vault_url(self, key_vault_name: str):  # pragma: no cover
+        """
+        Construct the Key Vault URL using the provided Key Vault name.
+
+        Args:
+            key_vault_name (str): The name of the Azure Key Vault.
+
+        Returns:
+            str: The URL of the Azure Key Vault.
+        """
+
+        # Construct the Key Vault URL
+        return f"https://{key_vault_name}.vault.azure.net/"
+
+    def _get_key_vault_client(self, key_vault_name: str):  # pragma: no cover
+        """
+        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.
+
+        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

mpt_extension_sdk/mpt_http/base.py

@@ -0,0 +1,43 @@
+from urllib.parse import urljoin
+
+from requests import Session
+from requests.adapters import HTTPAdapter, Retry
+
+from mpt_extension_sdk.constants import USER_AGENT
+
+
+class MPTClient(Session):
+    def __init__(self, base_url, api_token):
+        super().__init__()
+        retries = Retry(
+            total=5,
+            backoff_factor=0.1,
+            status_forcelist=[500, 502, 503, 504],
+        )
+        self.mount(
+            "http://",
+            HTTPAdapter(
+                max_retries=retries,
+                pool_maxsize=36,
+            ),
+        )
+        self.headers.update(
+            {
+                "User-Agent": USER_AGENT,
+                "Authorization": f"Bearer {api_token}",
+            },
+        )
+        self.base_url = f"{base_url}/" if base_url[-1] != "/" else base_url
+        self.api_token = api_token
+
+    def request(self, method, url, *args, **kwargs):
+        url = self.join_url(url)
+        return super().request(method, url, *args, **kwargs)
+
+    def prepare_request(self, request, *args, **kwargs):
+        request.url = self.join_url(request.url)
+        return super().prepare_request(request, *args, **kwargs)
+
+    def join_url(self, url):
+        url = url[1:] if url[0] == "/" else url
+        return urljoin(self.base_url, url)