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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.24
+Version: 1.1.25
 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.25/debug_imemoize.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""
+Debug the imemoize cache key generation
+"""
+
+import sys
+import time
+import os.path as osp
+sys.path.insert(0, osp.join(osp.dirname(__file__), 'src'))
+
+from speedy_utils.common.utils_cache import imemoize, _GLOBAL_MEMORY_CACHE, get_source, identify, _compute_cache_components
+
+def debug_cache_keys():
+    """Debug what cache keys are generated"""
+    print("=== Debugging cache key generation ===")
+    
+    # Clear cache
+    _GLOBAL_MEMORY_CACHE.clear()
+    
+    # First function
+    @imemoize
+    def test_func(x):
+        return x * x
+    
+    # Get cache components
+    func_source1, sub_dir1, key_id1 = _compute_cache_components(
+        test_func, (5,), {}, True, None, None
+    )
+    cache_key1 = identify((func_source1, sub_dir1, key_id1))
+    
+    print(f"Function 1 source length: {len(func_source1)}")
+    print(f"Function 1 source: {func_source1[:100]}...")
+    print(f"Function 1 cache key: {cache_key1}")
+    
+    # Call function
+    result1 = test_func(5)
+    print(f"After call 1, cache size: {len(_GLOBAL_MEMORY_CACHE)}")
+    
+    # Redefine same function 
+    @imemoize
+    def test_func(x):
+        return x * x
+    
+    # Get cache components for redefined function
+    func_source2, sub_dir2, key_id2 = _compute_cache_components(
+        test_func, (5,), {}, True, None, None
+    )
+    cache_key2 = identify((func_source2, sub_dir2, key_id2))
+    
+    print(f"\nFunction 2 source length: {len(func_source2)}")
+    print(f"Function 2 source: {func_source2[:100]}...")
+    print(f"Function 2 cache key: {cache_key2}")
+    
+    print(f"\nSource code same: {func_source1 == func_source2}")
+    print(f"Cache keys same: {cache_key1 == cache_key2}")
+    
+    # Call function again
+    result2 = test_func(5)
+    print(f"After call 2, cache size: {len(_GLOBAL_MEMORY_CACHE)}")
+    
+    print(f"\nCache contents:")
+    for i, (key, value) in enumerate(_GLOBAL_MEMORY_CACHE.items()):
+        print(f"  {i+1}. {key[:50]}... -> {value}")
+
+if __name__ == "__main__":
+    debug_cache_keys()

speedy_utils-1.1.25/debug_imemoize_flow.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+Debug the imemoize execution flow
+"""
+
+import sys
+import time
+import os.path as osp
+sys.path.insert(0, osp.join(osp.dirname(__file__), 'src'))
+
+from speedy_utils.common.utils_cache import _GLOBAL_MEMORY_CACHE, identify, _compute_cache_components
+from speedy_utils.common.utils_cache import mem_lock
+
+def create_debug_imemoize():
+    """Create a debug version of imemoize with detailed logging"""
+    import functools
+    import inspect
+    
+    def debug_imemoize(func):
+        print(f"Creating imemoize wrapper for {func.__name__}")
+        
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            print(f"\n--- Calling {func.__name__}({args}, {kwargs}) ---")
+            
+            # Compute cache key
+            func_source, sub_dir, key_id = _compute_cache_components(
+                func, args, kwargs, True, None, None
+            )
+            cache_key = identify((func_source, sub_dir, key_id))
+            
+            print(f"Function source: {func_source[:50]}...")
+            print(f"Cache key: {cache_key}")
+            print(f"Cache size before lookup: {len(_GLOBAL_MEMORY_CACHE)}")
+            
+            # Check cache
+            with mem_lock:
+                if cache_key in _GLOBAL_MEMORY_CACHE:
+                    cached_result = _GLOBAL_MEMORY_CACHE[cache_key]
+                    print(f"CACHE HIT: Found {cached_result}")
+                    return cached_result
+                else:
+                    print(f"CACHE MISS: Key not found")
+                    print(f"Available keys:")
+                    for i, key in enumerate(_GLOBAL_MEMORY_CACHE.keys()):
+                        print(f"  {i+1}. {key}")
+            
+            # Compute result
+            print(f"Computing result...")
+            start = time.time()
+            result = func(*args, **kwargs)
+            end = time.time()
+            print(f"Computation took {end - start:.6f}s")
+            
+            # Store in cache
+            with mem_lock:
+                _GLOBAL_MEMORY_CACHE[cache_key] = result
+                print(f"Stored result in cache. Cache size now: {len(_GLOBAL_MEMORY_CACHE)}")
+            
+            return result
+        
+        return wrapper
+    
+    return debug_imemoize
+
+def test_debug():
+    debug_imemoize = create_debug_imemoize()
+    
+    # Clear cache
+    _GLOBAL_MEMORY_CACHE.clear()
+    print("Cache cleared")
+    
+    # First function
+    @debug_imemoize
+    def test_func(x):
+        time.sleep(0.05)
+        return x * x
+    
+    print("\n=== FIRST CALL ===")
+    result1 = test_func(5)
+    
+    print("\n=== SECOND CALL (same function object) ===")
+    result2 = test_func(5)
+    
+    # Redefine function
+    @debug_imemoize
+    def test_func(x):
+        time.sleep(0.05) 
+        return x * x
+    
+    print("\n=== THIRD CALL (new function object, same source) ===")
+    result3 = test_func(5)
+
+if __name__ == "__main__":
+    test_debug()

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

