viur-core 3.8.25__tar.gz → 3.9.0.dev2__tar.gz

{viur_core-3.8.25 → viur_core-3.9.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: viur-core
-Version: 3.8.25
+Version: 3.9.0.dev2
 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.25 → viur_core-3.9.0.dev2}/src/viur/core/bones/base.py

@@ -1293,10 +1293,11 @@ class BaseBone(object):
                 the list may contain more than one hashed value.
         """
 
-        def hashValue(value: str | int | float | db.Key) -> str:
+        def hash_value(value: str | int | float | db.Key) -> str:
             h = hashlib.sha256()
             h.update(str(value).encode("UTF-8"))
             res = h.hexdigest()
+
             if isinstance(value, int | float):
                 return f"I-{res}"
             elif isinstance(value, str):
@@ -1307,27 +1308,32 @@ class BaseBone(object):
                 def keyHash(key):
                     if key is None:
                         return "-"
-                    return f"{hashValue(key.kind)}-{hashValue(key.id_or_name)}-<{keyHash(key.parent)}>"
+                    return f"{hash_value(key.kind)}-{hash_value(key.id_or_name)}-<{keyHash(key.parent)}>"
 
                 return f"K-{keyHash(value)}"
+
             raise NotImplementedError(f"Type {type(value)} can't be safely used in an uniquePropertyIndex")
 
+        # zero/empty string and these should not be locked
         if not value and not self.unique.lockEmpty:
-            return []  # We are zero/empty string and these should not be locked
-        if not self.multiple and not isinstance(value, list):
-            return [hashValue(value)]
-        # We have a multiple bone or multiple values here
+            return []
+
+        # Always work with list of values
         if not isinstance(value, list):
             value = [value]
-        tmpList = [hashValue(x) for x in value]
+
+        values = [hash_value(val) for val in value]
+
         if self.unique.method == UniqueLockMethod.SameValue:
-            # We should lock each entry individually; lock each value
-            return tmpList
+            # Lock each entry individually
+            return values
+
         elif self.unique.method == UniqueLockMethod.SameSet:
-            # We should ignore the sort-order; so simply sort that List
-            tmpList.sort()
-        # Lock the value for that specific list
-        return [hashValue(", ".join(tmpList))]
+            # Ignore the sort-order; so simply sort that list
+            values.sort()
+
+        # Lock the value for that specific list (equals to UniqueLockMethod.SameList)
+        return [hash_value(", ".join(values))]
 
     def getUniquePropertyIndexValues(self, skel: 'viur.core.skeleton.SkeletonInstance', name: str) -> list[str]:
         """
@@ -1341,10 +1347,11 @@ class BaseBone(object):
         :return: A list of strings representing the hashed values for the current bone value(s) in the skeleton.
                 If the bone has no value, an empty list is returned.
         """
-        val = skel[name]
-        if val is None:
-            return []
-        return self._hashValueForUniquePropertyIndex(val)
+        if self.compute:
+            self.serialize_compute(skel, name)
+
+        values = [value for _, _, value in self.iter_bone_value(skel, name) if value is not None]
+        return self._hashValueForUniquePropertyIndex(values) if values else []
 
     def getReferencedBlobs(self, skel: 'viur.core.skeleton.SkeletonInstance', name: str) -> set[str]:
         """

{viur_core-3.8.25 → viur_core-3.9.0.dev2}/src/viur/core/bones/record.py

@@ -215,13 +215,18 @@ class RecordBone(BaseBone):
 
         return result
 
-    def getUniquePropertyIndexValues(self, valuesCache: dict, name: str) -> list[str]:
+    def getUniquePropertyIndexValues(self, skel: "SkeletonInstance", name: str) -> list[str]:
         """
-        This method is intentionally not implemented as it's not possible to determine how to derive
-        a key from the related skeleton being used (i.e., which fields to include and how).
-
+        Returns hashes over all fields of each record value, using the serialized form as canonical input.
         """
