persistentvalues 0.0.1__py3-none-any.whl

persistentvalues/__init__.py

@@ -0,0 +1,5 @@
+from .persistentvalues import PersistentValue
+
+__all__ = [
+    "PersistentValue"
+]

persistentvalues/persistentvalues.py

@@ -0,0 +1,93 @@
+from hashlib import sha256
+import os
+import __main__
+from os import PathLike
+from typing import Any
+
+from cachier import cachier
+
+
+class PersistentValue:
+
+    def __init__(self, value: Any=None, id: str=None, access: str | int="script", cache_dir: str | PathLike | None=None, separate_files: bool=False):
+        """
+        The PersistentValue object. Stores the value in the cache with access determined by the access value.
+
+        :param value: The value to store
+        :param id: Unique identifier of the persistent value
+        :param access: Whether to store the value locally for only the current script ("script" or 0), locally for the current working directory ("cwd" or "local" or 1), or globally across the whole device ("global" or 2).
+        :param cache_dir: (Default automatic) The directory to store the cached value in. Default relies on access, "~/.cachier/" for global, ".cache/" for the rest
+        :param separate_files: Instead of a single cache file per-function, each function's cache is split between several files, one for each argument set. This can help if your per-function cache files become too large.
+        """
+
+        self.cache_dir = cache_dir or (None if access in ("global", 2, "2") else ".cache/")
+        self.cached = True
+
+        @cachier(cache_dir=self.cache_dir, separate_files=separate_files)
+        def get_value(id):
+            _ = id
+            self.cached = False
+            return self._value
+        self.get_value = get_value
+
+        if access not in (0, 1, 2, "0", "1", "2", "script", "cwd", "local", "global"):
+            raise ValueError("Access must be 0, 1, 2, '0', '1', '2', 'script', 'cwd', 'local', or 'global'.")
+
+        if not hasattr(__main__, "__file__"):
+            access = 1
+
+        self.id = sha256((repr(id if id is not None else value) + (__main__.__file__ if access in ("script", 0, "0") else (os.getcwd() if access in ("cwd", "local", 1, "1") else ""))).encode()).hexdigest()
+
+        self._value = value
+
+    def __setattr__(self, key, value):
+        if key in ['_value', 'id', 'value', 'cache_dir', 'get_value', 'cached']:
+            return object.__setattr__(self, key, value)
+        return setattr(self.value, key, value)
+
+    def __getattr__(self, name):
+        return getattr(self.value, name)
+
+    def __getitem__(self, key):
+        return self.value[key]
+
+    def __setitem__(self, key, value):
+        new_value = self.value.copy()
+        new_value[key] = value
+        self.value = new_value
+
+    def set(self, value):
+        self.value = value
+
+    def sync(self):
+        self._value = self.value
+
+    def update_cache(self):
+        self.get_value(self.id, cachier__overwrite_cache=True)
+
+    def clear_cache(self):
+        self.get_value.clear_cache()
+
+    @property
+    def value(self):
+        return self.get_value(self.id)
+
+    @value.setter
+    def value(self, value):
+        self._value = value
+        self.update_cache()
+
+    def __call__(self):
+        return self.value
+
+    def __eq__(self, other):
+        return object.__eq__(self.value, other)
+
+    def __hash__(self):
+        return self.value.__hash__()
+
+    def __str__(self):
+        return self.value.__str__()
+
+    def __repr__(self):
+        return self.value.__repr__()

persistentvalues-0.0.1.dist-info/METADATA

