minor fixes

Author: shaypal5

examples/redis_example.py

@@ -6,7 +6,6 @@
 
 Requirements:
     pip install redis cachier
-
 """
 
 import time
@@ -112,7 +111,7 @@ def demo_callable_client():
     print("\n=== Callable Client Demo ===")
 
     def get_redis_client():
-        """Factory function for Redis client."""
+        """Get a Redis client."""
         return redis.Redis(
             host="localhost", port=6379, db=0, decode_responses=False
         )

pyproject.toml

@@ -128,6 +128,9 @@ lint.per-file-ignores."tests/**" = [
   "S311",
   "S603",
 ]
+lint.per-file-ignores."examples/**" = [
+  "S101",
+]
 lint.unfixable = [
   "F401",
 ]

src/cachier/core.py

@@ -141,9 +141,8 @@ def cachier(
     backend : str, optional
         The name of the backend to use. Valid options currently include
         'pickle', 'mongo', 'memory', 'sql', and 'redis'. If not provided,
-        defaults to 'pickle', unless an argument is provided for one of the
-        other parameters that requires a different backend, in which case the
-        backend is set to the one required by that parameter.
+        defaults to 'pickle' unless the 'mongetter' argument is passed,
+        in which case the mongo backend is automatically selected.
     mongetter : callable, optional
         A callable that takes no arguments and returns a pymongo.Collection
         object with writing permissions. If unset a local pickle cache is used

tests/redis_requirements.txt

@@ -1,3 +1,3 @@
 redis>=4.0.0
 pandas>=1.3.0
-birch>=0.0.35
+birch>=0.0.35 

tests/test_redis_core.py

@@ -68,49 +68,101 @@ def _test_redis_getter():
     client = _get_test_redis_client()
     if client is None:
         # Create a mock Redis client for testing
-        class MockRedis:
-            def __init__(self):
-                self.data = {}
-
-            def hgetall(self, key):
-                return self.data.get(key, {})
-
-            def hset(self, key, mapping=None, **kwargs):
-                if key not in self.data:
-                    self.data[key] = {}
-                if mapping:
-                    self.data[key].update(mapping)
-                if kwargs:
-                    self.data[key].update(kwargs)
-
-            def keys(self, pattern):
-                import re
-
-                pattern = pattern.replace("*", ".*")
-                return [k for k in self.data if re.match(pattern, k.decode())]
-
-            def delete(self, *keys):
-                for key in keys:
-                    self.data.pop(key, None)
-
-            def pipeline(self):
-                return MockPipeline(self)
-
-        class MockPipeline:
-            def __init__(self, redis_client):
-                self.redis_client = redis_client
-                self.commands = []
-
-            def hset(self, key, field, value):
-                self.commands.append(("hset", key, field, value))
-                return self
-
-            def execute(self):
-                for cmd, key, field, value in self.commands:
-                    if cmd == "hset":
-                        self.redis_client.hset(key, field, value)
-
-        return MockRedis()
+        # Use a singleton pattern to ensure the same instance is returned
+        if not hasattr(_test_redis_getter, "_mock_client"):
+
+            class MockRedis:
+                def __init__(self):
+                    self.data = {}
+                    print("DEBUG: MockRedis initialized")
+
+                def hgetall(self, key):
+                    result = self.data.get(key, {})
+                    # Convert string values to bytes to match Redis behavior
+                    bytes_result = {}
+                    for k, v in result.items():
+                        if isinstance(v, str):
+                            bytes_result[k.encode("utf-8")] = v.encode("utf-8")
+                        else:
+                            bytes_result[k.encode("utf-8")] = v
+                    print(
+                        f"DEBUG: hgetall({key}) = {result} -> {bytes_result}"
+                    )
+                    return bytes_result
+
+                def hset(
+                    self, key, field=None, value=None, mapping=None, **kwargs
+                ):
+                    if key not in self.data:
+                        self.data[key] = {}
+
+                    # Handle different calling patterns
+                    if mapping is not None:
+                        # Called with mapping dict
+                        self.data[key].update(mapping)
+                    elif field is not None and value is not None:
+                        # Called with field, value arguments
+                        self.data[key][field] = value
+                    elif kwargs:
+                        # Called with keyword arguments
+                        self.data[key].update(kwargs)
+
+                    print(
+                        f"DEBUG: hset({key}, field={field}, value={value}, "
+                        "mapping={mapping}, kwargs={kwargs}) -> "
+                        "{self.data[key]}"
+                    )
+
+                def keys(self, pattern):
+                    import re
+
+                    pattern = pattern.replace("*", ".*")
+                    # Fix: keys are strings, not bytes, so no need to decode
+                    result = [k for k in self.data if re.match(pattern, k)]
+                    print(f"DEBUG: keys({pattern}) = {result}")
+                    return result
+
+                def delete(self, *keys):
+                    for key in keys:
+                        self.data.pop(key, None)
+                    print(f"DEBUG: delete({keys})")
+
+                def pipeline(self):
+                    return MockPipeline(self)
+
+                def ping(self):
+                    return True
+
+                def set(self, key, value):
+                    self.data[key] = value
+                    print(f"DEBUG: set({key}, {value})")
+
+                def get(self, key):
+                    result = self.data.get(key)
+                    if isinstance(result, str):
+                        result = result.encode("utf-8")
+                    print(f"DEBUG: get({key}) = {result}")
+                    return result
+
+            class MockPipeline:
+                def __init__(self, redis_client):
+                    self.redis_client = redis_client
+                    self.commands = []
+
+                def hset(self, key, field, value):
+                    self.commands.append(("hset", key, field, value))
+                    return self
+
+                def execute(self):
+                    for cmd, key, field, value in self.commands:
+                        if cmd == "hset":
+                            self.redis_client.hset(
+                                key, field=field, value=value
+                            )
+
+            _test_redis_getter._mock_client = MockRedis()
+
+        return _test_redis_getter._mock_client
     return client
 
 
@@ -213,46 +265,75 @@ def _stale_after_redis(arg_1, arg_2):
 
 
 def _calls_takes_time_redis(res_queue):
+    print("DEBUG: _calls_takes_time_redis started")
+
     @cachier(backend="redis", redis_client=_test_redis_getter)
     def _takes_time(arg_1, arg_2):
         """Some function."""
+        print(
+            f"DEBUG: _calls_takes_time_redis._takes_time({arg_1}, {arg_2})"
+            " called"
+        )
         sleep(3)
-        return random() + arg_1 + arg_2
+        result = random() + arg_1 + arg_2
+        print(
+            f"DEBUG: _calls_takes_time_redis._takes_time({arg_1}, {arg_2}) "
+            f"returning {result}"
+        )
+        return result
 
+    print("DEBUG: _calls_takes_time_redis calling _takes_time(34, 82.3)")
     res = _takes_time(34, 82.3)
+    print(f"DEBUG: _calls_takes_time_redis got result {res}, putting in queue")
     res_queue.put(res)
+    print("DEBUG: _calls_takes_time_redis completed")
 
 
 @pytest.mark.redis
 def test_redis_being_calculated():
     """Testing Redis core handling of being calculated scenarios."""
+    print("DEBUG: test_redis_being_calculated started")
 
     @cachier(backend="redis", redis_client=_test_redis_getter)
     def _takes_time(arg_1, arg_2):
         """Some function."""
+        print(f"DEBUG: _takes_time({arg_1}, {arg_2}) called")
         sleep(3)
-        return random() + arg_1 + arg_2
+        result = random() + arg_1 + arg_2
+        print(f"DEBUG: _takes_time({arg_1}, {arg_2}) returning {result}")
+        return result
 
+    print("DEBUG: Clearing cache")
     _takes_time.clear_cache()
     res_queue = queue.Queue()
+    print("DEBUG: Starting thread1")
     thread1 = threading.Thread(
         target=_calls_takes_time_redis,
         kwargs={"res_queue": res_queue},
         daemon=True,
     )
+    print("DEBUG: Starting thread2")
     thread2 = threading.Thread(
         target=_calls_takes_time_redis,
         kwargs={"res_queue": res_queue},
         daemon=True,
     )
+    print("DEBUG: Starting thread1")
     thread1.start()
+    print("DEBUG: Sleeping 1 second")
     sleep(1)
+    print("DEBUG: Starting thread2")
     thread2.start()
+    print("DEBUG: Waiting for thread1 to join")
     thread1.join()
+    print("DEBUG: Waiting for thread2 to join")
     thread2.join()
+    print("DEBUG: Getting results from queue")
     res1 = res_queue.get()
     res2 = res_queue.get()
+    print(f"DEBUG: Results: res1={res1}, res2={res2}")
     assert res1 == res2
+    print("DEBUG: test_redis_being_calculated completed successfully")
 
 
 @pytest.mark.redis