mpt-extension-sdk 4.3.4__tar.gz → 4.5.0__tar.gz

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/PKG-INFO

@@ -1,14 +1,16 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: mpt-extension-sdk
-Version: 4.3.4
+Version: 4.5.0
 Summary: Extensions SDK for SoftwareONE Marketplace Platform
 License: Apache-2.0
+License-File: LICENSE
 Author: SoftwareOne AG
 Requires-Python: >=3.12,<4
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: azure-identity (>=1.21.0,<2.0.0)
 Requires-Dist: azure-keyvault-secrets (>=4.9.0,<5.0.0)
 Requires-Dist: azure-monitor-opentelemetry-exporter (==1.0.0b25)

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/constants.py

@@ -2,6 +2,10 @@ 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.sdk"
+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-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/mpt_http/mpt.py

@@ -1,6 +1,5 @@
 import logging
-from datetime import date
-from enum import Enum
+from collections.abc import Iterable
 from functools import cache
 from itertools import batched
 
@@ -11,8 +10,6 @@ from mpt_extension_sdk.mpt_http.wrap_http_error import wrap_mpt_http_error
 
 logger = logging.getLogger(__name__)
 
-NotifyCategories = Enum("NotifyCategories", settings.MPT_NOTIFY_CATEGORIES)
-
 
 def _has_more_pages(page):
     if not page:
@@ -104,6 +101,74 @@ def set_processing_template(mpt_client, order_id, template):
     return response.json()
 
 
