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

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-4.5.0.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: mpt-extension-sdk
+Version: 4.5.0
+Summary: Extensions SDK for SoftwareONE Marketplace Platform
+License: Apache-2.0
+License-File: LICENSE
+Author: SoftwareOne AG
+Requires-Python: >=3.12,<4
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: azure-identity (>=1.21.0,<2.0.0)
+Requires-Dist: azure-keyvault-secrets (>=4.9.0,<5.0.0)
+Requires-Dist: azure-monitor-opentelemetry-exporter (==1.0.0b25)
+Requires-Dist: click (==8.1.*)
+Requires-Dist: debugpy (==1.8.*)
+Requires-Dist: django (==4.2.*)
+Requires-Dist: django-ninja (==1.1.*)
+Requires-Dist: gunicorn (==23.0.*)
+Requires-Dist: jinja2 (==3.1.*)
+Requires-Dist: markdown-it-py (==3.0.*)
+Requires-Dist: openpyxl (==3.1.*)
+Requires-Dist: opentelemetry-api (==1.30.*)
+Requires-Dist: opentelemetry-instrumentation-django (==0.51b0)
+Requires-Dist: opentelemetry-instrumentation-logging (==0.51b0)
+Requires-Dist: opentelemetry-instrumentation-requests (==0.51b0)
+Requires-Dist: opentelemetry-sdk (==1.30.*)
+Requires-Dist: phonenumbers (==8.13.*)
+Requires-Dist: pyairtable (==2.3.*)
+Requires-Dist: pyfiglet (==1.0.*)
+Requires-Dist: pyjwt (==2.8.*)
+Requires-Dist: pymsteams (==0.2.*)
+Requires-Dist: regex (>=2024.7.24,<2025.0.0)
+Requires-Dist: requests (==2.32.*)
+Requires-Dist: rich (==13.7.*)
+Requires-Dist: types-openpyxl (==3.1.*)
+Requires-Dist: typing-extensions (==4.14.*)
+Requires-Dist: watchfiles (==0.21.*)
+Description-Content-Type: text/markdown
+
+# swo-extension-sdk
+SDK for SoftwareONE python extensions
+

mpt_extension_sdk-4.5.0.dist-info/RECORD

