miso-client 0.1.0__py3-none-any.whl → 3.7.2__py3-none-any.whl

miso_client/services/cache.py

@@ -8,17 +8,18 @@ in-memory TTL-based caching when Redis is unavailable.
 
 import json
 import time
-from typing import Any, Optional, Dict, Tuple
+from typing import Any, Dict, Optional, Tuple
+
 from ..services.redis import RedisService
 
 
 class CacheService:
     """Cache service with Redis and in-memory TTL fallback."""
-    
+
     def __init__(self, redis: Optional[RedisService] = None):
         """
         Initialize cache service.
-        
+
         Args:
             redis: Optional RedisService instance. If provided, Redis will be used
                   as primary cache with in-memory as fallback. If None, only
@@ -29,31 +30,32 @@ class CacheService:
         self._memory_cache: Dict[str, Tuple[Any, float]] = {}
         # Cleanup threshold: clean expired entries if cache exceeds this size
         self._cleanup_threshold = 1000
-    
+
     def _is_expired(self, expiration: float) -> bool:
         """Check if entry has expired."""
         return time.time() > expiration
-    
+
     def _cleanup_expired(self) -> None:
         """Remove expired entries from memory cache."""
         if len(self._memory_cache) <= self._cleanup_threshold:
             return
-        
+
         expired_keys = [
-            key for key, (_, expiration) in self._memory_cache.items()
+            key
+            for key, (_, expiration) in self._memory_cache.items()
             if self._is_expired(expiration)
         ]
-        
+
         for key in expired_keys:
             del self._memory_cache[key]
-    
+
     def _serialize_value(self, value: Any) -> str:
         """
         Serialize value to JSON string.
-        
+
         Args:
             value: Value to serialize (can be any JSON-serializable type)
-            
+
         Returns:
             JSON string representation
         """
@@ -62,23 +64,23 @@ class CacheService:
             if isinstance(value, str):
                 return value
             return json.dumps(value)
-        
+
         # For complex types, use JSON serialization with a marker
         return json.dumps({"__cached_value__": value})
-    
+
     def _deserialize_value(self, value_str: str) -> Any:
         """
         Deserialize JSON string back to original value.
-        
+
         Args:
             value_str: JSON string to deserialize
-            
+
         Returns:
             Deserialized value
         """
         if not value_str:
             return None
-        
+
         try:
             # Try to parse as JSON
             parsed = json.loads(value_str)
@@ -90,16 +92,16 @@ class CacheService:
         except (json.JSONDecodeError, TypeError):
             # If JSON parsing fails, assume it's a plain string
             return value_str
-    
+
     async def get(self, key: str) -> Optional[Any]:
         """
         Get cached value.
-        
+
         Checks Redis first (if available), then falls back to in-memory cache.
-        
+
         Args:
             key: Cache key
-            
+
         Returns:
             Cached value if found, None otherwise
         """
@@ -112,7 +114,7 @@ class CacheService:
             except Exception:
                 # Redis operation failed, fall through to memory cache
                 pass
-        
+
         # Fallback to in-memory cache
         if key in self._memory_cache:
             value, expiration = self._memory_cache[key]
@@ -121,26 +123,26 @@ class CacheService:
             else:
                 # Entry expired, remove it
                 del self._memory_cache[key]
-        
+
         return None
-    
+
     async def set(self, key: str, value: Any, ttl: int) -> bool:
         """
         Set cached value with TTL.
-        
+
         Stores in both Redis (if available) and in-memory cache.
-        
+
         Args:
             key: Cache key
             value: Value to cache (any JSON-serializable type)
             ttl: Time to live in seconds
-            
+
         Returns:
             True if successful, False otherwise
         """
         serialized_value = self._serialize_value(value)
         success = False
-        
+
         # Store in Redis if available
         if self.redis and self.redis.is_connected():
             try:
@@ -148,57 +150,56 @@ class CacheService:
             except Exception:
                 # Redis operation failed, continue to memory cache
                 pass
-        
+
         # Also store in memory cache
         expiration = time.time() + ttl
         self._memory_cache[key] = (value, expiration)
-        
+
         # Cleanup expired entries periodically
         self._cleanup_expired()
-        
+
         return success or True  # Return True if at least memory cache succeeded
-    
+
     async def delete(self, key: str) -> bool:
         """
         Delete cached value.
