moose-lib 0.4.195__tar.gz → 0.4.197__tar.gz

{moose_lib-0.4.195 → moose_lib-0.4.197}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moose_lib
-Version: 0.4.195
+Version: 0.4.197
 Home-page: https://www.fiveonefour.com/moose
 Author: Fiveonefour Labs Inc.
 Author-email: support@fiveonefour.com
@@ -10,6 +10,7 @@ Requires-Dist: asyncio==3.4.3
 Requires-Dist: pydantic==2.10.6
 Requires-Dist: temporalio==1.9.0
 Requires-Dist: kafka-python-ng==2.2.2
+Requires-Dist: redis==6.2.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

{moose_lib-0.4.195 → moose_lib-0.4.197}/moose_lib/__init__.py

@@ -9,3 +9,5 @@ from .tasks import *
 from .data_models import *
 
 from .dmv2 import *
+
+from .clients.redis_client import MooseCache

moose_lib-0.4.197/moose_lib/clients/redis_client.py

@@ -0,0 +1,237 @@
+import atexit
+import json
+import os
+import redis
+import threading
+from pydantic import BaseModel
+from typing import Optional, TypeVar, Type, Union, TypeAlias
+
+
+T = TypeVar('T')
+SupportedValue: TypeAlias = Union[str, BaseModel]
+
+class MooseCache:
+    """
+    A singleton Redis cache client that automatically handles connection management
+    and key prefixing.
+
+    Example:
+        cache = MooseCache()  # Gets or creates the singleton instance
+    """
+    _instance = None
+    _redis_url: str
+    _key_prefix: str
+    _client: Optional[redis.Redis] = None
+    _is_connected: bool = False
+    _disconnect_timer: Optional[threading.Timer] = None
+    _idle_timeout: int
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(MooseCache, cls).__new__(cls)
+            atexit.register(cls._instance.disconnect)
+        return cls._instance
+
+    def __init__(self) -> None:
+        if self._client is not None:
+            return
+
+        self._redis_url = os.getenv('MOOSE_REDIS_CONFIG__URL', 'redis://127.0.0.1:6379')
+        prefix = os.getenv('MOOSE_REDIS_CONFIG__KEY_PREFIX', 'MS')
+        # 30 seconds of inactivity before disconnecting
+        self._idle_timeout = int(os.getenv('MOOSE_REDIS_CONFIG__IDLE_TIMEOUT', '30'))
+        self._key_prefix = f"{prefix}::moosecache::"
+
+        self._ensure_connected()
+
+    def _get_prefixed_key(self, key: str) -> str:
+        """Internal method to prefix keys with the configured prefix."""
+        return f"{self._key_prefix}{key}"
+
+    def _clear_disconnect_timer(self) -> None:
+        """Clear the disconnect timer if it exists and create a new one."""
+        if self._disconnect_timer is not None:
+            self._disconnect_timer.cancel()
+        self._disconnect_timer = threading.Timer(self._idle_timeout, self.disconnect)
+        self._disconnect_timer.daemon = True
+
+    def _ensure_connected(self) -> None:
+        """Ensure the client is connected and reset the disconnect timer."""
+        if not self._is_connected:
+            self._client = redis.from_url(self._redis_url, decode_responses=True)
+            self._is_connected = True
+            print("Python Redis client connected")
+
+        self._clear_disconnect_timer()
+        self._disconnect_timer.start()
+
+    def set(self, key: str, value: SupportedValue, ttl_seconds: Optional[int] = None) -> None:
+        """
+        Sets a value in the cache. Only accepts strings or Pydantic models.
+        Objects are automatically JSON stringified.
+
+        Args:
+            key: The key to store the value under
+            value: The value to store. Must be a string or Pydantic model
+            ttl_seconds: Optional time-to-live in seconds. If not provided, defaults to 1 hour (3600 seconds).
+                       Must be a non-negative number. If 0, the key will expire immediately.
+
+        Example:
+            ### Store a string
+            cache.set("foo", "bar")
+
+            ### Store a Pydantic model
+            class Config(BaseModel):
+                baz: int
+                qux: bool
+            cache.set("foo:config", Config(baz=123, qux=True))
+        """
+        try:
+            # Validate value type
+            if not isinstance(value, (str, BaseModel)):
+                raise TypeError(
+                    f"Value must be a string or Pydantic model. Got {type(value).__name__}"
+                )
+
+            # Validate TTL
+            if ttl_seconds is not None and ttl_seconds < 0:
+                raise ValueError("ttl_seconds must be a non-negative number")
+
+            self._ensure_connected()
+            prefixed_key = self._get_prefixed_key(key)
+
+            if isinstance(value, str):
+                string_value = value
+            else:
+                string_value = value.model_dump_json()
+
+            # Use provided TTL or default to 1 hour
+            ttl = ttl_seconds if ttl_seconds is not None else 3600
+            self._client.setex(prefixed_key, ttl, string_value)
+        except Exception as e:
+            print(f"Error setting cache key {key}: {e}")
+            raise
+
+    def get(self, key: str, type_hint: Type[T] = str) -> Optional[T]:
+        """
+        Retrieves a value from the cache. Only supports strings or Pydantic models.
+        The type_hint parameter determines how the value will be parsed and returned.
+
+        Args:
+            key: The key to retrieve
+            type_hint: Type hint for the return value. Must be str or a Pydantic model class.
+                      Defaults to str.
+
+        Returns:
+            The value parsed as the specified type. Returns None if key doesn't exist.
+
+        Example:
+            ### Get a string (default)
+            value = cache.get("foo")
+
+            ### Get and parse as Pydantic model
+            class Config(BaseModel):
+                baz: int
+                qux: bool
+            config = cache.get("foo:config", Config)
+        """
+        try:
+            # Validate type_hint
+            if not isinstance(type_hint, type):
+                raise TypeError("type_hint must be a type")
+            if not (type_hint is str or issubclass(type_hint, BaseModel)):
+                raise TypeError(
+                    "type_hint must be str or a Pydantic model class. "
+                    f"Got {type_hint.__name__}"
+                )
+
+            self._ensure_connected()
+            prefixed_key = self._get_prefixed_key(key)
+            value = self._client.get(prefixed_key)
+
+            if value is None:
+                return None
+            elif type_hint is str:
+                return value
+            elif isinstance(type_hint, type) and issubclass(type_hint, BaseModel):
+                try:
+                    parsed = json.loads(value)
+                    return type_hint.model_validate(parsed)
+                except Exception as e:
+                    raise ValueError(f"Failed to validate as {type_hint.__name__}: {e}")
+            else:
+                raise TypeError(f"Unsupported type_hint: {type_hint}")
+
+        except Exception as e:
+            print(f"Error getting cache key {key}: {e}")
+            raise
+
+    def delete(self, key: str) -> None:
+        """
+        Deletes a specific key from the cache.
+
+        Args:
+            key: The key to delete
+
+        Example:
+            cache.delete("foo")
+        """
+        try:
+            self._ensure_connected()
+            prefixed_key = self._get_prefixed_key(key)
+            self._client.delete(prefixed_key)
+        except Exception as e:
+            print(f"Error deleting cache key {key}: {e}")
+            raise
+
+    def clear_keys(self, key_prefix: str) -> None:
+        """
+        Deletes all keys that start with the given prefix.
+
+        Args:
+            key_prefix: The prefix of keys to delete
+
+        Example:
+            # Delete all keys starting with "foo"
+            cache.clear_keys("foo")
+        """
+        try:
+            self._ensure_connected()
+            prefixed_key = self._get_prefixed_key(key_prefix)
+            keys = self._client.keys(f"{prefixed_key}*")
+            if keys:
+                self._client.delete(*keys)
+        except Exception as e:
+            print(f"Error clearing cache keys with prefix {key_prefix}: {e}")
+            raise
+
+    def clear(self) -> None:
+        """
+        Deletes all keys in the cache
+
+        Example:
+            cache.clear()
+        """
+        try:
+            self._ensure_connected()
+            keys = self._client.keys(f"{self._key_prefix}*")
+            if keys:
+                self._client.delete(*keys)
+        except Exception as e:
+            print(f"Error clearing cache: {e}")
+            raise
+
+    def disconnect(self) -> None:
+        """
+        Manually disconnects the Redis client. The client will automatically reconnect
+        when the next operation is performed.
+
+        Example:
+            cache.disconnect()
+        """
+        if self._is_connected and self._client:
+            self._client.close()
+            self._is_connected = False
+            self._clear_disconnect_timer()
+
+        print("Python Redis client disconnected")