@@ -0,0 +1,53 @@
+mpt_extension_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/airtable/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/airtable/wrap_http_error.py,sha256=Shiy4uwpdpgkevooLjhpe1grhgJRj7cV6lUMMCQKogc,1263
+mpt_extension_sdk/constants.py,sha256=rlO7WRImnzrb41zlkjka25CQQtEYid-0iGaupg_pk_k,485
+mpt_extension_sdk/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/core/events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/core/events/dataclasses.py,sha256=wBxjEmjzIwpSH4trpCQKYQPNzONBAgr8eQzTr3ulzkA,469
+mpt_extension_sdk/core/events/registry.py,sha256=RbiAem_FZk4W137xTILm0hRav46pII1dgXxVriBDxOo,1268
+mpt_extension_sdk/core/extension.py,sha256=s0QE2s99RMywfKQRZrYqOdWxELQvlFFVZMwm0xo2hhw,266
+mpt_extension_sdk/core/security.py,sha256=0eCed1cmaNK1rCpgnsN9zw6wzr4m_Qb9aKxscO0uyYk,1419
+mpt_extension_sdk/core/utils.py,sha256=LsvciwlVBJCBbd7L1rIWrTo_8Fi-W_SkL6IEezKUb4s,362
+mpt_extension_sdk/flows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/flows/context.py,sha256=J_U9nTtY89mUvrcOqdgpk-21F8f6YENSmjxgpVK6XWs,964
+mpt_extension_sdk/flows/pipeline.py,sha256=3BO5X3jvuYnRTWrXRzImjVCVOCut8dSvkT2LZwfpaZk,1374
+mpt_extension_sdk/key_vault/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/key_vault/base.py,sha256=RVG_Wiq-MrPyngJ4gfUd8oxoh1LUop1SvtCM2xdlx8M,3361
+mpt_extension_sdk/mpt_http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/mpt_http/base.py,sha256=3qgo9BW-uTRAbex26urMvLZU0fwnYnBprDRIJCHvTOk,1284
+mpt_extension_sdk/mpt_http/mpt.py,sha256=4o1nVuQF_KfHD9svmb0B9yPjyVC-L_Jg8et8qL5AXpE,16040
+mpt_extension_sdk/mpt_http/utils.py,sha256=3wJTT84CXYGjZw6FksNDX8tIHijkL3Wcmld9r6Iz0xc,95
+mpt_extension_sdk/mpt_http/wrap_http_error.py,sha256=j8K6Ddx7NiM-FPRMQi25vuULAW8LXxzZ4EwuIJufxis,1801
+mpt_extension_sdk/runtime/__init__.py,sha256=PQSAz9qvXHbxrn4KvuXSHB8y-A4Jpgbm6ZV-wPiNPyw,194
+mpt_extension_sdk/runtime/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/runtime/commands/django.py,sha256=j0UC9WKhaTi-sxwV4F-ZF3SE-657-Ucu_jEG0mIzJU4,1229
+mpt_extension_sdk/runtime/commands/run.py,sha256=j-2eI4JJj4VNgVmES5tqKe1Pe2aKWgYchhpvT8Koq7Q,1146
+mpt_extension_sdk/runtime/djapp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/runtime/djapp/apps.py,sha256=YA1G5HaRqFBS-0DfYQuFpMgzUCYpu5T8x5LEC6MwI_M,1398
+mpt_extension_sdk/runtime/djapp/conf/__init__.py,sha256=_sHo76rGeXSTH8bW3pacyGFfNYSln8oLRwOSstYOmco,350
+mpt_extension_sdk/runtime/djapp/conf/default.py,sha256=9eAB_hRnkok2I7E1NjYHs3x8ifrVc4_ihosm37Qq7Zo,6405
+mpt_extension_sdk/runtime/djapp/conf/urls.py,sha256=g-h1vzwDgCGLliSE2BDjb1eRJevZxZ7ehJrqSis12So,309
+mpt_extension_sdk/runtime/djapp/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/runtime/djapp/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/runtime/djapp/management/commands/consume_events.py,sha256=BVb4sgKI2Ep759bDcOH5Qm1xJEewc5-bNt_snspV2ck,1229
+mpt_extension_sdk/runtime/djapp/middleware.py,sha256=oAA5khXW6xeUjnOV63pNCF4D7QFVD6PayIa_489KRmg,555
+mpt_extension_sdk/runtime/events/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mpt_extension_sdk/runtime/events/dispatcher.py,sha256=ZMswk50vGGfUgKeQ2Cc3k9wtrm63z0OH7EtlKCkWQYM,3008
+mpt_extension_sdk/runtime/events/producers.py,sha256=lsHFfBxL5czZEAqZEyaIDZ-l8Q1T5_OhH5BGiXqw4Bk,3597
+mpt_extension_sdk/runtime/events/utils.py,sha256=bxFo-iQUqEJDqcIotC88Ty3Xt0K2FyYjA9UMWFEyMKI,2663
+mpt_extension_sdk/runtime/initializer.py,sha256=V8fubCULUJlvCBkYhJM52GUNoHNWVI-siaecmZv3kzk,2154
+mpt_extension_sdk/runtime/logging.py,sha256=wJ6KyvnuvMZELI1Hd0fYbuHr7YiP3GIXFBvvSdmd7nQ,885
+mpt_extension_sdk/runtime/master.py,sha256=ALbtAsb6ubhWcEpAXpzHSZixYXZ3Qfdf2ttOLb04nlc,4536
+mpt_extension_sdk/runtime/swoext.py,sha256=LS0YZXwQsHDaYjalDGfYQi5cAL3aKQhphf3chrNmNBk,1665
+mpt_extension_sdk/runtime/tracer.py,sha256=Mvt1BKBdSvb4FlOcjUDhIKEXmiYETrFGgHdhOQwEr7g,415
+mpt_extension_sdk/runtime/utils.py,sha256=FWMsGCTPxgKPX8lbCpfCu-ZWuJCqnXZHVbt9bUHVJX4,4505
+mpt_extension_sdk/runtime/workers.py,sha256=8KdI6neBEiMcc0zha8toCsZutvK2BhEXxb8NdTMrNO4,2677
+mpt_extension_sdk/swo_rql/__init__.py,sha256=QrvRDYhpK-Pd3OF-U2aMeazuKm_kbvXwLRIjd9Mm6ok,104
+mpt_extension_sdk/swo_rql/constants.py,sha256=39BZ78OzdU_dIQtoy-Z_5utXqEXRweIFvM9Zfxg9j5M,171
+mpt_extension_sdk/swo_rql/query_builder.py,sha256=XAoMYV1jaAouYjpqrh8nMaDNzD0as-BhMx8rsvdeZ0k,10500
+mpt_extension_sdk-4.5.0.dist-info/METADATA,sha256=rpA1rtC1fk0Y6Y6MxLBKEUpb9FBIq4zxLzkZ1lyFzxw,1708
+mpt_extension_sdk-4.5.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+mpt_extension_sdk-4.5.0.dist-info/entry_points.txt,sha256=8uZQihFseK4Kp5XWHl9EDYneg-CLS8BFO-ygp0h34nc,143
+mpt_extension_sdk-4.5.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mpt_extension_sdk-4.5.0.dist-info/RECORD,,

mpt_extension_sdk-4.5.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.2.1
+Root-Is-Purelib: true
+Tag: py3-none-any

mpt_extension_sdk-4.5.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+swoext=mpt_extension_sdk.runtime.swoext:main
+
+[swo.mpt.sdk]
+app_config=mpt_extension_sdk.runtime.djapp.apps:ExtensionConfig
+