persidict 0.34.3__py3-none-any.whl → 0.35.0__py3-none-any.whl

persidict/file_dir_dict.py

@@ -74,16 +74,17 @@ class FileDirDict(PersiDict):
 
         Raises:
             ValueError: If base_dir points to a file; if file_type is "__etag__";
-                or if configuration is inconsistent (e.g., non-str values with
-                unsupported file_type).
-            AssertionError: If file_type contains unsafe characters.
+                if file_type contains unsafe characters; or if configuration is
+                inconsistent (e.g., non-str values with unsupported file_type).
+            RuntimeError: If base_dir cannot be created or is not a directory.
         """
 
         super().__init__(immutable_items = immutable_items
                 ,digest_len = digest_len
                 ,base_class_for_values = base_class_for_values)
 
-        assert file_type == replace_unsafe_chars(file_type, "")
+        if file_type != replace_unsafe_chars(file_type, ""):
+            raise ValueError("file_type contains unsafe characters")
         self.file_type = file_type
         if self.file_type == "__etag__":
             raise ValueError(
@@ -92,8 +93,8 @@ class FileDirDict(PersiDict):
 
         if (base_class_for_values is None or
                 not issubclass(base_class_for_values,str)):
-            assert file_type in {"json", "pkl"}, ("For non-string values"
-                + " file_type must be either 'pkl' or 'json'.")
+            if file_type not in {"json", "pkl"}:
+                raise ValueError("For non-string values file_type must be either 'pkl' or 'json'.")
 
         base_dir = str(base_dir)
 
@@ -101,7 +102,8 @@ class FileDirDict(PersiDict):
             raise ValueError(f"{base_dir} is a file, not a directory.")
 
         os.makedirs(base_dir, exist_ok=True)
-        assert os.path.isdir(base_dir)
+        if not os.path.isdir(base_dir):
+            raise RuntimeError(f"Failed to create or access directory: {base_dir}")
 
         # self.base_dir_param = _base_dir
         self._base_dir = os.path.abspath(base_dir)
@@ -539,7 +541,8 @@ class FileDirDict(PersiDict):
             KeyError: If immutable_items is True or if the key does not exist.
         """
         key = SafeStrTuple(key)
-        assert not self.immutable_items, "Can't delete immutable items"
+        if self.immutable_items:
+            raise KeyError("Can't delete immutable items")
         filename = self._build_full_path(key)
         if not os.path.isfile(filename):
             raise KeyError(f"File {filename} does not exist")
@@ -563,11 +566,19 @@ class FileDirDict(PersiDict):
                 - Any if result_type == {"values"}
                 - tuple[SafeStrTuple, Any] if result_type == {"keys", "values"}
                 - tuple[..., float] including POSIX timestamp if "timestamps" is requested.
+
+        Raises:
+            TypeError: If result_type is not a set.
+            ValueError: If result_type is empty or contains unsupported labels.
         """
-        assert isinstance(result_type, set)
-        assert 1 <= len(result_type) <= 3
-        assert len(result_type | {"keys", "values", "timestamps"}) == 3
-        assert 1 <= len(result_type & {"keys", "values", "timestamps"}) <= 3
+        if not isinstance(result_type, set):
+            raise TypeError("result_type must be a set")
+        if not (1 <= len(result_type) <= 3):
+            raise ValueError("result_type must be a non-empty subset of {'keys','values','timestamps'}")
+        allowed = {"keys", "values", "timestamps"}
+        invalid = result_type - allowed
+        if invalid:
+            raise ValueError(f"Unsupported result_type entries: {sorted(invalid)}; allowed: {sorted(allowed)}")
 
         walk_results = os.walk(self._base_dir)
         ext_len = len(self.file_type) + 1

persidict/overlapping_multi_dict.py

@@ -46,18 +46,22 @@ class OverlappingMultiDict:
                 resulting dict also receives file_type=<key>.
 
         Raises:
-            AssertionError: If dict_type is not a PersiDict subclass, or if
+            TypeError: If dict_type is not a PersiDict subclass, or if
                 shared_subdicts_params is not a dict, or if any individual
                 parameter set is not a dict.
         """
