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

mpt_extension_sdk/runtime/events/dispatcher.py

@@ -19,15 +19,18 @@ logger = logging.getLogger(__name__)
 
 
 def done_callback(futures, key, future):  # pragma: no cover
+    """Callback for when a future is done."""
     del futures[key]
     exc = future.exception()
     if not exc:
-        logger.debug(f"Future for {key} has been completed successfully")
+        logger.debug("Future for %s has been completed successfully", key)
         return
-    logger.error(f"Future for {key} has failed: {exc}")
+    logger.error("Future for %s has failed: %s", key, exc)
 
 
 class Dispatcher:
+    """Event dispatcher."""
+
     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()
@@ -38,46 +41,45 @@ class Dispatcher:
         self.client = setup_client()
 
     def start(self):
+        """Start the dispatcher."""
         self.running_event.set()
         self.processor.start()
 
     def stop(self):
+        """Stop the dispatcher."""
         self.running_event.clear()
         self.processor.join()
 
     @property
     def running(self):
+        """Return True if the dispatcher is running."""
         return self.running_event.is_set()
 
     def dispatch_event(self, event: Event):  # pragma: no cover
+        """Dispatch an event to the appropriate listener."""
         if self.registry.is_event_supported(event.type):
-            logger.info(f"event of type {event.type} with id {event.id} accepted")
+            logger.info("event of type %s with id %s accepted", event.type, event.id)
             self.queue.appendleft((event.type, event))
 
     def process_events(self):  # pragma: no cover
+        """Process events from the queue."""
         while self.running:
             skipped = []
             while len(self.queue) > 0:
                 event_type, event = self.queue.pop()
-                logger.debug(
-                    f"got event of type {event_type} ({event.id}) from queue..."
-                )
-                listener = wrap_for_trace(
-                    self.registry.get_listener(event_type), event_type
-                )
-                if (event.type, event.id) not in self.futures:
-                    future = self.executor.submit(listener, self.client, event)
-                    self.futures[(event.type, event.id)] = future
-                    future.add_done_callback(
-                        functools.partial(
-                            done_callback, self.futures, (event.type, event.id)
-                        )
-                    )
-                else:
+                logger.debug("got event of type %s (%s) from queue...", event_type, event.id)
+                listener = wrap_for_trace(self.registry.get_listener(event_type), event_type)
+                if (event.type, event.id) in self.futures:
                     logger.info(
-                        f"An event for {(event.type, event.id)} is already processing, skip it"
+                        "An event for (%s, %s) is already processing, skip it", event.type, event.id
                     )
                     skipped.append((event.type, event))
+                else:
+                    future = self.executor.submit(listener, self.client, event)
+                    self.futures[event.type, event.id] = future
+                    future.add_done_callback(
+                        functools.partial(done_callback, self.futures, (event.type, event.id))
+                    )
 
             self.queue.extendleft(skipped)
             time.sleep(0.5)

mpt_extension_sdk/runtime/events/producers.py

@@ -3,17 +3,22 @@ import threading
 import time
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
+from http import HTTPStatus
 
 import requests
 from django.conf import settings
+from django.utils.module_loading import import_string
 
 from mpt_extension_sdk.core.events.dataclasses import Event
 from mpt_extension_sdk.core.utils import setup_client
+from mpt_extension_sdk.swo_rql import RQLQuery
 
 logger = logging.getLogger(__name__)
 
 
 class EventProducer(ABC):
+    """Abstract base class for event producers."""
+
     def __init__(self, dispatcher):
         self.dispatcher = dispatcher
         self.running_event = threading.Event()
@@ -21,18 +26,22 @@ class EventProducer(ABC):
 
     @property
     def running(self):
+        """Return True if the producer is running."""
         return self.running_event.is_set()
 
     def start(self):
+        """Start the event producer."""
         self.running_event.set()
         self.producer.start()
 
     def stop(self):
+        """Stop the event producer."""
         self.running_event.clear()
         self.producer.join()
 
     @contextmanager
     def sleep(self, secs, interval=0.5):  # pragma: no cover
+        """Sleep for a given number of seconds."""
         yield
         sleeped = 0
         while sleeped < secs and self.running_event.is_set():
@@ -41,44 +50,40 @@ class EventProducer(ABC):
 
     @abstractmethod
     def produce_events(self):
-        pass
-
-    @abstractmethod
-    def produce_events_with_context(self):
-        pass
+        """Produce events."""
 
 
 class OrderEventProducer(EventProducer):
+    """Order event producer."""
+
     def __init__(self, dispatcher):
         super().__init__(dispatcher)
         self.client = setup_client()
