claude-mpm 4.4.3__py3-none-any.whl → 4.4.4__py3-none-any.whl

claude_mpm/services/unified/config_strategies/config_schema.py

@@ -3,20 +3,20 @@ Configuration Schema - Declarative configuration with automatic validation
 Part of Phase 3 Configuration Consolidation
 """
 
-from typing import Any, Dict, List, Optional, Union, Type, Callable, Generic, TypeVar
-from dataclasses import dataclass, field, asdict
-from enum import Enum
-from datetime import datetime
 import json
-from pathlib import Path
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Union
 
 from claude_mpm.core.logging_utils import get_logger
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
 class SchemaType(Enum):
     """Supported schema types"""
+
     STRING = "string"
     INTEGER = "integer"
     NUMBER = "number"
@@ -29,6 +29,7 @@ class SchemaType(Enum):
 
 class SchemaFormat(Enum):
     """Supported format constraints"""
+
     DATE = "date"
     DATETIME = "datetime"
     TIME = "time"
@@ -48,6 +49,7 @@ class SchemaFormat(Enum):
 @dataclass
 class SchemaProperty:
     """Schema property definition"""
+
     type: Union[SchemaType, List[SchemaType]]
     description: Optional[str] = None
     default: Any = None
@@ -72,19 +74,19 @@ class SchemaProperty:
     min_items: Optional[int] = None
     max_items: Optional[int] = None
     unique_items: bool = False
-    items: Optional['SchemaProperty'] = None
+    items: Optional["SchemaProperty"] = None
 
     # Object constraints
-    properties: Optional[Dict[str, 'SchemaProperty']] = None
-    additional_properties: Union[bool, 'SchemaProperty'] = True
+    properties: Optional[Dict[str, "SchemaProperty"]] = None
+    additional_properties: Union[bool, "SchemaProperty"] = True
     required_properties: Optional[List[str]] = None
 
     # Advanced
-    dependencies: Optional[Dict[str, Union[List[str], 'SchemaProperty']]] = None
-    one_of: Optional[List['SchemaProperty']] = None
-    any_of: Optional[List['SchemaProperty']] = None
-    all_of: Optional[List['SchemaProperty']] = None
-    not_schema: Optional['SchemaProperty'] = None
+    dependencies: Optional[Dict[str, Union[List[str], "SchemaProperty"]]] = None
+    one_of: Optional[List["SchemaProperty"]] = None
+    any_of: Optional[List["SchemaProperty"]] = None
+    all_of: Optional[List["SchemaProperty"]] = None
+    not_schema: Optional["SchemaProperty"] = None
 
     # Custom validation
     validator: Optional[Callable[[Any], bool]] = None
@@ -100,6 +102,7 @@ class SchemaProperty:
 @dataclass
 class ConfigSchema:
     """Complete configuration schema"""
+
     title: str
     description: Optional[str] = None
     version: str = "1.0.0"
@@ -119,15 +122,15 @@ class ConfigSchema:
     pattern_properties: Optional[Dict[str, SchemaProperty]] = None
 
     # Conditional schemas
-    if_schema: Optional['ConfigSchema'] = None
-    then_schema: Optional['ConfigSchema'] = None
-    else_schema: Optional['ConfigSchema'] = None
+    if_schema: Optional["ConfigSchema"] = None
+    then_schema: Optional["ConfigSchema"] = None
+    else_schema: Optional["ConfigSchema"] = None
 
     # Composition
-    all_of: Optional[List['ConfigSchema']] = None
-    any_of: Optional[List['ConfigSchema']] = None
-    one_of: Optional[List['ConfigSchema']] = None
-    not_schema: Optional['ConfigSchema'] = None
+    all_of: Optional[List["ConfigSchema"]] = None
+    any_of: Optional[List["ConfigSchema"]] = None
+    one_of: Optional[List["ConfigSchema"]] = None
+    not_schema: Optional["ConfigSchema"] = None
 
     # Custom handlers
     pre_validators: List[Callable] = field(default_factory=list)
@@ -142,22 +145,19 @@ class SchemaBuilder:
         self.schema = ConfigSchema(title=title)
         self.logger = get_logger(self.__class__.__name__)
 
-    def description(self, desc: str) -> 'SchemaBuilder':
+    def description(self, desc: str) -> "SchemaBuilder":
         """Set schema description"""
         self.schema.description = desc
         return self
 
-    def version(self, ver: str) -> 'SchemaBuilder':
+    def version(self, ver: str) -> "SchemaBuilder":
         """Set schema version"""
         self.schema.version = ver
         return self
 
     def property(
-        self,
-        name: str,
-        type: Union[SchemaType, str],
-        **kwargs
-    ) -> 'SchemaBuilder':
+        self, name: str, type: Union[SchemaType, str], **kwargs
+    ) -> "SchemaBuilder":
         """Add a property to the schema"""
         if isinstance(type, str):
             type = SchemaType(type)
@@ -165,55 +165,64 @@ class SchemaBuilder:
         prop = SchemaProperty(type=type, **kwargs)
         self.schema.properties[name] = prop
 
-        if kwargs.get('required', False):
+        if kwargs.get("required", False):
             if name not in self.schema.required:
                 self.schema.required.append(name)
 
         return self
 
-    def string(self, name: str, **kwargs) -> 'SchemaBuilder':
+    def string(self, name: str, **kwargs) -> "SchemaBuilder":
         """Add string property"""
         return self.property(name, SchemaType.STRING, **kwargs)
 
-    def integer(self, name: str, **kwargs) -> 'SchemaBuilder':
+    def integer(self, name: str, **kwargs) -> "SchemaBuilder":
         """Add integer property"""
         return self.property(name, SchemaType.INTEGER, **kwargs)
 
-    def number(self, name: str, **kwargs) -> 'SchemaBuilder':
+    def number(self, name: str, **kwargs) -> "SchemaBuilder":
         """Add number property"""
         return self.property(name, SchemaType.NUMBER, **kwargs)
 
-    def boolean(self, name: str, **kwargs) -> 'SchemaBuilder':
+    def boolean(self, name: str, **kwargs) -> "SchemaBuilder":
         """Add boolean property"""
         return self.property(name, SchemaType.BOOLEAN, **kwargs)
 
-    def array(self, name: str, items: Optional[SchemaProperty] = None, **kwargs) -> 'SchemaBuilder':
+    def array(
+        self, name: str, items: Optional[SchemaProperty] = None, **kwargs
+    ) -> "SchemaBuilder":
         """Add array property"""
         return self.property(name, SchemaType.ARRAY, items=items, **kwargs)
 
-    def object(self, name: str, properties: Optional[Dict[str, SchemaProperty]] = None, **kwargs) -> 'SchemaBuilder':
+    def object(
+        self,
+        name: str,
+        properties: Optional[Dict[str, SchemaProperty]] = None,
+        **kwargs,
+    ) -> "SchemaBuilder":
         """Add object property"""
         return self.property(name, SchemaType.OBJECT, properties=properties, **kwargs)
 
-    def enum(self, name: str, values: List[Any], **kwargs) -> 'SchemaBuilder':
+    def enum(self, name: str, values: List[Any], **kwargs) -> "SchemaBuilder":
         """Add enum property"""
         return self.property(name, SchemaType.STRING, enum=values, **kwargs)
 
-    def required_fields(self, *fields: str) -> 'SchemaBuilder':
+    def required_fields(self, *fields: str) -> "SchemaBuilder":
         """Mark fields as required"""
         for field in fields:
             if field not in self.schema.required:
                 self.schema.required.append(field)
         return self
 
-    def default(self, name: str, value: Any) -> 'SchemaBuilder':
+    def default(self, name: str, value: Any) -> "SchemaBuilder":
         """Set default value for property"""
         if name in self.schema.properties:
             self.schema.properties[name].default = value
         self.schema.defaults[name] = value
         return self
 
-    def dependency(self, field: str, depends_on: Union[str, List[str]]) -> 'SchemaBuilder':
+    def dependency(
+        self, field: str, depends_on: Union[str, List[str]]
+    ) -> "SchemaBuilder":
         """Add field dependency"""
         if self.schema.dependencies is None:
             self.schema.dependencies = {}
@@ -224,12 +233,12 @@ class SchemaBuilder:
         self.schema.dependencies[field] = depends_on
         return self
 
-    def validator(self, func: Callable) -> 'SchemaBuilder':
+    def validator(self, func: Callable) -> "SchemaBuilder":
         """Add custom validator"""
         self.schema.post_validators.append(func)
         return self
 
-    def transformer(self, func: Callable) -> 'SchemaBuilder':
+    def transformer(self, func: Callable) -> "SchemaBuilder":
         """Add transformer function"""
         self.schema.transformers.append(func)
         return self
@@ -319,7 +328,9 @@ class SchemaValidator:
         if prop.validator and not prop.validator(value):
             self.errors.append(f"{path}: custom validation failed")
 
-    def _check_type(self, value: Any, expected: Union[SchemaType, List[SchemaType]]) -> bool:
+    def _check_type(
+        self, value: Any, expected: Union[SchemaType, List[SchemaType]]
+    ) -> bool:
         """Check if value matches expected type"""
         if isinstance(expected, list):
             return any(self._check_type(value, t) for t in expected)
@@ -332,13 +343,15 @@ class SchemaValidator:
             SchemaType.ARRAY: list,
             SchemaType.OBJECT: dict,
             SchemaType.NULL: type(None),
-            SchemaType.ANY: object
+            SchemaType.ANY: object,
         }
 
         expected_type = type_map.get(expected, object)
         return isinstance(value, expected_type)
 
-    def _validate_numeric(self, value: Union[int, float], prop: SchemaProperty, path: str):
+    def _validate_numeric(
+        self, value: Union[int, float], prop: SchemaProperty, path: str
+    ):
         """Validate numeric constraints"""
         if prop.minimum is not None and value < prop.minimum:
             self.errors.append(f"{path}: value {value} is below minimum {prop.minimum}")
@@ -347,21 +360,30 @@ class SchemaValidator:
             self.errors.append(f"{path}: value {value} exceeds maximum {prop.maximum}")
 
         if prop.exclusive_minimum is not None and value <= prop.exclusive_minimum:
-            self.errors.append(f"{path}: value {value} must be greater than {prop.exclusive_minimum}")
+            self.errors.append(
+                f"{path}: value {value} must be greater than {prop.exclusive_minimum}"
+            )
 
         if prop.exclusive_maximum is not None and value >= prop.exclusive_maximum:
-            self.errors.append(f"{path}: value {value} must be less than {prop.exclusive_maximum}")
+            self.errors.append(
+                f"{path}: value {value} must be less than {prop.exclusive_maximum}"
+            )
 
     def _validate_string(self, value: str, prop: SchemaProperty, path: str):
         """Validate string constraints"""
         if prop.min_length is not None and len(value) < prop.min_length:
-            self.errors.append(f"{path}: length {len(value)} is below minimum {prop.min_length}")
+            self.errors.append(
+                f"{path}: length {len(value)} is below minimum {prop.min_length}"
+            )
 
         if prop.max_length is not None and len(value) > prop.max_length:
-            self.errors.append(f"{path}: length {len(value)} exceeds maximum {prop.max_length}")
+            self.errors.append(
+                f"{path}: length {len(value)} exceeds maximum {prop.max_length}"
+            )
 
         if prop.pattern:
             import re
+
             if not re.match(prop.pattern, value):
                 self.errors.append(f"{path}: does not match pattern {prop.pattern}")
 
@@ -372,15 +394,23 @@ class SchemaValidator:
     def _validate_array(self, value: List, prop: SchemaProperty, path: str):
         """Validate array constraints"""
         if prop.min_items is not None and len(value) < prop.min_items:
-            self.errors.append(f"{path}: array length {len(value)} is below minimum {prop.min_items}")
+            self.errors.append(
+                f"{path}: array length {len(value)} is below minimum {prop.min_items}"
+            )
 
         if prop.max_items is not None and len(value) > prop.max_items:
-            self.errors.append(f"{path}: array length {len(value)} exceeds maximum {prop.max_items}")
+            self.errors.append(
+                f"{path}: array length {len(value)} exceeds maximum {prop.max_items}"
+            )
 
         if prop.unique_items:
             seen = set()
             for item in value:
-                item_key = str(item) if not isinstance(item, (dict, list)) else json.dumps(item, sort_keys=True)
+                item_key = (
+                    str(item)
+                    if not isinstance(item, (dict, list))
+                    else json.dumps(item, sort_keys=True)
+                )
                 if item_key in seen:
                     self.errors.append(f"{path}: duplicate items not allowed")
                     break
@@ -406,7 +436,9 @@ class SchemaValidator:
             if prop.properties:
                 extra = set(value.keys()) - set(prop.properties.keys())
                 if extra:
-                    self.errors.append(f"{path}: additional properties not allowed: {extra}")
+                    self.errors.append(
+                        f"{path}: additional properties not allowed: {extra}"
+                    )
 
     def _validate_dependencies(self, config: Dict, dependencies: Dict):
         """Validate field dependencies"""
@@ -415,20 +447,24 @@ class SchemaValidator:
                 if isinstance(deps, list):
                     for dep in deps:
                         if dep not in config:
-                            self.errors.append(f"Field '{field}' requires '{dep}' to be present")
+                            self.errors.append(
+                                f"Field '{field}' requires '{dep}' to be present"
+                            )
 
     def _validate_format(self, value: str, format: SchemaFormat) -> bool:
         """Validate string format"""
         validators = {
-            SchemaFormat.EMAIL: lambda v: '@' in v and '.' in v.split('@')[1],
-            SchemaFormat.DATE: lambda v: self._try_parse_date(v, '%Y-%m-%d'),
-            SchemaFormat.DATETIME: lambda v: self._try_parse_date(v, '%Y-%m-%dT%H:%M:%S'),
+            SchemaFormat.EMAIL: lambda v: "@" in v and "." in v.split("@")[1],
+            SchemaFormat.DATE: lambda v: self._try_parse_date(v, "%Y-%m-%d"),
+            SchemaFormat.DATETIME: lambda v: self._try_parse_date(
+                v, "%Y-%m-%dT%H:%M:%S"
+            ),
             SchemaFormat.UUID: lambda v: self._validate_uuid(v),
             SchemaFormat.IPV4: lambda v: self._validate_ipv4(v),
             SchemaFormat.IPV6: lambda v: self._validate_ipv6(v),
-            SchemaFormat.URI: lambda v: '://' in v,
+            SchemaFormat.URI: lambda v: "://" in v,
             SchemaFormat.PATH: lambda v: True,  # Any string is valid path
-            SchemaFormat.SEMVER: lambda v: self._validate_semver(v)
+            SchemaFormat.SEMVER: lambda v: self._validate_semver(v),
         }
 
         validator = validators.get(format)
@@ -445,6 +481,7 @@ class SchemaValidator:
     def _validate_uuid(self, value: str) -> bool:
         """Validate UUID format"""
         import uuid
+
         try:
             uuid.UUID(value)
             return True
@@ -454,6 +491,7 @@ class SchemaValidator:
     def _validate_ipv4(self, value: str) -> bool:
         """Validate IPv4 address"""
         import ipaddress
+
         try:
             ipaddress.IPv4Address(value)
             return True
@@ -463,6 +501,7 @@ class SchemaValidator:
     def _validate_ipv6(self, value: str) -> bool:
         """Validate IPv6 address"""
         import ipaddress
+
         try:
             ipaddress.IPv6Address(value)
             return True
@@ -472,7 +511,8 @@ class SchemaValidator:
     def _validate_semver(self, value: str) -> bool:
         """Validate semantic version"""
         import re
-        pattern = r'^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$'
+
+        pattern = r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"
         return bool(re.match(pattern, value))
 
 
@@ -521,10 +561,7 @@ class ConfigMigration:
         self.migrations: Dict[tuple, Callable] = {}
 
     def register_migration(
-        self,
-        from_version: str,
-        to_version: str,
-        migration_func: Callable[[Dict], Dict]
+        self, from_version: str, to_version: str, migration_func: Callable[[Dict], Dict]
     ):
         """Register a migration function"""
         key = (from_version, to_version)
@@ -532,10 +569,7 @@ class ConfigMigration:
         self.logger.info(f"Registered migration: {from_version} -> {to_version}")
 
     def migrate(
-        self,
-        config: Dict[str, Any],
-        from_version: str,
-        to_version: str
+        self, config: Dict[str, Any], from_version: str, to_version: str
     ) -> Dict[str, Any]:
         """Migrate configuration between versions"""
         key = (from_version, to_version)
@@ -560,13 +594,15 @@ class ConfigMigration:
 
         return current
 
-    def _find_migration_path(self, from_version: str, to_version: str) -> Optional[List[str]]:
+    def _find_migration_path(
+        self, from_version: str, to_version: str
+    ) -> Optional[List[str]]:
         """Find migration path between versions using BFS"""
         from collections import deque
 
         # Build graph of migrations
         graph = {}
-        for (from_v, to_v) in self.migrations.keys():
+        for from_v, to_v in self.migrations.keys():
             if from_v not in graph:
                 graph[from_v] = []
             graph[from_v].append(to_v)
@@ -633,57 +669,67 @@ class TypedConfig(Generic[T]):
 # Predefined common schemas
 def create_database_schema() -> ConfigSchema:
     """Create common database configuration schema"""
-    return (SchemaBuilder("Database Configuration")
-            .string("host", required=True, default="localhost")
-            .integer("port", required=True, minimum=1, maximum=65535, default=5432)
-            .string("database", required=True)
-            .string("username", required=True)
-            .string("password", write_only=True)
-            .integer("pool_size", minimum=1, maximum=100, default=10)
-            .integer("timeout", minimum=1, default=30)
-            .boolean("ssl", default=False)
-            .build())
+    return (
+        SchemaBuilder("Database Configuration")
+        .string("host", required=True, default="localhost")
+        .integer("port", required=True, minimum=1, maximum=65535, default=5432)
+        .string("database", required=True)
+        .string("username", required=True)
+        .string("password", write_only=True)
+        .integer("pool_size", minimum=1, maximum=100, default=10)
+        .integer("timeout", minimum=1, default=30)
+        .boolean("ssl", default=False)
+        .build()
+    )
 
 
 def create_api_schema() -> ConfigSchema:
     """Create common API configuration schema"""
-    return (SchemaBuilder("API Configuration")
-            .string("base_url", required=True, format=SchemaFormat.URI)
-            .string("api_key", required=True, write_only=True)
-            .integer("timeout", minimum=1, default=30)
-            .integer("retry_count", minimum=0, maximum=10, default=3)
-            .number("retry_delay", minimum=0, default=1.0)
-            .array("allowed_methods", default=["GET", "POST", "PUT", "DELETE"])
-            .object("headers", default={})
-            .boolean("verify_ssl", default=True)
-            .build())
+    return (
+        SchemaBuilder("API Configuration")
+        .string("base_url", required=True, format=SchemaFormat.URI)
+        .string("api_key", required=True, write_only=True)
+        .integer("timeout", minimum=1, default=30)
+        .integer("retry_count", minimum=0, maximum=10, default=3)
+        .number("retry_delay", minimum=0, default=1.0)
+        .array("allowed_methods", default=["GET", "POST", "PUT", "DELETE"])
+        .object("headers", default={})
+        .boolean("verify_ssl", default=True)
+        .build()
+    )
 
 
 def create_logging_schema() -> ConfigSchema:
     """Create common logging configuration schema"""
-    return (SchemaBuilder("Logging Configuration")
-            .enum("level", ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], default="INFO")
-            .string("format", default="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-            .string("file", format=SchemaFormat.PATH)
-            .integer("max_size", minimum=1, default=10485760)  # 10MB
-            .integer("backup_count", minimum=0, default=5)
-            .boolean("console", default=True)
-            .boolean("file_enabled", default=False)
-            .build())
+    return (
+        SchemaBuilder("Logging Configuration")
+        .enum(
+            "level", ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], default="INFO"
+        )
+        .string(
+            "format", default="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        .string("file", format=SchemaFormat.PATH)
+        .integer("max_size", minimum=1, default=10485760)  # 10MB
+        .integer("backup_count", minimum=0, default=5)
+        .boolean("console", default=True)
+        .boolean("file_enabled", default=False)
+        .build()
+    )
 
 
 # Export main components
 __all__ = [
-    'ConfigSchema',
-    'SchemaProperty',
-    'SchemaBuilder',
-    'SchemaValidator',
-    'SchemaRegistry',
-    'ConfigMigration',
-    'TypedConfig',
-    'SchemaType',
-    'SchemaFormat',
-    'create_database_schema',
-    'create_api_schema',
-    'create_logging_schema'
-]
+    "ConfigMigration",
+    "ConfigSchema",
+    "SchemaBuilder",
+    "SchemaFormat",
+    "SchemaProperty",
+    "SchemaRegistry",
+    "SchemaType",
+    "SchemaValidator",
+    "TypedConfig",
+    "create_api_schema",
+    "create_database_schema",
+    "create_logging_schema",
+]