[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

README.rst

@@ -688,7 +688,7 @@ When writing tests for cachier, follow these critical guidelines to ensure test
 
   def test_feature_a():
       assert shared_func(5) == 10
-  
+
   def test_feature_b():
       assert shared_func(5) == 10  # This may conflict with test_feature_a
 

parallel_test_analysis.md

@@ -7,17 +7,20 @@ The parallel tests for MongoDB, Redis, and SQL backends successfully avoid confl
 ### 1. **Unique Function Names Per Cache Key**
 
 Cache keys in Cachier are generated using a combination of:
+
 - **Module name**: `func.__module__`
 - **Function name**: `func.__name__`
 - **Function arguments**: Hashed via the `hash_func`
 
 From `src/cachier/cores/base.py`:
+
 ```python
 def _get_func_str(func: Callable) -> str:
     return f".{func.__module__}.{func.__name__}"
 ```
 
 This means:
+
 - Each backend prefixes cache entries with the full module path and function name
 - Redis: `{prefix}:{func_str}:{key}` (e.g., `cachier:.tests.test_redis_core._test_redis_caching:hash123`)
 - MongoDB: Documents with `{"func": func_str, "key": key}`
@@ -26,18 +29,21 @@ This means:
 ### 2. **Function Name Isolation Within Test Files**
 
 Looking at the test files:
+
 - Functions within each test function are **locally scoped**
 - Even if multiple tests use `def f(x)` or `def _test_func()`, they are different function objects
 - Each function gets a unique module path because they're defined inside different test functions
 
 Examples:
+
 ```python
 # In test_sql_core.py
 def test_sql_core_basic():
     @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def f(x, y):  # This f is local to test_sql_core_basic
         return random() + x + y
 
+
 def test_sql_core_keywords():
     @cachier(backend="sql", sql_engine=SQL_CONN_STR)
     def f(x, y):  # This f is different from the one above
@@ -47,27 +53,32 @@ def test_sql_core_keywords():
 ### 3. **Clear Cache Operations**
 
 Most tests start with `func.clear_cache()` which removes all entries for that specific function:
+
 - MongoDB: `delete_many(filter={"func": self._func_str})`
 - Redis: Deletes all keys matching pattern `{prefix}:{func_str}:*`
 - SQL: `delete(CacheTable).where(CacheTable.function_id == self._func_str)`
 
 ### 4. **Backend-Specific Isolation**
 
 #### MongoDB:
+
 - Uses a collection name that includes platform and Python version: `cachier_test_{platform}_{python_version}`
 - Each function's entries are filtered by `func` field
 
 #### Redis:
+
 - Uses key prefixes that include the full function path
 - Pattern-based operations only affect keys for specific functions
 
 #### SQL:
+
 - Uses `function_id` column to separate entries by function
 - Composite operations use both `function_id` and `key`
 
 ### 5. **Test Fixtures for Additional Isolation**
 
 From `tests/conftest.py`:
+
 ```python
 @pytest.fixture(autouse=True)
 def isolated_cache_directory(tmp_path, monkeypatch, request, worker_id):
@@ -83,6 +94,7 @@ def isolated_cache_directory(tmp_path, monkeypatch, request, worker_id):
 ### 6. **No Shared Function Names Across Test Files**
 
 Analysis shows:
+
 - Test functions have unique names across files (no duplicate `test_*` function names)
 - Cached functions are either:
   - Defined locally within test functions (most common)
@@ -91,17 +103,19 @@ Analysis shows:
 ### 7. **Argument-Based Key Differentiation**
 
 Even if two tests used the same function name (which they don't), different arguments would create different cache keys:
+
 - Tests use different argument values (e.g., `(1, 2)`, `(34, 82.3)`, etc.)
 - The hash function ensures different arguments → different keys
 
 ## Conclusion
 
 The parallel tests avoid conflicts through:
+
 1. **Function name namespacing** - Full module path included in cache keys
 2. **Local function scope** - Functions defined inside test functions are unique objects
 3. **Clear cache operations** - Tests clean up their own function's cache
 4. **Backend-specific key prefixing** - Each backend uses function-specific prefixes/filters
 5. **Test isolation fixtures** - Separate cache directories for pickle backend
 6. **No naming collisions** - Test authors have been careful to use unique function names
 
-This design allows tests to run in parallel without interfering with each other, as each test operates on its own namespace within the cache backends.
+This design allows tests to run in parallel without interfering with each other, as each test operates on its own namespace within the cache backends.

tests/README.md

@@ -136,21 +136,23 @@ pytest -n 4
 import pytest
 from cachier import cachier
 
+
 def test_basic_caching():
     """Test basic caching functionality."""
+
     # Define a cached function local to this test
     @cachier()
     def expensive_computation(x):
-        return x ** 2
-    
+        return x**2
+
     # First call - should compute
     result1 = expensive_computation(5)
     assert result1 == 25
-    
+
     # Second call - should return from cache
     result2 = expensive_computation(5)
     assert result2 == 25
-    
+
     # Clear cache for cleanup
     expensive_computation.clear_cache()
 ```
@@ -162,11 +164,11 @@ def test_basic_caching():
 def test_mongo_specific_feature():
     """Test MongoDB-specific functionality."""
     from tests.test_mongo_core import _test_mongetter
-    
+
     @cachier(mongetter=_test_mongetter)
     def mongo_cached_func(x):
         return x * 2
-    
+
     # Test implementation
     assert mongo_cached_func(5) == 10
 ```
@@ -180,6 +182,7 @@ def test_mongo_specific_feature():
 #### Why This Matters
 
 Cachier identifies cached functions by their full module path and function name. When tests share decorated functions:
+
 - Cache entries can conflict between tests
 - Parallel test execution may fail unpredictably
 - Test results become non-deterministic
@@ -191,14 +194,15 @@ def test_feature_one():
     @cachier()
     def compute_one(x):  # Unique to this test
         return x * 2
-    
+
     assert compute_one(5) == 10
 
+
 def test_feature_two():
     @cachier()
     def compute_two(x):  # Different function for different test
         return x * 2
-    
+
     assert compute_two(5) == 10
 ```
 
@@ -210,9 +214,11 @@ def test_feature_two():
 def shared_compute(x):  # Shared between tests
     return x * 2
 
+
 def test_feature_one():
     assert shared_compute(5) == 10  # May conflict with test_feature_two
 
+
 def test_feature_two():
     assert shared_compute(5) == 10  # May conflict with test_feature_one
 ```
@@ -239,10 +245,11 @@ def test_feature_two():
 @pytest.mark.mongo
 def test_mongo_feature():
     """Test with MongoDB backend."""
+
     @cachier(mongetter=_test_mongetter, wait_for_calc_timeout=2)
     def mongo_func(x):
         return x
-    
+
     # MongoDB-specific assertions
     assert mongo_func.get_cache_mongetter() is not None
 ```
@@ -253,10 +260,11 @@ def test_mongo_feature():
 @pytest.mark.redis
 def test_redis_feature():
     """Test with Redis backend."""
-    @cachier(backend='redis', redis_client=_test_redis_client)
+
+    @cachier(backend="redis", redis_client=_test_redis_client)
     def redis_func(x):
         return x
-    
+
     # Redis-specific testing
     assert redis_func(5) == 5
 ```
@@ -267,10 +275,11 @@ def test_redis_feature():
 @pytest.mark.sql
 def test_sql_feature():
     """Test with SQL backend."""
-    @cachier(backend='sql', sql_engine=test_engine)
+
+    @cachier(backend="sql", sql_engine=test_engine)
     def sql_func(x):
         return x
-    
+
     # SQL-specific testing
     assert sql_func(5) == 5
 ```
@@ -281,10 +290,11 @@ def test_sql_feature():
 @pytest.mark.memory
 def test_memory_feature():
     """Test with memory backend."""
-    @cachier(backend='memory')
+
+    @cachier(backend="memory")
     def memory_func(x):
         return x
-    
+
     # Memory-specific testing
     assert memory_func(5) == 5
 ```
@@ -345,50 +355,61 @@ pytest -m sql
 ### Common Issues
 
 1. **Import Errors**: Install backend-specific requirements
+
    ```bash
    pip install -r tests/redis_requirements.txt
    ```
 
 2. **Docker Not Running**: Start Docker Desktop or daemon
+
    ```bash
    docker ps  # Check if Docker is running
    ```
 
 3. **Port Conflicts**: Stop conflicting services
+
    ```bash
    docker stop cachier-test-mongo cachier-test-redis cachier-test-postgres
    ```
 
 4. **Flaky Tests**: Usually due to timing issues
+
    - Increase timeouts
    - Add proper waits
    - Check for race conditions
 
 5. **Cache Conflicts**: Ensure function isolation
+
    - Don't share decorated functions
    - Clear cache after tests
    - Use unique function names
 
 ### Debugging Tips
 
-1. **Run Single Test**: 
+1. **Run Single Test**:
+
    ```bash
    pytest -k test_name -v
    ```
 
-2. **Disable Parallel**: 
+2. **Disable Parallel**:
+
    ```bash
    pytest -n 1
    ```
 
 3. **Check Logs**:
+
    ```bash
    docker logs cachier-test-mongo
    ```
 
 4. **Interactive Debugging**:
+
    ```python
-   import pdb; pdb.set_trace()
+   import pdb
+
+   pdb.set_trace()
    ```
 
 ### Performance Considerations
@@ -427,4 +448,4 @@ When adding new tests:
 - Check existing tests for examples
 - Review the main README.rst
 - Open an issue on GitHub
-- Contact maintainers listed in README.rst
+- Contact maintainers listed in README.rst