+        self.setup_contexts = import_string(settings.MPT_SETUP_CONTEXTS_FUNC)
 
     def produce_events(self):
+        """Produce order events."""
         while self.running:
             with self.sleep(settings.MPT_ORDERS_API_POLLING_INTERVAL_SECS):
                 orders = self.get_processing_orders()
-                logger.info(f"{len(orders)} orders found for processing...")
-                for order in orders:
-                    self.dispatcher.dispatch_event(Event(order["id"], "orders", order))
+                logger.info("%d orders found for processing...", len(orders))
+                self.dispatch_events(orders)
 
-    def produce_events_with_context(self):  # pragma: no cover
-        while self.running:
-            with self.sleep(settings.MPT_ORDERS_API_POLLING_INTERVAL_SECS):
-                orders = self.get_processing_orders()
-                orders, contexts = self.filter_and_enrich(self.client, orders)
-                logger.info(f"{len(orders)} orders found for processing...")
-                for order, context in zip(orders, contexts):
-                    self.dispatcher.dispatch_event(
-                        Event(order["id"], "orders", order, context)
-                    )
+    def dispatch_events(self, orders):
+        """Dispatch events for the given orders."""
+        contexts = self.setup_contexts(self.client, orders)
+        for context in contexts:
+            self.dispatcher.dispatch_event(Event(context.order_id, "orders", context))
 
     def get_processing_orders(self):
-        products = ",".join(settings.MPT_PRODUCTS_IDS)
+        """Get processing orders."""
         orders = []
-        rql_query = f"and(in(agreement.product.id,({products})),eq(status,processing))"
+        rql_query = RQLQuery().agreement.product.id.in_(settings.MPT_PRODUCTS_IDS) & RQLQuery(
+            status="processing"
+        )
         url = (
             f"/commerce/orders?{rql_query}&select=audit,parameters,lines,subscriptions,"
-            f"subscriptions.lines,agreement,buyer,seller&order=audit.created.at"
+            f"subscriptions.lines,agreement,buyer,seller,authorization.externalIds&order=audit.created.at"
         )
         page = None
         limit = 10
@@ -89,19 +94,18 @@ class OrderEventProducer(EventProducer):
             except requests.RequestException:
                 logger.exception("Cannot retrieve orders")
                 return []
-            if response.status_code == 200:
+            if response.status_code == HTTPStatus.OK.value:
                 page = response.json()
                 orders.extend(page["data"])
             else:
-                logger.warning(
-                    f"Order API error: {response.status_code} {response.content}"
-                )
+                logger.warning("Order API error: %s %s", response.status_code, response.content)
                 return []
             offset += limit
 
         return orders
 
     def has_more_pages(self, orders):
+        """Check if there are more pages of orders."""
         if not orders:
             return True
         pagination = orders["$meta"]["pagination"]

mpt_extension_sdk/runtime/events/utils.py

@@ -32,6 +32,7 @@ def _response_hook(span, request, response):  # pragma: no cover
 
 
 def instrument_logging():  # pragma: no cover
+    """Instrument logging for OpenTelemetry."""
     exporter = AzureMonitorTraceExporter(
         connection_string=settings.APPLICATIONINSIGHTS_CONNECTION_STRING
     )
@@ -46,14 +47,14 @@ def instrument_logging():  # pragma: no cover
 
 
 def wrap_for_trace(func, event_type):  # pragma: no cover
+    """Wrap a function to add OpenTelemetry tracing."""
+
     @wraps(func)
     def opentelemetry_wrapper(client, event):
         tracer = trace.get_tracer(event_type)
         object_id = event.id
 
-        with tracer.start_as_current_span(
-            f"Event {event_type} for {object_id}"
-        ) as span:
+        with tracer.start_as_current_span(f"Event {event_type} for {object_id}") as span:
             try:
                 func(client, event)
             except Exception:
@@ -74,12 +75,12 @@ def wrap_for_trace(func, event_type):  # pragma: no cover
 
 def setup_contexts(mpt_client, orders):
     """
-    List of contexts from orders
+    List of contexts from orders.
+
     Args:
         mpt_client (MPTClient): MPT client
         orders (list): List of orders
 
     Returns: List of contexts
-
     """
     return [Context(order=order) for order in orders]

mpt_extension_sdk/runtime/initializer.py

