persidict 0.38.0__py3-none-any.whl → 0.103.0__py3-none-any.whl

persidict/safe_chars.py

@@ -43,3 +43,16 @@ def replace_unsafe_chars(a_str: str, replace_with: str) -> str:
     result_list = [(c if c in safe_chars else replace_with) for c in a_str]
     result_str = "".join(result_list)
     return result_str
+
+def contains_unsafe_chars(a_str: str) -> bool:
+    """Check if a string contains unsafe characters.
+
+    Args:
+        a_str (str): Input string to check for unsafe characters.
+
+    Returns:
+        bool: True if the string contains any character not in the safe
+            character set, False otherwise.
+    """
+    safe_chars = get_safe_chars()
+    return any(c not in safe_chars for c in a_str)

persidict/safe_str_tuple.py

@@ -42,7 +42,7 @@ def _is_sequence_not_mapping(obj: Any) -> bool:
 
 
 class SafeStrTuple(Sequence, Hashable):
-    """An immutable sequence of non-empty URL/filename-safe strings.
+    """An immutable sequence of URL/filename-safe strings.
 
     The sequence is flat (no nested structures) and hashable, making it suitable
     for use as a dictionary key. All strings are validated to contain only
@@ -55,7 +55,7 @@ class SafeStrTuple(Sequence, Hashable):
     def __init__(self, *args, **kwargs):
         """Initialize from strings or nested sequences of strings.
 
-        The constructor accepts one or more arguments which may be:
+        The constructor accepts zero or more arguments which may be:
         - a SafeStrTuple
         - a single string
         - a sequence (list/tuple/etc.) containing any of the above recursively
@@ -66,7 +66,7 @@ class SafeStrTuple(Sequence, Hashable):
         SAFE_STRING_MAX_LENGTH.
 
         Args:
-            *args: One or more inputs (strings, sequences, or SafeStrTuple) that
+            *args: Zero or more inputs (strings, sequences, or SafeStrTuple) that
                 will be flattened into a tuple of safe strings.
             **kwargs: Not supported.
 
@@ -78,8 +78,6 @@ class SafeStrTuple(Sequence, Hashable):
         """
         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):
