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

{viur_core-3.9.0.dev5/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.dev5
+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
@@ -50,22 +51,21 @@ 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.dev5 → 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",
@@ -16,22 +16,21 @@ dependencies = [
     "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",
 ]
@@ -53,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.dev5 → 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.dev5 → 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,
+
         }