cledar-sdk 2.0.3__py3-none-any.whl → 2.1.0__py3-none-any.whl

cledar/logging/universal_plaintext_formatter.py

@@ -1,11 +1,16 @@
+"""Custom logging formatter for plaintext output with extra attributes.
+
+This module provides the UniversalPlaintextFormatter class which allows
+for easy logging of extra attributes in a human-readable format.
+"""
+
 import configparser
 import logging
 from typing import Any
 
 
 class UniversalPlaintextFormatter(logging.Formatter):
-    """
-    A custom formatter for logging that extends the standard logging.Formatter.
+    """A custom formatter for logging that extends the standard logging.Formatter.
 
     This formatter adds the ability to include extra attributes from log records while
     excluding standard attributes and configurable keys.
@@ -15,23 +20,23 @@ class UniversalPlaintextFormatter(logging.Formatter):
     DEFAULT_EXCLUDE_KEYS = {"message", "asctime"}
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        """
-        Initialize the formatter with standard formatter parameters.
+        """Initialize the formatter with standard formatter parameters.
 
         Args:
             *args: Variable length argument list for the parent class.
             **kwargs: Arbitrary keyword arguments for the parent class.
+
         """
         super().__init__(*args, **kwargs)
         self._standard_attrs: set[str] | None = None
         self._config_exclude_keys = self._load_exclude_keys_from_config()
 
     def _load_exclude_keys_from_config(self) -> set[str]:
-        """
-        Load additional keys to exclude from the configuration file.
+        """Load additional keys to exclude from the configuration file.
 
         Returns:
-            set: A set of keys to exclude from log records.
+            set[str]: A set of keys to exclude from log records.
+
         """
         try:
             config = configparser.ConfigParser()
@@ -44,14 +49,14 @@ class UniversalPlaintextFormatter(logging.Formatter):
         return set()
 
     def _get_standard_attrs(self) -> set[str]:
-        """
-        Get the set of standard attributes to exclude from log records.
+        """Get the set of standard attributes to exclude from log records.
 
         This includes standard LogRecord attributes, predefined exclusions,
         and exclusions from configuration.
 
         Returns:
-            set: A set of attribute names to exclude.
+            set[str]: A set of attribute names to exclude.
+
         """
         if self._standard_attrs is None:
             dummy_record = logging.LogRecord(
@@ -73,14 +78,14 @@ class UniversalPlaintextFormatter(logging.Formatter):
         return self._standard_attrs
 
     def format(self, record: logging.LogRecord) -> str:
-        """
-        Format the log record, adding any extra attributes not in the standard set.
+        """Format the log record, adding any extra attributes not in the standard set.
 
         Args:
             record: The log record to format.
 
         Returns:
             str: The formatted log message with extra attributes appended.
+
         """
         base = super().format(record)
         extras = {

cledar/monitoring/__init__.py

@@ -1,3 +1,5 @@
+"""Monitoring module for Prometheus metrics and health checks."""
+
 from .monitoring_server import EndpointFilter, MonitoringServer, MonitoringServerConfig
 
 __all__ = ["MonitoringServer", "MonitoringServerConfig", "EndpointFilter"]

cledar/monitoring/monitoring_server.py

@@ -1,6 +1,7 @@
+"""Prometheus monitoring and health checks server implementation."""
+
 import json
 import logging
-import logging.config
 import threading
 from collections.abc import Callable
 
@@ -28,22 +29,49 @@ def _run_monitoring_server(host: str, port: int, app: FastAPI) -> None:
 
 @dataclass
 class MonitoringServerConfig:
+    """Configuration for the MonitoringServer.
+
+    Args:
+        readiness_checks: A dictionary of name to callable for readiness checks.
+        liveness_checks: An optional dictionary for liveness checks.
+
+    """
+
     readiness_checks: dict[str, Callable[[], bool]]
     liveness_checks: dict[str, Callable[[], bool]] | None = None
 
 
 class EndpointFilter(logging.Filter):
+    """Filter for logging that excludes certain paths."""
+
     def __init__(self, paths_excluded_for_logging: list[str]):
+        """Initialize the EndpointFilter.
+
+        Args:
+            paths_excluded_for_logging: List of paths to exclude from logs.
+
+        """
         super().__init__()
         self.paths_excluded_for_logging = paths_excluded_for_logging
 
     def filter(self, record: logging.LogRecord) -> bool:
+        """Filter log records based on path exclusions.
+
+        Args:
+            record: The log record to check.
+
+        Returns:
+            bool: True if record should be logged, False otherwise.
+
+        """
         return not any(
             path in record.getMessage() for path in self.paths_excluded_for_logging
         )
 
 
 class MonitoringServer:
+    """A server that exposes Prometheus metrics and health check endpoints."""
+
     PATHS_EXCLUDED_FOR_LOGGING = ["/healthz/readiness", "/healthz/liveness"]
 
     def __init__(
@@ -52,6 +80,14 @@ class MonitoringServer:
         port: int,
         config: MonitoringServerConfig,
     ):
+        """Initialize the MonitoringServer.
+
+        Args:
+            host: The host to bind the server to.
+            port: The port to bind the server to.
+            config: The server configuration.
+
+        """
         self.config = config
         self.host = host
         self.port = port
@@ -60,6 +96,13 @@ class MonitoringServer:
         )
 
     def add_paths(self, app: FastAPI) -> None:
+        """Add monitoring and health check endpoints to the FastAPI application.
+
+        Args:
+            app: The FastAPI application to add routes to.
+
+        """
+
         @app.get("/metrics")
         async def get_metrics() -> Response:
             return Response(
@@ -101,6 +144,7 @@ class MonitoringServer:
             return Response(content=data_json, status_code=503)
 
     def start_monitoring_server(self) -> None:
+        """Start the monitoring server in a background thread."""
         local_app = _create_app()
         self.add_paths(local_app)
         server_thread = threading.Thread(

cledar/nonce/__init__.py

@@ -1,3 +1,5 @@
+"""Nonce service module for managing unique request identifiers."""
+
 from .nonce_service import NonceService
 
 __all__ = ["NonceService"]

cledar/nonce/nonce_service.py

@@ -1,5 +1,5 @@
-"""
-Simple nonce service for preventing duplicate request processing.
+"""Simple nonce service for preventing duplicate request processing.
+
 Uses Redis with TTL for automatic cleanup.
 """
 
@@ -10,17 +10,43 @@ class NonceService:
     """Simple service for managing nonces to prevent duplicate requests."""
 
     def __init__(self, redis_client: RedisService):
+        """Initialize the nonce service.
+
+        Args:
+            redis_client: The Redis client service used for storage.
+
+        """
         self.redis_client = redis_client
         self.nonce_prefix = "nonce"
         self.default_ttl = 3600  # 1 hour
 
     def _get_nonce_key(self, nonce: str, endpoint: str) -> str:
-        """Generate Redis key for nonce"""
+        """Generate Redis key for nonce.
+
+        Args:
+            nonce: The unique identifier for the request.
+            endpoint: The endpoint the request is directed at.
+
+        Returns:
+            str: The formatted Redis key.
+
+        """
         return f"{self.nonce_prefix}:{endpoint}:{nonce}"
 
     async def is_duplicate(self, nonce: str, endpoint: str) -> bool:
-        """Check if nonce was already used (returns True if duplicate)"""
+        """Check if nonce was already used (returns True if duplicate).
+
+        Args:
+            nonce: The unique identifier for the request.
+            endpoint: The endpoint the request is directed at.
+
+        Returns:
+            bool: True if the nonce is a duplicate, False otherwise.
+
+        Raises:
+            RuntimeError: If the Redis client is not initialized.
 
+        """
         nonce_key = self._get_nonce_key(nonce, endpoint)
 
         if self.redis_client._client is None:

cledar/redis/__init__.py

@@ -1,3 +1,5 @@
+"""Redis service module for the Cledar SDK."""
+
 from .redis import (
     AsyncRedisService,
     CustomEncoder,

cledar/redis/async_example.py

@@ -1,5 +1,4 @@
-"""
-Example usage of AsyncRedisService with async/await.
+"""Example usage of AsyncRedisService with async/await.
 
 This example demonstrates:
 - Connecting to Redis asynchronously
@@ -16,13 +15,15 @@ from cledar.redis import AsyncRedisService, RedisServiceConfig
 
 
 class UserModel(BaseModel):
+    """Simple user model for demonstration."""
+
     user_id: int
     name: str
     email: str
 
 
 async def basic_usage_example() -> None:
-    """Basic async Redis operations."""
+    """Demonstrate basic async Redis operations."""
     print("=== Basic Async Usage ===")
 
     # Configure service

cledar/redis/example.py

@@ -1,3 +1,5 @@
+"""Example usage of RedisConfigStore."""
+
 from dataclasses import dataclass
 from typing import Any
 
@@ -7,6 +9,8 @@ from .redis_config_store import RedisConfigStore
 
 @dataclass
 class ExampleConfig(BaseConfigClass):
+    """Example configuration model."""
+
     name: str
     index: int
     data: dict[str, Any]
@@ -17,20 +21,46 @@ CONFIG_KEY = "example_config"
 
 
 class ConfigProvider:
+    """Example provider for configuration using RedisConfigStore."""
+
     def __init__(self, redis_config_store: RedisConfigStore) -> None:
+        """Initialize the ConfigProvider.
+
+        Args:
+            redis_config_store: The Redis config store instance.
+
+        """
         self.redis_config_store = redis_config_store
         if self.redis_config_store.fetch(ExampleConfig, CONFIG_KEY) is None:
             self.redis_config_store[CONFIG_KEY] = DEFAULT_CONFIG
 
     def get_example_config(self) -> ExampleConfig:
+        """Get the example configuration.
+
+        Returns:
+            ExampleConfig: The current configuration.
+
+        """
         return (
             self.redis_config_store.fetch(ExampleConfig, CONFIG_KEY) or DEFAULT_CONFIG
         )
 
     def get_example_config_version(self) -> int:
+        """Get the version of the example configuration.
+
+        Returns:
+            int: The configuration version.
+
+        """
         return self.redis_config_store.cached_version(CONFIG_KEY) or -1
 
     def set_example_config(self, config: ExampleConfig | None) -> None:
+        """Set the example configuration.
+
+        Args:
+            config: The new configuration to set.
+
+        """
         if config is None:
             return
 

cledar/redis/exceptions.py

@@ -1,3 +1,6 @@
+"""Redis-related exceptions for the Cledar SDK."""
+
+
 class RedisServiceError(Exception):
     """Base exception for RedisService errors."""
 

cledar/redis/logger.py

@@ -1,3 +1,5 @@
+"""Logger configuration for the Redis module."""
+
 import logging
 
 logger = logging.getLogger("redis_service")

cledar/redis/model.py

@@ -1,9 +1,13 @@
+"""Base models for Redis-based configuration."""
+
 from dataclasses import dataclass
 from typing import TypeVar
 
 
 @dataclass
 class BaseConfigClass:
+    """Base class for configuration models stored in Redis."""
+
     pass