@@ -213,4 +211,28 @@ class SafeStrTuple(Sequence, Hashable):
         Returns:
             SafeStrTuple: A new instance with elements in reverse order.
         """
-        return SafeStrTuple(*reversed(self.strings))
+        return SafeStrTuple(*reversed(self.strings))
+
+class NonEmptySafeStrTuple(SafeStrTuple):
+    """A SafeStrTuple that must contain at least one string.
+
+    This subclass enforces that the tuple is non-empty.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize and enforce non-empty constraint.
+
+        Args:
+            *args: One or more inputs (strings, sequences, or SafeStrTuple) that
+                will be flattened into a tuple of safe strings.
+            **kwargs: Not supported.
+
+        Raises:
+            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, contains disallowed
+                characters, or if the resulting tuple is empty.
+        """
+        super().__init__(*args, **kwargs)
+        if len(self.strings) == 0:
+            raise ValueError("NonEmptySafeStrTuple must contain at least one string")

persidict/singletons.py

@@ -0,0 +1,232 @@
+"""Special singleton markers used to modify values in PersiDict without data payload.
+
+This module defines two singleton flags used as "joker" values when writing to
+persistent dictionaries:
+
+- KEEP_CURRENT: keep the current value unchanged.
+- DELETE_CURRENT: delete the current value if it exists.
+
+These flags are intended to be passed as the value part in dict-style
+assignments (e.g., d[key] = KEEP_CURRENT) and are interpreted by PersiDict
+implementations.
+
+Examples:
+    >>> from persidict.singletons import KEEP_CURRENT, DELETE_CURRENT
+    >>> d[key] = KEEP_CURRENT  # Do not alter existing value
+    >>> d[key] = DELETE_CURRENT  # Remove key if present
+"""
+from typing import Any
+
+from parameterizable import (
+    ParameterizableClass
+    , register_parameterizable_class)
+
+
+class Singleton(ParameterizableClass):
+    """Base class for singleton classes.
+
+    This class implements a singleton pattern where each subclass maintains
+    exactly one instance that is returned on every instantiation.
+    """
+    _instances: dict[type, "Singleton"] = {}
+
+    def get_params(self) -> dict[str, Any]:
+        """Return parameters for parameterizable API.
+
+        Returns:
+            dict[str, Any]: Always an empty dict for joker flags.
+        """
+        return {}
+
+    def __new__(cls):
+        """Create or return the singleton instance for the subclass.
+        
+        Args:
+            cls: The class for which to create or retrieve the singleton instance.
+            
+        Returns:
+            Joker: The singleton instance for the specified class.
+        """
+        if cls not in Singleton._instances:
+            Singleton._instances[cls] = super().__new__(cls)
+        return Singleton._instances[cls]
+
+
+class Joker(Singleton):
+    """Base class for joker flags.
+
+    Subclasses represent value-less commands that
+    alter persistence behavior when assigned to a key.
+    """
+    pass
+
+
+class KeepCurrentFlag(Joker):
+    """Flag instructing PersiDict to keep the current value unchanged.
+
+    Usage:
+        Assign this flag instead of a real value to indicate that an existing
+        value should not be modified.
+
+    Examples:
+        >>> d[key] = KEEP_CURRENT
+
+    Note:
+        This is a singleton class; constructing it repeatedly returns the same
+        instance.
+    """
+    pass
+
+class DeleteCurrentFlag(Joker):
+    """Flag instructing PersiDict to delete the current value for a key.
+
+    Usage:
+        Assign this flag instead of a real value to remove the key if it
+        exists. If the key is absent, implementations will typically no-op.
+
+    Examples:
+        >>> d[key] = DELETE_CURRENT
+
+    Note:
+        This is a singleton class; constructing it repeatedly returns the same
+        instance.
+    """
+    pass
+
+
+class StatusFlag(Singleton):
+    """Base class for process status flags.
+
+    Subclasses represent status flags that can be used to control
+    processing flow in various contexts.
+    """
+    pass
+
+class ETagHasNotChangedFlag(StatusFlag):
+    """Flag indicating that an ETag has not changed.
+
+    Usage:
+        This flag can be used in contexts where a notification is needed
+        to indicate that an ETag (entity tag) has not changed, typically in
+        web or caching scenarios.
+    """
+
+    pass
+
+
+class ContinueNormalExecutionFlag(StatusFlag):
+    """Flag indicating to continue normal execution without special handling.
+
+    Usage:
+        This flag can be used in contexts where a notification is needed
+        to indicate that normal processing should proceed without alteration.
+
+    Note:
+        This is a singleton class; constructing it repeatedly returns the same
+        instance.
+    """
+    pass
+
+class ExecutionIsCompleteFlag(StatusFlag):
+    """Flag indicating no more processing is required.
+
+    Usage:
+        This flag can be used in contexts where a notification is needed
+        to indicate that all necessary processing steps were
+        finished successfully and nore further action is needed.
+
+    Note:
+        This is a singleton class; constructing it repeatedly returns the same
+        instance.
+    """
+    pass
+
+
+register_parameterizable_class(KeepCurrentFlag)
+register_parameterizable_class(DeleteCurrentFlag)
+register_parameterizable_class(ContinueNormalExecutionFlag)
+register_parameterizable_class(ExecutionIsCompleteFlag)
+register_parameterizable_class(ETagHasNotChangedFlag)
+
+_KeepCurrent = KeepCurrentFlag()
+KEEP_CURRENT = KeepCurrentFlag()
+"""Flag indicating that the current value should be kept unchanged.
+
+This flag can be assigned to a key in a PersiDict to indicate that any existing
+value for that key should not be modified during an update operation.
+
+If assigned to a key that does not exist, the operation will succeed without
+eny change.
+
+Example:
+    >>> d = PersiDict()
+    >>> d['key'] = 'value'
+    >>> d['key'] = KEEP_CURRENT  # Keeps 'value' unchanged
+"""
+
+
+_DeleteCurrent = DeleteCurrentFlag()
+DELETE_CURRENT = DeleteCurrentFlag()
+"""Flag indicating that the current value should be deleted.
+
+This flag can be assigned to a key in a PersiDict to indicate that any existing
+value for that key should be deleted during an update operation.
+
+If assigned to a key that does not exist, the operation will succeed without
+any change.
+
+Example:
+    >>> d = PersiDict()
+    >>> d['key'] = 'value'
+    >>> d['key'] = DELETE_CURRENT  # same as d.discard('key')
+"""
+
+
+_ContinueNormalExecution = ContinueNormalExecutionFlag()
+CONTINUE_NORMAL_EXECUTION = ContinueNormalExecutionFlag()
+"""Flag indicating that normal execution should continue.
+
+This flag can be used in process flow control contexts to signal that normal
+execution should proceed without any special handling or alterations.
+
+When this flag is returned from a processing step, it indicates that the
+operation completed successfully and the next step in the normal execution
+flow should be performed.
+
+Example:
+    >>> if pre_process_input(data) is CONTINUE_NORMAL_EXECUTION:
+    ...     # Continue with next step
+    ...     perform_next_step()
+"""
+
+_ExecutionIsComplete = ExecutionIsCompleteFlag()
+EXECUTION_IS_COMPLETE = ExecutionIsCompleteFlag()
+"""Flag indicating that execution is complete, no further processing is needed.
+
+This flag can be used in process flow control contexts to signal that all necessary
+processing has been completed successfully and no additional steps are required.
+
+When this flag is returned from a processing step, it indicates that the
+operation completed successfully and no further processing should be performed.
+
+Example:
+    >>> if pre_process_input(data) is EXECUTION_IS_COMPLETE:
+    ...     # Skip remaining steps
+    ...     return result
+"""
+
+_ETagHasNotChanged = ETagHasNotChangedFlag()
+ETAG_HAS_NOT_CHANGED = ETagHasNotChangedFlag()
+"""Flag indicating that an ETag value has not changed.
+
+This flag can be used in contexts where a notification is needed to indicate
+that an ETag (entity tag) comparison shows no changes.
+
+When this flag is returned from a processing step, it indicates that the
+resource's ETag matches and no content updates are necessary.
+
+Example:
+    >>> if check_resource_etag(url) is ETAG_HAS_NOT_CHANGED:
+    ...     # Skip resource update
+    ...     return cached_content
+"""

persidict/write_once_dict.py

@@ -1,3 +1,13 @@
+"""Write-once dictionary with probabilistic consistency checking.
+
+This module provides WriteOnceDict, a wrapper around PersiDict that supports
+an alternative behavior of append-only dictionaries.
+It allows repeated writes to an existing key but assumes that
+all the subsequent writes have exactly the same value as the first one,
+so they can be safely ignored. Random consistency checks ensure that
+repeated writes contain the same values, helping detect data consistency issues.
+Setting the probability of random checks to 0 disables them.
+"""
 from __future__ import annotations
 
 import time
@@ -5,8 +15,9 @@ import time
 from deepdiff import DeepDiff
 from parameterizable import register_parameterizable_class, sort_dict_by_keys
 
-from .jokers import KEEP_CURRENT, KeepCurrentFlag
-from .persi_dict import PersiDict
+from . import SafeStrTuple
+from .singletons import KEEP_CURRENT, KeepCurrentFlag, ETagHasNotChangedFlag
+from .persi_dict import PersiDict, NonEmptyPersiDictKey
 from .file_dir_dict import FileDirDict
 import random
 import sys
@@ -72,7 +83,7 @@ class WriteOnceDict(PersiDict):
 
         Args:
             wrapped_dict: The underlying persistent dictionary to wrap. If not
-                provided, a FileDirDict with immutable_items=True is created.
+                provided, a FileDirDict with append_only=True is created.
             p_consistency_checks: Probability in [0, 1] to perform a
                 consistency check when a key already exists. ``None`` means 0.0
                 (disabled).
@@ -82,17 +93,16 @@ class WriteOnceDict(PersiDict):
             ValueError: If ``wrapped_dict`` does not enforce immutable items.
         """
         if wrapped_dict is None:
-            wrapped_dict = FileDirDict(immutable_items=True)
+            wrapped_dict = FileDirDict(append_only=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)")
+        if wrapped_dict.append_only is not True:
+            raise ValueError("wrapped_dict must be append-only")
         self.p_consistency_checks = p_consistency_checks
         PersiDict.__init__(self,
             base_class_for_values=wrapped_dict.base_class_for_values,
-            immutable_items=True,
-            digest_len=wrapped_dict.digest_len)
+            serialization_format=wrapped_dict.serialization_format,
+            append_only=True)
         self._wrapped_dict = wrapped_dict
         self._consistency_checks_passed = 0
         self._consistency_checks_attempted = 0
@@ -181,7 +191,10 @@ class WriteOnceDict(PersiDict):
         sorted_params = sort_dict_by_keys(params)
         return sorted_params
 
-    def __setitem__(self, key:PersiDictKey, value):
+    def set_item_get_etag(self, key: NonEmptyPersiDictKey, value: Any) -> str|None:
+        raise NotImplementedError("Operation not supported on WriteOnceDict.")
+
+    def __setitem__(self, key:NonEmptyPersiDictKey, value):
         """Set a value for a key, preserving the first assignment.
 
         If the key is new, the value is stored. If the key already exists,
@@ -233,7 +246,7 @@ class WriteOnceDict(PersiDict):
                         + f"which is not allowed. Details here: {diff_dict} ")
                 self._consistency_checks_passed += 1
 
-    def __contains__(self, item:PersiDictKey):
+    def __contains__(self, item:NonEmptyPersiDictKey):
         """Check if a key exists in the dictionary.
 
         Args:
@@ -244,7 +257,7 @@ class WriteOnceDict(PersiDict):
         """
         return item in self._wrapped_dict
 
-    def __getitem__(self, key:PersiDictKey):
+    def __getitem__(self, key:NonEmptyPersiDictKey):
         """Retrieve a value by key.
 
         Args:
@@ -255,6 +268,20 @@ class WriteOnceDict(PersiDict):
         """
         return self._wrapped_dict[key]
 
+
+    def get_item_if_etag_changed(self, key: NonEmptyPersiDictKey, etag: str | None
+                                 ) -> tuple[Any, str|None] |ETagHasNotChangedFlag:
+        """Retrieve a value and its etag if the etag is new.
+        Args:
+            key: Key to look up.
+            etag: Previous etag to compare against.
+        Returns:
+            tuple[Any, str|None] | ETagHasNotChangedFlag: Stored value and its
+                etag if the etag is new, or ETAG_HAS_NOT_CHANGED if the
+                etag matches the current one.
+        """
+        return self._wrapped_dict.get_item_if_etag_changed(key, etag)
+
     def __len__(self):
         """Return the number of items stored.
 
@@ -274,7 +301,7 @@ class WriteOnceDict(PersiDict):
         """
         return self._wrapped_dict._generic_iter(iter_type)
 
-    def timestamp(self, key: PersiDictKey) -> float:
+    def timestamp(self, key: NonEmptyPersiDictKey) -> float:
         """Return the timestamp for a given key.
 
         Args:
