persidict 0.15.0__tar.gz → 0.17.0__tar.gz

{persidict-0.15.0 → persidict-0.17.0}/PKG-INFO

@@ -1,11 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: persidict
-Version: 0.15.0
+Version: 0.17.0
 Summary: Simple persistent key-value store for Python. Values are stored as files on a disk or as S3 objects on AWS cloud.
-Home-page: https://github.com/pythagoras-dev/persidict
-Author: Vlad (Volodymyr) Pavlov
-Author-email: vlpavlov@ieee.org
 Keywords: persistence,dicts,distributed,parallel
+Author: Vlad (Volodymyr) Pavlov
+Author-email: Vlad (Volodymyr) Pavlov <vlpavlov@ieee.org>
+License: MIT
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -15,18 +15,20 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
 Requires-Dist: lz4
 Requires-Dist: joblib
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: jsonpickle
 Requires-Dist: boto3
-Requires-Dist: moto
-Requires-Dist: pytest
 Requires-Dist: parameterizable
+Requires-Dist: boto3 ; extra == 'dev'
+Requires-Dist: moto ; extra == 'dev'
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Python: >=3.10
+Project-URL: Homepage, https://github.com/pythagoras-dev/persidict
+Provides-Extra: dev
+Description-Content-Type: text/markdown
 
 # persidict
 
@@ -211,4 +213,4 @@ Binary installers for the latest released version are available at the Python pa
 
 ## Key Contacts
 
