generator.py

#!/usr/bin/env python3
"""
Configuration Generator using Jinja2 Templates
"""
import os
import sys
import yaml
from jinja2 import Environment, FileSystemLoader, TemplateNotFound
from pathlib import Path


class ConfigGenerator:
    """Generate configurations from Jinja2 templates and YAML data."""

    def __init__(self, template_dir='templates', output_dir='configs'):
        """
        Initialize the configuration generator.

        Args:
            template_dir: Directory containing Jinja2 templates
            output_dir: Directory for generated configurations
        """
        self.template_dir = template_dir
        self.output_dir = output_dir

        self.env = Environment(
            loader=FileSystemLoader(self.template_dir),
            trim_blocks=True,
            lstrip_blocks=True
        )

        # Create output directory if it doesn't exist
        Path(self.output_dir).mkdir(parents=True, exist_ok=True)

    def load_data(self, data_file):
        """
        Load configuration data from YAML file.

        Args:
            data_file: Path to YAML data file

        Returns:
            Dictionary containing configuration data
        """
        try:
            with open(data_file, 'r', encoding='utf-8') as f:
                data = yaml.safe_load(f)

            if data is None:
                return {}

            if not isinstance(data, dict):
                raise ValueError(f"YAML data in '{data_file}' must be a dictionary/object at the top level.")

            return data

        except FileNotFoundError:
            raise FileNotFoundError(f"Data file not found: {data_file}")
        except yaml.YAMLError as e:
            raise ValueError(f"Failed to parse YAML file '{data_file}': {e}")

    def generate_config(self, template_name, data, output_file=None):
        """
        Generate configuration from template and data.

        Args:
            template_name: Name of the template file
            data: Dictionary containing template variables
            output_file: Optional output filename (defaults to template name without .j2)

        Returns:
            Generated configuration as string
        """
        try:
            template = self.env.get_template(template_name)
        except TemplateNotFound:
            raise FileNotFoundError(f"Template not found: {template_name}")

        rendered = template.render(**data)

        if output_file is None:
            if template_name.endswith('.j2'):
                output_file = template_name[:-3]
            else:
                output_file = template_name

        output_path = Path(self.output_dir) / output_file
        with open(output_path, 'w', encoding='utf-8') as f:
            f.write(rendered)
            if not rendered.endswith('\n'):
                f.write('\n')

        return rendered

    def generate_all(self, data_file, template_list=None):
        """
        Generate multiple configurations from a data file.

        Args:
            data_file: Path to YAML data file
            template_list: List of template names (None = all templates)
        """
        data = self.load_data(data_file)

        if template_list is None:
            template_list = sorted(
                [f for f in os.listdir(self.template_dir) if f.endswith('.j2')]
            )

        generated_files = []

        for template_name in template_list:
            try:
                output_file = template_name[:-3] if template_name.endswith('.j2') else template_name
                self.generate_config(template_name, data, output_file=output_file)
                generated_files.append(str(Path(self.output_dir) / output_file))
                print(f"Generated: {Path(self.output_dir) / output_file}")
            except Exception as e:
                print(f"Error generating '{template_name}': {e}", file=sys.stderr)

        print(f"\nSummary: generated {len(generated_files)} file(s) from {data_file}")


def main():
    """Main execution function."""
    if len(sys.argv) < 2:
        print("Usage: python3 generator.py <data_file> [template1 template2 ...]")
        print("Example: python3 generator.py data/dev_config.yaml")
        sys.exit(1)

    data_file = sys.argv[1]
    templates = sys.argv[2:] if len(sys.argv) > 2 else None

    generator = ConfigGenerator()

    try:
        generator.generate_all(data_file, templates)
    except Exception as e:
        print(f"Generator error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == '__main__':
    main()