@@ -297,25 +324,14 @@ class WriteOnceDict(PersiDict):
         """
         return getattr(self._wrapped_dict, name)
 
-    @property
-    def base_dir(self) -> str|None:
-        """Base directory of the wrapped dict (if applicable).
-        
-        Returns:
-            str | None: The base directory path, or None if not applicable.
-        """
-        return self._wrapped_dict.base_dir
 
-    @property
-    def base_url(self) -> str|None:
-        """Base URL of the wrapped dict (if applicable).
-        
-        Returns:
-            str | None: The base URL, or None if not applicable.
-        """
-        return self._wrapped_dict.base_url
+    def __delitem__(self, key):
+        raise TypeError(
+            f"{self.__class__.__name__} has immutable items "
+            "and does not support deletion.")
+
 
-    def get_subdict(self, prefix_key: PersiDictKey) -> WriteOnceDict:
+    def get_subdict(self, prefix_key: NonEmptyPersiDictKey) -> WriteOnceDict:
         """Return a WriteOnceDict view over a sub-keyspace.
 
         Args:
@@ -330,4 +346,5 @@ class WriteOnceDict(PersiDict):
         result = WriteOnceDict(subdict, self.p_consistency_checks)
         return result
 
+
 register_parameterizable_class(WriteOnceDict)