{moose_lib-0.4.195 → moose_lib-0.4.197}/moose_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moose_lib
-Version: 0.4.195
+Version: 0.4.197
 Home-page: https://www.fiveonefour.com/moose
 Author: Fiveonefour Labs Inc.
 Author-email: support@fiveonefour.com
@@ -10,6 +10,7 @@ Requires-Dist: asyncio==3.4.3
 Requires-Dist: pydantic==2.10.6
 Requires-Dist: temporalio==1.9.0
 Requires-Dist: kafka-python-ng==2.2.2
+Requires-Dist: redis==6.2.0
 Dynamic: author
 Dynamic: author-email
 Dynamic: description

{moose_lib-0.4.195 → moose_lib-0.4.197}/moose_lib.egg-info/SOURCES.txt

@@ -15,8 +15,11 @@ moose_lib.egg-info/SOURCES.txt
 moose_lib.egg-info/dependency_links.txt
 moose_lib.egg-info/requires.txt
 moose_lib.egg-info/top_level.txt
+moose_lib/clients/__init__.py
+moose_lib/clients/redis_client.py
 moose_lib/streaming/__init__.py
 moose_lib/streaming/streaming_function_runner.py
 tests/__init__.py
 tests/conftest.py
-tests/test_moose.py
+tests/test_moose.py
+tests/test_redis_client.py