-        raise NotImplementedError()
+        values = []
+
+        for _, _, using_skel in self.iter_bone_value(skel, name):
+            if using_skel is None:
+                continue
+            values.append(json.dumps(using_skel.dump(), sort_keys=True, default=str))
+
+        return self._hashValueForUniquePropertyIndex(values) if values else []
 
     def structure(self) -> dict:
         return super().structure() | {

{viur_core-3.8.25 → viur_core-3.9.0.dev2}/src/viur/core/bones/relational.py

@@ -1271,24 +1271,32 @@ class RelationalBone(BaseBone):
 
         return result
 
-    def getUniquePropertyIndexValues(self, valuesCache: dict, name: str) -> list[str]:
+    def getUniquePropertyIndexValues(self, skel: "SkeletonInstance", name: str) -> list[str]:
         """
         Generates unique property index values for the RelationalBone based on the referenced keys.
         Can be overridden if different behavior is required (e.g., examining values from `prop:usingSkel`).
 
-        :param dict valuesCache: The cache containing the current values of the bone.
+        :param skel: The skeleton instance.
         :param str name: The name of the bone for which to generate unique property index values.
 
         :return: A list containing the unique property index values for the specified bone.
         :rtype: List[str]
         """
-        value = valuesCache.get(name)
-        if not value:  # We don't have a value to lock
-            return []
-        if isinstance(value, dict):
-            return self._hashValueForUniquePropertyIndex(value["dest"]["key"])
-        elif isinstance(value, list):
-            return self._hashValueForUniquePropertyIndex([entry["dest"]["key"] for entry in value if entry])
+        values = []
+
+        for _, _, v in self.iter_bone_value(skel, name):
+            if not v:
+                continue
+
+            if self.using and (rel_skel := v.get("rel")):
+                values.append(json.dumps(
+                    {"key": str(v["dest"]["key"]), "rel": rel_skel.dump()},
+                    sort_keys=True, default=str,
+                ))
+            else:
+                values.append(v["dest"]["key"])
+
+        return self._hashValueForUniquePropertyIndex(values) if values else []
 
     def structure(self) -> dict:
         return super().structure() | {

{viur_core-3.8.25 → viur_core-3.9.0.dev2}/src/viur/core/bones/string.py

@@ -292,19 +292,15 @@ class StringBone(RawBone):
         :param skel: The skeleton instance.
         :param name: The name of the property.
         :return: A list of unique index values for the property.
-        :raises NotImplementedError: If the StringBone has languages and the implementation
-            for this case is not yet defined.
         """
-        if self.languages:
-            # Not yet implemented as it's unclear if we should keep each language distinct or not
-            raise NotImplementedError()
+        if not self.caseSensitive:
+            values = [
+                value.lower() if isinstance(value, str) else value
+                for _, _, value in self.iter_bone_value(skel, name)
+                if value is not None
+            ]
 
-        if not self.caseSensitive and (value := skel[name]) is not None:
-            if self.multiple:
-                value = [v.lower() for v in value]
-            else:
-                value = value.lower()
-            return self._hashValueForUniquePropertyIndex(value)
+            return self._hashValueForUniquePropertyIndex(values) if values else []
 
         return super().getUniquePropertyIndexValues(skel, name)
 

{viur_core-3.8.25 → viur_core-3.9.0.dev2}/src/viur/core/bones/text.py

@@ -438,25 +438,6 @@ class TextBone(RawBone):
             elif not self.languages and isinstance(val, str):
                 skel[boneName] = self.singleValueFromClient(val, skel, boneName, None)[0]
 
-    def getUniquePropertyIndexValues(self, valuesCache: dict, name: str) -> list[str]:
-        """
-        Retrieves the unique property index values for the TextBone.
-
-        If the TextBone supports multiple languages, this method raises a NotImplementedError, as it's unclear
-        whether each language should be kept distinct or not. Otherwise, it calls the superclass's
-        getUniquePropertyIndexValues method to retrieve the unique property index values.
-
-        :param valuesCache: A dictionary containing the cached values for the TextBone.
-        :param name: The name of the TextBone.
-        :return: A list of unique property index values for the TextBone.
-        :raises NotImplementedError: If the TextBone supports multiple languages.
-        """
-        if self.languages:
-            # Not yet implemented as it's unclear if we should keep each language distinct or not
-            raise NotImplementedError()
-
-        return super().getUniquePropertyIndexValues(valuesCache, name)
-
     def structure(self) -> dict:
         return super().structure() | {
             "valid_html": self.validHtml,