fast-clean-architecture 1.0.0__py3-none-any.whl

fast_clean_architecture/generators/config_updater.py

@@ -0,0 +1,308 @@
+"""Configuration updater for managing fca-config.yaml updates."""
+
+import shutil
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+from rich.console import Console
+
+from ..config import Config
+from ..utils import generate_timestamp
+from ..exceptions import ConfigurationError
+
+
+class ConfigUpdater:
+    """Handles updates to the fca-config.yaml file with proper timestamp management."""
+
+    def __init__(self, config_path: Path, console: Console = None):
+        self.config_path = config_path
+        self.console = console or Console()
+        self._config: Optional[Config] = None
+
+    @property
+    def config(self) -> Config:
+        """Lazy load the configuration."""
+        if self._config is None:
+            self._config = self._load_config()
+        return self._config
+
+    def _load_config(self) -> Config:
+        """Load configuration from file or create default."""
+        if self.config_path.exists():
+            return Config.load_from_file(self.config_path)
+        else:
+            # Create default config if it doesn't exist
+            config = Config.create_default()
+            config.save_to_file(self.config_path)
+            return config
+
+    def backup_config(self) -> Path:
+        """Create a backup of the current configuration."""
+        if not self.config_path.exists():
+            raise ConfigurationError(
+                f"Configuration file does not exist: {self.config_path}"
+            )
+
+        timestamp = generate_timestamp().replace(":", "-").replace(".", "-")
+        backup_path = self.config_path.with_suffix(f".backup.{timestamp}.yaml")
+
+        shutil.copy2(self.config_path, backup_path)
+        self.console.print(f"📋 Config backed up to: {backup_path}")
+        return backup_path
+
+    def add_system(
+        self,
+        system_name: str,
+        description: Optional[str] = None,
+        backup: bool = True,
+    ) -> None:
+        """Add a new system to the configuration."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Add system to config
+        self.config.add_system(system_name, description)
+
+        # Save updated config
+        self._save_config_atomically()
+
+        self.console.print(f"✅ Added system: {system_name}")
+
+    def add_module(
+        self,
+        system_name: str,
+        module_name: str,
+        description: Optional[str] = None,
+        backup: bool = True,
+    ) -> None:
+        """Add a new module to a system."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Add module to config
+        self.config.add_module(system_name, module_name, description)
+
+        # Save updated config
+        self._save_config_atomically()
+
+        self.console.print(f"✅ Added module: {module_name} to system: {system_name}")
+
+    def add_component(
+        self,
+        system_name: str,
+        module_name: str,
+        layer: str,
+        component_type: str,
+        component_name: str,
+        file_path: Optional[Path] = None,
+        backup: bool = True,
+    ) -> None:
+        """Add a new component to a module."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Add component to config
+        self.config.add_component(
+            system_name=system_name,
+            module_name=module_name,
+            layer=layer,
+            component_type=component_type,
+            component_name=component_name,
+            file_path=str(file_path) if file_path else None,
+        )
+
+        # Save updated config
+        self._save_config_atomically()
+
+        self.console.print(
+            f"✅ Added component: {component_name} ({component_type}) "
+            f"to {system_name}/{module_name}/{layer}"
+        )
+
+    def update_system_timestamp(self, system_name: str, backup: bool = True) -> None:
+        """Update the timestamp for a system and cascade to project."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Update system timestamp
+        if system_name in self.config.project.systems:
+            current_time = generate_timestamp()
+            self.config.project.systems[system_name].updated_at = current_time
+            self.config.project.updated_at = current_time
+
+        # Save updated config
+        self._save_config_atomically()
+
+    def update_module_timestamp(
+        self, system_name: str, module_name: str, backup: bool = True
+    ) -> None:
+        """Update the timestamp for a module and cascade to system and project."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Update module, system, and project timestamps
+        if (
+            system_name in self.config.project.systems
+            and module_name in self.config.project.systems[system_name].modules
+        ):
+            current_time = generate_timestamp()
+            self.config.project.systems[system_name].modules[
+                module_name
+            ].updated_at = current_time
+            self.config.project.systems[system_name].updated_at = current_time
+            self.config.project.updated_at = current_time
+
+        # Save updated config
+        self._save_config_atomically()
+
+    def update_project_metadata(
+        self,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        version: Optional[str] = None,
+        backup: bool = True,
+    ) -> None:
+        """Update project metadata."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Update project metadata
+        current_time = generate_timestamp()
+
+        if name is not None:
+            self.config.project.name = name
+        if description is not None:
+            self.config.project.description = description
+        if version is not None:
+            self.config.project.version = version
+
+        self.config.project.updated_at = current_time
+
+        # Save updated config
+        self._save_config_atomically()
+
+        self.console.print("✅ Updated project metadata")
+
+    def remove_system(self, system_name: str, backup: bool = True) -> None:
+        """Remove a system from the configuration."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Remove system
+        if system_name in self.config.project.systems:
+            del self.config.project.systems[system_name]
+            self.config.project.updated_at = generate_timestamp()
+
+        # Save updated config
+        self._save_config_atomically()
+
+        self.console.print(f"🗑️ Removed system: {system_name}")
+
+    def remove_module(
+        self, system_name: str, module_name: str, backup: bool = True
+    ) -> None:
+        """Remove a module from a system."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Remove module
+        if (
+            system_name in self.config.project.systems
+            and module_name in self.config.project.systems[system_name].modules
+        ):
+            del self.config.project.systems[system_name].modules[module_name]
+            current_time = generate_timestamp()
+            self.config.project.systems[system_name].updated_at = current_time
+            self.config.project.updated_at = current_time
+
+        # Save updated config
+        self._save_config_atomically()
+
+        self.console.print(
+            f"🗑️ Removed module: {module_name} from system: {system_name}"
+        )
+
+    def remove_component(
+        self,
+        system_name: str,
+        module_name: str,
+        layer: str,
+        component_type: str,
+        component_name: str,
+        backup: bool = True,
+    ) -> None:
+        """Remove a component from a module."""
+        if backup and self.config_path.exists():
+            self.backup_config()
+
+        # Navigate to the component and remove it
+        try:
+            system = self.config.project.systems[system_name]
+            module = system.modules[module_name]
+            layer_components = getattr(module.components, layer)
+            component_list = getattr(layer_components, component_type)
+
+            # Find and remove the component
+            component_list[:] = [
+                comp for comp in component_list if comp.name != component_name
+            ]
+
+            # Update timestamps
+            current_time = generate_timestamp()
+            module.updated_at = current_time
+            system.updated_at = current_time
+            self.config.project.updated_at = current_time
+
+        except (KeyError, AttributeError) as e:
+            raise ConfigurationError(f"Component not found: {e}")
+
+        # Save updated config
+        self._save_config_atomically()
+
+        self.console.print(
+            f"🗑️ Removed component: {component_name} ({component_type}) "
+            f"from {system_name}/{module_name}/{layer}"
+        )
+
+    def get_config_summary(self) -> Dict[str, Any]:
+        """Get a summary of the current configuration."""
+        summary = {
+            "project": {
+                "name": self.config.project.name,
+                "version": self.config.project.version,
+                "created_at": self.config.project.created_at,
+                "updated_at": self.config.project.updated_at,
+            },
+            "systems": {},
+        }
+
+        for system_name, system in self.config.project.systems.items():
+            summary["systems"][system_name] = {
+                "description": system.description,
+                "created_at": system.created_at,
+                "updated_at": system.updated_at,
+                "modules": list(system.modules.keys()),
+            }
+
+        return summary
+
+    def _save_config_atomically(self) -> None:
+        """Save configuration atomically to prevent corruption."""
+        try:
+            # Write to temporary file first
+            temp_path = self.config_path.with_suffix(".tmp")
+            self.config.save_to_file(temp_path)
+
+            # Atomic move
+            temp_path.replace(self.config_path)
+
+        except Exception as e:
+            # Clean up temp file if it exists
+            temp_path = self.config_path.with_suffix(".tmp")
+            if temp_path.exists():
+                temp_path.unlink()
+            raise ConfigurationError(f"Failed to save configuration: {e}")
+
+    def reload_config(self) -> None:
+        """Reload configuration from file."""
+        self._config = None  # Force reload on next access

