mpt-extension-sdk 5.6.1__py3-none-any.whl → 5.8.0__py3-none-any.whl

mpt_extension_sdk/runtime/events/dispatcher.py

@@ -19,15 +19,17 @@ 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 +40,52 @@ 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..."
+                    "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) not in self.futures:
+                if (event.type, event.id) in self.futures:
+                    logger.info(
+                        "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
+                    self.futures[event.type, event.id] = future
                     future.add_done_callback(
                         functools.partial(
                             done_callback, self.futures, (event.type, event.id)
                         )
                     )
-                else:
-                    logger.info(
-                        f"An event for {(event.type, event.id)} is already processing, skip it"
-                    )
-                    skipped.append((event.type, event))
 
             self.queue.extendleft(skipped)
             time.sleep(0.5)

mpt_extension_sdk/runtime/events/producers.py

@@ -3,6 +3,7 @@ import threading
 import time
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
+from http import HTTPStatus
 
 import requests
 from django.conf import settings
@@ -15,6 +16,7 @@ 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()
@@ -22,18 +24,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():
@@ -42,38 +48,42 @@ class EventProducer(ABC):
 
     @abstractmethod
     def produce_events(self):
-        pass
+        """Produce events."""
 
     @abstractmethod
     def produce_events_with_context(self):
-        pass
+        """Produce events with context."""
 
 
 class OrderEventProducer(EventProducer):
+    """Order event producer."""
     def __init__(self, dispatcher):
         super().__init__(dispatcher)
         self.client = setup_client()
 
     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...")
+                logger.info("%d orders found for processing...", len(orders))
                 for order in orders:
                     self.dispatcher.dispatch_event(Event(order["id"], "orders", order))
 
     def produce_events_with_context(self):  # pragma: no cover
+        """Produce order events with context."""
         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...")
+                logger.info("%d orders found for processing...", len(orders))
                 for order, context in zip(orders, contexts, strict=False):
                     self.dispatcher.dispatch_event(
                         Event(order["id"], "orders", order, context)
                     )
 
     def get_processing_orders(self):
+        """Get processing orders."""
         orders = []
         rql_query = RQLQuery().agreement.product.id.in_(
             settings.MPT_PRODUCTS_IDS
@@ -91,12 +101,12 @@ 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}"
+                    "Order API error: %s %s", response.status_code, response.content
                 )
                 return []
             offset += limit
@@ -104,6 +114,7 @@ class OrderEventProducer(EventProducer):
         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,6 +47,7 @@ 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)
@@ -74,12 +76,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,14 @@ 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
     )
     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,11 @@
+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 +30,14 @@ 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,7 @@ 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 +62,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 +79,46 @@ 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:
+            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("%s worker exited", worker_type.capitalize())
+                    else:
                         logger.info(
-                            f"Process of type {worker_type} is dead, restart it"
+                            "Process of type %s is dead, restart it", worker_type
                         )
                         self.start_worker_process(
                             worker_type, self.proc_targets[worker_type]
                         )
-                    else:
-                        exited_workers.append(worker_type)
-                        logger.info(f"{worker_type.capitalize()} worker exited")
             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 +128,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={"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,7 @@ 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,12 +15,15 @@ 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
 ):
+    """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()
@@ -29,28 +33,37 @@ def get_extension_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__}",
+            == 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(
@@ -71,14 +84,15 @@ def gradient(start_hex, end_hex, num_samples=10):  # pragma: no cover
 
 
 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(
@@ -88,36 +102,38 @@ 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])
+        for idx, line_char in enumerate(line):
+            char = Text(line_char)
+            char.stylize(colors[idx])
             colored_line = Text.assemble(colored_line, char)
         console.print(colored_line)
 
 
 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),
     ]
@@ -131,9 +147,7 @@ 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(
@@ -144,6 +158,7 @@ def get_initializer_function():
 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)

mpt_extension_sdk/runtime/workers.py

@@ -10,25 +10,29 @@ from mpt_extension_sdk.runtime.utils import initialize_extension
 
 
 class ExtensionWebApplication(BaseApplication):
+    """Gunicorn application for the extension."""
     def __init__(self, app, options=None):
         self.options = options or {}
         self.application = app
         super().__init__()
 
     def load_config(self):
+        """Load configuration settings."""
         config = {
-            key: value
-            for key, value in self.options.items()
-            if key in self.cfg.settings and value is not None
+            opt_key: opt_value
+            for opt_key, opt_value in self.options.items()
+            if opt_key in self.cfg.settings and opt_value is not None
         }
-        for key, value in config.items():
-            self.cfg.set(key.lower(), value)
+        for opt_key, opt_value in config.items():
+            self.cfg.set(opt_key.lower(), opt_value)
 
     def load(self):
+        """Load the application."""
         return self.application
 
 
 def start_event_consumer(options):
+    """Start the event consumer."""
     initialize_extension(options)
     call_command("consume_events")
 
@@ -38,6 +42,7 @@ def start_gunicorn(
     group=DEFAULT_APP_CONFIG_GROUP,
     name=DEFAULT_APP_CONFIG_NAME,
 ):
+    """Start the Gunicorn server."""
     initialize_extension(options, group=group, name=name)
 
     logging_config = {
@@ -61,7 +66,7 @@ def start_gunicorn(
             "rich": {
                 "class": "rich.logging.RichHandler",
                 "formatter": "rich",
-                "log_time_format": lambda x: x.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3],
+                "log_time_format": lambda log_time: log_time.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3],
                 "rich_tracebacks": True,
             },
         },