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

mpt_extension_sdk/runtime/initializer.py

@@ -0,0 +1,62 @@
+import os
+
+import rich
+from rich.theme import Theme
+
+from mpt_extension_sdk.constants import (
+    DEFAULT_APP_CONFIG_GROUP,
+    DEFAULT_APP_CONFIG_NAME,
+    DJANGO_SETTINGS_MODULE,
+)
+from mpt_extension_sdk.runtime.djapp.conf import extract_product_ids
+from mpt_extension_sdk.runtime.events.utils import instrument_logging
+from mpt_extension_sdk.runtime.utils import (
+    get_extension_app_config_name,
+    get_extension_variables,
+)
+
+# TODO: Move this out of sdk
+JSON_EXT_VARIABLES = {
+    "EXT_WEBHOOKS_SECRETS",
+    "EXT_AIRTABLE_BASES",
+    "EXT_AIRTABLE_PRICING_BASES",
+    "EXT_PRODUCT_SEGMENT",
+}
+
+
+def initialize(options, group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_NAME):
+    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
+
+    root_logging_handler = "rich" if options.get("color") else "console"
+    if settings.USE_APPLICATIONINSIGHTS:
+        logging_handlers = [root_logging_handler, "opentelemetry"]
+    else:
+        logging_handlers = [root_logging_handler]
+
+    logging_level = "DEBUG" if options.get("debug") else "INFO"
+
+    app_config_name = get_extension_app_config_name(group=group, name=name)
+    app_root_module, _ = app_config_name.split(".", 1)
+    settings.DEBUG = options.get("debug", False)
+    settings.INSTALLED_APPS.append(app_config_name)
+    settings.LOGGING["root"]["handlers"] = logging_handlers
+    settings.LOGGING["loggers"]["swo.mpt"]["handlers"] = logging_handlers
+    settings.LOGGING["loggers"]["swo.mpt"]["level"] = logging_level
+    settings.LOGGING["loggers"][app_root_module] = {
+        "handlers": logging_handlers,
+        "level": logging_level,
+        "propagate": False,
+    }
+    settings.EXTENSION_CONFIG.update(get_extension_variables(JSON_EXT_VARIABLES))
+    settings.MPT_PRODUCTS_IDS = extract_product_ids(settings.MPT_PRODUCTS_IDS)
+
+    if settings.USE_APPLICATIONINSIGHTS:
+        instrument_logging()
+
+    django.setup()

mpt_extension_sdk/runtime/logging.py

@@ -0,0 +1,36 @@
+from rich.highlighter import ReprHighlighter as _ReprHighlighter
+from rich.logging import RichHandler as _RichHandler
+
+
+class ReprHighlighter(_ReprHighlighter):
+    accounts_prefixes = ("ACC", "BUY", "LCE", "MOD", "SEL", "USR", "AUSR", "UGR")
+    catalog_prefixes = (
+        "PRD",
+        "ITM",
+        "IGR",
+        "PGR",
+        "MED",
+        "DOC",
+        "TCS",
+        "TPL",
+        "WHO",
+        "PRC",
+        "LST",
+        "AUT",
+        "UNT",
+    )
+    commerce_prefixes = ("AGR", "ORD", "SUB", "REQ")
+    aux_prefixes = ("FIL", "MSG")
+    all_prefixes = (
+        *accounts_prefixes,
+        *catalog_prefixes,
+        *commerce_prefixes,
+        *aux_prefixes,
+    )
+    highlights = _ReprHighlighter.highlights + [
+        rf"(?P<mpt_id>(?:{'|'.join(all_prefixes)})(?:-\d{{4}})*)"
+    ]
+
+
+class RichHandler(_RichHandler):
+    HIGHLIGHTER_CLASS = ReprHighlighter

mpt_extension_sdk/runtime/master.py