@@ -1,6 +1,6 @@
 [project]
 name = "speedy-utils"
-version = "1.1.24"
+version = "1.1.25"
 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.25/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.25}/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.25}/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"]

speedy_utils-1.1.25/test_imemoize.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Test script for imemoize functionality
+"""
+
+import sys
+import time
+sys.path.insert(0, 'src')
+
+from speedy_utils import imemoize
+
+@imemoize
+def expensive_computation(x, y=1):
+    """Simulate an expensive computation"""
+    print(f"Computing expensive_computation({x}, {y})")
+    time.sleep(0.1)  # Simulate work
+    return x * x + y
+
+@imemoize
+async def async_expensive_computation(x):
+    """Simulate an expensive async computation"""
+    import asyncio
+    print(f"Computing async_expensive_computation({x})")
+    await asyncio.sleep(0.1)  # Simulate work
+    return x * x
+
+def test_basic_functionality():
+    print("=== Testing basic functionality ===")
+    
+    # Test sync function
+    print("First call:")
+    start = time.time()
+    result1 = expensive_computation(5)
+    end = time.time()
+    print(f"Result: {result1}, Time: {end - start:.3f}s")
+    
+    print("Second call (should be cached):")
+    start = time.time()
+    result2 = expensive_computation(5)
+    end = time.time()
+    print(f"Result: {result2}, Time: {end - start:.3f}s")
+    
+    assert result1 == result2
+    print("✓ Basic sync caching works")
+
+def test_different_arguments():
+    print("\n=== Testing different arguments ===")
+    
+    # Different arguments should compute separately
+    result1 = expensive_computation(3)
+    result2 = expensive_computation(4)
+    result3 = expensive_computation(3, y=2)  # Different y value
+    result4 = expensive_computation(3)  # Should be cached
+    
+    print(f"expensive_computation(3) = {result1}")
+    print(f"expensive_computation(4) = {result2}")
+    print(f"expensive_computation(3, y=2) = {result3}")
+    print(f"expensive_computation(3) again = {result4}")
+    
+    assert result1 != result2
+    assert result1 != result3
+    assert result1 == result4
+    print("✓ Different arguments work correctly")
+
+async def test_async_functionality():
+    print("\n=== Testing async functionality ===")
+    
+    start = time.time()
+    result1 = await async_expensive_computation(7)
+    end = time.time()
+    print(f"First async call: {result1}, Time: {end - start:.3f}s")
+    
+    start = time.time()
+    result2 = await async_expensive_computation(7)
+    end = time.time()
+    print(f"Second async call (cached): {result2}, Time: {end - start:.3f}s")
+    
+    assert result1 == result2
+    print("✓ Async caching works")
+
+def test_code_change_detection():
+    print("\n=== Testing code change detection ===")
+    
+    # Create a function dynamically to simulate code changes
+    def create_function(multiplier):
+        @imemoize
+        def dynamic_func(x):
+            print(f"Computing with multiplier {multiplier}")
+            return x * multiplier
+        return dynamic_func
+    
+    func1 = create_function(2)
+    func2 = create_function(3)
+    
+    result1a = func1(5)  # Should compute
+    result1b = func1(5)  # Should be cached
+    result2a = func2(5)  # Different function, should compute
+    
+    print(f"func1(5) first: {result1a}")
+    print(f"func1(5) second: {result1b}")
+    print(f"func2(5): {result2a}")
+    
+    assert result1a == result1b == 10
+    assert result2a == 15
+    print("✓ Code change detection works")
+
+if __name__ == "__main__":
+    test_basic_functionality()
+    test_different_arguments()
+    
+    import asyncio
+    asyncio.run(test_async_functionality())
+    
+    test_code_change_detection()
+    
+    print("\n🎉 All tests passed!")

speedy_utils-1.1.25/test_imemoize_persistence.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+Test imemoize persistence across function redefinition (simulating IPython reload)
+"""
+
+import sys
+import time
+import os.path as osp
+sys.path.insert(0, osp.join(osp.dirname(__file__), 'src'))
+
+from speedy_utils.common.utils_cache import imemoize, _GLOBAL_MEMORY_CACHE
+
+def test_ipython_reload_simulation():
+    """
+    Test that imemoize persists across function redefinition,
+    simulating what happens in IPython when %load is used
+    """
+    print("=== Testing IPython reload simulation ===")
+    
+    # Clear any existing cache
+    _GLOBAL_MEMORY_CACHE.clear()
+    
+    # First definition of the function
+    @imemoize
+    def computation_v1(x):
+        print(f"Computing v1({x})")
+        time.sleep(0.05)
+        return x * x
+    
+    # Call it first time
+    print("1. First call to v1:")
+    result1 = computation_v1(10)
+    print(f"   Result: {result1}")
+    
+    # Call it second time (should be cached)
+    print("2. Second call to v1 (should be cached):")
+    start = time.time()
+    result2 = computation_v1(10)
+    end = time.time()
+    print(f"   Result: {result2}, Time: {end - start:.6f}s")
+    
+    assert result1 == result2
+    assert end - start < 0.01  # Should be very fast (cached)
+    
+    # Check cache has content
+    print(f"3. Cache now contains {len(_GLOBAL_MEMORY_CACHE)} entries")
+    
+    # Now simulate IPython %load - redefine the SAME function
+    @imemoize 
+    def computation_v1(x):  # Same name, same logic
+        print(f"Computing v1({x})")
+        time.sleep(0.05)
+        return x * x
+    
+    # This should still be cached because source code is the same
+    print("4. Call after 'reload' with same code (should be cached):")
+    start = time.time()
+    result3 = computation_v1(10)
+    end = time.time()
+    print(f"   Result: {result3}, Time: {end - start:.6f}s")
+    
+    assert result3 == result1
+    assert end - start < 0.01  # Should still be fast (cached)
+    
+    # Now simulate a code change
+    @imemoize
+    def computation_v1(x):  # Same name, different logic
+        print(f"Computing v1 modified({x})")
+        time.sleep(0.05)
+        return x * x * 2  # Different computation!
+    
+    # This should NOT be cached because source code changed
+    print("5. Call after code change (should NOT be cached):")
+    start = time.time()
+    result4 = computation_v1(10)
+    end = time.time()
+    print(f"   Result: {result4}, Time: {end - start:.3f}s")
+    
+    assert result4 == 200  # New computation
+    assert result4 != result1  # Different from before
+    assert end - start > 0.04  # Should be slow (not cached)
+    
+    # Second call to modified function should now be cached
+    print("6. Second call to modified function (should be cached):")
+    start = time.time()
+    result5 = computation_v1(10)
+    end = time.time()
+    print(f"   Result: {result5}, Time: {end - start:.6f}s")
+    
+    assert result5 == result4
+    assert end - start < 0.01  # Should be fast (cached)
+    
+    print("✓ IPython reload simulation works correctly!")
+
+def test_cross_function_caching():
+    """Test that different functions have separate cache entries"""
+    print("\n=== Testing cross-function caching ===")
+    
+    @imemoize
+    def func_a(x):
+        print(f"Computing func_a({x})")
+        return x + 1
+    
+    @imemoize 
+    def func_b(x):
+        print(f"Computing func_b({x})")
+        return x + 1  # Same logic, different function
+    
+    # Both should compute independently
+    result_a = func_a(5)
+    result_b = func_b(5)
+    
+    print(f"func_a(5) = {result_a}")
+    print(f"func_b(5) = {result_b}")
+    
+    assert result_a == result_b == 6
+    print("✓ Different functions cache independently!")
+
+if __name__ == "__main__":
+    test_ipython_reload_simulation()
+    test_cross_function_caching()
+    print("\n🎉 All persistence tests passed!")