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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.25
+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.25 → 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.25 → speedy_utils-1.1.26}/pyproject.toml

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

@@ -1,66 +0,0 @@
-#!/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

@@ -1,95 +0,0 @@
-#!/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.25/test_imemoize.py

@@ -1,116 +0,0 @@
-#!/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

@@ -1,122 +0,0 @@
-#!/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!")