+@wrap_mpt_http_error
+def create_asset(mpt_client, asset):
+    """Create a new asset."""
+    response = mpt_client.post("/commerce/assets", json=asset)
+    response.raise_for_status()
+    return response.json()
+
+
+@wrap_mpt_http_error
+def create_order_asset(mpt_client, order_id, asset):
+    """Create a new asset for an order."""
+    response = mpt_client.post(f"/commerce/orders/{order_id}/assets", json=asset)
+    response.raise_for_status()
+    return response.json()
+
+
+@wrap_mpt_http_error
+def update_asset(mpt_client, asset_id, **kwargs):
+    """Update an asset."""
+    response = mpt_client.put(f"/commerce/assets/{asset_id}", json=kwargs)
+    response.raise_for_status()
+    return response.json()
+
+
+@wrap_mpt_http_error
+def update_order_asset(mpt_client, order_id, asset_id, **kwargs):
+    """Update an order asset."""
+    response = mpt_client.put(f"/commerce/orders/{order_id}/assets/{asset_id}", json=kwargs)
+    response.raise_for_status()
+    return response.json()
+
+
+@wrap_mpt_http_error
+def get_agreement_asset_by_external_id(mpt_client, agreement_id, asset_external_id):
+    """Retrieve an agreement asset by external ID."""
+    response = mpt_client.get(
+        f"/commerce/assets?eq(externalIds.vendor,{asset_external_id})"
+        f"&eq(agreement.id,{agreement_id})"
+        f"&eq(status,Active)"
+        f"&select=agreement.id&limit=1"
+    )
+    response.raise_for_status()
+    assets = response.json()
+    return assets["data"][0] if assets["data"] else None
+
+
+@wrap_mpt_http_error
+def get_asset_by_id(mpt_client, asset_id):
+    """Get an asset by ID."""
+    response = mpt_client.get(f"/commerce/assets/{asset_id}")
+    response.raise_for_status()
+    return response.json()
+
+
+@wrap_mpt_http_error
+def get_order_asset_by_external_id(mpt_client, order_id, asset_external_id):
+    """Retrieve an order asset by its external ID."""
+    response = mpt_client.get(
+        f"/commerce/orders/{order_id}/assets?eq(externalIds.vendor,{asset_external_id})&limit=1",
+    )
+    response.raise_for_status()
+    assets = response.json()
+    if assets["$meta"]["pagination"]["total"] == 1:
+        return assets["data"][0]
+
+    return None
+
+
 @wrap_mpt_http_error
 def create_subscription(mpt_client, order_id, subscription):
     response = mpt_client.post(
@@ -125,9 +190,8 @@ def update_subscription(mpt_client, order_id, subscription_id, **kwargs):
 
 
 @wrap_mpt_http_error
-def get_order_subscription_by_external_id(
-    mpt_client, order_id, subscription_external_id
-):
+def get_order_subscription_by_external_id(mpt_client, order_id, subscription_external_id):
+    """Retrieve an order subscription by its external ID."""
     response = mpt_client.get(
         f"/commerce/orders/{order_id}/subscriptions?eq(externalIds.vendor,{subscription_external_id})&limit=1",
     )
@@ -139,9 +203,9 @@ def get_order_subscription_by_external_id(
 
 @wrap_mpt_http_error
 def get_product_items_by_skus(mpt_client, product_id, skus):
-    rql_query = (
-        f"and(eq(product.id,{product_id}),in(externalIds.vendor,({','.join(skus)})))"
-    )
+    """Retrieve product items by their SKUs."""
+    skus_str = ",".join(skus)
+    rql_query = f"and(eq(product.id,{product_id}),in(externalIds.vendor,({skus_str})))"
     url = f"/catalog/items?{rql_query}"
     return _paginated(mpt_client, url)
 
@@ -168,6 +232,14 @@ def get_product_template_or_default(mpt_client, product_id, status, name=None):
     return templates["data"][0]
 
 
+def get_template_by_name(mpt_client, product_id, template_name):
+    url = f"/catalog/products/{product_id}/templates?eq(name,{template_name})"
+    response = mpt_client.get(url)
+    response.raise_for_status()
+    templates = response.json()
+    return templates["data"][0]
+
+
 @wrap_mpt_http_error
 def update_agreement(mpt_client, agreement_id, **kwargs):
     response = mpt_client.put(
@@ -184,21 +256,6 @@ def get_agreements_by_query(mpt_client, query):
     return _paginated(mpt_client, url)
 
 
-def get_agreements_by_next_sync(mpt_client, next_sync_parameter):
-    today = date.today().isoformat()
-    param_condition = (
-        f"any(parameters.fulfillment,and(eq(externalId,{next_sync_parameter})"
-        f",lt(displayValue,{today})))"
-    )
-    status_condition = "eq(status,Active)"
-
-    rql_query = (
-        f"and({status_condition},{param_condition})"
-        "&select=lines,parameters,subscriptions,product,listing"
-    )
-    return get_agreements_by_query(mpt_client, rql_query)
-
-
 @wrap_mpt_http_error
 def update_agreement_subscription(mpt_client, subscription_id, **kwargs):
     response = mpt_client.put(
@@ -237,29 +294,64 @@ def get_product_onetime_items_by_ids(mpt_client, product_id, item_ids):
     return _paginated(mpt_client, url)
 
 
+@wrap_mpt_http_error
+def get_product_items_by_period(
+    mpt_client,
+    product_id: str,
+    period: str,
+    vendor_external_ids: Iterable[str] | None = None,
+):
+    """
+    Fetches product items based on a specified period and filters.
+
+    Args:
+        mpt_client: Client in tance to interact with the required API.
+        product_id (str): The unique identifier of the product to fetch items for.
+        period (str): The period for which to fetch the product items.
+        vendor_external_ids (Iterable[str] | None):
+            Optional. A list of vendor external IDs to filter out the product items by. Defaults
+            to None.
+
+    Returns:
+        list:
+            A paginated list of product items matching the specified criteria.
+
+    """
+    product_cond = f"eq(product.id,{product_id})"
+    vendors_cond = ""
+    if vendor_external_ids:
+        vendor_ids = ",".join(vendor_external_ids)
+        vendors_cond = f",in(externalIds.vendor,({vendor_ids})))"
+    rql_query = f"and({product_cond},eq(terms.period,{period}){vendors_cond})"
+    url = f"/catalog/items?{rql_query}"
+
+    return _paginated(mpt_client, url)
+
+
 def get_agreements_by_ids(mpt_client, ids):
+    """Retrieve agreements by their IDs."""
+    ids_str = ",".join(ids)
     rql_query = (
-        f"and(in(id,({','.join(ids)})),eq(status,Active))"
-        "&select=lines,parameters,subscriptions,product,listing"
+        f"and(in(id,({ids_str})),eq(status,Active))"
+        "&select=assets,lines,parameters,subscriptions,product,listing"
     )
     return get_agreements_by_query(mpt_client, rql_query)
 
 
-def get_all_agreements(
-    mpt_client,
-):
-    product_condition = f"in(product.id,({','.join(settings.MPT_PRODUCTS_IDS)}))"
+def get_all_agreements(mpt_client):
+    """Retrieve all active agreements for specific products."""
+    product_ids_str = ",".join(settings.MPT_PRODUCTS_IDS)
+    product_condition = f"in(product.id,({product_ids_str}))"
 
     return get_agreements_by_query(
         mpt_client,
-        f"and(eq(status,Active),{product_condition})&select=lines,parameters,subscriptions,product,listing",
+        f"and(eq(status,Active),{product_condition})&select=assets,lines,parameters,subscriptions,product,listing",
     )
 
 
 @wrap_mpt_http_error
-def get_authorizations_by_currency_and_seller_id(
-    mpt_client, product_id, currency, owner_id
-):
+def get_authorizations_by_currency_and_seller_id(mpt_client, product_id, currency, owner_id):
+    """Retrieve authorizations by product ID, currency, and owner ID."""
     authorization_filter = (
         f"eq(product.id,{product_id})&eq(currency,{currency})&eq(owner.id,{owner_id})"
     )
@@ -328,9 +420,8 @@ def get_listing_by_id(mpt_client, listing_id):
 
 
 @wrap_mpt_http_error
-def get_agreement_subscription_by_external_id(
-    mpt_client, agreement_id, subscription_external_id
-):
+def get_agreement_subscription_by_external_id(mpt_client, agreement_id, subscription_external_id):
+    """Retrieve an agreement subscription by external ID."""
     response = mpt_client.get(
         f"/commerce/subscriptions?eq(externalIds.vendor,{subscription_external_id})"
         f"&eq(agreement.id,{agreement_id})"
@@ -359,15 +450,14 @@ def get_agreements_by_external_id_values(mpt_client, external_id, display_values
 
 
 @wrap_mpt_http_error
-def get_agreements_by_customer_deployments(
-    mpt_client, deployment_id_parameter, deployment_ids
-):
+def get_agreements_by_customer_deployments(mpt_client, deployment_id_parameter, deployment_ids):
+    """Retrieve agreements by customer deployments."""
     deployments_list = ",".join(deployment_ids)
     rql_query = (
         f"any(parameters.fulfillment,and("
         f"eq(externalId,{deployment_id_parameter}),"
         f"in(displayValue,({deployments_list}))))"
-        f"&select=lines,parameters,subscriptions,product,listing"
+        f"&select=lines,parameters,subscriptions,subscriptions.parameters,product,listing"
     )
 
     url = f"/commerce/agreements?{rql_query}"
@@ -391,25 +481,12 @@ def notify(
     subject: str,
     message_body: str,
     limit: int = 1000,
-):
+) -> None:
     """
     Sends notifications to multiple recipients in batches for a specific buyer and
     category through the MPTClient service. The function retrieves recipients,
     groups them into manageable batches, and sends notifications using the provided
     message details.
-
-    Args:
-        mpt_client (MPTClient): Client object for interacting with MPT service.
-        category_id (str): Identifier for the category of recipients or messages.
-        account_id (str): Identifier for the associated account.
-        buyer_id (str): Identifier for the buyer related to the notification.
-        subject (str): Subject/title of the notification to be sent.
-        message_body (str): Content/body of the notification message.
-        limit (int): Maximum number of recipients to process per batch. Defaults
-            to 1000.
-
-    Returns:
-        None
     """
     recipients = _paginated(
         mpt_client,
@@ -433,3 +510,21 @@ def notify(
             },
         )
         response.raise_for_status()
+
+
+@wrap_mpt_http_error
+def terminate_subscription(mpt_client: MPTClient, subscription_id: str, reason: str) -> dict:
+    """
+    Terminates a subscription by calling the MPT API.
+
+    Raises:
+        HTTPError: If the HTTP request fails, an HTTPError is raised with
+            information about the issue.
+    """
+    response = mpt_client.post(
+        f"/commerce/subscriptions/{subscription_id}/terminate",
+        json={"description": reason},
+    )
+    response.raise_for_status()
+
+    return response.json()

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/commands/django.py

@@ -1,21 +1,34 @@
 from contextlib import nullcontext
 
 import click
+from django.core.management import execute_from_command_line
 from opentelemetry import trace
 
+from mpt_extension_sdk.constants import (
+    DEFAULT_APP_CONFIG_GROUP,
+    DEFAULT_APP_CONFIG_NAME,
+    DJANGO_SETTINGS_MODULE,
+)
+from mpt_extension_sdk.runtime.utils import initialize_extension
+
 
 @click.command(
     add_help_option=False, context_settings=dict(ignore_unknown_options=True)
 )
 @click.argument("management_args", nargs=-1, type=click.UNPROCESSED)
 @click.pass_context
-def django(ctx, management_args):
+def django(ctx, management_args):  # pragma: no cover
     "Execute Django subcommands."
-    from mpt_extension_sdk.runtime.initializer import initialize
 
-    initialize({})
     from django.conf import settings
-    from django.core.management import execute_from_command_line
+
+    options = {
+        "group": DEFAULT_APP_CONFIG_GROUP,
+        "name": DEFAULT_APP_CONFIG_NAME,
+        "django_settings_module": DJANGO_SETTINGS_MODULE,
+    }
+
+    initialize_extension(options=options)
 
     if settings.USE_APPLICATIONINSIGHTS:
         tracer = trace.get_tracer(__name__)

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/commands/run.py

@@ -1,4 +1,6 @@
 import click
+import debugpy
+from django.conf import settings
 
 from mpt_extension_sdk.runtime.master import Master
 
@@ -25,17 +27,18 @@ def run(component, color, debug, reload, debug_py):
     """
 
     if debug_py:
-        import debugpy
-
         host, port = debug_py.split(":")
-        debugpy.listen((host, int(port)))
+        debugpy.listen((host, int(port)))  # pragma: no cover
+
+    options = {
+        "color": color,
+        "debug": debug,
+        "reload": reload,
+        "component": component,
+    }
 
     master = Master(
-        {
-            "color": color,
-            "debug": debug,
-            "reload": reload,
-            "component": component,
-        },
+        options,
+        settings=settings,
     )
-    master.run()
+    master.run()  # pragma: no cover

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/djapp/conf/default.py

@@ -10,7 +10,6 @@ For the full list of settings and their values, see
 https://docs.djangoproject.com/en/4.2/ref/settings/
 """
 
-import json
 import os
 from pathlib import Path
 
@@ -26,6 +25,12 @@ BASE_DIR = Path(__file__).resolve().parent.parent
 # Quick-start development settings - unsuitable for production
 # See https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/
 
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = os.getenv(
+    "MPT_DJANGO_SECRET_KEY",
+    "",
+)
+
 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG = True
 
@@ -128,7 +133,7 @@ APPLICATIONINSIGHTS_CONNECTION_STRING = os.getenv(
 USE_APPLICATIONINSIGHTS = APPLICATIONINSIGHTS_CONNECTION_STRING != ""
 
 
-if USE_APPLICATIONINSIGHTS:
+if USE_APPLICATIONINSIGHTS:  # pragma: no cover
     logger_provider = LoggerProvider()
     set_logger_provider(logger_provider)
     exporter = AzureMonitorLogExporter(
@@ -141,7 +146,7 @@ LOGGING = {
     "disable_existing_loggers": False,
     "formatters": {
         "verbose": {
-            "format": "{asctime} {name} {levelname} (pid: {process}) {message}",
+            "format": "{asctime} {name} {levelname} (pid: {process}, thread: {thread}) {message}",
             "style": "{",
         },
         "rich": {
@@ -149,7 +154,7 @@ LOGGING = {
             "style": "{",
         },
         "opentelemetry": {
-            "format": "(pid: {process}) {message}",
+            "format": "(pid: {process}, thread: {thread}) {message}",
             "style": "{",
         },
     },
@@ -203,16 +208,18 @@ MPT_API_TOKEN = os.getenv("MPT_API_TOKEN", "change-me!")
 MPT_API_TOKEN_OPERATIONS = os.getenv("MPT_API_TOKEN_OPERATIONS", "change-me!")
 MPT_PRODUCTS_IDS = os.getenv("MPT_PRODUCTS_IDS", "PRD-1111-1111")
 MPT_PORTAL_BASE_URL = os.getenv("MPT_PORTAL_BASE_URL", "https://portal.s1.show")
+MPT_KEY_VAULT_NAME = os.getenv("MPT_KEY_VAULT_NAME", "mpt-key-vault")
 
 MPT_ORDERS_API_POLLING_INTERVAL_SECS = int(
     os.getenv("MPT_ORDERS_API_POLLING_INTERVAL_SECS", "120")
 )
 
-# TODO: Should be synced with the initializer.py::initialize function
-MPT_NOTIFY_CATEGORIES = json.loads(
-    os.getenv("MPT_NOTIFY_CATEGORIES", '{"ORDERS": "NTC-0000-0006"}')
-)
-
 EXTENSION_CONFIG = {
     "DUE_DATE_DAYS": "30",
+    "ORDER_CREATION_WINDOW_HOURS": os.getenv("EXT_ORDER_CREATION_WINDOW_HOURS", "24"),
 }
+
+MPT_SETUP_CONTEXTS_FUNC = os.getenv(
+    "MPT_SETUP_CONTEXTS_FUNC",
+    "mpt_extension_sdk.runtime.events.utils.setup_contexts",
+)

mpt_extension_sdk-4.5.0/mpt_extension_sdk/runtime/djapp/conf/urls.py

@@ -0,0 +1,9 @@
+from mpt_extension_sdk.constants import (
+    DEFAULT_APP_CONFIG_GROUP,
+    DEFAULT_APP_CONFIG_NAME,
+)
+from mpt_extension_sdk.runtime.utils import get_extension, get_urlpatterns
+
+extension = get_extension(name=DEFAULT_APP_CONFIG_NAME, group=DEFAULT_APP_CONFIG_GROUP)
+
+urlpatterns = get_urlpatterns(extension)

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/djapp/management/commands/consume_events.py

@@ -1,11 +1,13 @@
-import signal
-from threading import Event
+import signal  # pragma: no cover
+from threading import Event  # pragma: no cover
 
-from django.core.management.base import BaseCommand
+from django.core.management.base import BaseCommand  # pragma: no cover
 
-from mpt_extension_sdk.constants import CONSUME_EVENTS_HELP_TEXT
-from mpt_extension_sdk.runtime.events.dispatcher import Dispatcher
-from mpt_extension_sdk.runtime.events.producers import OrderEventProducer
+from mpt_extension_sdk.constants import CONSUME_EVENTS_HELP_TEXT  # pragma: no cover
+from mpt_extension_sdk.runtime.events.dispatcher import Dispatcher  # pragma: no cover
+from mpt_extension_sdk.runtime.events.producers import (
+    OrderEventProducer,  # pragma: no cover
+)
 
 
 class Command(BaseCommand):  # pragma: no cover

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/events/dispatcher.py

@@ -5,6 +5,10 @@ import time
 from collections import deque
 from concurrent.futures import ThreadPoolExecutor
 
+from mpt_extension_sdk.constants import (
+    DEFAULT_APP_CONFIG_GROUP,
+    DEFAULT_APP_CONFIG_NAME,
+)
 from mpt_extension_sdk.core.events.dataclasses import Event
 from mpt_extension_sdk.core.events.registry import EventsRegistry
 from mpt_extension_sdk.core.utils import setup_client
@@ -24,8 +28,8 @@ def done_callback(futures, key, future):  # pragma: no cover
 
 
 class Dispatcher:
-    def __init__(self):
-        self.registry: EventsRegistry = get_events_registry()
+    def __init__(self, group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
+        self.registry: EventsRegistry = get_events_registry(group=group, name=name)
         self.queue = deque()
         self.futures = {}
         self.executor = ThreadPoolExecutor()
@@ -45,7 +49,7 @@ class Dispatcher:
     def running(self):
         return self.running_event.is_set()
 
-    def dispatch_event(self, event: Event):
+    def dispatch_event(self, event: Event):  # pragma: no cover
         if self.registry.is_event_supported(event.type):
             logger.info(f"event of type {event.type} with id {event.id} accepted")
             self.queue.appendleft((event.type, event))

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/events/producers.py

@@ -78,7 +78,7 @@ class OrderEventProducer(EventProducer):
         rql_query = f"and(in(agreement.product.id,({products})),eq(status,processing))"
         url = (
             f"/commerce/orders?{rql_query}&select=audit,parameters,lines,subscriptions,"
-            f"subscriptions.lines,agreement,buyer&order=audit.created.at"
+            f"subscriptions.lines,agreement,buyer,seller&order=audit.created.at"
         )
         page = None
         limit = 10

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/initializer.py

@@ -24,10 +24,8 @@ JSON_EXT_VARIABLES = {
 }
 
 
-def initialize(options):
+def initialize(options, group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
     rich.reconfigure(theme=Theme({"repr.mpt_id": "bold light_salmon3"}))
-    group = options.get("app_config_group", DEFAULT_APP_CONFIG_GROUP)
-    name = options.get("app_config_name", DEFAULT_APP_CONFIG_NAME)
     django_settings_module = options.get(
         "django_settings_module", DJANGO_SETTINGS_MODULE
     )

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/master.py

@@ -1,4 +1,5 @@
 import logging
+import os
 import signal
 import threading
 import time
@@ -14,20 +15,21 @@ logger = logging.getLogger(__name__)
 
 
 HANDLED_SIGNALS = (signal.SIGINT, signal.SIGTERM)
-PROCESS_CHECK_INTERVAL_SECS = 5
+PROCESS_CHECK_INTERVAL_SECS = int(os.environ.get("PROCESS_CHECK_INTERVAL_SECS", 5))
 
 
-def _display_path(path):
+def _display_path(path):  # pragma: no cover
     try:
         return f'"{path.relative_to(Path.cwd())}"'
-    except ValueError:  # pragma: no cover
+    except ValueError:
         return f'"{path}"'
 
 
 class Master:
-    def __init__(self, options):
+    def __init__(self, options, settings):
         self.workers = {}
         self.options = options
+        self.settings = settings
         self.stop_event = threading.Event()
         self.monitor_event = threading.Event()
         self.watch_filter = PythonFilter(ignore_paths=None)
@@ -51,9 +53,7 @@ class Master:
                     "gunicorn": start_gunicorn,
                 }
             case "consumer":
-                self.proc_targets = {
-                    "event-consumer": start_event_consumer,
-                }
+                self.proc_targets = {"event-consumer": start_event_consumer}
             case _:
                 self.proc_targets = {
                     "event-consumer": start_event_consumer,

mpt_extension_sdk-4.5.0/mpt_extension_sdk/runtime/tracer.py

@@ -0,0 +1,18 @@
+from functools import wraps
+
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+
+def dynamic_trace_span(name_fn):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            span_name = name_fn(*args, **kwargs)
+            with tracer.start_as_current_span(span_name):
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/utils.py

@@ -4,6 +4,9 @@ import sys
 from importlib.metadata import entry_points
 
 from django.apps import apps
+from django.contrib import admin
+from django.urls import path
+from django.utils.module_loading import import_string
 from pyfiglet import Figlet
 from rich.console import Console
 from rich.text import Text
@@ -85,10 +88,9 @@ def show_banner():  # pragma: no cover
 
     for line in banner_lines:
         colored_line = Text()
-        for i in range(len(line)):
-            char = line[i : i + 1]
-            char.stylize(colors[i])
-            colored_line = Text.assemble(colored_line, char)
+        for idx, line_char in enumerate(line):
+            line_char.stylize(colors[idx])
+            colored_line = Text.assemble(colored_line, line_char)
         console.print(colored_line)
 
 
@@ -105,3 +107,42 @@ def get_extension_variables(json_ext_variables):
 
         variables[var[0][4:]] = value
     return variables
+
+
+def get_api_url(extension):
+    if extension:
+        api_url = extension.api.urls
+        return api_url
+    return None
+
+
+def get_urlpatterns(extension):
+    urlpatterns = [
+        path("admin/", admin.site.urls),
+    ]
+
+    api_url = get_api_url(extension)
+
+    if api_url:
+        urlpatterns.append(path("api/", api_url))
+
+    return urlpatterns
+
+
+def get_initializer_function():
+    """
+    Dynamically import and return the initializer function from settings.INITIALIZER.
+    """
+    # Read from environment variable instead of Django settings to avoid circular dependency
+    # (Django settings need to be configured before we can read settings.INITIALIZER)
+    return os.getenv(
+        "MPT_INITIALIZER", "mpt_extension_sdk.runtime.initializer.initialize"
+    )
+
+
+def initialize_extension(
+    options, group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME
+):
+    initialize_path = get_initializer_function()
+    initialize_func = import_string(initialize_path)
+    initialize_func(options, group=group, name=name)

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/mpt_extension_sdk/runtime/workers.py

@@ -2,7 +2,11 @@ from django.core.management import call_command
 from django.core.wsgi import get_wsgi_application
 from gunicorn.app.base import BaseApplication
 
-from mpt_extension_sdk.runtime.initializer import initialize
+from mpt_extension_sdk.constants import (
+    DEFAULT_APP_CONFIG_GROUP,
+    DEFAULT_APP_CONFIG_NAME,
+)
+from mpt_extension_sdk.runtime.utils import initialize_extension
 
 
 class ExtensionWebApplication(BaseApplication):
@@ -25,19 +29,24 @@ class ExtensionWebApplication(BaseApplication):
 
 
 def start_event_consumer(options):
-    initialize(options)
+    initialize_extension(options)
     call_command("consume_events")
 
 
-def start_gunicorn(options):
-    initialize(options)
+def start_gunicorn(
+    options,
+    group=DEFAULT_APP_CONFIG_GROUP,
+    name=DEFAULT_APP_CONFIG_NAME,
+):
+    initialize_extension(options, group=group, name=name)
 
     logging_config = {
         "version": 1,
         "disable_existing_loggers": False,
         "formatters": {
             "verbose": {
-                "format": "{asctime} {name} {levelname} (pid: {process}) {message}",
+                "format":
+                    "{asctime} {name} {levelname} (pid: {process}, thread: {thread}) {message}",
                 "style": "{",
             },
             "rich": {

mpt_extension_sdk-4.5.0/mpt_extension_sdk/swo_rql/__init__.py

@@ -0,0 +1,5 @@
+from mpt_extension_sdk.swo_rql.query_builder import RQLQuery
+
+R = RQLQuery
+
+__all__ = ["R", "RQLQuery"]

mpt_extension_sdk-4.5.0/mpt_extension_sdk/swo_rql/constants.py

@@ -0,0 +1,7 @@
+COMP = ("eq", "ne", "lt", "le", "gt", "ge")
+SEARCH = ("like", "ilike")
+LIST = ("in", "out")
+NULL = "null"
+EMPTY = "empty"
+
+KEYWORDS = (*COMP, *SEARCH, *LIST, NULL, EMPTY)

mpt_extension_sdk-4.5.0/mpt_extension_sdk/swo_rql/query_builder.py

@@ -0,0 +1,392 @@
+from mpt_extension_sdk.swo_rql import constants
+
+
+def parse_kwargs(query_dict):
+    query = []
+    for lookup, value in query_dict.items():
+        tokens = lookup.split("__")
+        if len(tokens) == 1:
+            #  field=value
+            field = tokens[0]
+            value = rql_encode("eq", value)
+            query.append(f"eq({field},{value})")
+            continue
+        op = tokens[-1]
+        if op not in constants.KEYWORDS:
+            # field__nested=value
+            field = ".".join(tokens)
+            value = rql_encode("eq", value)
+            query.append(f"eq({field},{value})")
+            continue
+        field = ".".join(tokens[:-1])
+        if op in constants.COMP or op in constants.SEARCH:
+            value = rql_encode(op, value)
+            query.append(f"{op}({field},{value})")
+            continue
+        if op in constants.LIST:
+            value = rql_encode(op, value)
+            query.append(f"{op}({field},({value}))")
+            continue
+
+        cmpop = "eq" if value is True else "ne"
+        expr = "null()" if op == constants.NULL else "empty()"
+        query.append(f"{cmpop}({field},{expr})")
+
+    return query
+
+
+def rql_encode(op, value):
+    from datetime import date, datetime
+    from decimal import Decimal
+
+    if op not in constants.LIST:
+        if isinstance(value, str):
+            return value
+        if isinstance(value, bool):
+            return "true" if value else "false"
+        if isinstance(value, int | float | Decimal):
+            return str(value)
+        if isinstance(value, date | datetime):
+            return value.isoformat()
+    if op in constants.LIST and isinstance(value, list | tuple):
+        return ",".join(value)
+    raise TypeError(f"the `{op}` operator doesn't support the {type(value)} type.")
+
+
+class RQLQuery:
+    """
+    Helper class to construct complex RQL queries.
+
+    Usage:
+
+    ```py3
+        rql = R(field='value', field2__in=('v1', 'v2'), field3__empty=True)
+    ```
+    !!! note
+        All the lookups expressed as keyword arguments are combined together with a logical `and`.
+
+
+    Using the ``n`` method:
+
+    ```py3
+        rql = (
+            R().n('field').eq('value')
+            & R().n('field2').anyof(('v1', 'v2'))
+            & R().n('field3').empty(True)
+        )
+    ```
+
+    The previous query can be expressed in a more concise form like:
+
+    ```py3
+    rql = R().field.eq('value') & R().field2.anyof(('v1', 'v2')) & r.field3.empty(True)
+    ```
+
+    ```py3
+    rql = R("field").eq("value")
+    ```
+
+    The R object support the bitwise operators `&`, `|` and `~`.
+
+    Nested fields can be expressed using dot notation:
+
+    ```py3
+    rql = R().n('nested.field').eq('value')
+    ```
+
+    or
+
+    ```py3
+    rql = R().nested.field.eq('value')
+    ```
+    """
+
+    AND = "and"
+    OR = "or"
+    EXPRESSION = "expr"
+
+    def __init__(
+        self,
+        _field=None,
+        *,
+        _op=EXPRESSION,
+        _children=None,
+        _negated=False,
+        _expr=None,
+        **kwargs,
+    ):
+        self.op = _op
+        self.children = _children or []
+        self.negated = _negated
+        self.expr = _expr
+        self._path = []
+        self._field = None
+        if _field:
+            self.n(_field)
+        if len(kwargs) == 1:
+            self.op = self.EXPRESSION
+            self.expr = parse_kwargs(kwargs)[0]
+        if len(kwargs) > 1:
+            self.op = self.AND
+            for token in parse_kwargs(kwargs):
+                self.children.append(RQLQuery(_expr=token))
+
+    def __len__(self):
+        if self.op == self.EXPRESSION:
+            if self.expr:
+                return 1
+            return 0
+        return len(self.children)
+
+    def __bool__(self):
+        return bool(self.children) or bool(self.expr)
+
+    def __eq__(self, other):
+        return (
+            self.op == other.op
+            and self.children == other.children
+            and self.negated == other.negated
+            and self.expr == other.expr
+        )
+
+    def __hash__(self):
+        return hash(
+            (
+                self.op,
+                self.expr,
+                self.negated,
+                *(hash(value) for value in self.children),
+            ),
+        )
+
+    def __repr__(self):
+        if self.op == self.EXPRESSION:
+            return f"<R({self.op}) {self.expr}>"
+        return f"<R({self.op})>"
+
+    def __and__(self, other):
+        return self._join(other, self.AND)
+
+    def __or__(self, other):
+        return self._join(other, self.OR)
+
+    def __invert__(self):
+        query = RQLQuery(_op=self.AND, _expr=self.expr, _negated=True)
+        query._append(self)
+        return query
+
+    def __getattr__(self, name):
+        return self.n(name)
+
+    def __str__(self):
+        return self._to_string(self)
+
+    def n(self, name):
+        """
+        Set the current field for this `R` object.
+
+        Args:
+            name (str): Name of the field.
+        """
+        if self._field:
+            raise AttributeError("Already evaluated")
+
+        self._path.extend(name.split("."))
+        return self
+
+    def ne(self, value):
+        """
+        Apply the `ne` operator to the field this `R` object refers to.
+
+        Args:
+            value (str): The value to which compare the field.
+        """
+        return self._bin("ne", value)
+
+    def eq(self, value):
+        """
+        Apply the `eq` operator to the field this `R` object refers to.
+
+        Args:
+            value (str): The value to which compare the field.
+        """
+        return self._bin("eq", value)
+
+    def lt(self, value):
+        """
+        Apply the `lt` operator to the field this `R` object refers to.
+
+        Args:
+            value (str): The value to which compare the field.
+        """
+        return self._bin("lt", value)
+
+    def le(self, value):
+        """
+        Apply the `le` operator to the field this `R` object refers to.
+
+        Args:
+            value (str): The value to which compare the field.
+        """
+        return self._bin("le", value)
+
+    def gt(self, value):
+        """
+        Apply the `gt` operator to the field this `R` object refers to.
+
+        Args:
+            value (str): The value to which compare the field.
+        """
+        return self._bin("gt", value)
+
+    def ge(self, value):
+        """
+        Apply the `ge` operator to the field this `R` object refers to.
+
+        Args:
+            value (str): The value to which compare the field.
+        """
+        return self._bin("ge", value)
+
+    def out(self, value: list[str]):
+        """
+        Apply the `out` operator to the field this `R` object refers to.
+
+        Args:
+            value (list[str]): The list of values to which compare the field.
+        """
+        return self._list("out", value)
+
+    def in_(self, value):
+        return self._list("in", value)
+
+    def oneof(self, value: list[str]):
+        """
+        Apply the `in` operator to the field this `R` object refers to.
+
+        Args:
+            value (list[str]): The list of values to which compare the field.
+        """
+        return self._list("in", value)
+
+    def null(self, value: list[str]):
+        """
+        Apply the `null` operator to the field this `R` object refers to.
+
+        Args:
+            value (list[str]): The value to which compare the field.
+        """
+        return self._bool("null", value)
+
+    def empty(self, value: bool = True):
+        """
+        Apply the `empty` operator to the field this `R` object refers to.
+
+        Usage: `R().field.empty()
+
+        For not empty: `R().field.empty(False)` or `R().field.not_empty()`
+        """
+        return self._bool("empty", value)
+
+    def not_empty(self):
+        """
+        Apply the `not_empty` operator to the field this `R` object refers to.
+        """
+        query = self._bool("empty", False)
+        return query
+
+    def like(self, value: list[str]):
+        """
+        Apply the `like` operator to the field this `R` object refers to.
+
+        Args:
+            value (list[str]): The value to which compare the field.
+        """
+        return self._bin("like", value)
+
+    def ilike(self, value: list[str]):
+        """
+        Apply the `ilike` operator to the field this `R` object refers to.
+
+        Args:
+            value (list[str]): The value to which compare the field.
+        """
+        return self._bin("ilike", value)
+
+    def _bin(self, op, value):
+        self._field = ".".join(self._path)
+        value = rql_encode(op, value)
+        self.expr = f"{op}({self._field},{value})"
+        return self
+
+    def _list(self, op, value):
+        self._field = ".".join(self._path)
+        value = rql_encode(op, value)
+        self.expr = f"{op}({self._field},({value}))"
+        return self
+
+    def _bool(self, expr, value):
+        self._field = ".".join(self._path)
+        if bool(value) is False:
+            self.expr = f"ne({self._field},{expr}())"
+            return self
+        self.expr = f"eq({self._field},{expr}())"
+        return self
+
+    def _to_string(self, query):
+        tokens = []
+        if query.expr:
+            if query.negated:
+                return f"not({query.expr})"
+            return query.expr
+        for c in query.children:
+            if c.expr:
+                if c.negated:
+                    tokens.append(f"not({c.expr})")
+                else:
+                    tokens.append(c.expr)
+                continue
+            tokens.append(self._to_string(c))
+
+        if not tokens:
+            return ""
+
+        if query.negated:
+            return f'not({query.op}({",".join(tokens)}))'
+        return f'{query.op}({",".join(tokens)})'
+
+    def _copy(self, other):
+        return RQLQuery(
+            _op=other.op,
+            _children=other.children[:],
+            _expr=other.expr,
+        )
+
+    def _join(self, other, op):
+        if self == other:
+            return self._copy(self)
+        if not other:
+            return self._copy(self)
+        if not self:
+            return self._copy(other)
+
+        query = RQLQuery(_op=op)
+        query._append(self)
+        query._append(other)
+        return query
+
+    def _append(self, other):
+        if other in self.children:
+            return other
+
+        if (
+            other.op == self.op or (len(other) == 1 and other.op != self.EXPRESSION)
+        ) and not other.negated:
+            self.children.extend(other.children)
+            return self
+
+        self.children.append(other)
+        return self
+
+
+R = RQLQuery

{mpt_extension_sdk-4.3.4 → mpt_extension_sdk-4.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "mpt-extension-sdk"
-version = "4.3.4"
+version = "4.5.0"
 description = "Extensions SDK for SoftwareONE Marketplace Platform"
 authors = ["SoftwareOne AG"]
 readme = "README.md"
@@ -56,7 +56,7 @@ types-openpyxl = "3.1.*"
 types-requests = "2.31.*"
 
 [tool.poetry.scripts]
-swosdk = 'mpt_extension_sdk.runtime.swoext:main'
+swoext = 'mpt_extension_sdk.runtime.swoext:main'
 
 
 [tool.poetry.plugins."swo.mpt.sdk"]