{persidict-0.38.0.dist-info → persidict-0.103.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: persidict
-Version: 0.38.0
+Version: 0.103.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
@@ -18,11 +18,12 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Dist: parameterizable
 Requires-Dist: lz4
 Requires-Dist: joblib
-Requires-Dist: numpy
-Requires-Dist: pandas
 Requires-Dist: jsonpickle
 Requires-Dist: deepdiff
+Requires-Dist: boto3
 Requires-Dist: boto3 ; extra == 'aws'
+Requires-Dist: numpy ; extra == 'dev'
+Requires-Dist: pandas ; extra == 'dev'
 Requires-Dist: boto3 ; extra == 'dev'
 Requires-Dist: moto ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
@@ -44,7 +45,8 @@ storing each value as its own file or S3 object. Keys are limited to
 text strings or sequences of strings.
 
 In contrast to traditional persistent dictionaries (e.g., Python’s `shelve)`, 
-`persidict` is designed for distributed environments where multiple processes 
+`persidict` is [designed](https://github.com/pythagoras-dev/persidict/blob/master/design_principles.md) 
+for distributed environments where multiple processes 
 on different machines concurrently work with the same store.
 
 ## 2. Why Use It?
@@ -160,8 +162,8 @@ print(f"API Key: {cloud_config['api_key']}")
 You can also constrain values to a specific class.
 * **Order**: Insertion order is not preserved.
 * **Additional Methods**: `PersiDict` provides extra methods not in the standard 
-dict API, such as `timestamp()`, `random_key()`, `newest_keys()`, `subdicts()`
-, `delete_if_exists()`, `get_params()` and more.
+dict API, such as `timestamp()`, `etag()`, `random_key()`, `newest_keys()`
+, `subdicts()`, `discard()`, `get_params()` and more.
 * **Special Values**: Use `KEEP_CURRENT` to avoid updating a value 
 and `DELETE_CURRENT` to delete a value during an assignment.
 
@@ -172,13 +174,14 @@ and `DELETE_CURRENT` to delete a value during an assignment.
 * **`PersiDict`**: The abstract base class that defines the common interface 
 for all persistent dictionaries in the package. It's the foundation 
 upon which everything else is built.
-* **`PersiDictKey`**: A type hint that specifies what can be used
-as a key in any `PersiDict`. It can be a `SafeStrTuple`, a single string, 
+* **`NonEmptyPersiDictKey`**: A type hint that specifies what can be used
+as a key in any `PersiDict`. It can be a `NonEmptySafeStrTuple`, a single string, 
 or a sequence of strings. When a `PesiDict` method requires a key as an input,
-it will accept any of these types and convert them to a `SafeStrTuple` internally.
-* **`SafeStrTuple`**: The core data structure for keys. It's an immutable, 
-flat tuple of non-empty, URL/filename-safe strings, ensuring that 
-keys are consistent and safe for various storage backends. 
+it will accept any of these types and convert them to 
+a `NonEmptySafeStrTuple` internally.
+* **`NonEmptySafeStrTuple`**: The core data structure for keys. 
+It's an immutable, flat tuple of non-empty, URL/filename-safe strings, 
+ensuring that keys are consistent and safe for various storage backends. 
 When a `PersiDict` method returns a key, it will always be in this format.
 
 ### 5.2 Main Implementations
@@ -191,24 +194,25 @@ suitable for distributed environments.
 
 ### 5.3 Key Parameters
 
-* **`file_type`**: A key parameter for `FileDirDict` and `S3Dict` that 
-determines the serialization format for values. 
-Common options are `"pkl"` (pickle) and `"json"`. 
-Any other value is treated as plain text for string storage.
+* **`serialization_format`**: A key parameter for `FileDirDict` and `S3Dict` that 
+        determines the serialization format used to store values. 
+        Common options are `"pkl"` (pickle) and `"json"`. 
+        Any other value is treated as plain text for string storage.
 * **`base_class_for_values`**: An optional parameter for any `PersiDict` 
 that enforces type checking on all stored values, ensuring they are 
 instances of a specific class.
-* **`immutable_items`**: A boolean parameter that can make a `PersiDict` 
-"write-once," preventing any modification or deletion of existing items.
+* **`append_only`**: A boolean parameter that makes items inside a `PersiDict` immutable, 
+preventing them from modification or deletion.
 * **`digest_len`**: An integer that specifies the length of a hash suffix 
-added to key components to prevent collisions on case-insensitive file systems.
+added to key components in `FileDirDict` to prevent collisions 
+on case-insensitive file systems.
 * **`base_dir`**: A string specifying the directory path where a `FileDirDict`
 stores its files. For `S3Dict`, this directory is used to cache files locally.
 * **`bucket_name`**: A string specifying the name of the S3 bucket where
 an `S3Dict` stores its objects.
 * **`region`**: An optional string specifying the AWS region for the S3 bucket.
 
-### 5.4 Advanced Classes
+### 5.4 Advanced and Supporting Classes
 
 * **`WriteOnceDict`**: A wrapper that enforces write-once behavior 
 on any `PersiDict`, ignoring subsequent writes to the same key. 
@@ -216,7 +220,13 @@ It also allows for random consistency checks to ensure subsequent
 writes to the same key always match the original value.
 * **`OverlappingMultiDict`**: An advanced container that holds 
 multiple `PersiDict` instances sharing the same storage 
-but with different `file_type`s.
+but with different `serialization_format`s.
+* **`LocalDict`**: An in-memory `PersiDict` backed by 
+a RAM-only hierarchical store.
+* **`EmptyDict`**: A minimal implementation of `PersiDict` that behaves  
+like a null device in OS - accepts all writes but discards them, 
+returns nothing on reads. Always appears empty 
+regardless of operations performed on it.
 
 ### 5.5 Special "Joker" Values
 
@@ -241,7 +251,7 @@ from the dictionary when assigned to a key.
 | `newest_values(max_n=None)` | `list[Any]` | Returns a list of values corresponding to the newest keys. |
 | `get_subdict(prefix_key)` | `PersiDict` | Returns a new `PersiDict` instance that provides a view into a subset of keys sharing a common prefix. |
 | `subdicts()` | `dict[str, PersiDict]` | Returns a dictionary mapping all first-level key prefixes to their corresponding sub-dictionary views. |
-| `delete_if_exists(key)` | `bool` | Deletes a key-value pair if it exists and returns `True`; otherwise, returns `False`. |
+| `discard(key)` | `bool` | Deletes a key-value pair if it exists and returns `True`; otherwise, returns `False`. |
 | `get_params()` | `dict` | Returns a dictionary of the instance's configuration parameters, supporting the `parameterizable` API. |
 
 ## 7. Installation
@@ -278,14 +288,14 @@ pip install persidict[dev]
 * [jsonpickle](https://jsonpickle.github.io)
 * [joblib](https://joblib.readthedocs.io)
 * [lz4](https://python-lz4.readthedocs.io)
-* [pandas](https://pandas.pydata.org)
-* [numpy](https://numpy.org)
 * [deepdiff](https://zepworks.com/deepdiff)
 
 For AWS S3 support (`S3Dict`), you will also need:
 * [boto3](https://boto3.readthedocs.io)
 
 For development and testing, the following packages are used:
+* [pandas](https://pandas.pydata.org)
+* [numpy](https://numpy.org)
 * [pytest](https://pytest.org)
 * [moto](http://getmoto.org)
 

persidict-0.103.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+persidict/__init__.py,sha256=8PvvqAjitbHDe9aLWglsHThQDEnc7lkdu5jKAuJUZr4,2427
+persidict/basic_s3_dict.py,sha256=i_P2B_IvXlFXMhpvKFloK5cfbQrgpMFyk60B5ca_Ihc,23230
+persidict/cached_appendonly_dict.py,sha256=T1rCf2PYR0wDCcMLyB8FJ6eqlBgkeFO6ChZb0E96yP8,9754
+persidict/cached_mutable_dict.py,sha256=N-oInUol1y_VlZKyQ0TNPuwolcSbMLIyjtDoxo93A8Y,8979
+persidict/empty_dict.py,sha256=B1RnYdbo4rmnYfqWfUJPbKh18biuClHT9kFD2DCIfWo,6033
+persidict/file_dir_dict.py,sha256=TuqSCGLTPxK70sps4PVH_4WnfmY5RrkrqbBx13E92Mc,30782
+persidict/local_dict.py,sha256=HOJU_InRLLag7tG6j2D3Pa2MoyRy23SjJyYOKyD6b2A,21683
+persidict/overlapping_multi_dict.py,sha256=vh8SeZjhCN1pIZTcU0i4N6GlD9eZcSsdeZYEenk0xjc,6490
+persidict/persi_dict.py,sha256=vUxu0mlveVLoLhppiPdZAJ_6Qfijw8QaTQsmXHKQSQc,29138
+persidict/s3_dict_file_dir_cached.py,sha256=C6WoBO35UrPzNWRkFQcJ5fNrchtH_gwflJpa2aKPUsI,8628
+persidict/s3_dict_legacy.py,sha256=OM01o4Zs9_dB08iXb0VA-xUkKLx8TEK_ij_2CWHpn0c,22601
+persidict/safe_chars.py,sha256=gKYXA4RDuOVy_vhGXn8y0BFNHyuOvLsFyaJQXL013Go,2129
+persidict/safe_str_tuple.py,sha256=BSRMNgLfZoAwS7ZkiVA3fV2sfj2i_NO1tjstVP-XGOU,8047
+persidict/safe_str_tuple_signing.py,sha256=mpOfx_xyprc0_c60XPB_EihI3vR1gOn6T03iCx1HwwQ,7494
+persidict/singletons.py,sha256=eNo0SYJLtBksrb1jnIXOabhUQgi2uemEPpji5vrrIyk,7230
+persidict/write_once_dict.py,sha256=W3ABdX-Tt4SJnULUBWIattSP4bOnd_8tHT_Rdt_83_4,12691
+persidict-0.103.0.dist-info/WHEEL,sha256=-neZj6nU9KAMg2CnCY6T3w8J53nx1kFGw_9HfoSzM60,79
+persidict-0.103.0.dist-info/METADATA,sha256=3iLXoS735wH5tj-Xl_3M-ycTt7UDGr4SdRY7eKSkCf4,12944
+persidict-0.103.0.dist-info/RECORD,,

{persidict-0.38.0.dist-info → persidict-0.103.0.dist-info}/WHEEL

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