@@ -25,13 +25,12 @@ JSON_EXT_VARIABLES = {
 
 
 def initialize(options, group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
+    """Initialize the SDK."""
     rich.reconfigure(theme=Theme({"repr.mpt_id": "bold light_salmon3"}))
-    django_settings_module = options.get(
-        "django_settings_module", DJANGO_SETTINGS_MODULE
-    )
+    django_settings_module = options.get("django_settings_module", DJANGO_SETTINGS_MODULE)
     os.environ.setdefault("DJANGO_SETTINGS_MODULE", django_settings_module)
-    import django
-    from django.conf import settings
+    import django  # noqa: PLC0415
+    from django.conf import settings  # noqa: PLC0415
 
     root_logging_handler = "rich" if options.get("color") else "console"
     if settings.USE_APPLICATIONINSIGHTS:

mpt_extension_sdk/runtime/logging.py

@@ -1,8 +1,12 @@
+from typing import ClassVar
+
 from rich.highlighter import ReprHighlighter as _ReprHighlighter
 from rich.logging import RichHandler as _RichHandler
 
 
 class ReprHighlighter(_ReprHighlighter):
+    """Highlighter for MPT IDs."""
+
     accounts_prefixes = ("ACC", "BUY", "LCE", "MOD", "SEL", "USR", "AUSR", "UGR")
     catalog_prefixes = (
         "PRD",
@@ -27,10 +31,15 @@ class ReprHighlighter(_ReprHighlighter):
         *commerce_prefixes,
         *aux_prefixes,
     )
-    highlights = _ReprHighlighter.highlights + [
-        rf"(?P<mpt_id>(?:{'|'.join(all_prefixes)})(?:-\d{{4}})*)"
+    prefixes_pattern = "|".join(all_prefixes)
+    pattern = rf"(?P<mpt_id>(?:{prefixes_pattern})(?:-\d{{4}})*)"
+    highlights: ClassVar[list[str]] = [
+        *_ReprHighlighter.highlights,
+        pattern,
     ]
 
 
 class RichHandler(_RichHandler):
+    """Rich handler for logging with color support."""
+
     HIGHLIGHTER_CLASS = ReprHighlighter

mpt_extension_sdk/runtime/master.py

@@ -15,7 +15,7 @@ logger = logging.getLogger(__name__)
 
 
 HANDLED_SIGNALS = (signal.SIGINT, signal.SIGTERM)
-PROCESS_CHECK_INTERVAL_SECS = int(os.environ.get("PROCESS_CHECK_INTERVAL_SECS", 5))
+PROCESS_CHECK_INTERVAL_SECS = int(os.environ.get("PROCESS_CHECK_INTERVAL_SECS", "5"))
 
 
 def _display_path(path):  # pragma: no cover
@@ -26,6 +26,8 @@ def _display_path(path):  # pragma: no cover
 
 
 class Master:
+    """Master process for managing worker processes."""
+
     def __init__(self, options, settings):
         self.workers = {}
         self.options = options
@@ -61,13 +63,16 @@ class Master:
                 }
 
     def setup_signals_handler(self):
+        """Setup signal handlers for termination signals."""
         for sig in HANDLED_SIGNALS:
             signal.signal(sig, self.handle_signal)
 
     def handle_signal(self, *args, **kwargs):
+        """Handle termination signals."""
         self.stop_event.set()
 
     def start(self):
+        """Start all worker processes."""
         for worker_type, target in self.proc_targets.items():
             self.start_worker_process(worker_type, target)
         self.monitor_thread = threading.Thread(target=self.monitor_processes)
@@ -75,40 +80,42 @@ class Master:
         self.monitor_thread.start()
 
     def start_worker_process(self, worker_type, target):
-        p = start_process(target, "function", (self.options,), {})
-        self.workers[worker_type] = p
-        logger.info(f"{worker_type.capitalize()} worker pid: {p.pid}")
+        """Start a worker process."""
+        worker_proc = start_process(target, "function", (self.options,), {})
+        self.workers[worker_type] = worker_proc
+        logger.info("%s worker pid: %s", worker_type.capitalize(), worker_proc.pid)
 
     def monitor_processes(self):  # pragma: no cover
+        """Monitor the status of worker processes."""
         while self.monitor_event.is_set():
             exited_workers = []
-            for worker_type, p in self.workers.items():
-                if not p.is_alive():
-                    if p.exitcode != 0:
-                        logger.info(
-                            f"Process of type {worker_type} is dead, restart it"
-                        )
-                        self.start_worker_process(
-                            worker_type, self.proc_targets[worker_type]
-                        )
-                    else:
+            for worker_type, worker_proc in self.workers.items():
+                if not worker_proc.is_alive():
+                    if worker_proc.exitcode == 0:
                         exited_workers.append(worker_type)
-                        logger.info(f"{worker_type.capitalize()} worker exited")
+                        logger.info("%s worker exited", worker_type.capitalize())
+                    else:
+                        logger.info("Process of type %s is dead, restart it", worker_type)
+                        self.start_worker_process(worker_type, self.proc_targets[worker_type])
             if exited_workers == list(self.workers.keys()):
                 self.stop_event.set()
 
             time.sleep(PROCESS_CHECK_INTERVAL_SECS)
 
     def stop(self):
+        """Stop all worker processes."""
         self.monitor_event.clear()
         self.monitor_thread.join()
         for worker_type, process in self.workers.items():
             process.stop(sigint_timeout=5, sigkill_timeout=1)
             logger.info(
-                f"{worker_type.capitalize()} process with pid {process.pid} stopped."
+                "%s process with pid %s stopped.",
+                worker_type.capitalize(),
+                process.pid,
             )
 
     def restart(self):
+        """Restart the master process."""
         self.stop()
         self.start()
 
@@ -118,10 +125,11 @@ class Master:
     def __next__(self):  # pragma: no cover
         changes = next(self.watcher)
         if changes:
-            return list({Path(c[1]) for c in changes})
+            return list({Path(change[1]) for change in changes})
         return None
 
     def run(self):  # pragma: no cover
+        """Run the master process."""
         self.start()
         if self.options.get("reload"):
             for files_changed in self:

mpt_extension_sdk/runtime/swoext.py

@@ -6,6 +6,7 @@ from mpt_extension_sdk.runtime.utils import show_banner
 
 
 def print_version(ctx, param, value):
+    """Print the version of the SoftwareOne Extension CLI."""
     if not value or ctx.resilient_parsing:
         return
     click.echo(f"SoftwareOne Extension CLI, version {get_version()}")
@@ -22,7 +23,7 @@ def print_version(ctx, param, value):
 )
 @click.pass_context
 def cli(ctx):
-    """SoftwareOne Extension CLI"""
+    """SoftwareOne Extension CLI."""
     show_banner()
 
 
@@ -36,32 +37,33 @@ for cmd in map(
     cli.add_command(cmd)
 
 
-def make_django_command(name, django_command=None, help=None):
-    "A wrapper to convert a Django subcommand a Click command"
+def make_django_command(name, django_command=None, help_value=None):
+    """A wrapper to convert a Django subcommand a Click command."""
     if django_command is None:
         django_command = name
 
     @click.command(
         name=name,
-        help=help,
+        help=help_value,
         add_help_option=False,
-        context_settings=dict(ignore_unknown_options=True),
+        context_settings={"ignore_unknown_options": True},
     )
     @click.argument("management_args", nargs=-1, type=click.UNPROCESSED)
     @click.pass_context
     def inner(ctx, management_args):
-        from mpt_extension_sdk.runtime.commands.django import django
+        from mpt_extension_sdk.runtime.commands.django import django  # noqa: PLC0415
 
-        ctx.params["management_args"] = (django_command,) + management_args
+        ctx.params["management_args"] = (django_command, *management_args)
         ctx.forward(django)
 
     return inner
 
 
-cli.add_command(make_django_command("shell", help="Open Django console"))
+cli.add_command(make_django_command("shell", help_value="Open Django console"))
 
 
 def main():
+    """Main entry point for the CLI."""
     cli(standalone_mode=False)
 
 

mpt_extension_sdk/runtime/tracer.py

@@ -6,6 +6,8 @@ tracer = trace.get_tracer(__name__)
 
 
 def dynamic_trace_span(name_fn):
+    """Dynamically create a trace span."""
+
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):

mpt_extension_sdk/runtime/utils.py

@@ -2,6 +2,7 @@ import json
 import os
 import sys
 from importlib.metadata import entry_points
+from pathlib import Path
 
 from django.apps import apps
 from django.contrib import admin
@@ -14,71 +15,72 @@ from rich.text import Text
 from mpt_extension_sdk.constants import (
     DEFAULT_APP_CONFIG_GROUP,
     DEFAULT_APP_CONFIG_NAME,
+    GRADIENT_HEX_BASE,
 )
+from mpt_extension_sdk.runtime.errors import VariableNotWellFormedError
 
 
-def get_extension_app_config_name(
-    group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME
-):
+def get_extension_app_config_name(group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
+    """Get the extension app config name for the specified group and name."""
     eps = entry_points()
     (app_config_ep,) = eps.select(group=group, name=name)
     app_config = app_config_ep.load()
     return f"{app_config.__module__}.{app_config.__name__}"
 
 
-def get_extension_app_config(
-    group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME
-):
+def get_extension_app_config(group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
+    """Get the extension app config for the specified group and name."""
     app_config_name = get_extension_app_config_name(group=group, name=name)
     return next(
         filter(
-            lambda app: app_config_name
-            == f"{app.__class__.__module__}.{app.__class__.__name__}",
+            lambda app: app_config_name == get_app_name(app),
             apps.app_configs.values(),
         ),
         None,
     )
 
 
+def get_app_name(app):
+    """Get the app name for the specified app."""
+    return f"{app.__class__.__module__}.{app.__class__.__name__}"
+
+
 def get_extension(group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
+    """Get the extension for the specified group and name."""
     return get_extension_app_config(group=group, name=name).extension
 
 
 def get_events_registry(group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
+    """Get the events registry for the extension."""
     return get_extension(group=group, name=name).events
 
 
 def gradient(start_hex, end_hex, num_samples=10):  # pragma: no cover
-    start_rgb = tuple(int(start_hex[i : i + 2], 16) for i in range(1, 6, 2))
-    end_rgb = tuple(int(end_hex[i : i + 2], 16) for i in range(1, 6, 2))
+    """Retrieve the gradient."""
+    start_rgb = tuple(int(start_hex[idx : idx + 2], GRADIENT_HEX_BASE) for idx in range(1, 6, 2))
+    end_rgb = tuple(int(end_hex[idx : idx + 2], GRADIENT_HEX_BASE) for idx in range(1, 6, 2))
     gradient_colors = [start_hex]
     for sample in range(1, num_samples):
-        red = int(
-            start_rgb[0]
-            + (float(sample) / (num_samples - 1)) * (end_rgb[0] - start_rgb[0])
-        )
+        red = int(start_rgb[0] + (float(sample) / (num_samples - 1)) * (end_rgb[0] - start_rgb[0]))
         green = int(
-            start_rgb[1]
-            + (float(sample) / (num_samples - 1)) * (end_rgb[1] - start_rgb[1])
-        )
-        blue = int(
-            start_rgb[2]
-            + (float(sample) / (num_samples - 1)) * (end_rgb[2] - start_rgb[2])
+            start_rgb[1] + (float(sample) / (num_samples - 1)) * (end_rgb[1] - start_rgb[1])
         )
+        blue = int(start_rgb[2] + (float(sample) / (num_samples - 1)) * (end_rgb[2] - start_rgb[2]))
         gradient_colors.append(f"#{red:02X}{green:02X}{blue:02X}")
 
     return gradient_colors
 
 
 def show_banner():  # pragma: no cover
-    program_name = os.path.basename(sys.argv[0])
+    """Show the banner."""
+    program_name = Path(sys.argv[0]).name
     program_name = "".join((program_name[0:3].upper(), program_name[3:]))
     figlet = Figlet("georgia11")
 
     banner_text = figlet.renderText(program_name)
 
     banner_lines = [Text(line) for line in banner_text.splitlines()]
-    max_line_length = max([len(line) for line in banner_lines])
+    max_line_length = max(len(line) for line in banner_lines)
     half_length = max_line_length // 2
 
     colors = gradient("#00C9CD", "#472AFF", half_length) + gradient(
@@ -95,28 +97,30 @@ def show_banner():  # pragma: no cover
 
 
 def get_extension_variables(json_ext_variables):
+    """Get the extension variables from the environment."""
     variables = {}
-    for var in filter(lambda x: x[0].startswith("EXT_"), os.environ.items()):
+    for var in filter(lambda ext_item: ext_item[0].startswith("EXT_"), os.environ.items()):
         if var[0] in json_ext_variables:
             try:
-                value = json.loads(var[1])
+                item_value = json.loads(var[1])
             except json.JSONDecodeError:
-                raise Exception(f"Variable {var[0]} not well formatted")
+                raise VariableNotWellFormedError(f"Variable {var[0]} not well formatted")
         else:
-            value = var[1]
+            item_value = var[1]
 
-        variables[var[0][4:]] = value
+        variables[var[0][4:]] = item_value
     return variables
 
 
 def get_api_url(extension):
+    """Get the API URL for the extension."""
     if extension:
-        api_url = extension.api.urls
-        return api_url
+        return extension.api.urls
     return None
 
 
 def get_urlpatterns(extension):
+    """Get the URL patterns for the extension."""
     urlpatterns = [
         path("admin/", admin.site.urls),
     ]
@@ -130,19 +134,14 @@ def get_urlpatterns(extension):
 
 
 def get_initializer_function():
-    """
-    Dynamically import and return the initializer function from settings.INITIALIZER.
-    """
+    """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"
-    )
+    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
-):
+def initialize_extension(options, group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
+    """Initialize the extension."""
     initialize_path = get_initializer_function()
     initialize_func = import_string(initialize_path)
     initialize_func(options, group=group, name=name)