fast_clean_architecture/generators/package_generator.py

@@ -0,0 +1,174 @@
+"""Package generator for creating directory structures and __init__.py files."""
+
+from pathlib import Path
+from typing import List, Dict, Optional
+
+import jinja2
+from rich.console import Console
+
+from ..templates import TEMPLATES_DIR
+from ..utils import ensure_directory
+from ..exceptions import TemplateError
+
+
+class PackageGenerator:
+    """Generator for creating Python packages with proper __init__.py files."""
+
+    def __init__(self, console: Optional[Console] = None):
+        self.console = console or Console()
+        self.template_env = jinja2.Environment(
+            loader=jinja2.FileSystemLoader(TEMPLATES_DIR),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def create_system_structure(
+        self, base_path: Path, system_name: str, dry_run: bool = False
+    ) -> None:
+        """Create the complete system directory structure."""
+        system_path = base_path / "systems" / system_name
+
+        if dry_run:
+            self.console.print(
+                f"[yellow]DRY RUN:[/yellow] Would create system structure: {system_path}"
+            )
+            return
+
+        # Create systems root if it doesn't exist
+        systems_root = base_path / "systems"
+        if not systems_root.exists():
+            ensure_directory(systems_root)
+            self._create_init_file(
+                systems_root / "__init__.py",
+                package_type="empty",
+                package_description="Systems",
+                context="fast-clean-architecture",
+            )
+
+        # Create system directory
+        ensure_directory(system_path)
+
+        # Create system __init__.py
+        self._create_init_file(
+            system_path / "__init__.py",
+            package_type="system",
+            system_name=system_name,
+        )
+
+        # Create main.py for system entry point
+        main_content = f'"""\nMain entry point for {system_name} system.\n"""\n\n# System initialization and configuration\n'
+        (system_path / "main.py").write_text(main_content, encoding="utf-8")
+
+        self.console.print(f"✅ Created system structure: {system_path}")
+
+    def create_module_structure(
+        self, base_path: Path, system_name: str, module_name: str, dry_run: bool = False
+    ) -> None:
+        """Create the complete module directory structure."""
+        module_path = base_path / "systems" / system_name / module_name
+
+        if dry_run:
+            self.console.print(
+                f"[yellow]DRY RUN:[/yellow] Would create module structure: {module_path}"
+            )
+            return
+
+        # Create module directory
+        ensure_directory(module_path)
+
+        # Create module __init__.py
+        self._create_init_file(
+            module_path / "__init__.py",
+            package_type="module",
+            module_name=module_name,
+            system_name=system_name,
+        )
+
+        # Create layer directories
+        layers = {
+            "domain": {
+                "entities": [],
+                "repositories": [],
+                "value_objects": [],
+            },
+            "application": {
+                "services": [],
+                "commands": [],
+                "queries": [],
+            },
+            "infrastructure": {
+                "models": [],
+                "repositories": [],
+                "external": [],
+                "internal": [],
+            },
+            "presentation": {
+                "api": [],
+                "schemas": [],
+            },
+        }
+
+        for layer_name, components in layers.items():
+            layer_path = module_path / layer_name
+            ensure_directory(layer_path)
+
+            # Create layer __init__.py
+            self._create_init_file(
+                layer_path / "__init__.py",
+                package_type="empty",
+                package_description=layer_name.title(),
+                context=f"{module_name} module",
+            )
+
+            # Create component directories
+            for component_type in components:
+                component_path = layer_path / component_type
+                ensure_directory(component_path)
+
+                # Create component __init__.py
+                self._create_init_file(
+                    component_path / "__init__.py",
+                    package_type="component",
+                    component_type=component_type,
+                    module_name=module_name,
+                    components=[],
+                )
+
+        # Create module.py file
+        module_content = f'"""\nModule registration for {module_name}.\n"""\n\n# Module configuration and dependencies\n'
+        (module_path / "module.py").write_text(module_content, encoding="utf-8")
+
+        self.console.print(f"✅ Created module structure: {module_path}")
+
+    def update_component_init(
+        self,
+        component_path: Path,
+        component_type: str,
+        module_name: str,
+        components: List[Dict[str, str]],
+    ) -> None:
+        """Update component __init__.py with new imports."""
+        init_path = component_path / "__init__.py"
+
+        self._create_init_file(
+            init_path,
+            package_type="component",
+            component_type=component_type,
+            module_name=module_name,
+            components=components,
+        )
+
+        self.console.print(f"📝 Updated {init_path}")
+
+    def _create_init_file(self, file_path: Path, **template_vars) -> None:
+        """Create __init__.py file from template."""
+        try:
+            template = self.template_env.get_template("__init__.py.j2")
+            content = template.render(**template_vars)
+
+            file_path.write_text(content, encoding="utf-8")
+
+        except jinja2.TemplateError as e:
+            raise TemplateError(f"Error rendering __init__.py template: {e}")
+        except Exception as e:
+            raise TemplateError(f"Error creating __init__.py file: {e}")