ob-metaflow-extensions 1.1.175rc1__py2.py3-none-any.whl → 1.1.175rc3__py2.py3-none-any.whl

metaflow_extensions/outerbounds/plugins/apps/core/config/schema_export.py

@@ -0,0 +1,285 @@
+"""
+Schema Export Module for Unified Configuration System
+
+This module provides standalone functions to export configuration schemas in various formats:
+- OpenAPI schemas in YAML or JSON format
+- JSON schemas in YAML or JSON format
+
+Usage:
+    from schema_export import export_schema, to_openapi_schema, to_json_schema, to_dict
+
+    # Export schema to file
+    export_schema(CoreConfig, "schema.yaml")
+    export_schema(CoreConfig, "schema.json", schema_type="json", format="json")
+
+    # Generate schema in memory
+    openapi_schema = to_openapi_schema(CoreConfig)
+    json_schema = to_json_schema(CoreConfig)
+
+    # Export config instance to dict
+    config_instance = CoreConfig(name="myapp", port=8000)
+    config_dict = to_dict(config_instance)
+
+No external dependencies required for basic functionality.
+PyYAML is optional for YAML export support.
+"""
+
+import json
+import textwrap
+from collections import OrderedDict
+from typing import Any, Dict
+
+try:
+    import yaml
+
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+
+def to_openapi_schema(config_class) -> Dict[str, Any]:
+    """Generate OpenAPI schema for a configuration class.
+
+    Args:
+        config_class: The configuration class to generate schema for
+
+    Returns:
+        OpenAPI schema dictionary
+    """
+    return _generate_openapi_schema(config_class)
+
+
+def to_json_schema(config_class) -> Dict[str, Any]:
+    """Generate JSON schema for a configuration class.
+
+    Args:
+        config_class: The configuration class to generate schema for
+
+    Returns:
+        JSON schema dictionary
+    """
+    return _generate_json_schema(config_class)
+
+
+def export_schema(
+    config_class, filepath: str, schema_type: str = "openapi", format: str = "yaml"
+) -> None:
+    """Export configuration schema to file.
+
+    Args:
+        config_class: The configuration class to export schema for
+        filepath: Path to save the schema file
+        schema_type: Type of schema to generate ('openapi' or 'json')
+        format: Output format ('yaml' or 'json')
+
+    Examples:
+        # Export OpenAPI schema as YAML (default)
+        export_schema(CoreConfig, "schema.yaml")
+
+        # Export JSON schema as YAML
+        export_schema(CoreConfig, "schema.yaml", schema_type="json")
+
+        # Export OpenAPI schema as JSON
+        export_schema(CoreConfig, "schema.json", schema_type="openapi", format="json")
+
+        # Export JSON schema as JSON
+        export_schema(CoreConfig, "schema.json", schema_type="json", format="json")
+    """
+    # Validate inputs
+    if schema_type.lower() not in ["openapi", "json"]:
+        raise ValueError(
+            f"Unsupported schema type: {schema_type}. Use 'openapi' or 'json'."
+        )
+
+    if format.lower() not in ["yaml", "json"]:
+        raise ValueError(f"Unsupported format: {format}. Use 'yaml' or 'json'.")
+
+    # Generate the appropriate schema
+    if schema_type.lower() == "openapi":
+        base_schema = _generate_openapi_schema(config_class)
+        # Wrap in OpenAPI document structure with proper ordering
+        schema_data = OrderedDict(
+            [
+                ("openapi", "3.0.0"),
+                (
+                    "info",
+                    OrderedDict(
+                        [
+                            ("title", f"{config_class.__name__} Configuration Schema"),
+                            ("version", "1.0.0"),
+                        ]
+                    ),
+                ),
+                (
+                    "components",
+                    OrderedDict(
+                        [
+                            (
+                                "schemas",
+                                OrderedDict([(config_class.__name__, base_schema)]),
+                            )
+                        ]
+                    ),
+                ),
+            ]
+        )
+    else:  # json schema
+        schema_data = _generate_json_schema(config_class)
+
+    # Export in the requested format
+    if format.lower() == "yaml":
+        if not HAS_YAML:
+            raise ImportError(
+                "PyYAML is required for YAML export. Install with: pip install pyyaml"
+            )
+
+        # Custom YAML representer for multiline strings
+        def multiline_representer(dumper, data):
+            if "\n" in data or len(data) > 80:
+                style = "|"  # use literal block
+            else:
+                style = None  # normal flow
+            return dumper.represent_scalar("tag:yaml.org,2002:str", data, style=style)
+
+        # Custom YAML representer for OrderedDict to preserve order
+        def ordered_dict_representer(dumper, data):
+            return dumper.represent_dict(data.items())
+
+        yaml.add_representer(str, multiline_representer)
+        yaml.add_representer(OrderedDict, ordered_dict_representer)
+
+        with open(filepath, "w") as f:
+            yaml.dump(
+                schema_data,
+                f,
+                default_flow_style=False,
+                sort_keys=False,
+                allow_unicode=True,
+                width=120,
+                indent=2,
+            )
+    else:  # json format
+        with open(filepath, "w") as f:
+            json.dump(schema_data, f, indent=2)
+
+
+# Private helper functions
+def _generate_openapi_schema(cls) -> Dict[str, Any]:
+    """Generate OpenAPI schema for a configuration class."""
+    # Clean up class docstring for better YAML formatting
+    description = f"{cls.__name__} configuration"
+    get_description = getattr(cls, "SCHEMA_DOC", None)
+    if get_description:
+        description = get_description
+    elif cls.__doc__:
+        # Remove common indentation and clean up whitespace
+        cleaned_doc = textwrap.dedent(cls.__doc__).strip()
+        # Replace multiple spaces with single spaces but preserve line breaks
+        lines = [line.strip() for line in cleaned_doc.split("\n") if line.strip()]
+        description = "\n".join(lines)
+
+    # Create ordered schema with specific order: title, description, type, required, then properties
+    schema = OrderedDict(
+        [
+            ("title", cls.__name__),
+            ("description", description),
+            ("type", "object"),
+            ("required", []),
+            ("properties", OrderedDict()),
+        ]
+    )
+
+    for field_name, field_info in cls._fields.items():
+        if field_name.startswith("_"):
+            continue
+
+        field_schema = _get_field_schema(field_info)
+        schema["properties"][field_name] = field_schema
+
+        # Add to required if field is required
+        if field_info.required:
+            schema["required"].append(field_name)
+
+    return schema
+
+
+def _generate_json_schema(cls) -> Dict[str, Any]:
+    """Generate JSON schema for a configuration class."""
+    openapi_schema = _generate_openapi_schema(cls)
+
+    # Create ordered JSON schema with $schema first
+    schema = OrderedDict(
+        [
+            ("$schema", "https://json-schema.org/draft/2020-12/schema"),
+            ("title", openapi_schema["title"]),
+            ("description", openapi_schema["description"]),
+            ("type", openapi_schema["type"]),
+            ("required", openapi_schema["required"]),
+            ("properties", openapi_schema["properties"]),
+        ]
+    )
+
+    return schema
+
+
+def _get_field_schema(field_info) -> Dict[str, Any]:
+    """Generate schema for a single field."""
+    field_schema = OrderedDict()
+
+    # Get description from ConfigField.help first, then CLI metadata
+    description = field_info.help or (
+        field_info.cli_meta.help if field_info.cli_meta else None
+    )
+    if description:
+        field_schema["description"] = description
+
+    # Handle field type
+    if field_info.field_type == str:
+        field_schema["type"] = "string"
+    elif field_info.field_type == int:
+        field_schema["type"] = "integer"
+    elif field_info.field_type == float:
+        field_schema["type"] = "number"
+    elif field_info.field_type == bool:
+        field_schema["type"] = "boolean"
+    elif field_info.field_type == list:
+        field_schema["type"] = "array"
+        field_schema["items"] = {"type": "string"}  # Default to string items
+    elif field_info.field_type == dict:
+        field_schema["type"] = "object"
+        field_schema["additionalProperties"] = True
+    elif hasattr(field_info.field_type, "_fields"):
+        # Nested configuration object
+        field_schema = _generate_openapi_schema(field_info.field_type)
+    else:
+        # Fallback to string for unknown types
+        field_schema["type"] = "string"
+
+    # Add default value
+    if field_info.default is not None and not callable(field_info.default):
+        field_schema["default"] = field_info.default
+
+    # Handle choices from CLI metadata
+    if field_info.cli_meta and field_info.cli_meta.choices:
+        if "type" in field_schema:
+            field_schema["enum"] = field_info.cli_meta.choices
+
+    # Add examples from ConfigField
+    if field_info.example is not None:
+        field_schema["example"] = field_info.example
+
+    # Add experimental flag
+    if field_info.is_experimental:
+        field_schema["experimental"] = True
+
+    # Add Field Behavior
+    if field_info.behavior:
+        field_schema["mutation_behavior"] = field_info.behavior
+
+    # Handle validation from CLI metadata
+    if field_info.cli_meta and field_info.validation_fn:
+        # Add validation hints in description
+        if "description" in field_schema:
+            field_schema["description"] += " (validation applied)"
+
+    return field_schema

