mpt-extension-sdk 5.2.2__tar.gz → 5.2.4__tar.gz

{mpt_extension_sdk-5.2.2 → mpt_extension_sdk-5.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpt-extension-sdk
-Version: 5.2.2
+Version: 5.2.4
 Summary: Extensions SDK for SoftwareONE Marketplace Platform
 Author: SoftwareOne AG
 License: Apache-2.0 license
@@ -9,7 +9,6 @@ Requires-Python: <4,>=3.12
 Requires-Dist: azure-identity<2,>=1.21.0
 Requires-Dist: azure-keyvault-secrets<5,>=4.9.0
 Requires-Dist: azure-monitor-opentelemetry-exporter==1.0.0b25
-Requires-Dist: boto3==1.34.*
 Requires-Dist: click==8.1.*
 Requires-Dist: debugpy==1.8.*
 Requires-Dist: django-ninja==1.1.*

{mpt_extension_sdk-5.2.2 → mpt_extension_sdk-5.2.4}/mpt_extension_sdk/mpt_http/mpt.py

@@ -1,5 +1,4 @@
 import logging
-from datetime import date
 from functools import cache
 from itertools import batched
 
@@ -191,21 +190,6 @@ def get_subscriptions_by_query(
     return _paginated(mpt_client, url, limit=limit)
 
 
-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(

{mpt_extension_sdk-5.2.2 → mpt_extension_sdk-5.2.4}/mpt_extension_sdk/runtime/djapp/conf/default.py

@@ -146,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": {
@@ -154,7 +154,7 @@ LOGGING = {
             "style": "{",
         },
         "opentelemetry": {
-            "format": "(pid: {process}) {message}",
+            "format": "(pid: {process}, thread: {thread}) {message}",
             "style": "{",
         },
     },
@@ -208,6 +208,7 @@ 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")
@@ -217,3 +218,8 @@ 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-5.2.2 → mpt_extension_sdk-5.2.4}/mpt_extension_sdk/runtime/djapp/conf/urls.py

@@ -1,4 +1,3 @@
-
 from mpt_extension_sdk.constants import (
     DEFAULT_APP_CONFIG_GROUP,
     DEFAULT_APP_CONFIG_NAME,

{mpt_extension_sdk-5.2.2 → mpt_extension_sdk-5.2.4}/mpt_extension_sdk/runtime/events/producers.py

@@ -9,6 +9,7 @@ from django.conf import settings
 
 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__)
 
@@ -73,12 +74,13 @@ class OrderEventProducer(EventProducer):
                     )
 
     def get_processing_orders(self):
-        products = ",".join(settings.MPT_PRODUCTS_IDS)
         orders = []
-        rql_query = f"and(in(agreement.product.id,({products})),eq(status,processing))"
+        rql_query = RQLQuery().agreement.product.id.in_(
+            settings.MPT_PRODUCTS_IDS
+        ) and RQLQuery(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-5.2.4/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-5.2.4/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-5.2.4/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-5.2.2 → mpt_extension_sdk-5.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mpt-extension-sdk"
-version = "5.2.2"
+version = "5.2.4"
 description = "Extensions SDK for SoftwareONE Marketplace Platform"
 authors = [{ name = "SoftwareOne AG" }]
 requires-python = ">=3.12,<4"
@@ -10,7 +10,6 @@ dependencies = [
     "azure-identity>=1.21.0,<2",
     "azure-keyvault-secrets>=4.9.0,<5",
     "azure-monitor-opentelemetry-exporter==1.0.0b25",
-    "boto3==1.34.*",
     "click==8.1.*",
     "debugpy==1.8.*",
     "django==4.2.*",
@@ -38,7 +37,7 @@ dependencies = [
 ]
 
 [project.scripts]
-swoext = "mpt_extension_sdk.runtime.swoext:main"
+swosdk = "mpt_extension_sdk.runtime.swoext:main"
 
 [project.entry-points."swo.mpt.sdk"]
 app_config = "mpt_extension_sdk.runtime.djapp.apps:ExtensionConfig"