speedy-utils 1.1.24__tar.gz → 1.1.26__tar.gz

{speedy_utils-1.1.24 → speedy_utils-1.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.24
+Version: 1.1.26
 Summary: Fast and easy-to-use package for data science
 Project-URL: Homepage, https://github.com/anhvth/speedy
 Project-URL: Repository, https://github.com/anhvth/speedy

{speedy_utils-1.1.24 → speedy_utils-1.1.26}/bumpversion.sh

@@ -1,7 +1,7 @@
 #!/bin/zsh
 # Bump patch version using poetry, commit, and push
 set -e
-
+uv pip install poetry
 echo 'Current version:'
 poetry version
 

{speedy_utils-1.1.24 → speedy_utils-1.1.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "speedy-utils"
-version = "1.1.24"
+version = "1.1.26"
 description = "Fast and easy-to-use package for data science"
 authors = [{ name = "AnhVTH", email = "anhvth.226@gmail.com" }]
 readme = "README.md"

speedy_utils-1.1.26/simple_test_imemoize.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Simple test for imemoize without heavy dependencies
+"""
+
+import sys
+import time
+import os.path as osp
+sys.path.insert(0, osp.join(osp.dirname(__file__), 'src'))
+
+# Test basic imports first
+print("Testing imports...")
+
+try:
+    from speedy_utils.common.utils_cache import imemoize, identify, get_source
+    print("✓ Successfully imported imemoize from utils_cache")
+except Exception as e:
+    print(f"✗ Failed to import: {e}")
+    sys.exit(1)
+
+@imemoize
+def simple_computation(x):
+    """Simple computation for testing"""
+    print(f"Computing simple_computation({x})")
+    time.sleep(0.05)  # Small delay to verify caching
+    return x * x
+
+def test_basic():
+    print("\n=== Testing basic imemoize functionality ===")
+    
+    # Test first call
+    print("First call:")
+    start = time.time()
+    result1 = simple_computation(5)
+    end = time.time()
+    print(f"Result: {result1}, Time: {end - start:.3f}s")
+    
+    # Test second call (should be cached)
+    print("Second call (should be cached):")
+    start = time.time()
+    result2 = simple_computation(5)
+    end = time.time()
+    print(f"Result: {result2}, Time: {end - start:.3f}s")
+    
+    assert result1 == result2 == 25
+    print("✓ Basic caching works!")
+
+def test_function_source_hashing():
+    print("\n=== Testing function source code detection ===")
+    
+    # Test that get_source works
+    source = get_source(simple_computation)
+    print(f"Function source hash length: {len(source)}")
+    
+    # Test identity
+    identity = identify((source, (5,), {}))
+    print(f"Cache key identity: {identity[:50]}...")
+    
+    print("✓ Function source detection works!")
+
+if __name__ == "__main__":
+    test_basic()
+    test_function_source_hashing()
+    print("\n🎉 Simple tests passed!")

{speedy_utils-1.1.24 → speedy_utils-1.1.26}/src/speedy_utils/__init__.py

@@ -16,6 +16,7 @@
 # • timef(func) -> Callable - Function execution time decorator
 # • retry_runtime(sleep_seconds: int, max_retry: int, exceptions) -> Callable
 # • memoize(func) -> Callable - Function result caching decorator
+# • imemoize(func) -> Callable - In-memory caching decorator (global persistent)
 # • identify(obj: Any) -> str - Generate unique object identifier
 # • identify_uuid(obj: Any) -> str - Generate UUID-based object identifier
 # • load_by_ext(fname: Union[str, list[str]]) -> Any - Auto-detect file format loader
@@ -125,7 +126,7 @@ from .common.notebook_utils import (
 )
 
 # Cache utilities
-from .common.utils_cache import identify, identify_uuid, memoize
+from .common.utils_cache import identify, identify_uuid, imemoize, memoize
 
 # IO utilities
 from .common.utils_io import (
@@ -224,6 +225,7 @@ __all__ = [
     "retry_runtime",
     # Cache utilities
     "memoize",
+    "imemoize",
     "identify",
     "identify_uuid",
     # IO utilities

{speedy_utils-1.1.24 → speedy_utils-1.1.26}/src/speedy_utils/common/utils_cache.py

@@ -44,6 +44,9 @@ _MEM_CACHES: "weakref.WeakKeyDictionary[Callable[..., Any], cachetools.LRUCache]
     weakref.WeakKeyDictionary()
 )
 
+# Global memory cache for imemoize (persists across IPython reloads)
+_GLOBAL_MEMORY_CACHE: dict[str, Any] = {}
+
 # Backward-compat global symbol (internal only; not exported)
 LRU_MEM_CACHE = cachetools.LRUCache(maxsize=256)
 
@@ -680,4 +683,142 @@ def memoize(
         return decorator(_func)
 
 
-__all__ = ["memoize", "identify"]
+# --------------------------------------------------------------------------------------
+# In-memory memoize with global persistent cache
+# --------------------------------------------------------------------------------------
+
+
+@overload
+def imemoize(
+    _func: Callable[P, R],
+    *,
+    keys: Optional[list[str]] = ...,
+    key: Optional[Callable[..., Any]] = ...,
+    ignore_self: bool = ...,
+) -> Callable[P, R]: ...
+
+
+@overload
+def imemoize(
+    _func: Callable[P, Awaitable[R]],
+    *,
+    keys: Optional[list[str]] = ...,
+    key: Optional[Callable[..., Any]] = ...,
+    ignore_self: bool = ...,
+) -> Callable[P, Awaitable[R]]: ...
+
+
+@overload
+def imemoize(
+    _func: None = ...,
+    *,
+    keys: Optional[list[str]] = ...,
+    key: Optional[Callable[..., Any]] = ...,
+    ignore_self: bool = ...,
+) -> Callable[[Callable[P, R]], Callable[P, R]]: ...
+
+
+@overload
+def imemoize(  # type: ignore
+    _func: None = ...,
+    *,
+    keys: Optional[list[str]] = ...,
+    key: Optional[Callable[..., Any]] = ...,
+    ignore_self: bool = ...,
+) -> Callable[[Callable[P, Awaitable[R]]], Callable[P, Awaitable[R]]]: ...
+
+
+def imemoize(
+    _func: Optional[Callable[P, Any]] = None,
+    *,
+    keys: Optional[list[str]] = None,
+    key: Optional[Callable[..., Any]] = None,
+    ignore_self: bool = True,
+):
+    """
+    In-memory memoization decorator with global persistent cache.
+    
+    Unlike regular memoize, this uses a global memory cache that persists
+    across IPython %load executions. The cache key is based on the function's
+    source code combined with runtime arguments, making it suitable for
+    notebook environments where functions may be reloaded.
+    
+    Args:
+        keys: list of argument names to include in key (optional).
+        key: custom callable (*args, **kwargs) -> hashable for keying (optional).
+        ignore_self: ignore 'self' when building cache key for bound methods.
+    
+    Example:
+        @imemoize
+        def expensive_computation(x):
+            import time
+            time.sleep(2)
+            return x * x
+        
+        # First call computes and caches
+        result1 = expensive_computation(5)
+        
+        # Second call retrieves from memory cache
+        result2 = expensive_computation(5) 
+        
+        # Even after %load file.py in IPython, the cache persists
+    """
+    
+    def decorator(func: Callable[P, Any]) -> Callable[P, Any]:
+        is_async = inspect.iscoroutinefunction(func)
+        
+        if is_async:
+            @functools.wraps(func)
+            async def async_wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
+                # Compute cache key based on function source + args
+                func_source, sub_dir, key_id = _compute_cache_components(
+                    func, args, kwargs, ignore_self, keys, key
+                )
+                cache_key = identify((func_source, sub_dir, key_id))
+                
+                # Check global memory cache
+                with mem_lock:
+                    if cache_key in _GLOBAL_MEMORY_CACHE:
+                        return _GLOBAL_MEMORY_CACHE[cache_key]
+                
+                # Compute result and store in cache
+                result = await func(*args, **kwargs)
+                
+                with mem_lock:
+                    _GLOBAL_MEMORY_CACHE[cache_key] = result
+                
+                return result
+            
+            return async_wrapper
+        else:
+            @functools.wraps(func)
+            def sync_wrapper(*args: P.args, **kwargs: P.kwargs) -> Any:
+                # Compute cache key based on function source + args
+                func_source, sub_dir, key_id = _compute_cache_components(
+                    func, args, kwargs, ignore_self, keys, key
+                )
+                cache_key = identify((func_source, sub_dir, key_id))
+                
+                # Check global memory cache
+                with mem_lock:
+                    if cache_key in _GLOBAL_MEMORY_CACHE:
+                        return _GLOBAL_MEMORY_CACHE[cache_key]
+                
+                # Compute result and store in cache
+                result = func(*args, **kwargs)
+                
+                with mem_lock:
+                    _GLOBAL_MEMORY_CACHE[cache_key] = result
+                
+                return result
+            
+            return sync_wrapper
+    
+    # Support both @imemoize and @imemoize(...)
+    if _func is None:
+        return decorator
+    else:
+        return decorator(_func)
+
+
+__all__ = ["memoize", "imemoize", "identify"]