viperx 0.9.49__tar.gz → 0.9.72__tar.gz

{viperx-0.9.49 → viperx-0.9.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: viperx
-Version: 0.9.49
+Version: 0.9.72
 Summary: Professional Python Project Initializer with uv, ml/dl support, and embedded config.
 Keywords: python,project-template,uv,data-science,machine-learning
 Author: Ivann KAMDEM

{viperx-0.9.49 → viperx-0.9.72}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "viperx"
-version = "0.9.49"
+version = "0.9.72"
 description = "Professional Python Project Initializer with uv, ml/dl support, and embedded config."
 readme = "README.md"
 authors = [

viperx-0.9.72/src/viperx/config_engine.py

@@ -0,0 +1,325 @@
+import yaml
+from pathlib import Path
+from rich.console import Console
+from rich.panel import Panel
+
+from viperx.core import ProjectGenerator
+from viperx.constants import DEFAULT_LICENSE, DEFAULT_BUILDER, TYPE_CLASSIC, TYPE_ML, TYPE_DL, FRAMEWORK_PYTORCH
+
+console = Console()
+
+class ConfigEngine:
+    """
+    Orchestrates project creation and updates based on a declarative YAML config.
+    Implements the 'Infrastructure as Code' pattern for ViperX.
+    """
+    
+    def __init__(self, config_path: Path, verbose: bool = False):
+        self.config_path = config_path
+        self.verbose = verbose
+        self.config = self._load_config()
+        self.root_path = Path.cwd()
+
+    def _load_config(self) -> dict:
+        """Load and validate the YAML configuration."""
+        if not self.config_path.exists():
+            console.print(f"[bold red]Error:[/bold red] Config file not found at {self.config_path}")
+            raise FileNotFoundError(f"Config file not found: {self.config_path}")
+            
+        with open(self.config_path, "r") as f:
+            try:
+                data = yaml.safe_load(f)
+            except yaml.YAMLError as e:
+                console.print(f"[bold red]Error:[/bold red] Invalid YAML format: {e}")
+                raise ValueError("Invalid YAML")
+                
+        # Basic Validation
+        if "project" not in data or "name" not in data["project"]:
+            console.print("[bold red]Error:[/bold red] Config must contain 'project.name'")
+            raise ValueError("Missing project.name")
+            
+        return data
+
+    def apply(self):
+        """Apply the configuration to the current directory."""
+        from viperx.report import UpdateReport
+        from viperx.utils import sanitize_project_name
+        
+        report = UpdateReport()
+        project_conf = self.config.get("project", {})
+        settings_conf = self.config.get("settings", {})
+        workspace_conf = self.config.get("workspace", {})
+        
+        project_name = project_conf.get("name")
+        clean_name = sanitize_project_name(project_name)
+        
+        # Determine Root
+        current_root = self.root_path / clean_name
+        # Heuristic: Are we already inside?
+        if self.root_path.name == project_name or self.root_path.name == clean_name:
+            current_root = self.root_path
+
+        # ---------------------------------------------------------
+        # Phase 0: Context Aggregation (PRESERVED LOGIC)
+        # ---------------------------------------------------------
+        # We assume dependencies logic is required for both generation and validation.
+        
+        root_use_config = settings_conf.get("use_config", True)
+        root_use_env = settings_conf.get("use_env", False)
+        root_use_tests = settings_conf.get("use_tests", True)
+        root_type = settings_conf.get("type", TYPE_CLASSIC)
+        root_framework = settings_conf.get("framework", FRAMEWORK_PYTORCH)
+        
+        glob_has_config = root_use_config
+        glob_has_env = root_use_env
+        glob_is_ml_dl = root_type in [TYPE_ML, TYPE_DL]
+        glob_is_dl = root_type == TYPE_DL
+        glob_frameworks = {root_framework} if glob_is_dl else set()
+
+        project_scripts = {project_name: f"{clean_name}.main:main"} # Use clean mapping
+        
+        # List for README generation (Order: Root, then packages)
+        packages_list = [{
+            "raw_name": project_name,
+            "clean_name": clean_name,
+            "use_config": root_use_config,
+            "use_tests": root_use_tests,
+            "use_env": root_use_env
+        }]
+        
+        packages = workspace_conf.get("packages", [])
+        for pkg in packages:
+            # Scripts
+            pkg_name = pkg.get("name")
+            pkg_name_clean = sanitize_project_name(pkg_name)
+            project_scripts[pkg_name] = f"{pkg_name_clean}.main:main"
+            
+            # Dependency Aggregation
+            p_config = pkg.get("use_config", settings_conf.get("use_config", True))
+            p_env = pkg.get("use_env", settings_conf.get("use_env", False))
+            p_tests = pkg.get("use_tests", settings_conf.get("use_tests", True))
+            p_type = pkg.get("type", TYPE_CLASSIC)
+            p_framework = pkg.get("framework", FRAMEWORK_PYTORCH)
+
+            if p_config: glob_has_config = True
+            if p_env: glob_has_env = True
+            if p_type in [TYPE_ML, TYPE_DL]: glob_is_ml_dl = True
+            if p_type == TYPE_DL: 
+                 glob_is_dl = True
+                 glob_frameworks.add(p_framework)
+                 
+            packages_list.append({
+                "raw_name": pkg_name,
+                "clean_name": pkg_name_clean,
+                "use_config": p_config,
+                "use_tests": p_tests,
+                "use_env": p_env
+            })
+
+        dep_context = {
+            "has_config": glob_has_config,
+            "has_env": glob_has_env,
+            "is_ml_dl": glob_is_ml_dl,
+            "is_dl": glob_is_dl,
+            "frameworks": list(glob_frameworks),
+            "packages": packages_list
+        }
+
+        # ---------------------------------------------------------
+        # Phase 1: Root Project (Hydration vs Update)
+        # ---------------------------------------------------------
+        if not (current_root / "pyproject.toml").exists():
+            # CASE A: New Project (Hydration)
+            if not current_root.exists() and current_root != self.root_path:
+                report.added.append(f"Project '{project_name}' (Scaffolding)")
+            else:
+                report.added.append(f"Project Scaffolding in existing '{current_root.name}'")
+                
+            gen = ProjectGenerator(
+                name=project_name, # Raw name
+                description=project_conf.get("description", ""),
+                type=settings_conf.get("type", TYPE_CLASSIC),
+                author=project_conf.get("author", None),
+                license=project_conf.get("license", DEFAULT_LICENSE),
+                builder=project_conf.get("builder", DEFAULT_BUILDER),
+                use_env=settings_conf.get("use_env", False),
+                use_config=settings_conf.get("use_config", True),
+                use_tests=settings_conf.get("use_tests", True),
+                framework=settings_conf.get("framework", FRAMEWORK_PYTORCH),
+                scripts=project_scripts,
+                dependency_context=dep_context,
+                verbose=self.verbose
+            )
+            # We generate at parent if we are creating subfolder, or current if inside
+            target_gen_path = current_root.parent if current_root != self.root_path else self.root_path
+            gen.generate(target_gen_path)
+            
+            # Verify creation reference for packages
+            if not current_root.exists():
+                     if (self.root_path / project_name).exists():
+                         current_root = self.root_path / project_name
+
+        else:
+            # CASE B: Update Existing Project
+            self._update_root_metadata(current_root, project_conf, report)
+            
+            # Conflict Checks (Root)
+            # Check use_env
+            if not root_use_env and (current_root / ".env").exists():
+                 report.conflicts.append("Root: use_env=False but .env exists")
+            pass
+
+        # ---------------------------------------------------------
+        # Phase 2: Workspace Packages (Iterative Sync)
+        # ---------------------------------------------------------
+        
+        for pkg in packages:
+            pkg_name = pkg.get("name")
+            pkg_name_clean = sanitize_project_name(pkg_name)
+            
+            # Approximate check for existing package src directory
+            pkg_path = current_root / "src" / pkg_name_clean
+            # Also check if user used hyphens in folder name (classic behavior)
+            if not pkg_path.exists():
+                 pkg_path_hyphen = current_root / "src" / pkg_name
+                 if pkg_path_hyphen.exists():
+                      pkg_path = pkg_path_hyphen
+
+            if pkg_path.exists():
+                # --- UPDATE CHECK ---
+                # Check for REMOVAL of features (Conflict Reporting)
+                p_use_env = pkg.get("use_env", settings_conf.get("use_env", False))
+                if not p_use_env and (pkg_path / ".env").exists():
+                    report.conflicts.append(f"Package '{pkg_name}': use_env=False but .env exists")
+                
+                # Check for Metadata updates (Assuming we don't sub-update dependencies often)
+                # We skip regeneration to be SAFE.
+                pass
+            else:
+                # --- NEW PACKAGE ---
+                report.added.append(f"Package '{pkg_name}'")
+                
+                pkg_gen = ProjectGenerator(
+                    name=pkg_name,
+                    description=pkg.get("description", ""),
+                    type=pkg.get("type", TYPE_CLASSIC),
+                    author=project_conf.get("author", "Your Name"),
+                    use_env=pkg.get("use_env", settings_conf.get("use_env", False)),
+                    use_config=pkg.get("use_config", settings_conf.get("use_config", True)),
+                    use_readme=pkg.get("use_readme", False),
+                    use_tests=pkg.get("use_tests", settings_conf.get("use_tests", True)),
+                    framework=pkg.get("framework", FRAMEWORK_PYTORCH),
+                    scripts=project_scripts, 
+                    dependency_context=dep_context,
+                    verbose=self.verbose
+                )
+                pkg_gen.add_to_workspace(current_root)
+
+        # Check for Deletions (Packages on disk not in config)
+        existing_pkgs = set()
+        if (current_root / "src").exists():
+             existing_pkgs = {p.name for p in (current_root / "src").iterdir() if p.is_dir()}
+        
+        # We need to map config names to folder names to check existence
+        config_folder_names = {p["clean_name"] for p in packages_list if p["raw_name"] != project_name}
+        
+        # Also include raw names if they exist on disk (classic case)
+        config_raw_names = {p["raw_name"] for p in packages_list if p["raw_name"] != project_name}
+        
+        for ep in existing_pkgs:
+            if ep not in config_folder_names and ep not in config_raw_names:
+                report.deletions.append(f"Package '{ep}' found on disk but missing from config.")
+
+        # ---------------------------------------------------------
+        # Phase 3: Config Sync & Reporting
+        # ---------------------------------------------------------
+        # Sync viperx.yaml
+        system_config_path = current_root / "viperx.yaml"
+        if self.config_path.absolute() != system_config_path.absolute():
+            import shutil
+            shutil.copy2(self.config_path, system_config_path)
+            
+        if report.added or report.updated:
+             report.manual_checks.append("Review README.md for any necessary updates (e.g. Project Name, Description).")
+
+        self._print_report(report)
+
+    def _update_root_metadata(self, root: Path, project_conf: dict, report):
+        """Safely update pyproject.toml metadata."""
+        import toml
+        pyproject_path = root / "pyproject.toml"
+        if not pyproject_path.exists():
+            return
+
+        with open(pyproject_path, "r") as f:
+            data = toml.load(f)
+
+        changed = False
+        proj = data.get("project", {})
+        
+        # 1. Description
+        new_desc = project_conf.get("description")
+        if new_desc and proj.get("description") != new_desc:
+            proj["description"] = new_desc
+            report.updated.append(f"Root description -> '{new_desc}'")
+            changed = True
+            
+        # 2. Author (simplified, assumes list of dicts)
+        new_author = project_conf.get("author")
+        if new_author:
+             authors = proj.get("authors", [])
+             if authors and authors[0].get("name") != new_author:
+                 authors[0]["name"] = new_author
+                 report.updated.append(f"Root author -> '{new_author}'")
+                 changed = True
+                 
+        # 3. License
+        new_license = project_conf.get("license")
+        current_lic = proj.get("license", {}).get("text")
+        if new_license and current_lic != new_license:
+            proj["license"] = {"text": new_license}
+            report.updated.append(f"Root license -> '{new_license}'")
+            changed = True
+            report.manual_checks.append("License type changed. Verify LICENSE file content.")
+
+        if changed:
+            data["project"] = proj
+            with open(pyproject_path, "w") as f:
+                toml.dump(data, f)
+                
+    def _print_report(self, report):
+        from rich.tree import Tree
+        
+        if not report.has_events:
+            console.print(Panel("✨ [bold green]Start[/bold green]\nNothing to change. Project is in sync.", border_style="green"))
+            return
+
+        tree = Tree("📝 [bold]Update Report[/bold]")
+        
+        if report.added:
+            added_node = tree.add("[green]Added[/green]")
+            for item in report.added:
+                added_node.add(f"[green]+ {item}[/green]")
+                
+        if report.updated:
+            updated_node = tree.add("[blue]Updated (Safe)[/blue]")
+            for item in report.updated:
+                updated_node.add(f"[blue]~ {item}[/blue]")
+                
+        if report.conflicts:
+            con_node = tree.add("[yellow]Conflicts (No Action Taken)[/yellow]")
+            for item in report.conflicts:
+                con_node.add(f"[yellow]! {item}[/yellow]")
+
+        if report.deletions:
+            del_node = tree.add("[red]Deletions Detected (No Action Taken)[/red]")
+            for item in report.deletions:
+                del_node.add(f"[red]- {item}[/red]")
+                
+        if report.manual_checks:
+            check_node = tree.add("[magenta]Manual Checks Required[/magenta]")
+            for item in report.manual_checks:
+                check_node.add(f"[magenta]? {item}[/magenta]")
+
+        console.print(tree)
+        console.print("\n[dim]Run completed.[/dim]")

{viperx-0.9.49 → viperx-0.9.72}/src/viperx/core.py

@@ -235,6 +235,7 @@ class ProjectGenerator:
             "use_env": self.use_env,
             "framework": self.framework,
             "scripts": self.scripts,
+            "is_subpackage": is_subpackage,
         }
         # Merge dependency context overrides
         context.update(self.dependency_context)

viperx-0.9.72/src/viperx/report.py

@@ -0,0 +1,15 @@
+from dataclasses import dataclass, field
+from typing import List
+
+@dataclass
+class UpdateReport:
+    """Collects events during the update process for final reporting."""
+    added: List[str] = field(default_factory=list)
+    updated: List[str] = field(default_factory=list)
+    conflicts: List[str] = field(default_factory=list)
+    deletions: List[str] = field(default_factory=list)
+    manual_checks: List[str] = field(default_factory=list)
+
+    @property
+    def has_events(self) -> bool:
+        return any([self.added, self.updated, self.conflicts, self.deletions, self.manual_checks])

{viperx-0.9.49 → viperx-0.9.72}/src/viperx/templates/README.md.j2

@@ -7,31 +7,42 @@
 ## 🧐 Philosophy & Architecture
 
 Values transparency and standard tooling over "black box" magic.
-This project was generated with [ViperX](https://github.com/kpihx/viperx).sh/uv/)**, the extremely fast Python package and project manager written in Rust.
+This project was generated with [ViperX](https://github.com/kpihx/viperx), using **[uv](https://docs.astral.sh/uv/)**, the extremely fast Python package and project manager written in Rust.
 
 ### Why `uv`?
 Unlike traditional workflows (pip, poetry, venv mixing), `uv` manages the **entire lifecycle**:
 - **Python Version**: It installs and manages the correct Python version for this project automatically.
 - **Dependencies**: Locking is instant.
-{% if project_type == 'dl' %}
+{%- if project_type == 'dl' %}
 - **Stack**: {{ framework|title }}
-{% endif %}
+{%- endif %}
 - **Environment**: Virtual environments are managed internally, you just run `uv run`.
 
+{%- if has_config or use_env %}
 ### ⚙️ Configuration
 
+{%- if has_config %}
 - **Config**: `src/{{ package_name }}/config.yaml` (Loaded automatically)
-{% if has_config %}
+{%- endif %}
+{%- if use_env %}
 - **Environment**: `src/{{ package_name }}/.env` (Isolated variables)
-{% endif %}
+- **Template**: `src/{{ package_name }}/.env.example` (Copy this to `.env`)
+{%- endif %}
 
-Edit `config.yaml` to change parameters. The project uses a **Config-in-Package** architecture:
+The project uses a **Config-in-Package** architecture:
+{%- if has_config %}
 1. `config.yaml` is inside the package.
-2. `config.py` loads it safely (even in production wheels).
-3. `.env` is isolated within the package source.
+1. `config.py` loads it safely (even in production wheels).
+{%- endif %}
+{%- if use_env %}
+1. `.env` is isolated within the package source.
+1. `.env.example` serves as a template for new developers.
+{%- endif %}
+{%- endif %}
 
 ---
 
+{%- if not is_subpackage %}
 ## 🚀 Getting Started
 
 ### Prerequisites
@@ -42,31 +53,29 @@ No need to install Python or create venvs manually.
 ### Installation
 
 ```bash
-# Clone the repo
-git clone https://github.com/{{ author_name | lower | replace(" ", "") }}/{{ project_name }}.git
+# Ensure you are in the project directory
 cd {{ project_name }}
 
 # Sync dependencies (creates .venv and installs python if needed)
 uv sync
 ```
+{%- endif %}
 
 ## 🧑‍💻 Usage
 
-The entry point depends on your project type.
-
 ### For Developers (Code)
 
 To run the package entry point or scripts:
 
 ```bash
 # Run the main package
-uv run {{ package_name }}
+uv run {{ project_name }}
 
 # Or run a specific script
 uv run python src/{{ package_name }}/main.py
 ```
 
-{% if project_type in ['ml', 'dl'] %}
+{%- if project_type in ['ml', 'dl'] and not is_subpackage %}
 ### For Data Scientists (Notebooks)
 
 We use `uv` to launch Jupyter, ensuring it sees the local package and config.
@@ -77,46 +86,93 @@ uv run jupyter notebook
 
 - Open `notebooks/Base.ipynb`.
 - Note how it imports `config` from the package.
-{% endif %}
 
 ### ☁️ Cloud (Colab / Kaggle)
 
 You can use the code and config from this repository directly in cloud environments without cloning.
 
-**Step 1: Install directly from GitHub**
+**Step 1: Install directly from Git**
 ```python
-!pip install git+https://github.com/{{ author_name | lower | replace(" ", "") }}/{{ project_name }}.git
+!pip install url_to_repo.git
 ```
 
 **Step 2: Use the unified config**
 ```python
+{%- if project_type == 'classic' %}
+from {{ package_name }} import SETTINGS
+{%- else %}
 from {{ package_name }} import get_dataset_path, SETTINGS
 import kagglehub as kh
+{%- endif %}
 
 # Transparency: You can inspect what was loaded
-print(f"Loaded config for: {SETTINGS['project_name']}")
+print(f"Loaded config for: {SETTINGS.get('project_name', 'Unknown')}")
 
+{%- if project_type != 'classic' %}
 # Download datasets defined in config.yaml
 # The key 'titanic' maps to 'heptapod/titanic' in the yaml
-path = kh.dataset_download(SETTINGS['datasets']['titanic'])
+if 'datasets' in SETTINGS and 'titanic' in SETTINGS['datasets']:
+    path = kh.dataset_download(SETTINGS['datasets']['titanic'])
+{%- endif %}
 ```
+{%- endif %}
 
 ## 🔧 Internal Structure
 
 ```text
+{%- if is_subpackage %}
+{{ package_name }}/
+├── __init__.py
+{%- if has_config %}
+├── config.yaml # EDIT THIS for project settings
+├── config.py   # Code that loads the yaml above
+{%- endif %}
+{%- if use_env %}
+├── .env        # Secrets (Ignored by git)
+├── .env.example # Template for secrets
+{%- endif %}
+{%- if use_tests %}
+└── tests/      # Unit tests
+{%- endif %}
+{%- else %}
 {{ project_name }}/
 ├── pyproject.toml      # The Single Source of Truth (Dependencies, Metadata)
 ├── uv.lock             # Exact versions lockfile
 ├── .python-version     # Pinned Python version
 ├── src/
+{%- if packages %}
+{%- for pkg in packages %}
+│   └── {{ pkg.clean_name }}/
+│       ├── __init__.py
+{%- if pkg.use_config %}
+│       ├── config.yaml # EDIT THIS for project settings
+│       ├── config.py   # Code that loads the yaml above
+{%- endif %}
+{%- if pkg.use_env %}
+│       ├── .env        # Secrets (Ignored by git)
+│       ├── .env.example # Template for secrets
+{%- endif %}
+{%- if pkg.use_tests %}
+│       └── tests/      # Unit tests
+{%- endif %}
+{%- endfor %}
+{%- else %}
 │   └── {{ package_name }}/
 │       ├── __init__.py
+{%- if has_config %}
 │       ├── config.yaml # EDIT THIS for project settings
 │       ├── config.py   # Code that loads the yaml above
+{%- endif %}
+{%- if use_env %}
+│       ├── .env        # Secrets (Ignored by git)
+│       ├── .env.example # Template for secrets
+{%- endif %}
+{%- if use_tests %}
 │       └── tests/      # Unit tests
-{% if project_type in ['ml', 'dl'] %}
+{%- endif %}
+{%- endif %}
+{%- if project_type in ['ml', 'dl'] %}
 └── notebooks/          # Experimentation (Jupyter)
-{% endif %}
+{%- endif %}
+{%- endif %}
 ```
-
-

viperx-0.9.72/src/viperx/templates/__init__.py.j2

@@ -0,0 +1,8 @@
+{%- if has_config %}
+from .config import SETTINGS, get_config
+{%- if project_type != 'classic' %}
+from .config import get_dataset_path
+{%- endif %}
+{%- endif %}
+
+

{viperx-0.9.49 → viperx-0.9.72}/src/viperx/templates/config.py.j2

@@ -2,12 +2,12 @@ import yaml
 import importlib.resources
 from pathlib import Path
 from typing import Any, Dict
-{% if use_env %}
+{%- if use_env %}
 from dotenv import load_dotenv
 
 # Load Environment Variables from the isolated .env file in this package
 load_dotenv(Path(__file__).parent / ".env")
-{% endif %}
+{%- endif %}
 
 # Load configuration safely whether installed or local
 try:
@@ -28,7 +28,7 @@ def get_config(key: str, default: Any = None) -> Any:
     """Retrieve a value from the globally loaded settings."""
     return SETTINGS.get(key, default)
 
-{% if project_type != 'classic' %}
+{%- if project_type != 'classic' %}
 def get_dataset_path(notebook_name: str, key: str = "datasets", extension: str = ".csv") -> str | None:
     """
     Helper for notebook data loading.
@@ -39,4 +39,4 @@ def get_dataset_path(notebook_name: str, key: str = "datasets", extension: str =
     if not dataset_name:
         return None
     return f"{dataset_name}{extension}"
-{% endif %}
+{%- endif %}

{viperx-0.9.49 → viperx-0.9.72}/src/viperx/templates/config.yaml.j2

@@ -1,7 +1,7 @@
 # Global Project Configuration
 project_name: "{{ project_name }}"
 
-{% if project_type in ['ml', 'dl'] %}
+{%- if project_type in ['ml', 'dl'] %}
 data_urls:
   iris: "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"
   titanic: "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
@@ -11,7 +11,7 @@ datasets:
   Base_Kaggle: "titanic"
   # Usage: kh.dataset_download(SETTINGS['datasets']['titanic'])
   titanic: "heptapod/titanic"
-{% else %}
+{%- else %}
 # Configuration file for {{ package_name }}
 # Add your settings here.
-{% endif %}
+{%- endif %}

{viperx-0.9.49 → viperx-0.9.72}/src/viperx/templates/pyproject.toml.j2

@@ -2,9 +2,9 @@
 name = "{{ project_name }}"
 version = "{{ version }}"
 description = "{{ description }}"
-{% if use_readme %}
+{%- if use_readme %}
 readme = "README.md"
-{% endif %}
+{%- endif %}
 requires-python = ">={{ python_version }}"
 authors = [
     { name = "{{ author_name }}", email = "{{ author_email }}" }

viperx-0.9.49/src/viperx/config_engine.py

@@ -1,199 +0,0 @@
-import yaml
-from pathlib import Path
-from rich.console import Console
-from rich.panel import Panel
-
-from viperx.core import ProjectGenerator
-from viperx.constants import DEFAULT_LICENSE, DEFAULT_BUILDER, TYPE_CLASSIC, TYPE_ML, TYPE_DL, FRAMEWORK_PYTORCH
-
-console = Console()
-
-class ConfigEngine:
-    """
-    Orchestrates project creation and updates based on a declarative YAML config.
-    Implements the 'Infrastructure as Code' pattern for ViperX.
-    """
-    
-    def __init__(self, config_path: Path, verbose: bool = False):
-        self.config_path = config_path
-        self.verbose = verbose
-        self.config = self._load_config()
-        self.root_path = Path.cwd()
-
-    def _load_config(self) -> dict:
-        """Load and validate the YAML configuration."""
-        if not self.config_path.exists():
-            console.print(f"[bold red]Error:[/bold red] Config file not found at {self.config_path}")
-            raise FileNotFoundError(f"Config file not found: {self.config_path}")
-            
-        with open(self.config_path, "r") as f:
-            try:
-                data = yaml.safe_load(f)
-            except yaml.YAMLError as e:
-                console.print(f"[bold red]Error:[/bold red] Invalid YAML format: {e}")
-                raise ValueError("Invalid YAML")
-                
-        # Basic Validation
-        if "project" not in data or "name" not in data["project"]:
-            console.print("[bold red]Error:[/bold red] Config must contain 'project.name'")
-            raise ValueError("Missing project.name")
-            
-        return data
-
-    def apply(self):
-        """Apply the configuration to the current directory."""
-        project_conf = self.config.get("project", {})
-        settings_conf = self.config.get("settings", {})
-        workspace_conf = self.config.get("workspace", {})
-        
-        project_name = project_conf.get("name")
-        
-        # STRICT NAMING: Always calculate the expected root path using sanitized name
-        from viperx.utils import sanitize_project_name
-        clean_name = sanitize_project_name(project_name)
-        
-        # Default assumption: current_root is the target directory (folder with underscores)
-        current_root = self.root_path / clean_name
-        target_dir = current_root
-
-        # 1. Root Project Handling
-        # Heuristic: Are we already in a folder matching the raw name OR sanitized name?
-        # e.g. inside test_classic/
-        if self.root_path.name == project_name or self.root_path.name == clean_name:
-            # We are inside the project folder
-            current_root = self.root_path
-            
-            if not (self.root_path / "pyproject.toml").exists():
-                 console.print(Panel(f"⚠️  [bold yellow]Current directory matches name but is not initialized. Hydrating:[/bold yellow] {project_name}", border_style="yellow"))
-                 gen = ProjectGenerator(
-                    name=project_name,
-                    description=project_conf.get("description", ""),
-                    type=settings_conf.get("type", TYPE_CLASSIC),
-                    author=project_conf.get("author", None),
-                    license=project_conf.get("license", DEFAULT_LICENSE),
-                    builder=project_conf.get("builder", DEFAULT_BUILDER),
-                    use_env=settings_conf.get("use_env", False),
-                    use_config=settings_conf.get("use_config", True),
-                    use_tests=settings_conf.get("use_tests", True),
-                    framework=settings_conf.get("framework", FRAMEWORK_PYTORCH),
-                    scripts={project_name: f"{clean_name}.main:main"}, 
-                    verbose=self.verbose
-                )
-                 gen.generate(self.root_path.parent)
-            else:
-                console.print(Panel(f"♻️  [bold blue]Syncing Project:[/bold blue] {project_name}", border_style="blue"))
-                
-        else:
-            # We are outside
-            # target_dir (clean) is already set as current_root default
-            
-            if target_dir.exists() and (target_dir / "pyproject.toml").exists():
-                console.print(Panel(f"♻️  [bold blue]Updating Existing Project:[/bold blue] {project_name} ({target_dir.name})", border_style="blue"))
-            else:
-                if target_dir.exists():
-                     console.print(Panel(f"⚠️  [bold yellow]Directory exists but not initialized. Hydrating:[/bold yellow] {project_name}", border_style="yellow"))
-                
-                # Prepare Scripts & Dependency Context
-                packages = workspace_conf.get("packages", [])
-                
-                # --- Aggregate Global Dependencies ---
-                root_use_config = settings_conf.get("use_config", True)
-                root_use_env = settings_conf.get("use_env", False)
-                root_type = settings_conf.get("type", TYPE_CLASSIC)
-                root_framework = settings_conf.get("framework", FRAMEWORK_PYTORCH)
-                
-                glob_has_config = root_use_config
-                glob_has_env = root_use_env
-                glob_is_ml_dl = root_type in [TYPE_ML, TYPE_DL]
-                glob_is_dl = root_type == TYPE_DL
-                glob_frameworks = {root_framework} if glob_is_dl else set()
-
-                project_scripts = {project_name: f"{clean_name}.main:main"} # Use clean mapping
-                
-                for pkg in packages:
-                    # Scripts
-                    pkg_name = pkg.get("name")
-                    pkg_name_clean = sanitize_project_name(pkg_name)
-                    project_scripts[pkg_name] = f"{pkg_name_clean}.main:main"
-                    
-                    # Dependency Aggregation
-                    p_config = pkg.get("use_config", settings_conf.get("use_config", True))
-                    p_env = pkg.get("use_env", settings_conf.get("use_env", False))
-                    p_type = pkg.get("type", TYPE_CLASSIC)
-                    p_framework = pkg.get("framework", FRAMEWORK_PYTORCH)
-
-                    if p_config: glob_has_config = True
-                    if p_env: glob_has_env = True
-                    if p_type in [TYPE_ML, TYPE_DL]: glob_is_ml_dl = True
-                    if p_type == TYPE_DL: 
-                         glob_is_dl = True
-                         glob_frameworks.add(p_framework)
-
-                dep_context = {
-                    "has_config": glob_has_config,
-                    "has_env": glob_has_env,
-                    "is_ml_dl": glob_is_ml_dl,
-                    "is_dl": glob_is_dl,
-                    "frameworks": list(glob_frameworks)
-                }
-
-                gen = ProjectGenerator(
-                    name=project_name, # Raw name
-                    description=project_conf.get("description", ""),
-                    type=settings_conf.get("type", TYPE_CLASSIC),
-                    author=project_conf.get("author", None),
-                    license=project_conf.get("license", DEFAULT_LICENSE),
-                    builder=project_conf.get("builder", DEFAULT_BUILDER),
-                    use_env=settings_conf.get("use_env", False),
-                    use_config=settings_conf.get("use_config", True),
-                    use_tests=settings_conf.get("use_tests", True),
-                    framework=settings_conf.get("framework", FRAMEWORK_PYTORCH),
-                    scripts=project_scripts,
-                    dependency_context=dep_context,
-                    verbose=self.verbose
-                )
-                gen.generate(self.root_path)
-                
-                # Verify creation
-                if not current_root.exists():
-                     if (self.root_path / project_name).exists():
-                         current_root = self.root_path / project_name
-                     
-                if self.verbose:
-                     console.print(f"[debug] Project Root resolves to: {current_root}")
-        
-        # 2. Copy Config to Root (Source of Truth)
-        # Only if we aren't reading the one already there
-        system_config_path = current_root / "viperx.yaml"
-        if self.config_path.absolute() != system_config_path.absolute():
-            import shutil
-            shutil.copy2(self.config_path, system_config_path)
-            console.print(f"[dim]Saved configuration to {system_config_path.name}[/dim]")
-
-        # 3. Handle Workspace Packages
-        packages = workspace_conf.get("packages", [])
-        if packages:
-            console.print(f"\\n📦 [bold]Processing {len(packages)} workspace packages...[/bold]")
-            
-            for pkg in packages:
-                pkg_name = pkg.get("name")
-                pkg_path = current_root / "src" / pkg_name.replace("-", "_") # Approximate check
-                
-                # We instantiate a generator for this package
-                pkg_gen = ProjectGenerator(
-                    name=pkg_name,
-                    description=pkg.get("description", ""),
-                    type=pkg.get("type", TYPE_CLASSIC),
-                    author=project_conf.get("author", "Your Name"), # Inherit author
-                    use_env=pkg.get("use_env", settings_conf.get("use_env", False)),     # Inherit settings or default False
-                    use_config=pkg.get("use_config", settings_conf.get("use_config", True)), # Inherit or default True
-                    use_readme=pkg.get("use_readme", False),
-                    use_tests=pkg.get("use_tests", settings_conf.get("use_tests", True)),
-                    framework=pkg.get("framework", FRAMEWORK_PYTORCH),
-                    verbose=self.verbose
-                )
-                
-                # Check if package seems to exist (ProjectGenerator handles upgrade logic too)
-                pkg_gen.add_to_workspace(current_root)
-
-        console.print(Panel(f"✨ [bold green]Configuration Applied Successfully![/bold green]\\nProject is up to date with {self.config_path.name}", border_style="green"))

viperx-0.9.49/src/viperx/templates/__init__.py.j2

@@ -1,8 +0,0 @@
-{% if has_config %}
-from .config import SETTINGS, get_config
-{% if project_type != 'classic' %}
-from .config import get_dataset_path
-{% endif %}
-{% endif %}
-
-