@@ -0,0 +1,136 @@
+import logging
+import os
+import signal
+import threading
+import time
+from pathlib import Path
+
+from watchfiles import watch
+from watchfiles.filters import PythonFilter
+from watchfiles.run import start_process
+
+from mpt_extension_sdk.runtime.workers import start_event_consumer, start_gunicorn
+
+logger = logging.getLogger(__name__)
+
+
+HANDLED_SIGNALS = (signal.SIGINT, signal.SIGTERM)
+PROCESS_CHECK_INTERVAL_SECS = int(os.environ.get("PROCESS_CHECK_INTERVAL_SECS", 5))
+
+
+def _display_path(path):  # pragma: no cover
+    try:
+        return f'"{path.relative_to(Path.cwd())}"'
+    except ValueError:
+        return f'"{path}"'
+
+
+class Master:
+    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)
+        self.watcher = watch(
+            Path.cwd(),
+            watch_filter=self.watch_filter,
+            stop_event=self.stop_event,
+            yield_on_timeout=True,
+        )
+        self.monitor_thread = None
+        self.setup_signals_handler()
+
+        match self.options["component"]:
+            case "all":
+                self.proc_targets = {
+                    "event-consumer": start_event_consumer,
+                    "gunicorn": start_gunicorn,
+                }
+            case "api":
+                self.proc_targets = {
+                    "gunicorn": start_gunicorn,
+                }
+            case "consumer":
+                self.proc_targets = {"event-consumer": start_event_consumer}
+            case _:
+                self.proc_targets = {
+                    "event-consumer": start_event_consumer,
+                    "gunicorn": start_gunicorn,
+                }
+
+    def setup_signals_handler(self):
+        for sig in HANDLED_SIGNALS:
+            signal.signal(sig, self.handle_signal)
+
+    def handle_signal(self, *args, **kwargs):
+        self.stop_event.set()
+
+    def start(self):
+        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)
+        self.monitor_event.set()
+        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}")
+
+    def monitor_processes(self):  # pragma: no cover
+        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:
+                        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):
+        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."
+            )
+
+    def restart(self):
+        self.stop()
+        self.start()
+
+    def __iter__(self):  # pragma: no cover
+        return self
+
+    def __next__(self):  # pragma: no cover
+        changes = next(self.watcher)
+        if changes:
+            return list({Path(c[1]) for c in changes})
+        return None
+
+    def run(self):  # pragma: no cover
+        self.start()
+        if self.options.get("reload"):
+            for files_changed in self:
+                if files_changed:
+                    logger.warning(
+                        "Detected changes in %s. Reloading...",
+                        ", ".join(map(_display_path, files_changed)),
+                    )
+                    self.restart()
+        else:
+            self.stop_event.wait()
+        self.stop()

mpt_extension_sdk/runtime/swoext.py