-* [Vlad (Volodymyr) Pavlov](https://www.linkedin.com/in/vlpavlov/)
+* [Vlad (Volodymyr) Pavlov](https://www.linkedin.com/in/vlpavlov/)

persidict-0.17.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["uv_build"]
+build-backend = "uv_build"
+
+[project]
+name = "persidict"
+version = "0.17.0"
+description = "Simple persistent key-value store for Python. Values are stored as files on a disk or as S3 objects on AWS cloud."
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [
+    {name = "Vlad (Volodymyr) Pavlov", email = "vlpavlov@ieee.org"}
+]
+keywords = ["persistence", "dicts", "distributed", "parallel"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules"
+]
+dependencies = [
+    "lz4",
+    "joblib",
+    "numpy",
+    "pandas",
+    "jsonpickle",
+    "boto3",
+    "parameterizable"
+]
+
+[project.urls]
+Homepage = "https://github.com/pythagoras-dev/persidict"
+
+[project.optional-dependencies]
+dev = [
+    "boto3",
+    "moto",
+    "pytest"
+]

{persidict-0.15.0 → persidict-0.17.0/src}/persidict/file_dir_dict.py

@@ -156,7 +156,7 @@ class FileDirDict(PersiDict):
         """Convert a key into a filesystem path."""
 
         key = sign_safe_str_tuple(key, self.digest_len)
-        key = [self.base_dir] + list(key.str_chain)
+        key = [self.base_dir] + list(key.strings)
         dir_names = key[:-1] if is_file_path else key
 
         if create_subdirs:

{persidict-0.15.0 → persidict-0.17.0/src}/persidict/persi_dict.py

@@ -23,7 +23,6 @@ from __future__ import annotations
 from abc import abstractmethod
 import random
 from parameterizable import ParameterizableClass
-from copy import deepcopy
 from typing import Any, Sequence, Optional
 from collections.abc import MutableMapping
 

{persidict-0.15.0 → persidict-0.17.0/src}/persidict/s3_dict.py

@@ -82,7 +82,11 @@ class S3Dict(PersiDict):
         else:
             self.s3_client = boto3.client('s3', region_name=region)
 
-        self.bucket = self.s3_client.create_bucket(Bucket=bucket_name)
+        try:
+            self.s3_client.create_bucket(Bucket=bucket_name)
+        except:
+            pass
+
         self.bucket_name = bucket_name
 
         self.root_prefix=root_prefix

{persidict-0.15.0 → persidict-0.17.0/src}/persidict/safe_chars.py

@@ -2,6 +2,7 @@ import string
 from copy import deepcopy
 
 SAFE_CHARS_SET = set(string.ascii_letters + string.digits + "()_-~.=")
+SAFE_STRING_MAX_LENGTH = 254
 
 def get_safe_chars() -> set[str]:
     """Return a set of allowed characters."""

{persidict-0.15.0 → persidict-0.17.0/src}/persidict/safe_str_tuple.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 from collections.abc import Sequence, Mapping, Hashable
 from typing import Any
-from persidict.safe_chars import SAFE_CHARS_SET
+from src.persidict.safe_chars import SAFE_CHARS_SET, SAFE_STRING_MAX_LENGTH
 
 
 def _is_sequence_not_mapping(obj:Any) -> bool:
@@ -23,7 +23,7 @@ class SafeStrTuple(Sequence, Hashable):
     """An immutable sequence of non-emtpy URL/filename-safe strings.
     """
 
-    str_chain: tuple[str, ...]
+    strings: tuple[str, ...]
 
     def __init__(self, *args, **kwargs):
         """Create a SafeStrTuple from a sequence/tree of strings.
@@ -36,36 +36,42 @@ class SafeStrTuple(Sequence, Hashable):
         """
         assert len(kwargs) == 0
         assert len(args) > 0
-        candidate_str_chain = []
+        candidate_strings = []
         for a in args:
             if isinstance(a, SafeStrTuple):
-                candidate_str_chain.extend(a.str_chain)
+                candidate_strings.extend(a.strings)
             elif isinstance(a, str):
                 assert len(a) > 0
+                assert len(a) < SAFE_STRING_MAX_LENGTH
                 assert len(set(a) - SAFE_CHARS_SET) == 0
-                candidate_str_chain.append(a)
+                candidate_strings.append(a)
             elif _is_sequence_not_mapping(a):
                 if len(a) > 0:
-                    candidate_str_chain.extend(SafeStrTuple(*a).str_chain)
+                    candidate_strings.extend(SafeStrTuple(*a).strings)
             else:
                 assert False, f"Invalid argument type: {type(a)}"
-        self.str_chain = tuple(candidate_str_chain)
+        self.strings = tuple(candidate_strings)
+
+    @property
+    def str_chain(self) -> tuple[str, ...]:
+        """for backward compatibility"""
+        return self.strings
 
     def __getitem__(self, key:int)-> str:
         """Return a string at position key."""
-        return self.str_chain[key]
+        return self.strings[key]
 
     def __len__(self) -> int:
         """Return the number of strings in the tuple."""
-        return len(self.str_chain)
+        return len(self.strings)
 
     def __hash__(self):
         """Return a hash of the tuple."""
-        return hash(self.str_chain)
+        return hash(self.strings)
 
     def __repr__(self) -> str:
         """Return repr(self)."""
-        return f"{type(self).__name__}({self.str_chain})"
+        return f"{type(self).__name__}({self.strings})"
 
 
     def __eq__(self, other) -> bool:
@@ -76,27 +82,27 @@ class SafeStrTuple(Sequence, Hashable):
         else:
             other = SafeStrTuple(other)
 
-        return self.str_chain == other.str_chain
+        return self.strings == other.strings
 
 
     def __add__(self, other) -> SafeStrTuple:
         """Return self + other."""
         other = SafeStrTuple(other)
-        return SafeStrTuple(*(self.str_chain + other.str_chain))
+        return SafeStrTuple(*(self.strings + other.strings))
 
     def __radd__(self, other) -> SafeStrTuple:
         """Return other + self."""
         other = SafeStrTuple(other)
-        return SafeStrTuple(*(other.str_chain + self.str_chain))
+        return SafeStrTuple(*(other.strings + self.strings))
 
     def __iter__(self):
         """Return iter(self)."""
-        return iter(self.str_chain)
+        return iter(self.strings)
 
     def __contains__(self, item) -> bool:
         """Return item in self."""
-        return item in self.str_chain
+        return item in self.strings
 
     def __reversed__(self) -> SafeStrTuple:
         """Return a reversed SafeStrTuple."""
-        return SafeStrTuple(*reversed(self.str_chain))
+        return SafeStrTuple(*reversed(self.strings))

{persidict-0.15.0 → persidict-0.17.0/src}/persidict/safe_str_tuple_signing.py

@@ -11,7 +11,7 @@ e.g. MacOS HFS.
 
 import base64
 import hashlib
-from persidict.safe_str_tuple import SafeStrTuple
+from src.persidict.safe_str_tuple import SafeStrTuple
 
 
 def _create_signature_suffix(input_str:str, digest_len:int) -> str:

persidict-0.15.0/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020-2024  Vlad (Volodymyr) Pavlov, Kai Zhao, Illia Shestakov.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

persidict-0.15.0/persidict.egg-info/PKG-INFO

@@ -1,214 +0,0 @@
-Metadata-Version: 2.1
-Name: persidict
-Version: 0.15.0
-Summary: Simple persistent key-value store for Python. Values are stored as files on a disk or as S3 objects on AWS cloud.
-Home-page: https://github.com/pythagoras-dev/persidict
-Author: Vlad (Volodymyr) Pavlov
-Author-email: vlpavlov@ieee.org
-Keywords: persistence,dicts,distributed,parallel
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: lz4
-Requires-Dist: joblib
-Requires-Dist: numpy
-Requires-Dist: pandas
-Requires-Dist: jsonpickle
-Requires-Dist: boto3
-Requires-Dist: moto
-Requires-Dist: pytest
-Requires-Dist: parameterizable
-
-# persidict
-
-Simple persistent dictionaries for Python.
-
-## What Is It?
-
-`persidict` offers a simple persistent key-value store for Python. 
-It saves the content of the dictionary in a folder on a disk 
-or in an S3 bucket on AWS. Each value is stored as a separate file / S3 object.
-Only text strings or sequences of strings are allowed as keys.
-
-Unlike other persistent dictionaries (e.g. Python's native `shelve`), 
-`persidict` is designed for use in highly **distributed environments**, 
-where multiple instances of a program run concurrently across many machines.
-
-## Usage
-Class `FileDirDict` is a persistent dictionary that stores its content 
-in a folder on a disk.
-
-    from persidict import FileDirDict    
-    my_dictionary = FileDirDict(base_dir="my_folder")
-
-Once created, it can be used as a regular Python dictionary 
-that stores key-value pairs. A key must be a sequence of strings, 
-a value can be any (pickleable) Python object:
-
-    my_dictionary["Eliza"] = "MIT Eliza was a mock psychotherapist."
-    my_dictionary["Eliza","year"] = 1965
-    my_dictionary["Eliza","authors"] = ["Joseph Weizenbaum"]
-    
-    my_dictionary["Shoebox"] = "IBM Shoebox performed arithmetic operations"
-    my_dictionary["Shoebox"] += " on voice commands."
-    my_dictionary["Shoebox", "year"] = 1961
-    my_dictionary["Shoebox", "authors"] = ["W.C. Dersch", "E.A. Quade"]
-
-    for k in my_dictionary:
-        print(list(k), "==>",  my_dictionary[k])
-
-    if not "Eliza" in my_dictionary:
-        print("Something is wrong")
-
-If you run the code above, it will produce the following output:
-
-    >>> ['Eliza'] ==> MIT Eliza was a mock psychotherapist.
-    >>> ['Shoebox'] ==> IBM Shoebox performed arithmetic operations on voice commands.
-    >>> ['Shoebox', 'authors'] ==> ['W.C. Dersch', 'E.A. Quade']
-    >>> ['Shoebox', 'year'] ==> 1961
-    >>> ['Eliza', 'authors'] ==> ['Joseph Weizenbaum']
-    >>> ['Eliza', 'year'] ==> 1965
-
-The dictionary automatically creates a folder named "my_folder" 
-on the local disk. Each key-value pair is stored as 
-a separate file within this folder.
-
-If the key is a string, it becomes the filename for the object. 
-If the key is a sequence of strings, all strings except the last 
-are used to create nested subfolders within the main folder. 
-The final string in the sequence serves as the filename for the object, 
-which is stored in the deepest subfolder.
-
-Persistent dictionaries only accept sequences of strings as keys. 
-Any pickleable Python object can be used as a value. 
-Unlike regular Python dictionaries, insertion order is not preserved.
-
-    del my_dictionary
-    new_dict = FileDirDict(base_dir="my_folder")
-    print("len(new_dict) == ",len(new_dict))
-
-The code above will create a new object named new_dict and then will
-print its length: 
-
-    >>> len(new_dict) == 6
-
-The length is 6, because the dictionary was already stored on a disk 
-in the "my_folder" directory, which contained 6 pickle files.
-
-Technically, `FileDirDict` saves its content in a folder on a local disk. 
-But you can share this folder with other machines 
-(for example, using Dropbox or NFS), and work with the same dictionary 
-simultaneously from multiple computers (from multiple instances of your program). 
-This approach would allow you to use a persistent dictionary in 
-a system that is distributed over dozens of computers.
-
-If you need to run your program on hundreds (or more) computers, 
-class `S3Dict` is a better choice: it's a persistent dictionary that 
-stores its content in an AWS S3 bucket.
-
-    from persidict import S3Dict
-    my_cloud_dictionary = S3Dict(bucket_name="my_bucket")
-
-Once created, it can be used as a regular Python dictionary.
-
-## Key Classes
-
-* `SafeStrTuple` - an immutable sequence of URL/filename-safe non-empty strings.
-* `PersiDict` - an abstract base class for persistent dictionaries. 
-* `FileDirDict` - a persistent dictionary that stores its content 
-in a folder on a disk.
-* `S3Dict` - a persistent dictionary that stores its content 
-in an AWS S3 bucket.
-
-## Key Similarities With Python Built-in Dictionaries
-
-`PersiDict` and its subclasses can be used as regular Python dictionaries. 
-
-* You can use square brackets to get, set, or delete values. 
-* You can iterate over keys, values, or items. 
-* You can check if a key is in the dictionary. 
-* You can check whether two dicts are equal
-(meaning they contain the same key-value pairs).
-* You can get the length of the dictionary.
-* Methods `keys()`, `values()`, `items()`, `get()`, `clear()`
-, `setdefault()`, `update()` etc. work as expected.
-
-## Key Differences From Python Built-in Dictionaries
-
-`PersiDict` and its subclasses persist values between program executions, 
-as well as make it possible to concurrently run programs 
-that simultaneously work with the same instance of a dictionary.
-
-* Keys must be sequences of URL/filename-safe non-empty strings.
-* Values must be pickleable Python objects.
-* You can constrain values to be an instance of a specific class.
-* Insertion order is not preserved.
-* You can not assign initial key-value pairs to a dictionary in its constructor.
-* `PersiDict` API has additional methods `delete_if_exists()`, `timestamp()`,
-`get_subdict()`, `subdicts()`, `random_keys()`, `newest_keys()`, 
-`oldest_keys()`, `newest_values()`, `oldest_values()`, 
-`get_params()`, `get_metaparams()`, and `get_default_metaparams()`,
-which are not available in native Python dicts.
-
-## Fine Tuning
-
-`PersiDict` subclasses have a number of parameters that can be used 
-to impact behaviour of a dictionary. 
-
-* `base_class_for_values` - A base class for values stored in a dictionary.  
-If specified, it will be used to check types of values in the dictionary. 
-If not specified (if set to `None`), no type checking will be performed 
-and all types will be allowed.
-* `file_type` - a string that specifies the type of files used to store objects.
-If `file_type` has one of two values: "pkl" or "json", it defines 
-which file format will be used by the dictionary to store values. 
-For all other values of `file_type`, the file format will always be plain
-text. "pkl" or "json" allow to store arbitrary Python objects,
-while all other file_type-s only work with str objects; 
-it means `base_class_for_values` must be explicitly set to `str` 
-if `file_type` is not set to "pkl" or "json".
-* `immutable_items` - a boolean that specifies whether items in a dictionary 
-can be modified/deleted. It enables various distributed cache optimizations 
-for remote storage. True means an append-only dictionary. 
-False means normal dict-like behaviour. The default value is False. 
-* `digest_len` - a length of a hash signature suffix which `PersiDict` 
-automatically adds to each string in a key while mapping the key to 
-the address of a value in a persistent storage backend 
-(e.g. a filename or an S3 objectname). It is needed to ensure correct work
-of persistent dictionaries with case-insensitive (even if case-preserving) 
-filesystems, such as MacOS HFS. The default value is 8. 
-
-
-## How To Get It?
-
-The source code is hosted on GitHub at:
-[https://github.com/pythagoras-dev/persidict](https://github.com/pythagoras-dev/persidict) 
-
-Binary installers for the latest released version are available at the Python package index at:
-[https://pypi.org/project/persidict](https://pypi.org/project/persidict)
-
-        pip install persidict
-
-## Dependencies
-
-* [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)
-* [boto3](https://boto3.readthedocs.io)
-* [pytest](https://pytest.org)
-* [moto](http://getmoto.org)
-
-## Key Contacts
-
-* [Vlad (Volodymyr) Pavlov](https://www.linkedin.com/in/vlpavlov/)

persidict-0.15.0/persidict.egg-info/SOURCES.txt

@@ -1,15 +0,0 @@
-LICENSE
-README.md
-setup.py
-persidict/__init__.py
-persidict/file_dir_dict.py
-persidict/persi_dict.py
-persidict/s3_dict.py
-persidict/safe_chars.py
-persidict/safe_str_tuple.py
-persidict/safe_str_tuple_signing.py
-persidict.egg-info/PKG-INFO
-persidict.egg-info/SOURCES.txt
-persidict.egg-info/dependency_links.txt
-persidict.egg-info/requires.txt
-persidict.egg-info/top_level.txt

persidict-0.15.0/persidict.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

persidict-0.15.0/persidict.egg-info/requires.txt

@@ -1,9 +0,0 @@
-lz4
-joblib
-numpy
-pandas
-jsonpickle
-boto3
-moto
-pytest
-parameterizable

persidict-0.15.0/persidict.egg-info/top_level.txt

@@ -1 +0,0 @@
-persidict

persidict-0.15.0/setup.cfg

@@ -1,4 +0,0 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-

persidict-0.15.0/setup.py

@@ -1,42 +0,0 @@
-import setuptools
-
-with open("README.md", "r") as f:
-    long_description = f.read()
-
-setuptools.setup(
-    name="persidict"
-    ,version="0.15.0"
-    ,author="Vlad (Volodymyr) Pavlov"
-    ,author_email="vlpavlov@ieee.org"
-    ,description= "Simple persistent key-value store for Python. " 
-        "Values are stored as files on a disk or as S3 objects on AWS cloud."
-    ,long_description=long_description
-    ,long_description_content_type="text/markdown"
-    ,url="https://github.com/pythagoras-dev/persidict"
-    ,packages=["persidict"]
-    ,classifiers=[
-        "Development Status :: 3 - Alpha"
-        , "Intended Audience :: Developers"
-        , "Intended Audience :: Science/Research"
-        , "Programming Language :: Python"
-        , "Programming Language :: Python :: 3"
-        , "License :: OSI Approved :: MIT License"
-        , "Operating System :: OS Independent"
-        , "Topic :: Software Development :: Libraries"
-        , "Topic :: Software Development :: Libraries :: Python Modules"
-    ]
-    ,keywords='persistence, dicts, distributed, parallel'
-    ,python_requires='>=3.10'
-    ,install_requires=[
-        'lz4'
-        , 'joblib'
-        , 'numpy'
-        , 'pandas'
-        , 'jsonpickle'
-        , 'boto3'
-        , 'moto'
-        , 'pytest'
-        , 'parameterizable'
-    ]
-
-)