cachify 0.1.0__py3-none-any.whl

cachify-0.1.0.dist-info/LICENSE

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

cachify-0.1.0.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.1
+Name: cachify
+Version: 0.1.0
+Summary: A simple cache library with sync/async support, Memory and Redis backend
+Home-page: https://github.com/PulsarDataSolutions/cachify
+License: MIT
+Keywords: cachify,cache,caching,redis,async,decorator,memoization
+Author: dynalz
+Author-email: git@pulsar.finance
+Requires-Python: >=3.10,<3.15
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Dist: redis[hiredis] (>5.0.0)
+Project-URL: Repository, https://github.com/PulsarDataSolutions/cachify
+Description-Content-Type: text/markdown
+
+# Python Cachify Library
+
+A simple and robust caching library for Python functions, supporting both synchronous and asynchronous code.
+
+## Features
+
+- Cache function results based on function ID and arguments
+- Supports both synchronous and asynchronous functions
+- Thread-safe locking to prevent duplicate cached function calls
+- Configurable Time-To-Live (TTL) for cached items
+- "Never Die" mode for functions that should keep cache refreshed automatically
+- Skip cache functionality to force fresh function execution while updating cache
+- Redis cache for distributed caching across multiple processes/machines
+
+## Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/PulsarDefi/cachify.git
+cd cachify
+
+# Install the package
+poetry install
+```
+
+## Usage
+
+### Basic Usage
+
+```python
+from cachify import cache
+
+# Cache function in sync functions
+@cache(ttl=60) # ttl in seconds
+def expensive_calculation(a, b):
+    # Some expensive operation
+    return a + b
+
+# And async functions
+@cache(ttl=3600) # ttl in seconds
+async def another_calculation(url):
+    # Some expensive IO call
+    return await httpx.get(url).json()
+```
+
+### Redis Cache
+
+For distributed caching across multiple processes or machines, use `rcache`:
+
+```python
+import redis
+from cachify import setup_redis_config, rcache
+
+# Configure Redis (call once at startup)
+setup_redis_config(
+    sync_client=redis.from_url("redis://localhost:6379/0"),
+    key_prefix="myapp",       # default: "key_prefix", prefix searchable on redis "PREFIX:*"
+    lock_timeout=10,          # default: 10, maximum lock lifetime in seconds
+    on_error="silent",        # "silent" (default) or "raise" in case of redis errors
+)
+
+@rcache(ttl=300)
+def get_user(user_id: int) -> dict:
+    return fetch_from_database(user_id)
+
+# Async version
+import redis.asyncio as aredis
+
+setup_redis_config(async_client=aredis.from_url("redis://localhost:6379/0"))
+
+@rcache(ttl=300)
+def get_user_async(user_id: int) -> dict:
+    return await fetch_from_database(user_id)
+```
+
+### Never Die Cache
+
+The `never_die` feature ensures that cached values never expire by automatically refreshing them in the background:
+
+```python
+# Cache with never_die (automatic refresh)
+@cache(ttl=300, never_die=True)
+def critical_operation(data_id: str):
+    # Expensive operation that should always be available from cache
+    return fetch_data_from_database(data_id)
+```
+
+**How Never Die Works:**
+
+1. When a function with `never_die=True` is first called, the result is cached
+2. A background thread monitors all `never_die` functions
+3. On cache expiration (TTL), the function is automatically called again
+4. The cache is updated with the new result
+5. If the refresh operation fails, the existing cached value is preserved
+6. Clients always get fast response times by reading from cache
+
+**Benefits:**
+
+- Cache is always "warm" and ready to serve
+- No user request ever has to wait for the expensive operation
+- If a dependency service from the cached function goes down temporarily, the last successful result is still available
+- Perfect for critical operations where latency must be minimized
+
+### Skip Cache
+
+The `skip_cache` feature allows you to bypass reading from cache while still updating it with fresh results:
+
+```python
+@cache(ttl=300)
+def get_user_data(user_id):
+    # Expensive operation to fetch user data
+    return fetch_from_database(user_id)
+
+# Normal call - uses cache if available
+user = get_user_data(123)
+# Force fresh execution while updating cache
+fresh_user = get_user_data(123, skip_cache=True)
+# Next normal call will get the updated cached value
+updated_user = get_user_data(123)
+```
+
+**How Skip Cache Works:**
+
+1. When `skip_cache=True` is passed, the function bypasses reading from cache
+2. The function executes normally and returns fresh results
+3. The fresh result is stored in the cache, updating any existing cached value
+4. Subsequent calls without `skip_cache=True` will use the updated cached value
+5. The TTL timer resets from when the cache last was updated
+
+**Benefits:**
+
+- Force refresh of potentially stale data while keeping cache warm
+- Ensuring fresh data for critical operations while maintaining cache for other calls
+
+## Testing
+
+Run the test scripts
+
+```bash
+poetry run python -m pytest
+```
+
+## License
+
+MIT
+

cachify-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+cachify/__init__.py,sha256=5Q5eK7Pyty7-eSF99DBSa79FnKq27MGNiCYPkhY3uxo,553
+cachify/cache.py,sha256=Y1hh3t9DlcaG8KoVi3gZHevPzZf59WPIdDb_VsooHqo,4137
+cachify/config/__init__.py,sha256=xWH80AN6A2O2DlrY3ITkLYEkqnNv8WqGWhNAszVZq5w,102
+cachify/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachify/features/never_die.py,sha256=A8sVAgVP-s6hlEs8FqrmHFg_-TJ8Bu8E8M_d3gwBpdg,7330
+cachify/memory_cache.py,sha256=9bDgV0Lb7ZB_ieARQmiKyi0nrn7E-cqQX9lH4d9xFFk,1365
+cachify/redis/__init__.py,sha256=4ZCbpo1tfU1O06pvIjerCuSR7XfopJly7mWgp9NZ_tg,429
+cachify/redis/config.py,sha256=ShaNvP6-vRnxWtFk3cD6lzMcPigpCM8FnFVBv21jxk4,3673
+cachify/redis/lock.py,sha256=NwrCa-z9fcXLvuaUrTsdCeNqoHIhR-Rm0J56fZ_0kT4,7513
+cachify/redis_cache.py,sha256=roQ3ENdqUe6n03nX4RFB0wrOKowUEcEY96BJV48hzRQ,900
+cachify/storage/__init__.py,sha256=p62r3EJPidhkHtw2OgV-gAH4U-wDtB8ZU_IbE5e3CdQ,259
+cachify/storage/memory_storage.py,sha256=lwSbCYqT4NyRwgPs8TMSjHIp5aTJs6bXmQmMKFOIhVM,1533
+cachify/storage/redis_storage.py,sha256=NOwWaSjca6591pMbLaHMmtelutXkAhxuWbFkoWChRnA,4905
+cachify/types/__init__.py,sha256=VpDvMLFAxVo-J9MISzE-liT-wiZzo4AYHG7cQgVi-TI,2736
+cachify/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cachify/utils/arguments.py,sha256=m4TMXmZ5nC9tDyS4BBDjsW41Q7L2LOx6zEWFN70ux70,2065
+cachify/utils/decorator_factory.py,sha256=5Cqz_QQDc7jVvVb_yscF41EC5o8mOda2nDeR6NvPGh8,1369
+cachify/utils/functions.py,sha256=QqpdJVvmwkPtHnPhFj5xpouJL_jQ29ySOjPkgvNg-Y0,322
+cachify/utils/locks.py,sha256=nvNnFuu3ooGpptH4-5tpaUU2YJmXlVqZ_GTQRWmKX7g,222
+cachify-0.1.0.dist-info/entry_points.txt,sha256=a8B7GSYgDPfUClqct0o7yyBbJ61AWgSSy1idL6YZLUM,45
+cachify-0.1.0.dist-info/LICENSE,sha256=nOY-lEC7Zaqf05sDxPYQ8iOGaShYMB2zf1Kr-M5hE-w,1092
+cachify-0.1.0.dist-info/METADATA,sha256=pkPXhJ5vOrtH8qi56CaESR_gI4B7c_iaZbg-ZNrlNVc,5340
+cachify-0.1.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+cachify-0.1.0.dist-info/RECORD,,

cachify-0.1.0.dist-info/WHEEL

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

cachify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+shell=scripts.shell:shell
+