@@ -0,0 +1,199 @@
+Metadata-Version: 2.5
+Name: persistentvalues
+Version: 0.0.1
+Summary: A really tiny cachier wrapper for persistent value storage
+Project-URL: Homepage, https://github.com/arukusuiinpu/persistentvalues
+Project-URL: Issues, https://github.com/arukusuiinpu/persistentvalues/issues
+Author-email: arukusuiinpu <Alex.Nompe@yandex.ru>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Requires-Dist: cachier
+Description-Content-Type: text/markdown
+
+# persistentvalues
+
+Contains a PersistentValue object that stores the input object as self.value and allows you to interact with it directly as if the object is its own value.
+
+persistentValue.(any function attribute that modifies its own value) <- doesn't work, the object requires explicit assignments to update the value and cache it.
+
+---
+To modify the stored value, use:
+```pycon
+persistentValue.value = (something)
+```
+or
+```pycon
+persistentValue.set((something))
+```
+
+---
+To get the stored value, use:
+```pycon
+(variable) = persistentValue.value
+```
+or
+```pycon
+(variable) = persistentValue()
+```
+
+---
+The input value of PersistentValue(0) is an id determining what cache corresponds to which PersistentValue. That means the following code will use the same cached value despite the intention obviously being in creation of two different persistent values:
+```pycon
+a = PersistentValue(0) # <- create a new persistentValue
+b = PersistentValue(0) # <- has the same id as the previous one, so behaves like the same object
+
+a += 2 # <- now stores 2
+b += 3 # <- now stores 5
+```
+
+---
+You can define your own id using:
+```pycon
+a = PersistentValue(0, id=(your id))
+```
+Which means:
+```pycon
+a = PersistentValue(0, "a") # <- create a new persistentValue with id "a"
+b = PersistentValue(0, "b") # <- create a new persistentValue with id "b"
+
+a += 2 # <- "a" now stores 2
+b += 3 # <- "b" now stores 3
+```
+
+---
+Your persistent values may have different types of access depending on your intentions:
+```pycon
+acc_0 = PersistentValue(None, id="acc_0", access=("script" or 0))
+"""
+^ (Default) Local script access, values with the same id from different scripts don't overlap.
+  Python console is the exception, it is actually access=1 by default.
+"""
+
+acc_1 = PersistentValue(None, id="acc_1", access=("cwd" or "local" or 1))
+"""
+^ Local current working directory access, values with the same id from different working directories
+  don't overlap, but can be accessed across different scripts from the same working directory.
+"""
+
+acc_2 = PersistentValue(None, id="acc_2", access=("global" or 2))
+"""
+^ Global device access, any values with the same id will be accessible across any scripts on your
+  device from any projects as long as they all use the same cache_dir folder (Default "~/.cachier/").
+  Requires access to the cache_dir from the script context.
+"""
+```
+
+---
+Additional parameters:
+```pycon
+PersistentValue(cache_dir=(your path))
+"""
+^ Cache path to store values at. Overrides the default automatic one determined by access.
+  
+  Default:
+      access=0 -> ".cache/"
+      access=1 -> ".cache/"
+      access=2 -> "~/.cachier/"
+"""
+
+PersistentValue(separate_files=(True or False))
+"""
+^ Instead of a single cache file per-function, each function's cache is split between
+  several files, one for each argument set. This can help if your per-function cache
+  files become too large.
+  
+  Default: False
+"""
+```
+
+---
+PersistentValue functions:
+```pycon
+persistentValue.sync() # <- Syncs the uncached stored value with the cached one. (sets self._value = (cached)self.value)
+
+persistentValue.update_cache() # <- Syncs the cached stored value with the uncached one. (sets (cached)self.value = self._value)
+
+persistentValue.clear_cache() # <- Clears the cached value
+```
+
+---
+Example usage:
+```python
+import random
+from persistentvalues import PersistentValue
+
+a = """Option 0
+Option 1
+Option 2
+Option 3
+Option 4
+Option 5
+Option 6""".split("\n")
+
+b = PersistentValue([(i, 0) for i in a], "b") # <- store the initial value under id "b"
+last = PersistentValue([None for _ in range(2)]) # <- store the initial value under procedural id derived from the initial value
+
+def get_random_activity():
+    global last, b
+    ch = random.choices(b(), weights=[(1 / j if i not in last() else 0) if j > 0 else 1 for i, j in b()], k=1)[0] # <- get the values here and use them just like the initial ones
+
+    b[b.index(ch)] = (ch[0], ch[1] + 1) # <- modify b using assignment
+
+    last.value = [ch[0]] + last()[:-1] # <- modify last using assignment
+
+    return ch[0]
+
+if __name__ == "__main__":
+    print(get_random_activity()) # <- each 
+```
+
+Console Example:
+```pycon
+>>> from persistentvalues import PersistentValue
+>>> a = PersistentValue(0)
+>>> a.value += 1
+>>> a
+1
+
+Process finished with exit code 0
+
+>>> from persistentvalues import PersistentValue
+>>> a = PersistentValue(0)
+>>> a
+1
+
+Process finished with exit code 0
+```
+
+Local current working directory access:
+```pycon
+# ./test_pers0.py
+
+from persistentvalues import PersistentValue
+
+a = PersistentValue(0, access=1)
+
+a.value += 1
+
+print(a)
+1
+
+Process finished with exit code 0
+```
+
+```pycon
+# ./test_pers1.py
+
+from persistentvalues import PersistentValue
+
+a = PersistentValue(0, access=1)
+
+print(a)
+1
+
+Process finished with exit code 0
+```

persistentvalues-0.0.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+persistentvalues/__init__.py,sha256=m7SyJmOrDFSl5s3XRYJ-8u1dsVMnrYqTSy1auoNNahw,86
+persistentvalues/persistentvalues.py,sha256=y-kHdUwcPewgUquRbhcNMxGI_0g-1dP3PQENZflKGxA,3345
+persistentvalues-0.0.1.dist-info/METADATA,sha256=yekJ3l_COpyrr_qUxKTeUYqNlNq80Rmkt3X7KTxXpaI,5391
+persistentvalues-0.0.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+persistentvalues-0.0.1.dist-info/licenses/LICENSE,sha256=E0aq-h-uxaHh__yC8OQvSLv_LbCAv9_AdALvB64WvVg,1090
+persistentvalues-0.0.1.dist-info/RECORD,,

persistentvalues-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

persistentvalues-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 arukusuiinpu
+
+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.