-        assert issubclass(dict_type, PersiDict)
-        assert isinstance(shared_subdicts_params, dict)
+        if not issubclass(dict_type, PersiDict):
+            raise TypeError("dict_type must be a subclass of PersiDict")
+        if not isinstance(shared_subdicts_params, dict):
+            raise TypeError("shared_subdicts_params must be a dict")
         self.dict_type = dict_type
         self.shared_subdicts_params = shared_subdicts_params
         self.individual_subdicts_params = individual_subdicts_params
         self.subdicts_names = list(individual_subdicts_params.keys())
         for subdict_name in individual_subdicts_params:
-            assert isinstance(individual_subdicts_params[subdict_name], dict)
+            if not isinstance(individual_subdicts_params[subdict_name], dict):
+                raise TypeError(
+                    f"Params for subdict {subdict_name!r} must be a dict")
             self.__dict__[subdict_name] = dict_type(
                 **{**shared_subdicts_params
                 ,**individual_subdicts_params[subdict_name]

persidict/persi_dict.py

@@ -240,11 +240,21 @@ class PersiDict(MutableMapping, ParameterizableClass):
         Returns:
             Any: An iterator yielding keys, values, and/or timestamps based on
                 result_type.
-        """
-        assert isinstance(result_type, set)
-        assert 1 <= len(result_type) <= 3
-        assert len(result_type | {"keys", "values", "timestamps"}) == 3
-        assert 1 <= len(result_type & {"keys", "values", "timestamps"}) <= 3
+
+        Raises:
+            TypeError: If result_type is not a set.
+            ValueError: If result_type contains invalid entries or an invalid number of items.
+            NotImplementedError: Subclasses must implement the concrete iterator.
+        """
+        if not isinstance(result_type, set):
+            raise TypeError("result_type must be a set of strings")
+        if not (1 <= len(result_type) <= 3):
+            raise ValueError("result_type must contain between 1 and 3 elements")
+        allowed = {"keys", "values", "timestamps"}
+        if (result_type | allowed) != allowed:
+            raise ValueError("result_type can only contain 'keys', 'values', 'timestamps'")
+        if not (1 <= len(result_type & allowed) <= 3):
+            raise ValueError("result_type must include at least one of 'keys', 'values', 'timestamps'")
         raise NotImplementedError
 
 
@@ -322,11 +332,12 @@ class PersiDict(MutableMapping, ParameterizableClass):
             Any: Existing value if present; otherwise the provided default.
 
         Raises:
-            AssertionError: If default is a Joker command.
+            TypeError: If default is a Joker command (KEEP_CURRENT/DELETE_CURRENT).
         """
         # TODO: check edge cases to ensure the same semantics as standard dicts
         key = SafeStrTuple(key)
-        assert not isinstance(default, Joker)
+        if isinstance(default, Joker):
+            raise TypeError("default must be a regular value, not a Joker command")
         if key in self:
             return self[key]
         else:
@@ -383,7 +394,7 @@ class PersiDict(MutableMapping, ParameterizableClass):
         Raises:
             KeyError: If items are immutable (immutable_items is True).
         """
-        if self.immutable_items: # TODO: change to exceptions
+        if self.immutable_items:
             raise KeyError("Can't delete an immutable key-value pair")
 
         for k in self.keys():
@@ -408,7 +419,7 @@ class PersiDict(MutableMapping, ParameterizableClass):
             KeyError: If items are immutable (immutable_items is True).
         """
 
-        if self.immutable_items: # TODO: change to exceptions
+        if self.immutable_items:
             raise KeyError("Can't delete an immutable key-value pair")
 
         key = SafeStrTuple(key)

persidict/s3_dict.py

@@ -433,12 +433,23 @@ class S3Dict(PersiDict):
                 - Any if result_type == {"values"}
                 - tuple[SafeStrTuple, Any] if result_type == {"keys", "values"}
                 - tuple[..., float] including POSIX timestamp if "timestamps" is requested.
+
+        Raises:
+            ValueError: If result_type is not a set or contains entries other than
+                "keys", "values", and/or "timestamps", or if it is empty.
         """
 
-        assert isinstance(result_type, set)
-        assert 1 <= len(result_type) <= 3
-        assert len(result_type | {"keys", "values", "timestamps"}) == 3
-        assert 1 <= len(result_type & {"keys", "values", "timestamps"}) <= 3
+        if not isinstance(result_type, set):
+            raise ValueError(
+                "result_type must be a set containing one to three of: 'keys', 'values', 'timestamps'"
+            )
+        if not (1 <= len(result_type) <= 3):
+            raise ValueError("result_type must be a non-empty set with at most three elements")
+        allowed = {"keys", "values", "timestamps"}
+        if not result_type.issubset(allowed):
+            invalid = ", ".join(sorted(result_type - allowed))
+            raise ValueError(f"result_type contains invalid entries: {invalid}. Allowed: {sorted(allowed)}")
+        # Intersections/length checks are implied by the above conditions.
 
         suffix = "." + self.file_type
         ext_len = len(self.file_type) + 1
@@ -452,8 +463,14 @@ class S3Dict(PersiDict):
 
             Returns:
                 SafeStrTuple: The parsed key parts, still signed.
+
+            Raises:
+                ValueError: If the provided key does not start with this dictionary's root_prefix.
             """
-            assert full_name.startswith(self.root_prefix)
+            if not full_name.startswith(self.root_prefix):
+                raise ValueError(
+                    f"S3 object key '{full_name}' is outside of root_prefix '{self.root_prefix}'"
+                )
             result = full_name[prefix_len:-ext_len].split(sep="/")
             return SafeStrTuple(result)
 

persidict/safe_str_tuple.py

@@ -71,26 +71,33 @@ class SafeStrTuple(Sequence, Hashable):
             **kwargs: Not supported.
 
         Raises:
-            AssertionError: If kwargs are provided; if no args are provided; if
-                any string is empty, too long, or contains disallowed chars; or
-                if an argument has an invalid type.
+            TypeError: If unexpected keyword arguments are provided, if no args
+                are provided, or if an argument has an invalid type.
+            ValueError: If a string is empty, too long, or contains disallowed
+                characters.
         """
-        assert len(kwargs) == 0
-        assert len(args) > 0
+        if len(kwargs) != 0:
+            raise TypeError(f"Unexpected keyword arguments: {list(kwargs.keys())}")
+        if len(args) == 0:
+            raise TypeError("At least one argument is required")
         candidate_strings = []
         for a in args:
             if isinstance(a, SafeStrTuple):
                 candidate_strings.extend(a.strings)
             elif isinstance(a, str):
-                assert len(a) > 0
-                assert len(a) < SAFE_STRING_MAX_LENGTH
-                assert all(c in SAFE_CHARS_SET for c in a)
+                if len(a) == 0:
+                    raise ValueError("Strings must be non-empty")
+                if len(a) >= SAFE_STRING_MAX_LENGTH:
+                    raise ValueError(
+                        f"String length must be < {SAFE_STRING_MAX_LENGTH}, got {len(a)}")
+                if not all(c in SAFE_CHARS_SET for c in a):
+                    raise ValueError("String contains disallowed characters")
                 candidate_strings.append(a)
             elif _is_sequence_not_mapping(a):
                 if len(a) > 0:
                     candidate_strings.extend(SafeStrTuple(*a).strings)
             else:
-                assert False, f"Invalid argument type: {type(a)}"
+                raise TypeError(f"Invalid argument type: {type(a)}")
         self.strings = tuple(candidate_strings)
 
     @property

persidict/safe_str_tuple_signing.py

@@ -34,11 +34,18 @@ def _create_signature_suffix(input_str: str, digest_len: int) -> str:
 
     Returns:
         str: The computed suffix to append (may be an empty string).
+
+    Raises:
+        TypeError: If input_str is not a str or digest_len is not an int.
+        ValueError: If digest_len is negative.
     """
 
-    assert isinstance(input_str, str)
-    assert isinstance(digest_len, int)
-    assert digest_len >= 0
+    if not isinstance(input_str, str):
+        raise TypeError(f"input_str must be str, got {type(input_str)!r}")
+    if not isinstance(digest_len, int):
+        raise TypeError(f"digest_len must be int, got {type(digest_len)!r}")
+    if digest_len < 0:
+        raise ValueError(f"digest_len must be >= 0, got {digest_len}")
 
     if digest_len == 0:
         return ""
@@ -64,11 +71,18 @@ def _add_signature_suffix_if_absent(input_str: str, digest_len: int) -> str:
 
     Returns:
         str: The original or suffixed string.
+
+    Raises:
+        TypeError: If input_str is not a str or digest_len is not an int.
+        ValueError: If digest_len is negative.
     """
 
-    assert isinstance(input_str, str)
-    assert isinstance(digest_len, int)
-    assert digest_len >= 0
+    if not isinstance(input_str, str):
+        raise TypeError(f"input_str must be str, got {type(input_str)!r}")
+    if not isinstance(digest_len, int):
+        raise TypeError(f"digest_len must be int, got {type(digest_len)!r}")
+    if digest_len < 0:
+        raise ValueError(f"digest_len must be >= 0, got {digest_len}")
 
     if digest_len == 0:
         return input_str
@@ -121,11 +135,18 @@ def _remove_signature_suffix_if_present(input_str: str, digest_len: int) -> str:
     Returns:
         str: The original string without the suffix if detected; otherwise the
         original string.
+
+    Raises:
+        TypeError: If input_str is not a str or digest_len is not an int.
+        ValueError: If digest_len is negative.
     """
 
-    assert isinstance(input_str, str)
-    assert isinstance(digest_len, int)
-    assert digest_len >= 0
+    if not isinstance(input_str, str):
+        raise TypeError(f"input_str must be str, got {type(input_str)!r}")
+    if not isinstance(digest_len, int):
+        raise TypeError(f"digest_len must be int, got {type(digest_len)!r}")
+    if digest_len < 0:
+        raise ValueError(f"digest_len must be >= 0, got {digest_len}")
 
     if digest_len == 0:
         return input_str

persidict/write_once_dict.py

@@ -79,13 +79,16 @@ class WriteOnceDict(PersiDict):
                 (disabled).
 
         Raises:
-            AssertionError: If ``wrapped_dict`` is not a PersiDict or does not
-                enforce immutable items.
+            TypeError: If ``wrapped_dict`` is not a PersiDict instance.
+            ValueError: If ``wrapped_dict`` does not enforce immutable items.
         """
         if wrapped_dict is None:
             wrapped_dict = FileDirDict(immutable_items=True)
-        assert isinstance(wrapped_dict, PersiDict)
-        assert wrapped_dict.immutable_items == True
+        if not isinstance(wrapped_dict, PersiDict):
+            raise TypeError("wrapped_dict must be a PersiDict instance")
+        if wrapped_dict.immutable_items is not True:
+            raise ValueError("wrapped_dict must be append-only "
+                             "(immutable_items==True)")
         self.p_consistency_checks = p_consistency_checks
         PersiDict.__init__(self,
             base_class_for_values=wrapped_dict.base_class_for_values,

{persidict-0.34.3.dist-info → persidict-0.35.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: persidict
-Version: 0.34.3
+Version: 0.35.0
 Summary: Simple persistent key-value store for Python. Values are stored as files on a disk or as S3 objects on AWS cloud.
 Keywords: persistence,dicts,distributed,parallel
 Author: Vlad (Volodymyr) Pavlov

persidict-0.35.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+persidict/__init__.py,sha256=CDOSJGgCnyRTkGUTzaeg3Cqsxwx0-0EFieOtldXwAls,1380
+persidict/file_dir_dict.py,sha256=gvCyk_kp_3AC-zkHuSj-0lM4hf_fBK6iz3ffGQ7jtvU,25757
+persidict/jokers.py,sha256=H2MzKllvgm7t2sjX3GaRNLngOiG2ohE-lv0B3g3J1SQ,2710
+persidict/overlapping_multi_dict.py,sha256=v1c2kf3Bhm2Dh6SGEsRV58hQI11YX9ZPxyrDV_1d5s8,5360
+persidict/persi_dict.py,sha256=DIMQaY4gE8NSYTlHlk9rfOJJEYUuLV8kmQ-gc474py4,20052
+persidict/s3_dict.py,sha256=VKDqY9sASffeXtfbavVWk8-umrioIG5Xq57Qqg1wPH4,21522
+persidict/safe_chars.py,sha256=9Qy24fu2dmiJOdmCF8mKZULfQaRp7H4oxfgDXeLgogI,1160
+persidict/safe_str_tuple.py,sha256=YBTcYjUKIffznOawXb9xKjz4HaKdklrgyVtegJFmr5w,7202
+persidict/safe_str_tuple_signing.py,sha256=RQAj4fnpRVaOe0KpwLler1UTaeNOgXCQpU3t80ixtxg,7493
+persidict/write_once_dict.py,sha256=-lPQ_yuU62pczHT0BYO6SFbiZBKFq8Tj9ln3jCzNDzA,11443
+persidict-0.35.0.dist-info/WHEEL,sha256=F3mArEuDT3LDFEqo9fCiUx6ISLN64aIhcGSiIwtu4r8,79
+persidict-0.35.0.dist-info/METADATA,sha256=oo_YL1_W4ux3lTJZvREQPcin1ILJmvxtMDlWuITUwCw,9262
+persidict-0.35.0.dist-info/RECORD,,

{persidict-0.34.3.dist-info → persidict-0.35.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.15
+Generator: uv 0.8.16
 Root-Is-Purelib: true
 Tag: py3-none-any

persidict-0.34.3.dist-info/RECORD

@@ -1,13 +0,0 @@
-persidict/__init__.py,sha256=CDOSJGgCnyRTkGUTzaeg3Cqsxwx0-0EFieOtldXwAls,1380
-persidict/file_dir_dict.py,sha256=Lf65HqI00J7Pi2jELWEXo5DUk8cW1GdKdgkVyFgFHGo,25135
-persidict/jokers.py,sha256=H2MzKllvgm7t2sjX3GaRNLngOiG2ohE-lv0B3g3J1SQ,2710
-persidict/overlapping_multi_dict.py,sha256=ZUbkNConqUDTP1LFxKv0WFvsAPcCiHUjhNKe8912wNs,5112
-persidict/persi_dict.py,sha256=mwHng2pjXf_durHKeiTZRDOVJbpHjANkdVR1_y2Bs4E,19408
-persidict/s3_dict.py,sha256=Xl-ZOukY7dl-LkujaPiPNVZo9sK9t5bFhG2lCYLAbjs,20635
-persidict/safe_chars.py,sha256=9Qy24fu2dmiJOdmCF8mKZULfQaRp7H4oxfgDXeLgogI,1160
-persidict/safe_str_tuple.py,sha256=4wt3Jfd7efKczTP1o--XkOSic5_7riVDIgnK19Bzfbk,6741
-persidict/safe_str_tuple_signing.py,sha256=ihV1hLx24N9f64nFbqAvbnsPZDon-kUAVncs1628Q6M,6428
-persidict/write_once_dict.py,sha256=5tGqm51EIEcjnAhP8oOY-eQ1AaQhteQxSd0SPIp934c,11217
-persidict-0.34.3.dist-info/WHEEL,sha256=Jb20R3Ili4n9P1fcwuLup21eQ5r9WXhs4_qy7VTrgPI,79
-persidict-0.34.3.dist-info/METADATA,sha256=nXLxLxK2mZ7NmVfRu6H--W8hVNJOQZl1lAs1mbkALXQ,9262
-persidict-0.34.3.dist-info/RECORD,,