provide-foundation 0.0.0.dev2__py3-none-any.whl → 0.0.0.dev3__py3-none-any.whl

provide/foundation/config/converters.py

@@ -8,7 +8,7 @@ parse and validate environment variable values into the correct types.
 import json
 from typing import Any
 
-from provide.foundation.errors.decorators import with_error_handling
+# Error handling decorator temporarily removed to break circular import
 
 # Type definitions to avoid circular imports
 LogLevelStr = str
@@ -32,13 +32,13 @@ _VALID_FORMATTER_TUPLE = (
 def parse_log_level(value: str) -> LogLevelStr:
     """
     Parse and validate log level string.
-    
+
     Args:
         value: Log level string (case-insensitive)
-        
+
     Returns:
         Valid log level string in uppercase
-        
+
     Raises:
         ValueError: If the log level is invalid
     """
@@ -50,17 +50,16 @@ def parse_log_level(value: str) -> LogLevelStr:
     return level
 
 
-
 def parse_console_formatter(value: str) -> ConsoleFormatterStr:
     """
     Parse and validate console formatter string.
-    
+
     Args:
         value: Formatter string (case-insensitive)
-        
+
     Returns:
         Valid formatter string in lowercase
-        
+
     Raises:
         ValueError: If the formatter is invalid
     """
@@ -72,21 +71,18 @@ def parse_console_formatter(value: str) -> ConsoleFormatterStr:
     return formatter
 
 
-@with_error_handling(
-    fallback={},
-    suppress=(ValueError, KeyError),
-    context_provider=lambda: {"function": "parse_module_levels", "module": "config.converters"}
-)
+# Temporarily remove error handling to break circular import
+# @with_error_handling(...)
 def parse_module_levels(value: str | dict[str, str]) -> dict[str, LogLevelStr]:
     """
     Parse module-specific log levels from string format.
-    
+
     Format: "module1:LEVEL,module2:LEVEL"
     Example: "auth.service:DEBUG,database:ERROR"
-    
+
     Args:
         value: Comma-separated module:level pairs or dict
-        
+
     Returns:
         Dictionary mapping module names to log levels
     """
@@ -100,64 +96,64 @@ def parse_module_levels(value: str | dict[str, str]) -> dict[str, LogLevelStr]:
                 # Skip invalid levels silently
                 continue
         return result
-    
+
     if not value or not value.strip():
         return {}
-    
+
     result = {}
     for pair in value.split(","):
         pair = pair.strip()
         if not pair:
             continue
-            
+
         if ":" not in pair:
             # Skip invalid entries silently
             continue
-            
+
         module, level = pair.split(":", 1)
         module = module.strip()
         level = level.strip()
-        
+
         if module:
             try:
                 result[module] = parse_log_level(level)
             except ValueError:
                 # Skip invalid log levels silently
                 continue
-    
+
     return result
 
 
 def parse_rate_limits(value: str) -> dict[str, tuple[float, float]]:
     """
     Parse per-logger rate limits from string format.
-    
+
     Format: "logger1:rate:capacity,logger2:rate:capacity"
     Example: "api:10.0:100.0,worker:5.0:50.0"
-    
+
     Args:
         value: Comma-separated logger:rate:capacity triplets
-        
+
     Returns:
         Dictionary mapping logger names to (rate, capacity) tuples
     """
     if not value or not value.strip():
         return {}
-    
+
     result = {}
     for item in value.split(","):
         item = item.strip()
         if not item:
             continue
-            
+
         parts = item.split(":")
         if len(parts) != 3:
             # Skip invalid entries silently
             continue
-            
+
         logger, rate_str, capacity_str = parts
         logger = logger.strip()
-        
+
         if logger:
             try:
                 rate = float(rate_str.strip())
@@ -166,29 +162,29 @@ def parse_rate_limits(value: str) -> dict[str, tuple[float, float]]:
             except (ValueError, TypeError):
                 # Skip invalid numbers silently
                 continue
-    
+
     return result
 
 
 def parse_foundation_log_output(value: str) -> str:
     """
     Parse and validate foundation log output destination.
-    
+
     Args:
         value: Output destination string
-        
+
     Returns:
         Valid output destination (stderr, stdout, main)
-        
+
     Raises:
         ValueError: If the value is invalid
     """
     if not value:
         return "stderr"
-        
+
     normalized = value.lower().strip()
     valid_options = ("stderr", "stdout", "main")
-    
+
     if normalized in valid_options:
         return normalized
     else:
@@ -200,35 +196,35 @@ def parse_foundation_log_output(value: str) -> str:
 def parse_comma_list(value: str) -> list[str]:
     """
     Parse comma-separated list of strings.
-    
+
     Args:
         value: Comma-separated string
-        
+
     Returns:
         List of trimmed non-empty strings
     """
     if not value or not value.strip():
         return []
-    
+
     return [item.strip() for item in value.split(",") if item.strip()]
 
 
 def parse_bool_extended(value: str | bool) -> bool:
     """
     Parse boolean from string with extended format support.
-    
+
     Recognizes: true/false, yes/no, 1/0, on/off (case-insensitive)
-    
+
     Args:
         value: Boolean string representation or bool
-        
+
     Returns:
         Boolean value
     """
     # If already a bool, return as-is
     if isinstance(value, bool):
         return value
-    
+
     # Convert to string and parse
     value_lower = str(value).lower().strip()
     return value_lower in ("true", "yes", "1", "on")
@@ -237,56 +233,58 @@ def parse_bool_extended(value: str | bool) -> bool:
 def parse_bool_strict(value: str | bool) -> bool:
     """
     Parse boolean from string with strict validation.
-    
+
     Recognizes: true/false, yes/no, 1/0, on/off (case-insensitive)
-    
+
     Args:
         value: Boolean string representation or bool
-        
+
     Returns:
         Boolean value
-        
+
     Raises:
         TypeError: If value is not a string or bool
         ValueError: If the value cannot be parsed as boolean
     """
     # Check type first
     if not isinstance(value, (str, bool)):
-        raise TypeError(f"Boolean field requires str or bool, got {type(value).__name__}")
-    
+        raise TypeError(
+            f"Boolean field requires str or bool, got {type(value).__name__}"
+        )
+
     # If already a bool, return as-is
     if isinstance(value, bool):
         return value
-    
+
     # Convert to string and parse
     value_lower = value.lower().strip()
-    
+
     if value_lower in ("true", "yes", "1", "on"):
         return True
     elif value_lower in ("false", "no", "0", "off"):
         return False
     else:
-        raise ValueError(f"Invalid boolean value '{value}'. Valid options: true/false, yes/no, 1/0, on/off")
+        raise ValueError(
+            f"Invalid boolean value '{value}'. Valid options: true/false, yes/no, 1/0, on/off"
+        )
 
 
-@with_error_handling(
-    fallback=0.0,
-    context_provider=lambda: {"module": "config.converters"}
-)
+# Temporarily remove error handling to break circular import
+# @with_error_handling(...)
 def parse_float_with_validation(
     value: str, min_val: float | None = None, max_val: float | None = None
 ) -> float:
     """
     Parse float with optional range validation.
-    
+
     Args:
         value: String representation of float
         min_val: Minimum allowed value (inclusive)
         max_val: Maximum allowed value (inclusive)
-        
+
     Returns:
         Parsed float value
-        
+
     Raises:
         ValueError: If value is not a valid float or out of range
     """
@@ -294,26 +292,26 @@ def parse_float_with_validation(
         result = float(value)
     except (ValueError, TypeError) as e:
         raise ValueError(f"Invalid float value '{value}': {e}")
-    
+
     if min_val is not None and result < min_val:
         raise ValueError(f"Value {result} is below minimum {min_val}")
-    
+
     if max_val is not None and result > max_val:
         raise ValueError(f"Value {result} is above maximum {max_val}")
-    
+
     return result
 
 
 def parse_sample_rate(value: str) -> float:
     """
     Parse sampling rate (0.0 to 1.0).
-    
+
     Args:
         value: String representation of sampling rate
-        
+
     Returns:
         Float between 0.0 and 1.0
-        
+
     Raises:
         ValueError: If value is not valid or out of range
     """
@@ -323,19 +321,19 @@ def parse_sample_rate(value: str) -> float:
 def parse_json_dict(value: str) -> dict[str, Any]:
     """
     Parse JSON string into dictionary.
-    
+
     Args:
         value: JSON string
-        
+
     Returns:
         Parsed dictionary
-        
+
     Raises:
         ValueError: If JSON is invalid
     """
     if not value or not value.strip():
         return {}
-    
+
     try:
         result = json.loads(value)
         if not isinstance(result, dict):
@@ -348,19 +346,19 @@ def parse_json_dict(value: str) -> dict[str, Any]:
 def parse_json_list(value: str) -> list[Any]:
     """
     Parse JSON string into list.
-    
+
     Args:
         value: JSON string
-        
+
     Returns:
         Parsed list
-        
+
     Raises:
         ValueError: If JSON is invalid
     """
     if not value or not value.strip():
         return []
-    
+
     try:
         result = json.loads(value)
         if not isinstance(result, list):
@@ -373,41 +371,42 @@ def parse_json_list(value: str) -> list[Any]:
 def parse_headers(value: str) -> dict[str, str]:
     """
     Parse HTTP headers from string format.
-    
+
     Format: "key1=value1,key2=value2"
     Example: "Authorization=Bearer token,Content-Type=application/json"
-    
+
     Args:
         value: Comma-separated key=value pairs
-        
+
     Returns:
         Dictionary of headers
     """
     if not value or not value.strip():
         return {}
-    
+
     result = {}
     for pair in value.split(","):
         pair = pair.strip()
         if not pair:
             continue
-            
+
         if "=" not in pair:
             # Skip invalid entries
             continue
-            
+
         key, val = pair.split("=", 1)
         key = key.strip()
         val = val.strip()
-        
+
         if key:
             result[key] = val
-    
+
     return result
 
 
 # Validators (used with validator parameter in field())
 
+
 def validate_log_level(instance: Any, attribute: Any, value: str) -> None:
     """Validate that a log level is valid."""
     if value not in _VALID_LOG_LEVEL_TUPLE:
@@ -455,11 +454,10 @@ def validate_overflow_policy(instance: Any, attribute: Any, value: str) -> None:
         )
 
 
-
 __all__ = [
     # Parsers/Converters
     "parse_log_level",
-    "parse_console_formatter", 
+    "parse_console_formatter",
     "parse_module_levels",
     "parse_rate_limits",
     "parse_comma_list",
@@ -476,4 +474,4 @@ __all__ = [
     "validate_positive",
     "validate_non_negative",
     "validate_overflow_policy",
-]
+]

provide/foundation/config/defaults.py

@@ -64,4 +64,4 @@ DEFAULT_TEST_CHECKPOINT_TIMEOUT = 5.0
 # =================================
 EXIT_SUCCESS = 0
 EXIT_ERROR = 1
-EXIT_SIGINT = 130  # Standard exit code for SIGINT
+EXIT_SIGINT = 130  # Standard exit code for SIGINT

provide/foundation/config/env.py

@@ -203,6 +203,7 @@ class RuntimeConfig(BaseConfig):
                 else:
                     # Try to infer parser from type
                     from provide.foundation.utils.parsing import auto_parse
+
                     value = auto_parse(attr, value)
 
                 data[attr.name] = value
@@ -284,6 +285,7 @@ class RuntimeConfig(BaseConfig):
             else:
                 # Try to infer parser from type
                 from provide.foundation.utils.parsing import auto_parse
+
                 value = auto_parse(attr, value)
 
             data[field_name] = value
@@ -306,7 +308,6 @@ class RuntimeConfig(BaseConfig):
         except Exception as e:
             raise ValueError(f"Failed to read secret from file '{file_path}': {e}")
 
-
     def to_env_dict(self, prefix: str = "", delimiter: str = "_") -> dict[str, str]:
         """
         Convert configuration to environment variable dictionary.

provide/foundation/config/loader.py

@@ -150,7 +150,7 @@ class FileConfigLoader(ConfigLoader):
                 format=str(self.format),
             )
 
-    def _ini_to_dict(self, parser) -> ConfigDict:
+    def _ini_to_dict(self, parser: object) -> ConfigDict:
         """Convert INI parser to dictionary."""
         result = {}
         for section in parser.sections():

provide/foundation/config/sync.py

@@ -14,18 +14,18 @@ from typing import Any, TypeVar
 from provide.foundation.config.base import BaseConfig
 from provide.foundation.config.env import RuntimeConfig
 from provide.foundation.config.loader import (
+    ConfigLoader,
     DictConfigLoader,
     FileConfigLoader,
     MultiSourceLoader,
 )
 from provide.foundation.config.manager import ConfigManager
 from provide.foundation.config.types import ConfigDict, ConfigSource
-from provide.foundation.config.loader import ConfigLoader
 
 T = TypeVar("T", bound=BaseConfig)
 
 
-def run_async(coro):
+def run_async(coro: Any) -> Any:
     """
     Run an async coroutine in a sync context.
 
@@ -230,7 +230,7 @@ class SyncConfigManager:
 
     def __init__(self, loader: ConfigLoader | None = None) -> None:
         """Initialize sync config manager.
-        
+
         Args:
             loader: Optional config loader for loading configurations.
         """
@@ -245,14 +245,16 @@ class SyncConfigManager:
         """Get a configuration by name (sync)."""
         return run_async(self._async_manager.get(name))
 
-    def load(self, name: str, config_class: type[T], loader: ConfigLoader | None = None) -> T:
+    def load(
+        self, name: str, config_class: type[T], loader: ConfigLoader | None = None
+    ) -> T:
         """Load a configuration (sync).
-        
+
         Args:
             name: Configuration name
             config_class: Configuration class
             loader: Optional loader (uses registered if None)
-            
+
         Returns:
             Configuration instance
         """

provide/foundation/config/types.py

@@ -20,31 +20,31 @@ class ConfigSource(Enum):
     ENV = 20
     RUNTIME = 30  # Highest precedence
 
-    def __lt__(self, other):
+    def __lt__(self, other: object) -> bool:
         """Enable comparison for precedence."""
         if not isinstance(other, ConfigSource):
             return NotImplemented
         return self.value < other.value
 
-    def __le__(self, other):
+    def __le__(self, other: object) -> bool:
         """Enable <= comparison for precedence."""
         if not isinstance(other, ConfigSource):
             return NotImplemented
         return self.value <= other.value
 
-    def __gt__(self, other):
+    def __gt__(self, other: object) -> bool:
         """Enable > comparison for precedence."""
         if not isinstance(other, ConfigSource):
             return NotImplemented
         return self.value > other.value
 
-    def __ge__(self, other):
+    def __ge__(self, other: object) -> bool:
         """Enable >= comparison for precedence."""
         if not isinstance(other, ConfigSource):
             return NotImplemented
         return self.value >= other.value
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         """Enable == comparison for precedence."""
         if not isinstance(other, ConfigSource):
             return NotImplemented

provide/foundation/config/validators.py

@@ -22,7 +22,7 @@ def validate_choice(choices: list[Any]) -> Callable[[Any, Any, Any], None]:
         Validator function
     """
 
-    def validator(instance, attribute, value):
+    def validator(instance: object, attribute: object, value: Any) -> None:
         if value not in choices:
             raise ValidationError(
                 f"Invalid value '{value}' for {attribute.name}. "
@@ -46,7 +46,7 @@ def validate_range(
         Validator function
     """
 
-    def validator(instance, attribute, value):
+    def validator(instance: object, attribute: object, value: Any) -> None:
         if not isinstance(value, (int, float)):
             raise ValidationError(f"Value must be a number, got {type(value).__name__}")
 
@@ -58,7 +58,7 @@ def validate_range(
     return validator
 
 
-def validate_positive(instance, attribute, value):
+def validate_positive(instance: object, attribute: object, value: Any) -> None:
     """
     Validate that a numeric value is positive.
     """
@@ -69,7 +69,7 @@ def validate_positive(instance, attribute, value):
         raise ValidationError(f"Value must be positive, got {value}")
 
 
-def validate_non_negative(instance, attribute, value):
+def validate_non_negative(instance: object, attribute: object, value: Any) -> None:
     """
     Validate that a numeric value is non-negative.
     """

provide/foundation/console/output.py

@@ -42,18 +42,18 @@ def _should_use_json(ctx: CLIContext | None = None) -> bool:
     return ctx.json_output if ctx else False
 
 
-def _should_use_color(ctx: CLIContext | None = None, stream=None) -> bool:
+def _should_use_color(ctx: CLIContext | None = None, stream: Any = None) -> bool:
     """Determine if color output should be used."""
     if ctx is None:
         ctx = _get_context()
 
     # Check FORCE_COLOR first (enables color even for non-TTY)
-    force_color = os.environ.get('FORCE_COLOR', '').lower()
-    if force_color in ('1', 'true', 'yes'):
+    force_color = os.environ.get("FORCE_COLOR", "").lower()
+    if force_color in ("1", "true", "yes"):
         return True
 
     # Check NO_COLOR (disables color even for TTY)
-    if os.environ.get('NO_COLOR'):
+    if os.environ.get("NO_COLOR"):
         return False
 
     # Check context no_color setting
@@ -68,7 +68,7 @@ def _should_use_color(ctx: CLIContext | None = None, stream=None) -> bool:
 
 
 @with_error_handling(fallback=None, suppress=(TypeError, ValueError, AttributeError))
-def _output_json(data: Any, stream=sys.stdout) -> None:
+def _output_json(data: Any, stream: Any = sys.stdout) -> None:
     """Output data as JSON."""
     json_str = json.dumps(data, indent=2, default=str)
     if _HAS_CLICK:
@@ -80,7 +80,7 @@ def _output_json(data: Any, stream=sys.stdout) -> None:
 @with_error_handling(
     fallback=None,
     suppress=(OSError, IOError, UnicodeEncodeError),
-    context_provider=lambda: {"function": "pout"}
+    context_provider=lambda: {"function": "pout"},
 )
 def pout(message: Any, **kwargs: Any) -> None:
     """
@@ -142,7 +142,7 @@ def pout(message: Any, **kwargs: Any) -> None:
 @with_error_handling(
     fallback=None,
     suppress=(OSError, IOError, UnicodeEncodeError),
-    context_provider=lambda: {"function": "perr"}
+    context_provider=lambda: {"function": "perr"},
 )
 def perr(message: Any, **kwargs: Any) -> None:
     """