viur-core 3.9.0.dev4__tar.gz → 3.9.0.dev6__tar.gz

{viur_core-3.9.0.dev4/src/viur_core.egg-info → viur_core-3.9.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viur-core
-Version: 3.9.0.dev4
+Version: 3.9.0.dev6
 Summary: The core component of ViUR, a development framework for Google App Engine
 Author-email: Mausbrand Informationssysteme GmbH <devs@viur.dev>
 Maintainer-email: Jan Max Meyer <jm@mausbrand.de>
@@ -36,11 +36,12 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: appengine-python-standard~=1.0
+Requires-Dist: appengine-python-standard~=2.0
 Requires-Dist: Deprecated~=1.2
 Requires-Dist: google-api-core[grpc]~=2.0
 Requires-Dist: google-auth~=2.0
@@ -48,23 +49,23 @@ Requires-Dist: google-cloud-bigquery~=3.0
 Requires-Dist: google-cloud-datastore~=2.0
 Requires-Dist: google-cloud-iam~=2.0
 Requires-Dist: google-cloud-logging~=3.0
+Requires-Dist: google-cloud-recaptcha-enterprise~=1.0
 Requires-Dist: google-cloud-secret-manager~=2.0
-Requires-Dist: google-cloud-storage~=2.0
+Requires-Dist: google-cloud-storage<4,>=2
 Requires-Dist: google-cloud-tasks~=2.0
 Requires-Dist: google-resumable-media~=2.0
 Requires-Dist: googleapis-common-protos[grpc]~=1.0
-Requires-Dist: gunicorn~=23.0
+Requires-Dist: gunicorn<27,>=23
 Requires-Dist: jinja2~=3.0
 Requires-Dist: jsonschema~=4.0
 Requires-Dist: logics-py==0.0.12
-Requires-Dist: pillow~=11.0
+Requires-Dist: pillow<13,>=11
 Requires-Dist: pyotp~=2.0
-Requires-Dist: pytz~=2023.0
+Requires-Dist: pytz>=2023
 Requires-Dist: pyyaml~=6.0
-Requires-Dist: qrcode~=7.0
+Requires-Dist: qrcode<9,>=7
 Requires-Dist: requests~=2.0
 Requires-Dist: tzlocal~=5.0
-Requires-Dist: urllib3==1.26.20
 Requires-Dist: user-agents~=2.0
 Requires-Dist: webob~=1.0
 Provides-Extra: mailjet

{viur_core-3.9.0.dev4 → viur_core-3.9.0.dev6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "viur-core"
 dynamic = ["version"]
 dependencies = [
-    "appengine-python-standard~=1.0",
+    "appengine-python-standard~=2.0",
     "Deprecated~=1.2",
     "google-api-core[grpc]~=2.0",
     "google-auth~=2.0",
@@ -14,23 +14,23 @@ dependencies = [
     "google-cloud-datastore~=2.0",
     "google-cloud-iam~=2.0",
     "google-cloud-logging~=3.0",
+    "google-cloud-recaptcha-enterprise~=1.0",
     "google-cloud-secret-manager~=2.0",
-    "google-cloud-storage~=2.0",
+    "google-cloud-storage>=2,<4",
     "google-cloud-tasks~=2.0",
     "google-resumable-media~=2.0",
     "googleapis-common-protos[grpc]~=1.0",
-    "gunicorn~=23.0",
+    "gunicorn>=23,<27",
     "jinja2~=3.0",
     "jsonschema~=4.0",
     "logics-py==0.0.12",
-    "pillow~=11.0",
+    "pillow>=11,<13",
     "pyotp~=2.0",
-    "pytz~=2023.0",
+    "pytz>=2023",
     "pyyaml~=6.0",
-    "qrcode~=7.0",
+    "qrcode>=7,<9",
     "requests~=2.0",
     "tzlocal~=5.0",
-    "urllib3==1.26.20", # for appengine-python-standard (https://github.com/GoogleCloudPlatform/appengine-python-standard/blob/main/setup.py#L28)
     "user-agents~=2.0",
     "webob~=1.0",
 ]
@@ -52,6 +52,7 @@ classifiers = [
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Topic :: Software Development :: Libraries :: Application Frameworks",
 ]
 

{viur_core-3.9.0.dev4 → viur_core-3.9.0.dev6}/src/viur/core/bones/__init__.py

@@ -29,6 +29,7 @@ from .phone import PhoneBone
 from .randomslice import RandomSliceBone
 from .raw import RawBone
 from .record import RecordBone
+from .address import AddressBone, AddressRelSkel
 from .relational import RelationalBone, RelationalConsistency, RelationalUpdateLevel
 from .selectcountry import SelectCountryBone
 from .select import (
@@ -49,6 +50,8 @@ from .user import UserBone
 
 # Expose only specific names
 __all = [
+    "AddressBone",
+    "AddressRelSkel",
     "BaseBone",
     "BooleanBone",
     "CaptchaBone",

viur_core-3.9.0.dev6/src/viur/core/bones/address.py

@@ -0,0 +1,105 @@
+import hashlib
+import logging
+import typing as t
+import urllib.parse
+
+import requests
+
+from .record import RecordBone
+from .string import StringBone
+from .selectcountry import SelectCountryBone
+from .spatial import SpatialBone
+from ..skeleton.relskel import RelSkel
+from .. import db, i18n
+from ..data.zip_patterns import ZIP_CODE_PATTERNS
+
+CACHE_KIND = "viur-addressbone-geocache"
+
+
+class AddressRelSkel(RelSkel):
+    street_name = StringBone(descr="Street", required=True)
+    street_number = StringBone(descr="House number")
+    address_addition = StringBone(descr="Address addition")
+    zip_code = StringBone(
+        descr="ZIP / Postal code",
+        params={
+            "pattern": ZIP_CODE_PATTERNS,
+            "pattern-error": i18n.translate(
+                "viur.core.bones.address.zip_code.invalid",
+                defaultText="Invalid ZIP code",
+            ),
+        },
+    )
+    city = StringBone(descr="City", required=True)
+    country = SelectCountryBone(descr="Country")
+    coordinates = SpatialBone(
+        descr="Coordinates",
+        boundsLat=(-90, 90),
+        boundsLng=(-180, 180),
+        gridDimensions=(10, 10),
+    )
+
+
+class AddressBone(RecordBone):
+    type = RecordBone.type + ".address"
+
+    def __init__(
+        self,
+        *,
+        using: t.Type[RelSkel] = AddressRelSkel,
+        format: str = "$(street_name) $(street_number), $(zip_code) $(city)",
+        **kwargs,
+    ):
+        super().__init__(using=using, format=format, **kwargs)
+
+    def after_from_client(self, skel, name, errors):
+        value = skel[name]
+        if value is not None:
+            coords = self.geocode(value)
+            if coords:
+                value["coordinates"] = coords
+
+    @staticmethod
+    def _cache_key(params: str) -> db.Key:
+        digest = hashlib.sha256(params.encode()).hexdigest()
+        return db.Key(CACHE_KIND, digest)
+
+    @staticmethod
+    def geocode(skel: RelSkel) -> tuple[float, float] | None:
+        street = f"{skel['street_name'] or ''} {skel['street_number'] or ''}".strip()
+        params = {
+            "street": street,
+            "postalcode": skel["zip_code"] or "",
+            "city": skel["city"] or "",
+            "country": skel["country"] or "",
+            "format": "json",
+            "limit": 1,
+        }
+        cache_key = AddressBone._cache_key(urllib.parse.urlencode(params))
+        try:
+            cached = db.get(cache_key)
+            if cached is not None:
+                return cached["lat"], cached["lng"]
+            response = requests.get(
+                "https://nominatim.openstreetmap.org/search",
+                params=params,
+                headers={"User-Agent": "viur-addressbone/1.0 (viur.dev)"},
+                timeout=5,
+            )
+            if response.status_code != 200:
+                logging.error(
+                    f"AddressBone: Nominatim returned {response.status_code=}"
+                )
+                return None
+            data = response.json()
+            if not data:
+                return None
+            lat, lng = float(data[0]["lat"]), float(data[0]["lon"])
+            entity = db.Entity(cache_key)
+            entity["lat"] = lat
+            entity["lng"] = lng
+            db.put(entity)
+            return lat, lng
+        except Exception as e:
+            logging.error(f"AddressBone: Nominatim geocoding failed with {e=}")
+        return None

viur_core-3.9.0.dev6/src/viur/core/bones/captcha.py

@@ -0,0 +1,177 @@
+import logging
+import typing as t
+import warnings
+
+from viur.core import conf, current
+from viur.core.bones.base import BaseBone, ReadFromClientError, ReadFromClientErrorSeverity
+
+from google.cloud import recaptchaenterprise_v1
+from google.cloud.recaptchaenterprise_v1 import Assessment
+
+if t.TYPE_CHECKING:
+    from viur.core.skeleton import SkeletonInstance
+
+
+class CaptchaBone(BaseBone):
+    r"""
+    The CaptchaBone validates reCAPTCHA Enterprise tokens to protect forms from bots.
+
+    It uses the Google reCAPTCHA Enterprise API and supports both invisible (v3-style score-based)
+    and visible (checkbox widget) challenges via the ``render_challenge`` parameter.
+
+    The token is submitted by the client as the bone's field value and verified server-side
+    against the configured site key. A configurable score threshold determines whether
+    invisible challenges pass.
+
+    .. seealso::
+
+        `Google reCAPTCHA Enterprise setup
+        <https://cloud.google.com/recaptcha/docs/set-up-non-google-cloud-environments-api-keys>`
+        for creating a site key and enabling the API.
+
+        Option :attr:`core.config.Security.captcha_default_public_key`
+        for global security settings.
+
+        Option :attr:`core.config.Security.captcha_enforce_always`
+        to enforce validation even on development servers.
+    """
+
+    type = "captcha"
+
+    def __init__(
+        self,
+        *,
+        public_key: str = None,
+        score_threshold: float = 0.5,
+        render_challenge: bool = False,
+        recaptcha_action: str = "",
+        **kwargs: t.Any
+    ):
+        """
+        Initializes a new CaptchaBone.
+
+        :param public_key: The reCAPTCHA Enterprise site key shown to the client.
+            Can be omitted if set globally via :attr:`core.config.Security.captcha_default_public_key`.
+        :param score_threshold: Minimum score (0–1) required for invisible challenges to pass.
+            Ignored when ``render_challenge`` is ``True``.
+        :param render_challenge: If ``True``, renders a visible checkbox widget instead of
+            running an invisible background check.
+        :param recaptcha_action: The action name passed to reCAPTCHA for analytics and scoring.
+            Should match the action used on the client side.
+        """
+        if "publicKey" in kwargs:
+            warnings.warn("publicKey parameter is deprecated, please use public_key",
+                          DeprecationWarning, stacklevel=2)
+            public_key = kwargs.pop("publicKey")
+        super().__init__(**kwargs)
+        if not public_key and conf.security.captcha_default_public_key:
+            public_key = conf.security.captcha_default_public_key
+        if not public_key:
+            raise ValueError("CaptchaBone requires either a public_key or conf.security.captcha_default_public_key")
+
+        self.public_key = public_key
+
+        if not (0 < score_threshold <= 1):
+            raise ValueError("score_threshold must be between 0 and 1.")
+        self.render_challenge = render_challenge
+        self.recaptcha_action = recaptcha_action
+        self.score_threshold = score_threshold
+        self.required = True
+
+    def serialize(self, skel: "SkeletonInstance", name: str, parentIndexed: bool) -> bool:
+        """
+        Serializing the Captcha bone is not possible so it return False
+        """
+        return False
+
+    def unserialize(self, skel: "SkeletonInstance", name) -> t.Literal[True]:
+        """
+        Stores the public_key in the SkeletonInstance
+
+        :param skel: The target :class:`SkeletonInstance`.
+        :param name: The name of the CaptchaBone in the :class:`SkeletonInstance`.
+
+        :returns: boolean, that is true, as the Captcha bone is always unserialized successfully.
+        """
+        skel.accessedValues[name] = self.public_key
+        return True
+
+    def fromClient(self, skel: "SkeletonInstance", name: str, data: dict) -> None | list[ReadFromClientError]:
+        """
+        Load the reCAPTCHA token from the provided data and validate it with the help of the API.
+
+        reCAPTCHA provides the token via callback usually as "g-recaptcha-response",
+        but to fit into the skeleton logic, we support both names.
+        So the token can be provided as "g-recaptcha-response" or the name of the CaptchaBone in the Skeleton.
+        While the latter one is the preferred name.
+        """
+
+        if not conf.security.captcha_enforce_always and conf.instance.is_dev_server:
+            logging.info("Skipping captcha validation on development server")
+            return None
+        if not conf.security.captcha_enforce_always and (user := current.user.get()) and "root" in user["access"]:
+            logging.info("Skipping captcha validation for root user")
+            return None  # Don't bother trusted users with this (not supported by admin/vi anyway)
+
+        client = recaptchaenterprise_v1.RecaptchaEnterpriseServiceClient()
+
+        # Set the attributes of the event to be tracked.
+        event = recaptchaenterprise_v1.Event()
+        event.site_key = self.public_key
+        if name in data:
+            event.token = data[name]
+        else:
+            return [ReadFromClientError(
+                ReadFromClientErrorSeverity.NotSet,
+                "Token not set"
+            )]
+        assessment = recaptchaenterprise_v1.Assessment()
+        assessment.event = event
+
+        project_name = f"projects/{conf.instance.project_id}"
+
+        # Create the assessment request.
+        request = recaptchaenterprise_v1.CreateAssessmentRequest()
+        request.assessment = assessment
+        request.parent = project_name
+
+        response = client.create_assessment(request)
+
+        if not response.token_properties.valid:
+            logging.info(
+                "The CreateAssessment call failed because the token was "
+                + "invalid for the following reasons: "
+                + str(response.token_properties.invalid_reason)
+            )
+            return [ReadFromClientError(
+                ReadFromClientErrorSeverity.Invalid,
+                "Invalid Token"
+            )]
+
+        # Check if the expected action was executed.
+        if response.token_properties.action != self.recaptcha_action:
+            logging.info(
+                "The action attribute in your reCAPTCHA tag does not match the action you are expecting to score"
+            )
+            return [ReadFromClientError(
+                ReadFromClientErrorSeverity.Invalid,
+                f"Invalid Action: {self.recaptcha_action}"
+            )]
+        else:
+            # Retrieve the risk score and reasons.
+            # For more information on interpreting the assessment, see:
+            # https://cloud.google.com/recaptcha/docs/interpret-assessment
+            if response.risk_analysis.score < self.score_threshold:
+                return [ReadFromClientError(
+                    ReadFromClientErrorSeverity.Invalid,
+                    f"Invalid Captcha: {response.risk_analysis.score}"
+                )]
+
+        return None
+
+    def structure(self) -> dict:
+        return super().structure() | {
+            "public_key": self.public_key,
+            "render_challenge": self.render_challenge,
+            "action": self.recaptcha_action
+        }

{viur_core-3.9.0.dev4 → viur_core-3.9.0.dev6}/src/viur/core/bones/numeric.py

@@ -3,6 +3,7 @@ import numbers
 import sys
 import typing as t
 import warnings
+import decimal as deci
 
 from viur.core import db, i18n
 from viur.core.bones.base import BaseBone, ReadFromClientError, ReadFromClientErrorSeverity
@@ -33,6 +34,7 @@ class NumericBone(BaseBone):
         min: int | float = MIN,
         max: int | float = MAX,
         precision: int = 0,
+        decimal: bool = False,
         mode=None,  # deprecated!
         **kwargs
     ):
@@ -42,6 +44,7 @@ class NumericBone(BaseBone):
         :param min: Minimum accepted value (including).
         :param max: Maximum accepted value (including).
         :param precision: How may decimal places should be saved. Zero casts the value to int instead of float.
+        :param decimal: If True, use deci.Decimal internally for exact arithmetic.
         """
         super().__init__(**kwargs)
 
@@ -61,6 +64,9 @@ class NumericBone(BaseBone):
         self.precision = precision
         self.min = min
         self.max = max
+        self.decimal = decimal
+        if decimal:
+            self._quantize_exp = deci.Decimal(10) ** -precision
 
     def __setattr__(self, key, value):
         """
@@ -80,16 +86,42 @@ class NumericBone(BaseBone):
 
         return super().__setattr__(key, value)
 
+    def _convert_to_decimal(self, value) -> deci.Decimal | None:
+        """Convert *value* to a quantized Decimal. Uses str() roundtrip for floats.
+        Accepts comma as decimal separator in strings."""
+        if value is None:
+            return None
+        with deci.localcontext() as ctx:
+            # +20 as buffer for integer digits to avoid InvalidOperation on quantize
+            ctx.prec = self.precision + 20
+            if isinstance(value, deci.Decimal):
+                return value.quantize(self._quantize_exp)
+            if isinstance(value, str):
+                value = value.replace(",", ".", 1)
+                return deci.Decimal(value).quantize(self._quantize_exp)
+            if isinstance(value, (int, float)):
+                return deci.Decimal(str(value)).quantize(self._quantize_exp)
+        raise ValueError(f"Cannot convert {type(value).__name__} to Decimal")
+
     def singleValueUnserialize(self, val):
         if val is not None:
             try:
+                if self.decimal:
+                    if isinstance(val, dict) and "decimal" in val:
+                        val = val["decimal"]
+                    return self._convert_to_decimal(val)
                 return self._convert_to_numeric(val)
-            except (ValueError, TypeError):
+            except (ValueError, TypeError, deci.InvalidOperation):
                 return self.getDefaultValue(None)  # FIXME: callable needs the skeleton instance
 
         return val
 
     def singleValueSerialize(self, value, skel: 'SkeletonInstance', name: str, parentIndexed: bool):
+        if self.decimal and value is not None:
+            return {
+                "val": self._convert_to_numeric(value),
+                "decimal": str(self._convert_to_decimal(value)),
+            }
         return self.singleValueUnserialize(value)  # same logic for unserialize here!
 
     def isInvalid(self, value):
@@ -110,6 +142,8 @@ class NumericBone(BaseBone):
         :return: Returns 0 for integers (when precision is 0) or 0.0 for floating-point numbers (when
             precision is non-zero).
         """
+        if self.decimal:
+            return deci.Decimal(0).quantize(self._quantize_exp)
         if self.precision:
             return 0.0
         else:
@@ -124,33 +158,53 @@ class NumericBone(BaseBone):
         :param value: The raw value to be checked for emptiness.
         :return: Returns True if the raw value is considered empty, otherwise False.
         """
+        if value is None:
+            return True
         if isinstance(value, str) and not value:
             return True
         try:
-            value = self._convert_to_numeric(value)
-        except (ValueError, TypeError):
+            if self.decimal:
+                value = self._convert_to_decimal(value)
+            else:
+                value = self._convert_to_numeric(value)
+        except (ValueError, TypeError, deci.InvalidOperation):
             return True
         return value == self.getEmptyValue()
 
     def singleValueFromClient(self, value, skel, bone_name, client_data):
-        if not isinstance(value, (int, float)):
-            # Replace , with .
-            try:
-                value = str(value).replace(",", ".", 1)
-            except TypeError:
-                return self.getEmptyValue(), [ReadFromClientError(ReadFromClientErrorSeverity.Invalid)]
-
-            # Convert to float or int -- depending on the precision
-            # Since we convert direct to int if precision=0, a float value isn't valid
+        if self.decimal:
+            if value is None or (isinstance(value, str) and not value.strip()):
+                return self.getEmptyValue(), [
+                    ReadFromClientError(ReadFromClientErrorSeverity.Empty, "No value entered")
+                ]
             try:
-                value = float(value) if self.precision else int(value)
-            except ValueError:
-                return self.getEmptyValue(), [ReadFromClientError(ReadFromClientErrorSeverity.Invalid)]
+                if isinstance(value, str):
+                    value = value.replace(",", ".", 1)
+                value = self._convert_to_decimal(value)
+            except (deci.InvalidOperation, ValueError, TypeError):
+                return self.getEmptyValue(), [
+                    ReadFromClientError(ReadFromClientErrorSeverity.Invalid, "Invalid decimal value")
+                ]
 
-        if self.precision:
-            value = round(float(value), self.precision)
         else:
-            value = int(value)
+            if not isinstance(value, (int, float)):
+                # Replace , with .
+                try:
+                    value = str(value).replace(",", ".", 1)
+                except TypeError:
+                    return self.getEmptyValue(), [ReadFromClientError(ReadFromClientErrorSeverity.Invalid)]
+
+                # Convert to float or int -- depending on the precision
+                # Since we convert direct to int if precision=0, a float value isn't valid
+                try:
+                    value = float(value) if self.precision else int(value)
+                except ValueError:
+                    return self.getEmptyValue(), [ReadFromClientError(ReadFromClientErrorSeverity.Invalid)]
+
+            if self.precision:
+                value = round(float(value), self.precision)
+            else:
+                value = int(value)
 
         # Check the limits after rounding, as the rounding may change the value.
         if not (self.min <= value <= self.max):
@@ -182,23 +236,44 @@ class NumericBone(BaseBone):
         prefix: t.Optional[str] = None
     ) -> db.Query:
         updatedFilter = {}
-
         for parmKey, paramValue in rawFilter.items():
             if parmKey.startswith(name):
                 if parmKey != name and not parmKey.startswith(name + "$"):
                     # It's just another bone which name start's with our's
                     continue
                 try:
-                    if not self.precision:
+                    if self.decimal:
+                        paramValue = float(str(paramValue).replace(",", ".", 1))
+                    elif not self.precision:
                         paramValue = int(paramValue)
                     else:
                         paramValue = float(paramValue)
-                except ValueError:
+                except (ValueError, deci.InvalidOperation):
                     # The value we should filter by is garbage, cancel this query
                     logging.warning(f"Invalid filtering! Unparsable int/float supplied to NumericBone {name}")
                     raise RuntimeError()
                 updatedFilter[parmKey] = paramValue
 
+        if self.decimal:
+            # Values are stored as {"val": float, "decimal": str} — filter on the .val sub-property
+            prop = (prefix or "") + name + ".val"
+            for key, value in updatedFilter.items():
+                if key == name:
+                    dbFilter.filter(prop + " =", value)
+                else:
+                    op = key[len(name) + 1:]  # the part after "$"
+                    if op == "lt":
+                        dbFilter.filter(prop + " <", value)
+                    elif op == "le":
+                        dbFilter.filter(prop + " <=", value)
+                    elif op == "gt":
+                        dbFilter.filter(prop + " >", value)
+                    elif op == "ge":
+                        dbFilter.filter(prop + " >=", value)
+                    else:
+                        dbFilter.filter(prop + " =", value)
+            return dbFilter
+
         return super().buildDBFilter(name, skel, dbFilter, updatedFilter, prefix)
 
     def getSearchTags(self, skel: "SkeletonInstance", name: str) -> set[str]:
@@ -240,9 +315,12 @@ class NumericBone(BaseBone):
         """
         super().refresh(skel, boneName)
 
-        def refresh_single_value(value: t.Any) -> float | int:
+        def refresh_single_value(value: t.Any) -> float | int | deci.Decimal:
             if value == "":
                 return self.getEmptyValue()
+            elif self.decimal:
+                if not isinstance(value, (deci.Decimal, type(None))):
+                    return self._convert_to_decimal(value)
             elif not isinstance(value, (int, float, type(None))):
                 return self._convert_to_numeric(value)
             return value
@@ -276,4 +354,6 @@ class NumericBone(BaseBone):
             "min": self.min,
             "max": self.max,
             "precision": self.precision,
+            "decimal": self.decimal,
+
         }

{viur_core-3.9.0.dev4 → viur_core-3.9.0.dev6}/src/viur/core/bones/randomslice.py

@@ -112,13 +112,13 @@ class RandomSliceBone(BaseBone):
                 q = db.QueryDefinition(origKind, {}, [])
                 property, value = applyFilterHook(dbFilter, f"{name} <=", rndVal)
                 q.filters[property] = value
-                q.orders = [(name, db.SortOrder.Descending)]
+                q.orders = [db.QueryOrder(name, db.SortOrder.Descending)]
                 queries.append(q)
                 # Left Side
                 q = db.QueryDefinition(origKind, {}, [])
                 property, value = applyFilterHook(dbFilter, f"{name} >", rndVal)
                 q.filters[property] = value
-                q.orders = [(name, db.SortOrder.Ascending)]
+                q.orders = [db.QueryOrder(name)]
                 queries.append(q)
             dbFilter.queries = queries
             # Map the original filter back in