mpt-extension-sdk 5.2.3__tar.gz → 5.3.0__tar.gz

{mpt_extension_sdk-5.2.3 → mpt_extension_sdk-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpt-extension-sdk
-Version: 5.2.3
+Version: 5.3.0
 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.3 → mpt_extension_sdk-5.3.0}/mpt_extension_sdk/mpt_http/mpt.py

@@ -382,25 +382,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,
@@ -424,3 +411,23 @@ 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-5.2.3 → mpt_extension_sdk-5.3.0}/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,9 +74,10 @@ 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,seller&order=audit.created.at"

mpt_extension_sdk-5.3.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-5.3.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-5.3.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-5.2.3 → mpt_extension_sdk-5.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mpt-extension-sdk"
-version = "5.2.3"
+version = "5.3.0"
 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"