viur-core 3.8.0.dev6__tar.gz → 3.8.0.dev7__tar.gz

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viur-core
-Version: 3.8.0.dev6
+Version: 3.8.0.dev7
 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>

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/bones/file.py

@@ -35,7 +35,8 @@ def ensureDerived(key: db.Key, srcKey, deriveMap: dict[str, t.Any], refreshKey:
     the updated results are written back to the database and the updateRelations function is called
     to ensure proper relations are maintained.
     """
-    from viur.core.skeleton import skeletonByKind, updateRelations
+    from viur.core.skeleton.utils import skeletonByKind
+    from viur.core.skeleton.tasks import updateRelations
     deriveFuncMap = conf.file_derivations
     skel = skeletonByKind("file")()
     if not skel.read(key):
@@ -226,7 +227,10 @@ class FileBone(TreeLeafBone):
         the derived files directly.
         """
         super().postSavedHandler(skel, boneName, key)
-        if current.request.get().is_deferred and current.request_data.get().get("__update_relations_bone") == "derived":
+        if (
+            current.request.get().is_deferred
+            and "derived" in current.request_data.get().get("__update_relations_bones")
+        ):
             return
         from viur.core.skeleton import RelSkel, Skeleton
 

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/db/utils.py

@@ -88,7 +88,6 @@ def key_helper(
             decoded_key = None
 
         # If it did decode, recall keyHelper with Key object
-        print(f"decoded key: {decoded_key!r}")
         if decoded_key:
             return key_helper(
                 decoded_key,

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/i18n.py

@@ -501,7 +501,7 @@ def add_missing_translation(
     key = key.lower()
 
     # Check if key already exists
-    # if db.Get(db.Key(KINDNAME, key)):  # FIXME ViUR4 should only use named keys
+    # if db.get(db.Key(KINDNAME, key)):  # FIXME ViUR4 should only use named keys
     entity = db.Query(KINDNAME).filter("name =", key).getEntry()
     if entity is not None:
         # Ensure it doesn't exist to avoid datastore conflicts

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/modules/file.py

@@ -198,7 +198,7 @@ def cloudfunction_thumbnailer(fileSkel, existingFiles, params):
             authRequest = google.auth.transport.requests.Request()
             expiresAt = datetime.datetime.now() + datetime.timedelta(seconds=60)
             signing_credentials = google.auth.compute_engine.IDTokenCredentials(authRequest, "")
-            content_disposition = f"""filename={fileSkel["name"]}"""
+            content_disposition = utils.build_content_disposition_header(fileSkel["name"])
             signedUrl = blob.generate_signed_url(
                 expiresAt,
                 credentials=signing_credentials,
@@ -1029,12 +1029,7 @@ class File(Tree):
         if not filename:
             filename = download_filename or urlquote(blob.name.rsplit("/", 1)[-1])
 
-        content_disposition = "; ".join(
-            item for item in (
-                "attachment" if download else None,
-                f"filename={filename}" if filename else None,
-            ) if item
-        )
+        content_disposition = utils.build_content_disposition_header(filename, attachment=download)
 
         if isinstance(_CREDENTIALS, ServiceAccountCredentials):
             expiresAt = datetime.datetime.now() + datetime.timedelta(seconds=60)
@@ -1152,10 +1147,7 @@ class File(Tree):
         response = current.request.get().response
         response.headers["Content-Type"] = f"image/{file_fmt}"
         response.headers["Cache-Control"] = "public, max-age=604800"  # 7 Days
-        if download:
-            response.headers["Content-Disposition"] = f"attachment; filename={filename}"
-        else:
-            response.headers["Content-Disposition"] = f"filename={filename}"
+        response.headers["Content-Disposition"] = utils.build_content_disposition_header(filename, attachment=download)
 
         answ = requests.get(url, timeout=20)
         if not answ.ok:

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/modules/translation.py

@@ -255,14 +255,17 @@ class Translation(List):
     def dump(
         self,
         *,
-        pattern: list[str] = [],
-        language: list[str] = [],
-    ) -> dict[str, str] | dict[str, dict[str, str]]:
+        pattern: list[str] | None = None,
+        language: list[str] | None = None,
+    ) -> dict[str, dict[str, str]]:
         """
         Dumps translations as JSON.
 
-        :param pattern: Required, provide fnmatch-style tramslaton key filter patterns of the translations wanted.
+        :param pattern: Optional, provide fnmatch-style translation key filter patterns of the translations wanted.
         :param language: Allows to request a specific language.
+            By default, the language of the current request is used.
+
+        :return: A dictionary with translations as JSON. Structure: ``{language: {key: value, ...}, ...}``
 
         Example calls:
 
@@ -276,11 +279,6 @@ class Translation(List):
 
         current.request.get().response.headers["Content-Type"] = "application/json"
 
-        # The pattern may not be a matcher for all!
-        for pat in pattern:
-            if not pat.strip("*?."):
-                raise errors.BadRequest("Pattern is too generic.")
-
         if (
             not (conf.debug.disable_cache and current.request.get().disableCache)
             and any(os.getenv("HTTP_HOST", "") in dlm for dlm in conf.i18n.domain_language_mapping)
@@ -294,12 +292,12 @@ class Translation(List):
         else:
             language = [current.language.get()]
 
-        return json.dumps({
+        return json.dumps({  # type: ignore
             lang: {
                 name: str(translate(name, force_lang=lang))
                 for name, values in systemTranslations.items()
                 if (conf.i18n.dump_can_view(name) or values.get("_public_"))
-                and any(fnmatch.fnmatch(name, pat) for pat in pattern)
+                and (not pattern or any(fnmatch.fnmatch(name, pat) for pat in pattern))
             }
             for lang in language
         })

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/request.py

@@ -14,11 +14,11 @@ import re
 import time
 import traceback
 import typing as t
+import unicodedata
 from abc import ABC, abstractmethod
 from urllib import parse
-from urllib.parse import unquote, urljoin, urlparse
+from urllib.parse import quote, unquote, urljoin, urlparse
 
-import unicodedata
 import webob
 
 from viur.core import current, db, errors, session, utils
@@ -367,6 +367,9 @@ class Router:
                 raise
             self.response.status = f"{e.status} {e.name}"
             url = e.url
+            url = unquote(url)  # decode first
+            # safe = https://url.spec.whatwg.org/#url-path-segment-string
+            url = quote(url, encoding="utf-8", safe="!$&'()*+,-./:;=?@_~")  # re-encode all in utf-8
             if url.startswith(('.', '/')):
                 url = str(urljoin(self.request.url, url))
             self.response.headers['Location'] = url

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/skeleton/instance.py

@@ -8,6 +8,7 @@ import warnings
 from functools import partial
 from ..bones.base import BaseBone
 from .skeleton import Skeleton
+from viur.core import db
 
 
 class SkeletonInstance:

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/skeleton/skeleton.py

@@ -10,13 +10,25 @@ from deprecated.sphinx import deprecated
 from viur.core import conf, db, errors, utils
 
 from .meta import BaseSkeleton, MetaSkel, _UNDEFINED_KINDNAME
-from .tasks import updateRelations
-from ..bones.base import Compute, ComputeInterval, ComputeMethod,  ReadFromClientException
+from .tasks import updateRelations, processRemovedRelations
+from .utils import skeletonByKind
+from ..bones.base import (
+    Compute,
+    ComputeInterval,
+    ComputeMethod,
+    ReadFromClientException,
+    ReadFromClientError,
+    ReadFromClientErrorSeverity
+)
 from ..bones.relational import RelationalConsistency
 from ..bones.key import KeyBone
 from ..bones.date import DateBone
 from ..bones.string import StringBone
 
+if t.TYPE_CHECKING:
+    from .instance import SkeletonInstance
+    from .adapter import DatabaseAdapter
+    from .meta import KeyType
 
 class SeoKeyBone(StringBone):
     """
@@ -185,7 +197,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
             if boneInstance.unique:
                 lockValues = boneInstance.getUniquePropertyIndexValues(skel, boneName)
                 for lockValue in lockValues:
-                    dbObj = db.Get(db.Key(f"{skel.kindName}_{boneName}_uniquePropertyIndex", lockValue))
+                    dbObj = db.get(db.Key(f"{skel.kindName}_{boneName}_uniquePropertyIndex", lockValue))
                     if dbObj and (not skel["key"] or dbObj["references"] != skel["key"].id_or_name):
                         # This value is taken (sadly, not by us)
                         complete = False
@@ -258,7 +270,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
         except (ValueError, NotImplementedError):  # This key did not parse
             return None
 
-        if db_res := db.Get(db_key):
+        if db_res := db.get(db_key):
             skel.setEntity(db_res)
             return skel
         elif create in (False, None):
@@ -340,7 +352,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                 is_add = True
             else:
                 db_key = db.keyHelper(db_key, skel.kindName)
-                if db_obj := db.Get(db_key):
+                if db_obj := db.get(db_key):
                     skel.dbEntity = db_obj
                     old_copy = {k: v for k, v in skel.dbEntity.items()}
                     is_add = False
@@ -399,7 +411,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                     new_lock_kind = f"{skel.kindName}_{bone_name}_uniquePropertyIndex"
                     for new_lock_value in new_unique_values:
                         new_lock_key = db.Key(new_lock_kind, new_lock_value)
-                        if lock_db_obj := db.Get(new_lock_key):
+                        if lock_db_obj := db.get(new_lock_key):
 
                             # There's already a lock for that value, check if we hold it
                             if lock_db_obj["references"] != skel.dbEntity.key.id_or_name:
@@ -412,7 +424,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                             # This value is locked for the first time, create a new lock-object
                             lock_obj = db.Entity(new_lock_key)
                             lock_obj["references"] = skel.dbEntity.key.id_or_name
-                            db.Put(lock_obj)
+                            db.put(lock_obj)
                         if new_lock_value in old_unique_values:
                             old_unique_values.remove(new_lock_value)
                     skel.dbEntity["viur"][f"{bone_name}_uniqueIndexValue"] = new_unique_values
@@ -422,7 +434,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                         # Try to delete the old lock
 
                         old_lock_key = db.Key(f"{skel.kindName}_{bone_name}_uniquePropertyIndex", old_unique_value)
-                        if old_lock_obj := db.Get(old_lock_key):
+                        if old_lock_obj := db.get(old_lock_key):
                             if old_lock_obj["references"] != skel.dbEntity.key.id_or_name:
 
                                 # We've been supposed to have that lock - but we don't.
@@ -430,7 +442,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                                 logging.critical("Detected Database corruption! A Value-Lock had been reassigned!")
                             else:
                                 # It's our lock which we don't need anymore
-                                db.Delete(old_lock_key)
+                                db.delete(old_lock_key)
                         else:
                             logging.critical("Detected Database corruption! Could not delete stale lock-object!")
 
@@ -526,7 +538,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                 fixDotNames(skel.dbEntity)
 
             # Write the core entry back
-            db.Put(skel.dbEntity)
+            db.put(skel.dbEntity)
 
             # Now write the blob-lock object
             blob_list = skel.preProcessBlobLocks(blob_list)
@@ -537,7 +549,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                 logging.error(msg)
                 raise ValueError(msg)
 
-            if not is_add and (old_blob_lock_obj := db.Get(db.Key("viur-blob-locks", db_key.id_or_name))):
+            if not is_add and (old_blob_lock_obj := db.get(db.Key("viur-blob-locks", db_key.id_or_name))):
                 removed_blobs = set(old_blob_lock_obj.get("active_blob_references", [])) - blob_list
                 old_blob_lock_obj["active_blob_references"] = list(blob_list)
                 if old_blob_lock_obj["old_blob_references"] is None:
@@ -550,14 +562,14 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
 
                 old_blob_lock_obj["has_old_blob_references"] = bool(old_blob_lock_obj["old_blob_references"])
                 old_blob_lock_obj["is_stale"] = False
-                db.Put(old_blob_lock_obj)
+                db.put(old_blob_lock_obj)
             else:  # We need to create a new blob-lock-object
                 blob_lock_obj = db.Entity(db.Key("viur-blob-locks", skel.dbEntity.key.id_or_name))
                 blob_lock_obj["active_blob_references"] = list(blob_list)
                 blob_lock_obj["old_blob_references"] = []
                 blob_lock_obj["has_old_blob_references"] = False
                 blob_lock_obj["is_stale"] = False
-                db.Put(blob_lock_obj)
+                db.put(blob_lock_obj)
 
             return skel.dbEntity.key, write_skel, change_list, is_add
 
@@ -620,7 +632,7 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                     flushList = []
                     for lockValue in viur_data.get(f"{boneName}_uniqueIndexValue") or []:
                         lockKey = db.Key(f"{skel.kindName}_{boneName}_uniquePropertyIndex", lockValue)
-                        lockObj = db.Get(lockKey)
+                        lockObj = db.get(lockKey)
                         if not lockObj:
                             logging.error(f"{lockKey=} missing!")
                         elif lockObj["references"] != key.id_or_name:
@@ -629,15 +641,15 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                         else:
                             flushList.append(lockObj)
                     if flushList:
-                        db.Delete(flushList)
+                        db.delete(flushList)
 
             # Delete the blob-key lock object
             lockObjectKey = db.Key("viur-blob-locks", key.id_or_name)
-            lockObj = db.Get(lockObjectKey)
+            lockObj = db.get(lockObjectKey)
 
             if lockObj is not None:
                 if lockObj["old_blob_references"] is None and lockObj["active_blob_references"] is None:
-                    db.Delete(lockObjectKey)  # Nothing to do here
+                    db.delete(lockObjectKey)  # Nothing to do here
                 else:
                     if lockObj["old_blob_references"] is None:
                         # No old stale entries, move active_blob_references -> old_blob_references
@@ -648,9 +660,9 @@ class Skeleton(BaseSkeleton, metaclass=MetaSkel):
                     lockObj["active_blob_references"] = []  # There are no active ones left
                     lockObj["is_stale"] = True
                     lockObj["has_old_blob_references"] = True
-                    db.Put(lockObj)
+                    db.put(lockObj)
 
-            db.Delete(key)
+            db.delete(key)
             processRemovedRelations(key)
 
         if key := (key or skel["key"]):

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/skeleton/tasks.py

@@ -1,7 +1,7 @@
 import logging
 import typing as t
 
-from viur.core import conf, current, db, email, translate
+from viur.core import conf, current, db, email, translate, utils
 from .utils import skeletonByKind, listKnownSkeletons
 from .meta import BaseSkeleton
 
@@ -58,7 +58,13 @@ def processRemovedRelations(removedKey, cursor=None):
 
 
 @CallDeferred
-def updateRelations(destKey: db.Key, minChangeTime: int, changedBone: t.Optional[str], cursor: t.Optional[str] = None):
+def updateRelations(
+        dest_key: db.Key,
+        min_change_time: int,
+        changed_bones: t.Optional[t.Iterable[str] | str] = (),
+        cursor: t.Optional[str] = None,
+        **kwargs
+):
     """
         This function updates Entities, which may have a copy of values from another entity which has been recently
         edited (updated). In ViUR, relations are implemented by copying the values from the referenced entity into the
@@ -67,51 +73,60 @@ def updateRelations(destKey: db.Key, minChangeTime: int, changedBone: t.Optional
         us to track changes made to entities as we might have to update these mirrored values.     This is the deferred
         call from meth:`viur.core.skeleton.Skeleton.write()` after an update (edit) on one Entity to do exactly that.
 
-        :param destKey: The database-key of the entity that has been edited
-        :param minChangeTime: The timestamp on which the edit occurred. As we run deferred, and the entity might have
+        :param dest_key: The database-key of the entity that has been edited
+        :param min_change_time: The timestamp on which the edit occurred. As we run deferred, and the entity might have
             been edited multiple times before we get acutally called, we can ignore entities that have been updated
-            in the meantime as they're  already up2date
-        :param changedBone: If set, we'll update only entites that have a copy of that bone. Relations mirror only
+            in the meantime as they're  already up-to-date
+        :param changed_bones: If set, we'll update only entites that have a copy of that bones. Relations mirror only
             key and name by default, so we don't have to update these if only another bone has been changed.
         :param cursor: The database cursor for the current request as we only process five entities at once and then
             defer again.
     """
-    logging.debug(f"Starting updateRelations for {destKey=}; {minChangeTime=}, {changedBone=}, {cursor=}")
+    changed_bones = list(utils.ensure_iterable(changed_bones))
+    if "changedBone" in kwargs:
+        logging.warning("Use of `changedBone` is deprecated; Use `changed_bones` instead!", stacklevel=2)
+        changed_bones.extend(utils.ensure_iterable(kwargs["changedBone"]))
+    if "minChangeTime" in kwargs:
+        logging.warning("Use of `minChangeTime` is deprecated; Use `min_cahnge_time` instead!", stacklevel=2)
+        min_change_time = kwargs["minChangeTime"]
+    if "destKey" in kwargs:
+        logging.warning("Use of `destKey` is deprecated; Use `dest_key` instead!", stacklevel=2)
+        dest_key = kwargs["destKey"]
+    logging.debug(f"Starting updateRelations for {dest_key=}; {min_change_time=}, {changed_bones=}, {cursor=}")
     if request_data := current.request_data.get():
-        request_data["__update_relations_bone"] = changedBone
-    updateListQuery = (
+        request_data["__update_relations_bones"] = changed_bones
+    update_list_query = (
         db.Query("viur-relations")
-        .filter("dest.__key__ =", destKey)
-        .filter("viur_delayed_update_tag <", minChangeTime)
+        .filter("dest.__key__ =", dest_key)
+        .filter("viur_delayed_update_tag <", min_change_time)
         .filter("viur_relational_updateLevel =", RelationalUpdateLevel.Always.value)
     )
-    if changedBone:
-        updateListQuery.filter("viur_foreign_keys =", changedBone)
+    if changed_bones:
+        update_list_query.filter("viur_foreign_keys IN", changed_bones)
     if cursor:
-        updateListQuery.setCursor(cursor)
-    updateList = updateListQuery.run(limit=5)
+        update_list_query.setCursor(cursor)
+    update_list = update_list_query.run(limit=5)
 
-    def updateTxn(skel, key, srcRelKey):
-        if not skel.read(key):
+    def __txn_update(_skel, key, srcRelKey):
+        if not _skel.read(key):
             logging.warning(f"Cannot update stale reference to {key=} (referenced from {srcRelKey=})")
             return
 
-        skel.refresh()
-        skel.write(update_relations=False)
+        _skel.refresh()
+        _skel.write(update_relations=False)
 
-    for srcRel in updateList:
+    for src_rel in update_list:
         try:
-            skel = skeletonByKind(srcRel["viur_src_kind"])()
+            skel = skeletonByKind(src_rel["viur_src_kind"])()
         except AssertionError:
-            logging.info(f"""Ignoring {srcRel.key!r} which refers to unknown kind {srcRel["viur_src_kind"]!r}""")
+            logging.info(f"""Ignoring {src_rel.key!r} which refers to unknown kind {src_rel["viur_src_kind"]!r}""")
             continue
         if db.is_in_transaction():
-            updateTxn(skel, srcRel["src"].key, srcRel.key)
+            __txn_update(skel, src_rel["src"].key, src_rel.key)
         else:
-            db.run_in_transaction(updateTxn, skel, srcRel["src"].key, srcRel.key)
-    nextCursor = updateListQuery.getCursor()
-    if len(updateList) == 5 and nextCursor:
-        updateRelations(destKey, minChangeTime, changedBone, nextCursor)
+            db.run_in_transaction(__txn_update, skel, src_rel["src"].key, src_rel.key)
+    if len(update_list) == 5 and (next_cursor := update_list_query.getCursor()):
+        updateRelations(dest_key, min_change_time, changed_bones, next_cursor)
 
 
 @CallableTask

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/utils/__init__.py

@@ -1,12 +1,14 @@
+import datetime
 import logging
 import typing as t
+import urllib.parse
 import warnings
-import datetime
 from collections.abc import Iterable
-from . import string, parse, json  # noqa: used by external imports
+
 from viur.core import current, db
 from viur.core.config import conf
 from deprecated.sphinx import deprecated
+from . import json, parse, string  # noqa: used by external imports
 
 
 def utcNow() -> datetime.datetime:
@@ -114,18 +116,60 @@ def ensure_iterable(
     if allow_callable and callable(obj):
         obj = obj()
 
-    if isinstance(obj, Iterable):  # uses collections.abc.Iterable
+    if not isinstance(obj, str) and isinstance(obj, Iterable):  # uses collections.abc.Iterable
         if test is None or test(obj):
             return obj  # return the obj, which is an iterable
 
         return ()  # empty tuple
 
-    elif obj is None:
+    elif obj is None or (isinstance(obj, str) and not obj):
         return ()  # empty tuple
 
     return obj,  # return a tuple with the obj
 
 
+def build_content_disposition_header(
+    filename: str,
+    *,
+    attachment: bool = False,
+    inline: bool = False,
+) -> str:
+    """
+    Build a Content-Disposition header with UTF-8 support and ASCII fallback.
+
+    Generates a properly formatted `Content-Disposition` header value, including
+    both a fallback ASCII filename and a UTF-8 encoded filename using RFC 5987.
+
+    Set either `attachment` or `inline` to control content disposition type.
+    If both are False, the header will omit disposition type (not recommended).
+
+    Example:
+        filename = "Änderung.pdf" ➜
+        'attachment; filename="Anderung.pdf"; filename*=UTF-8\'\'%C3%84nderung.pdf'
+
+    :param filename: The desired filename for the content.
+    :param attachment: Whether to mark the content as an attachment.
+    :param inline: Whether to mark the content as inline.
+    :return: A `Content-Disposition` header string.
+    """
+    if attachment and inline:
+        raise ValueError("Only one of 'attachment' or 'inline' may be True.")
+
+    fallback = string.normalize_ascii(filename)
+    quoted_utf8 = urllib.parse.quote_from_bytes(filename.encode("utf-8"))
+
+    content_disposition = "; ".join(
+        item for item in (
+            "attachment" if attachment else None,
+            "inline" if inline else None,
+            f'filename="{fallback}"' if filename else None,
+            f'filename*=UTF-8\'\'{quoted_utf8}' if filename else None,
+        ) if item
+    )
+
+    return content_disposition
+
+
 # DEPRECATED ATTRIBUTES HANDLING
 __UTILS_CONF_REPLACEMENT = {
     "projectID": "viur.instance.project_id",

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/utils/string.py

@@ -4,6 +4,7 @@ ViUR utility functions regarding string processing.
 import re
 import secrets
 import string
+import unicodedata
 import warnings
 
 
@@ -85,6 +86,28 @@ def unescape(val: str) -> str:
     return re.sub(r"&(\w{2,4}|#0*(\d{2}));", __escape_replace, str(val).strip())
 
 
+def normalize_ascii(text: str) -> str:
+    """
+    Normalize a Unicode string to an ASCII-only version.
+
+    This function uses NFKD normalization to decompose accented and special characters,
+    then encodes the result to ASCII, ignoring any characters that can't be represented.
+
+    For example:
+        "Änderung" -> "Anderung"
+        "Café" -> "Cafe"
+
+    :param text: The input Unicode string to normalize.
+    :return: A normalized ASCII-only version of the input string.
+    """
+    return (
+        unicodedata
+        .normalize("NFKD", text)
+        .encode("ascii", "ignore")
+        .decode("ascii")
+    )
+
+
 def is_prefix(name: str, prefix: str, delimiter: str = ".") -> bool:
     """
     Utility function to check if a given name matches a prefix,

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur/core/version.py

@@ -3,7 +3,7 @@
 # This will mark it as a pre-release as well on PyPI.
 # See CONTRIBUTING.md for further information.
 
-__version__ = "3.8.0.dev6"
+__version__ = "3.8.0.dev7"
 
 assert __version__.count(".") >= 2 and "".join(__version__.split(".", 3)[:3]).isdigit(), \
     "Semantic __version__ expected!"

{viur_core-3.8.0.dev6 → viur_core-3.8.0.dev7}/src/viur_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viur-core
-Version: 3.8.0.dev6
+Version: 3.8.0.dev7
 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>