-        
+
         Deletes from both Redis (if available) and in-memory cache.
-        
+
         Args:
             key: Cache key
-            
+
         Returns:
             True if deleted from at least one cache, False otherwise
         """
         deleted = False
-        
+
         # Delete from Redis if available
         if self.redis and self.redis.is_connected():
             try:
                 deleted = await self.redis.delete(key)
             except Exception:
                 pass
-        
+
         # Delete from memory cache
         if key in self._memory_cache:
             del self._memory_cache[key]
             deleted = True
-        
+
         return deleted
-    
+
     async def clear(self) -> None:
         """
         Clear all cached values.
-        
+
         Clears both Redis (if available) and in-memory cache.
         Note: Redis clear operation only clears keys with the configured prefix,
         not the entire Redis database.
         """
         # Clear memory cache
         self._memory_cache.clear()
-        
+
         # For Redis, we would need to delete all keys with the prefix
         # This is more complex and potentially dangerous, so we'll skip it
         # Users should use delete() for specific keys or clear Redis manually
         # if needed
-

miso_client/services/encryption.py

@@ -6,36 +6,38 @@ in the application. It supports reading the encryption key from environment vari
 or accepting it as a constructor parameter.
 """
 
-import os
 import base64
+import os
 from typing import Optional
+
 from cryptography.fernet import Fernet
+
 from ..errors import ConfigurationError
 
 
 class EncryptionService:
     """Service for encrypting/decrypting sensitive data using Fernet encryption."""
-    
+
     def __init__(self, encryption_key: Optional[str] = None):
         """
         Initialize encryption service with key from environment or parameter.
-        
+
         Args:
             encryption_key: Optional encryption key. If not provided, reads from EXTENSION_KEY env var.
                            If provided, overrides environment variable.
-        
+
         Raises:
             ConfigurationError: If encryption key is not found or invalid
         """
         # Use provided key, or fall back to environment variable
         key = encryption_key or os.environ.get("ENCRYPTION_KEY")
-        
+
         if not key:
             raise ConfigurationError(
                 "ENCRYPTION_KEY not found. Either set ENCRYPTION_KEY environment variable "
                 "or pass encryption_key parameter to EncryptionService constructor."
             )
-        
+
         try:
             # Fernet.generate_key() returns bytes, but env vars are strings
             # Convert string to bytes if needed
@@ -45,49 +47,48 @@ class EncryptionService:
             raise ConfigurationError(
                 f"Failed to initialize encryption service with provided key: {str(e)}"
             ) from e
-    
+
     def encrypt(self, plaintext: str) -> str:
         """
         Encrypt sensitive data.
-        
+
         Args:
             plaintext: Plain text string to encrypt
-            
+
         Returns:
             Base64-encoded encrypted string
-            
+
         Raises:
             ValueError: If encryption fails
         """
         if not plaintext:
             return ""
-        
+
         try:
             encrypted = self.fernet.encrypt(plaintext.encode())
             return base64.b64encode(encrypted).decode()
         except Exception as e:
             raise ValueError(f"Failed to encrypt data: {str(e)}") from e
-    
+
     def decrypt(self, encrypted_text: str) -> str:
         """
         Decrypt sensitive data.
-        
+
         Args:
             encrypted_text: Base64-encoded encrypted string
-            
+
         Returns:
             Decrypted plain text string
-            
+
         Raises:
             ValueError: If decryption fails or data is invalid
         """
         if not encrypted_text:
             return ""
-        
+
         try:
             decoded = base64.b64decode(encrypted_text.encode())
             decrypted = self.fernet.decrypt(decoded)
             return decrypted.decode()
         except Exception as e:
             raise ValueError(f"Failed to decrypt data: {str(e)}") from e
-