metaflow_extensions/outerbounds/plugins/apps/core/config/typed_configs.py

@@ -0,0 +1,104 @@
+"""
+Auto-generated typed classes for ConfigMeta classes.
+
+This module provides IDE-friendly typed interfaces for all configuration classes.
+"""
+
+from typing import Optional, List, Dict, Any, TypedDict
+from .unified_config import CoreConfig
+
+
+class ResourceConfigDict(TypedDict, total=False):
+    cpu: Optional[str]
+    memory: Optional[str]
+    gpu: Optional[str]
+    disk: Optional[str]
+
+
+class AuthConfigDict(TypedDict, total=False):
+    type: Optional[str]
+    public: Optional[bool]
+
+
+class ReplicaConfigDict(TypedDict, total=False):
+    fixed: Optional[int]
+    min: Optional[int]
+    max: Optional[int]
+
+
+class DependencyConfigDict(TypedDict, total=False):
+    from_requirements_file: Optional[str]
+    from_pyproject_toml: Optional[str]
+    python: Optional[str]
+    pypi: Optional[dict]
+    conda: Optional[dict]
+
+
+class PackageConfigDict(TypedDict, total=False):
+    src_path: Optional[str]
+    suffixes: Optional[list]
+
+
+class TypedCoreConfig:
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        port: Optional[int] = None,
+        description: Optional[str] = None,
+        app_type: Optional[str] = None,
+        image: Optional[str] = None,
+        tags: Optional[list] = None,
+        secrets: Optional[list] = None,
+        compute_pools: Optional[list] = None,
+        environment: Optional[dict] = None,
+        commands: Optional[list] = None,
+        resources: Optional[ResourceConfigDict] = None,
+        auth: Optional[AuthConfigDict] = None,
+        replicas: Optional[ReplicaConfigDict] = None,
+        dependencies: Optional[DependencyConfigDict] = None,
+        package: Optional[PackageConfigDict] = None,
+        no_deps: Optional[bool] = None,
+        force_upgrade: Optional[bool] = None,
+        persistence: Optional[str] = None,
+        project: Optional[str] = None,
+        branch: Optional[str] = None,
+        models: Optional[list] = None,
+        data: Optional[list] = None,
+        **kwargs
+    ) -> None:
+        self._kwargs = {
+            "name": name,
+            "port": port,
+            "description": description,
+            "app_type": app_type,
+            "image": image,
+            "tags": tags,
+            "secrets": secrets,
+            "compute_pools": compute_pools,
+            "environment": environment,
+            "commands": commands,
+            "resources": resources,
+            "auth": auth,
+            "replicas": replicas,
+            "dependencies": dependencies,
+            "package": package,
+            "no_deps": no_deps,
+            "force_upgrade": force_upgrade,
+            "persistence": persistence,
+            "project": project,
+            "branch": branch,
+            "models": models,
+            "data": data,
+        }
+        # Add any additional kwargs
+        self._kwargs.update(kwargs)
+        # Remove None values
+        self._kwargs = {k: v for k, v in self._kwargs.items() if v is not None}
+        self._config_class = CoreConfig
+        self._config = self.create_config()
+
+    def create_config(self) -> CoreConfig:
+        return CoreConfig.from_dict(self._kwargs)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self._config.to_dict()