{moose_lib-0.4.195 → moose_lib-0.4.197}/moose_lib.egg-info/requires.txt

@@ -3,3 +3,4 @@ asyncio==3.4.3
 pydantic==2.10.6
 temporalio==1.9.0
 kafka-python-ng==2.2.2
+redis==6.2.0

{moose_lib-0.4.195 → moose_lib-0.4.197}/setup.py

@@ -28,5 +28,6 @@ setup(
         "pydantic==2.10.6",
         "temporalio==1.9.0",
         "kafka-python-ng==2.2.2",
+        "redis==6.2.0",
     ],
 )

moose_lib-0.4.197/tests/test_redis_client.py

@@ -0,0 +1,127 @@
+import os
+import sys
+import time
+import subprocess
+import pytest
+from pydantic import BaseModel
+from moose_lib import MooseCache
+
+class Config(BaseModel):
+    baz: int
+    qux: bool
+
+@pytest.mark.integration
+def test_cache_strings():
+    cache = MooseCache()
+
+    # Test setting and getting strings
+    cache.set("test:string", "hello")
+    value = cache.get("test:string")
+    assert value == "hello"
+
+    # Test with explicit str type hint
+    value = cache.get("test:string", str)
+    assert value == "hello"
+
+    # Clean up
+    cache.clear_keys("test")
+
+@pytest.mark.integration
+def test_cache_pydantic():
+    cache = MooseCache()
+
+    # Test setting and getting Pydantic models
+    config = Config(baz=123, qux=True)
+    cache.set("test:config", config)
+
+    retrieved = cache.get("test:config", Config)
+    assert retrieved is not None
+    assert retrieved.baz == 123
+    assert retrieved.qux is True
+
+    # Test invalid JSON
+    cache.set("test:invalid", "not json")
+    with pytest.raises(ValueError):
+        cache.get("test:invalid", Config)
+
+    # Clean up
+    cache.clear_keys("test")
+
+@pytest.mark.integration
+def test_cache_ttl():
+    cache = MooseCache()
+
+    # Test setting and getting with TTL
+    cache.set("test:ttl", "hello", ttl_seconds=3)
+    value = cache.get("test:ttl")
+    assert value == "hello"
+    time.sleep(5)
+    value = cache.get("test:ttl")
+    assert value is None
+
+    # Test negative TTL
+    with pytest.raises(ValueError):
+        cache.set("test:negative_ttl", "hello", ttl_seconds=-1)
+
+    # Clean up
+    cache.clear_keys("test")
+
+@pytest.mark.integration
+def test_cache_nonexistent():
+    cache = MooseCache()
+
+    # Test getting nonexistent keys
+    assert cache.get("nonexistent") is None
+    assert cache.get("nonexistent", str) is None
+    assert cache.get("nonexistent", Config) is None
+
+@pytest.mark.integration
+def test_cache_invalid_type():
+    cache = MooseCache()
+
+    # Test invalid type hints
+    with pytest.raises(TypeError):
+        cache.get("test", int)
+
+    with pytest.raises(TypeError):
+        cache.get("test", dict)
+
+@pytest.mark.integration
+def test_atexit_cleanup():
+    # Create a test script that will be run in a separate process
+    test_script = """
+import sys
+from moose_lib.clients.redis_client import MooseCache
+
+# Create instance
+cache = MooseCache()
+print("Created cache instance")
+
+# Force exit without calling disconnect
+sys.exit(0)
+"""
+
+    # Write the test script to a temporary file
+    with open("test_atexit.py", "w") as f:
+        f.write(test_script)
+
+    try:
+        # Run the script and capture output
+        result = subprocess.run([sys.executable, "test_atexit.py"],
+                              capture_output=True,
+                              text=True)
+
+        # Check if we see both the connection and disconnection messages
+        output = result.stdout + result.stderr
+        print("\nTest output:")
+        print("------------")
+        print(output)
+        print("------------")
+
+        assert "Python Redis client connected" in output
+        assert "Python Redis client disconnected" in output
+        print("\nTest passed! Verified atexit cleanup is working.")
+
+    finally:
+        # Clean up the test script
+        os.remove("test_atexit.py")