Schema

provide.foundation.config.schema

Configuration schema and validation.

Classes

ConfigSchema

ConfigSchema(fields: list[SchemaField] | None = None)

Schema definition for configuration classes.

Initialize configuration schema.

Parameters:

Name	Type	Description	Default
fields	list[SchemaField] | None	List of schema fields	None

Source code in provide/foundation/config/schema.py

def __init__(self, fields: list[SchemaField] | None = None) -> None:
    """Initialize configuration schema.

    Args:
        fields: List of schema fields

    """
    self.fields = fields or []
    self._field_map = {field.name: field for field in self.fields}

Functions

add_field

add_field(field: SchemaField) -> None

Add a field to the schema.

Source code in provide/foundation/config/schema.py

def add_field(self, field: SchemaField) -> None:
    """Add a field to the schema."""
    self.fields.append(field)
    self._field_map[field.name] = field

apply_defaults

apply_defaults(data: ConfigDict) -> ConfigDict

Apply default values to configuration data.

Parameters:

Name	Type	Description	Default
data	ConfigDict	Configuration data	required

Returns:

Type	Description
ConfigDict	Data with defaults applied

Source code in provide/foundation/config/schema.py

def apply_defaults(self, data: ConfigDict) -> ConfigDict:
    """Apply default values to configuration data.

    Args:
        data: Configuration data

    Returns:
        Data with defaults applied

    """
    result = data.copy()

    for field in self.fields:
        if field.name not in result and field.default is not None:
            result[field.name] = field.default

    return result

filter_extra_fields

filter_extra_fields(data: ConfigDict) -> ConfigDict

Remove fields not defined in schema.

Parameters:

Name	Type	Description	Default
data	ConfigDict	Configuration data	required

Returns:

Type	Description
ConfigDict	Filtered data

Source code in provide/foundation/config/schema.py

def filter_extra_fields(self, data: ConfigDict) -> ConfigDict:
    """Remove fields not defined in schema.

    Args:
        data: Configuration data

    Returns:
        Filtered data

    """
    return {k: v for k, v in data.items() if k in self._field_map}

from_config_class classmethod

from_config_class(
    config_class: type[BaseConfig],
) -> ConfigSchema

Generate schema from configuration class.

Parameters:

Name	Type	Description	Default
config_class	type[BaseConfig]	Configuration class	required

Returns:

Type	Description
ConfigSchema	Generated schema

Source code in provide/foundation/config/schema.py

@classmethod
def from_config_class(cls, config_class: type[BaseConfig]) -> ConfigSchema:
    """Generate schema from configuration class.

    Args:
        config_class: Configuration class

    Returns:
        Generated schema

    """
    schema_fields = []

    for attr in fields(config_class):
        schema_field = cls._attr_to_schema_field(attr)
        schema_fields.append(schema_field)

    return cls(schema_fields)

validate

validate(data: ConfigDict) -> None

Validate configuration data against schema.

Parameters:

Name	Type	Description	Default
data	ConfigDict	Configuration data to validate	required

Raises:

Type	Description
ConfigValidationError	If validation fails

Source code in provide/foundation/config/schema.py

def validate(self, data: ConfigDict) -> None:
    """Validate configuration data against schema.

    Args:
        data: Configuration data to validate

    Raises:
        ConfigValidationError: If validation fails

    """
    # Check required fields
    for field in self.fields:
        if field.required and field.name not in data:
            raise ConfigValidationError("Required field missing", field=field.name)

    # Validate each field
    for key, value in data.items():
        if key in self._field_map:
            self._field_map[key].validate(value)

SchemaField

Schema definition for a configuration field.

Functions

validate

validate(value: Any) -> None

Validate a value against this schema field.

Parameters:

Name	Type	Description	Default
value	Any	Value to validate	required

Raises:

Type	Description
ConfigValidationError	If validation fails

Source code in provide/foundation/config/schema.py

def validate(self, value: Any) -> None:
    """Validate a value against this schema field.

    Args:
        value: Value to validate

    Raises:
        ConfigValidationError: If validation fails

    """
    # Check required
    self._validate_required(value)

    # Skip further validation for None values
    if value is None:
        return

    # Run all validations
    self._validate_type(value)
    self._validate_choices(value)
    self._validate_range(value)
    self._validate_pattern(value)
    self._validate_custom(value)

Functions

validate_email

validate_email(value: str) -> bool

Validate email format.

Source code in provide/foundation/config/schema.py

def validate_email(value: str) -> bool:
    """Validate email format."""
    import re

    pattern = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
    return bool(re.match(pattern, value))

validate_path

validate_path(value: str) -> bool

Validate file path.

Source code in provide/foundation/config/schema.py

def validate_path(value: str) -> bool:
    """Validate file path."""
    from pathlib import Path

    try:
        Path(value)
        return True
    except (ValueError, TypeError, Exception):
        # ValueError: Invalid path characters or format
        # TypeError: Non-string input
        # Exception: Any other path creation errors
        return False

validate_port

validate_port(value: int) -> bool

Validate port number.

Source code in provide/foundation/config/schema.py

def validate_port(value: int) -> bool:
    """Validate port number."""
    return 1 <= value <= 65535

validate_schema

validate_schema(
    config: BaseConfig, schema: ConfigSchema
) -> None

Validate configuration instance against schema.

Parameters:

Name	Type	Description	Default
config	BaseConfig	Configuration instance	required
schema	ConfigSchema	Schema to validate against	required

Raises:

Type	Description
ConfigValidationError	If validation fails

Source code in provide/foundation/config/schema.py

def validate_schema(config: BaseConfig, schema: ConfigSchema) -> None:
    """Validate configuration instance against schema.

    Args:
        config: Configuration instance
        schema: Schema to validate against

    Raises:
        ConfigValidationError: If validation fails

    """
    data = config.to_dict(include_sensitive=True)
    schema.validate(data)

validate_url

validate_url(value: str) -> bool

Validate URL format.

Source code in provide/foundation/config/schema.py

def validate_url(value: str) -> bool:
    """Validate URL format."""
    from urllib.parse import urlparse

    try:
        result = urlparse(value)
        return all([result.scheme, result.netloc])
    except (ValueError, TypeError, AttributeError, Exception):
        # ValueError: Invalid URL format
        # TypeError: Non-string input
        # AttributeError: Missing required attributes
        # Exception: Any other parsing errors
        return False

validate_url_accessible

validate_url_accessible(value: str) -> bool

Validate URL is accessible (example async validator).

Source code in provide/foundation/config/schema.py

def validate_url_accessible(value: str) -> bool:
    """Validate URL is accessible (example async validator)."""
    # This is just an example - in real use you'd use aiohttp or similar
    # For now, just do basic URL validation
    return validate_url(value)

validate_version

validate_version(value: str) -> bool

Validate semantic version.

Source code in provide/foundation/config/schema.py

def validate_version(value: str) -> bool:
    """Validate semantic version."""
    import re

    pattern = r"^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$"
    return bool(re.match(pattern, value))