metaflow_extensions/outerbounds/plugins/apps/core/config/typed_init_generator.py

@@ -0,0 +1,317 @@
+"""
+Typed Init Generator for ConfigMeta Classes
+
+This module provides a mechanism to dynamically generate explicit typed classes
+from ConfigMeta classes that IDEs can understand and provide autocomplete for.
+"""
+
+from typing import Any, Dict, List, Optional, Union, Type
+
+from .config_utils import ConfigMeta
+
+import os
+
+current_dir = os.path.dirname(__file__)
+
+
+def generate_typed_class_code(config_class: Type) -> str:
+    """
+    Generate the actual Python code for a typed class that IDEs can understand.
+
+    Args:
+        config_class: A class that inherits from ConfigMeta
+
+    Returns:
+        Python code string for the typed class
+    """
+    if not hasattr(config_class, "_fields"):
+        raise ValueError(f"Class {config_class.__name__} is not a ConfigMeta class")
+
+    class_name = f"Typed{config_class.__name__}"
+
+    # Generate TypedDict for nested configs
+    nested_typeddict_code = []
+
+    # First pass: collect all nested configs
+    nested_configs = {}
+    for field_name, field_info in config_class._fields.items():
+        if ConfigMeta.is_instance(field_info.field_type):
+            nested_configs[field_info.field_type.__name__] = field_info.field_type
+
+    # Generate TypedDict classes for nested configs
+    for nested_name, nested_class in nested_configs.items():
+        dict_name = f"{nested_name}Dict"
+        fields = []
+
+        for field_name, field_info in nested_class._fields.items():
+            field_type = _get_type_string(field_info.field_type)
+            if not field_info.required:
+                field_type = f"Optional[{field_type}]"
+            fields.append(f"    {field_name}: {field_type}")
+
+        typeddict_code = f"""class {dict_name}(TypedDict, total=False):
+{chr(10).join(fields)}"""
+        nested_typeddict_code.append(typeddict_code)
+
+    # Generate __init__ method signature
+    required_params = []
+    optional_params = []
+    all_assignments = []
+
+    for field_name, field_info in config_class._fields.items():
+        field_type = field_info.field_type
+
+        # Handle nested ConfigMeta classes
+        if ConfigMeta.is_instance(field_type):
+            type_hint = f"Optional[{field_type.__name__}Dict]"
+            param_line = f"        {field_name}: {type_hint} = None"
+            optional_params.append(param_line)
+        else:
+            # All params will be set as options here even if the are required in the
+            # configMeta
+            type_hint = _get_type_string(field_type)
+            param_line = f"        {field_name}: Optional[{type_hint}] = None"
+            optional_params.append(param_line)
+
+        all_assignments.append(f'            "{field_name}": {field_name}')
+
+    # Combine required params first, then optional params
+    all_params = required_params + optional_params
+
+    # Generate the class code
+    newline = "\n"
+    comma_newline = ",\n"
+
+    # Add **kwargs to the parameter list
+    if all_params:
+        params_with_kwargs = all_params + ["        **kwargs"]
+    else:
+        params_with_kwargs = ["        **kwargs"]
+
+    class_code = f"""class {class_name}:
+    def __init__(
+        self,
+{comma_newline.join(params_with_kwargs)}
+    ) -> None:
+        self._kwargs = {{
+{comma_newline.join(all_assignments)}
+        }}
+        # Add any additional kwargs
+        self._kwargs.update(kwargs)
+        # Remove None values
+        self._kwargs = {{k: v for k, v in self._kwargs.items() if v is not None}}
+        self._config_class = {config_class.__name__}
+        self._config = self.create_config()
+
+    def create_config(self) -> {config_class.__name__}:
+        return {config_class.__name__}.from_dict(self._kwargs)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return self._config.to_dict()"""
+
+    # Combine all code
+    full_code = []
+    if nested_typeddict_code:
+        full_code.extend(nested_typeddict_code)
+        full_code.append("")  # Empty line
+    full_code.append(class_code)
+
+    return (newline + newline).join(full_code)
+
+
+def _get_type_string(field_type: Type) -> str:
+    """Convert a type to its string representation for code generation."""
+    if field_type == str:
+        return "str"
+    elif field_type == int:
+        return "int"
+    elif field_type == float:
+        return "float"
+    elif field_type == bool:
+        return "bool"
+    elif hasattr(field_type, "__origin__"):
+        # Handle generic types like List[str], Dict[str, str], etc.
+        origin = field_type.__origin__
+        args = getattr(field_type, "__args__", ())
+
+        if origin == list:
+            if args:
+                return f"List[{_get_type_string(args[0])}]"
+            return "List[Any]"
+        elif origin == dict:
+            if len(args) == 2:
+                return f"Dict[{_get_type_string(args[0])}, {_get_type_string(args[1])}]"
+            return "Dict[str, Any]"
+        elif origin == Union:
+            # Handle Optional types
+            if len(args) == 2 and type(None) in args:
+                non_none_type = args[0] if args[1] is type(None) else args[1]
+                return f"Optional[{_get_type_string(non_none_type)}]"
+            return f"Union[{', '.join(_get_type_string(arg) for arg in args)}]"
+
+    # Default case - use the type name
+    return getattr(field_type, "__name__", str(field_type))
+
+
+def generate_typed_classes_module(
+    config_classes: List[Type], module_name: str = "typed_configs"
+) -> str:
+    """
+    Generate a complete Python module with typed classes for multiple ConfigMeta classes.
+
+    Args:
+        config_classes: List of ConfigMeta classes
+        module_name: Name for the generated module
+
+    Returns:
+        Complete Python module code
+    """
+    imports = [
+        "from typing import Optional, List, Dict, Any, TypedDict",
+        "from .unified_config import "
+        + ", ".join(cls.__name__ for cls in config_classes),
+    ]
+
+    class_codes = []
+    for config_class in config_classes:
+        class_codes.append(generate_typed_class_code(config_class))
+
+    # Use string concatenation instead of f-string with backslashes
+    newline = "\n"
+    module_code = (
+        '"""'
+        + newline
+        + "Auto-generated typed classes for ConfigMeta classes."
+        + newline
+        + newline
+        + "This module provides IDE-friendly typed interfaces for all configuration classes."
+        + newline
+        + '"""'
+        + newline
+        + newline
+        + newline.join(imports)
+        + newline
+        + newline
+        + (newline + newline).join(class_codes)
+        + newline
+    )
+
+    return module_code
+
+
+def create_typed_init_class_dynamic(config_class: Type) -> Type:
+    """
+    Dynamically create a typed init class with proper IDE support.
+
+    This creates the class at runtime but with proper type annotations
+    that IDEs can understand.
+    """
+    if not hasattr(config_class, "_fields"):
+        raise ValueError(f"Class {config_class.__name__} is not a ConfigMeta class")
+
+    class_name = f"Typed{config_class.__name__}"
+
+    # Create the init method with proper signature
+    def create_init_method():
+        # Build the signature dynamically
+        sig_params = []
+        annotations = {"return": None}
+
+        for field_name, field_info in config_class._fields.items():
+            field_type = field_info.field_type
+
+            # Handle nested ConfigMeta classes
+            if ConfigMeta.is_instance(field_type):
+                field_type = Dict[str, Any]  # Use Dict for nested configs
+
+            # Handle Optional fields
+            if not field_info.required:
+                field_type = Optional[field_type]
+
+            annotations[field_name] = field_type
+
+        def __init__(self, **kwargs):
+            # Validate kwargs
+            required_fields = {
+                name for name, info in config_class._fields.items() if info.required
+            }
+            provided_fields = set(kwargs.keys())
+            valid_fields = set(config_class._fields.keys())
+
+            # Check required fields
+            missing_fields = required_fields - provided_fields
+            if missing_fields:
+                raise ValueError(
+                    f"Missing required fields: {', '.join(missing_fields)}"
+                )
+
+            # Check for unknown fields - but allow them for flexibility
+            unknown_fields = provided_fields - valid_fields
+            if unknown_fields:
+                print(
+                    f"Warning: Unknown fields will be passed through: {', '.join(unknown_fields)}"
+                )
+
+            self._kwargs = kwargs
+            self._config_class = config_class
+
+        # Set annotations
+        __init__.__annotations__ = annotations
+        return __init__
+
+    def create_config(self) -> config_class:
+        """Create and return the ConfigMeta class instance."""
+        return config_class.from_dict(self._kwargs)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the raw kwargs as a dictionary."""
+        return self._kwargs.copy()
+
+    def __repr__(self) -> str:
+        return f"{class_name}({self._kwargs})"
+
+    # Create the class
+    init_method = create_init_method()
+
+    TypedClass = type(
+        class_name,
+        (object,),
+        {
+            "__init__": init_method,
+            "create_config": create_config,
+            "to_dict": to_dict,
+            "__repr__": __repr__,
+            "__module__": __name__,
+            "__qualname__": class_name,
+        },
+    )
+
+    return TypedClass
+
+
+# Auto-generate and write typed classes to a file
+def generate_typed_classes_file(output_file: str = None):
+    """
+    Generate typed classes and write them to a file for IDE support.
+
+    Args:
+        output_file: Path to write the generated classes. If None, prints to stdout.
+    """
+    from .unified_config import CoreConfig
+
+    config_classes = [CoreConfig]
+
+    module_code = generate_typed_classes_module(config_classes)
+
+    if output_file:
+        with open(output_file, "w") as f:
+            f.write(module_code)
+        print(f"Generated typed classes written to {output_file}")
+    else:
+        print(module_code)
+
+
+# Example usage and testing
+if __name__ == "__main__":
+    # Generate typed classes file
+    generate_typed_classes_file(os.path.join(current_dir, "typed_configs.py"))