@@ -0,0 +1,69 @@
+import click
+from django.utils.module_loading import import_string
+
+from mpt_extension_sdk.runtime import get_version
+from mpt_extension_sdk.runtime.utils import show_banner
+
+
+def print_version(ctx, param, value):
+    if not value or ctx.resilient_parsing:
+        return
+    click.echo(f"SoftwareOne Extension CLI, version {get_version()}")
+    ctx.exit()
+
+
+@click.group(context_settings={"help_option_names": ["-h", "--help"]})
+@click.option(
+    "--version",
+    is_flag=True,
+    expose_value=False,
+    is_eager=True,
+    callback=print_version,
+)
+@click.pass_context
+def cli(ctx):
+    """SoftwareOne Extension CLI"""
+    show_banner()
+
+
+for cmd in map(
+    import_string,
+    (
+        "mpt_extension_sdk.runtime.commands.run.run",
+        "mpt_extension_sdk.runtime.commands.django.django",
+    ),
+):
+    cli.add_command(cmd)
+
+
+def make_django_command(name, django_command=None, help=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,
+        add_help_option=False,
+        context_settings=dict(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
+
+        ctx.params["management_args"] = (django_command,) + management_args
+        ctx.forward(django)
+
+    return inner
+
+
+cli.add_command(make_django_command("shell", help="Open Django console"))
+
+
+def main():
+    cli(standalone_mode=False)
+
+
+if __name__ == "__main__":
+    main()

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/runtime/utils.py

@@ -0,0 +1,148 @@
+import json
+import os
+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
+
+from mpt_extension_sdk.constants import (
+    DEFAULT_APP_CONFIG_GROUP,
+    DEFAULT_APP_CONFIG_NAME,
+)
+
+
+def get_extension_app_config_name(
+    group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_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
+):
+    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__}",
+            apps.app_configs.values(),
+        ),
+        None,
+    )
+
+
+def get_extension(group=DEFAULT_APP_CONFIG_GROUP, name=DEFAULT_APP_CONFIG_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):
+    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))
+    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])
+        )
+        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])
+        )
+        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])
+    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])
+    half_length = max_line_length // 2
+
+    colors = gradient("#00C9CD", "#472AFF", half_length) + gradient(
+        "#472AFF", "#392D9C", half_length + 1
+    )
+    console = Console()
+
+    for line in banner_lines:
+        colored_line = Text()
+        for idx, line_char in enumerate(line):
+            line_char.stylize(colors[idx])
+            colored_line = Text.assemble(colored_line, line_char)
+        console.print(colored_line)
+
+
+def get_extension_variables(json_ext_variables):
+    variables = {}
+    for var in filter(lambda x: x[0].startswith("EXT_"), os.environ.items()):
+        if var[0] in json_ext_variables:
+            try:
+                value = json.loads(var[1])
+            except json.JSONDecodeError:
+                raise Exception(f"Variable {var[0]} not well formatted")
+        else:
+            value = var[1]
+
+        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/runtime/workers.py

@@ -0,0 +1,90 @@
+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.constants import (
+    DEFAULT_APP_CONFIG_GROUP,
+    DEFAULT_APP_CONFIG_NAME,
+)
+from mpt_extension_sdk.runtime.utils import initialize_extension
+
+
+class ExtensionWebApplication(BaseApplication):
+    def __init__(self, app, options=None):
+        self.options = options or {}
+        self.application = app
+        super().__init__()
+
+    def load_config(self):
+        config = {
+            key: value
+            for key, value in self.options.items()
+            if key in self.cfg.settings and value is not None
+        }
+        for key, value in config.items():
+            self.cfg.set(key.lower(), value)
+
+    def load(self):
+        return self.application
+
+
+def start_event_consumer(options):
+    initialize_extension(options)
+    call_command("consume_events")
+
+
+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}, thread: {thread}) {message}",
+                "style": "{",
+            },
+            "rich": {
+                "format": "%(message)s",
+            },
+        },
+        "handlers": {
+            "console": {
+                "class": "logging.StreamHandler",
+                "formatter": "verbose",
+            },
+            "rich": {
+                "class": "rich.logging.RichHandler",
+                "formatter": "rich",
+                "log_time_format": lambda x: x.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3],
+                "rich_tracebacks": True,
+            },
+        },
+        "root": {
+            "handlers": ["rich" if options.get("color") else "console"],
+            "level": "INFO",
+        },
+        "loggers": {
+            "gunicorn.access": {
+                "handlers": ["rich" if options.get("color") else "console"],
+                "level": "INFO",
+                "propagate": False,
+            },
+            "gunicorn.error": {
+                "handlers": ["rich" if options.get("color") else "console"],
+                "level": "INFO",
+                "propagate": False,
+            },
+        },
+    }
+
+    guni_options = {
+        "bind": options.get("bind", "0.0.0.0:8080"),
+        "logconfig_dict": logging_config,
+    }
+    ExtensionWebApplication(get_wsgi_application(), options=guni_options).run()

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/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)