viperx 0.9.5__tar.gz → 0.9.49__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: viperx
-Version: 0.9.5
+Version: 0.9.49
 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
@@ -64,7 +64,7 @@ viperx init -n deep-vision -t dl --framework pytorch
 viperx init -n deep-vision -t dl --framework pytorch
 
 # ✨ Declarative Config (Infrastructure as Code)
-viperx config init                  # Generate template
+viperx config get                   # Generate template
 viperx init -c viperx.yaml          # Apply config
 ```
 
@@ -174,7 +174,7 @@ viperx init -c viperx.yaml
 Manage your project infrastructure using a YAML file.
 
 ```bash
-viperx config init
+viperx config get
 ```
 Generates a `viperx.yaml` template in the current directory.
 

{viperx-0.9.5 → viperx-0.9.49}/README.md

@@ -45,7 +45,7 @@ viperx init -n deep-vision -t dl --framework pytorch
 viperx init -n deep-vision -t dl --framework pytorch
 
 # ✨ Declarative Config (Infrastructure as Code)
-viperx config init                  # Generate template
+viperx config get                   # Generate template
 viperx init -c viperx.yaml          # Apply config
 ```
 
@@ -155,7 +155,7 @@ viperx init -c viperx.yaml
 Manage your project infrastructure using a YAML file.
 
 ```bash
-viperx config init
+viperx config get
 ```
 Generates a `viperx.yaml` template in the current directory.
 

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

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

{viperx-0.9.5 → viperx-0.9.49}/src/viperx/config_engine.py

@@ -4,7 +4,7 @@ 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, FRAMEWORK_PYTORCH
+from viperx.constants import DEFAULT_LICENSE, DEFAULT_BUILDER, TYPE_CLASSIC, TYPE_ML, TYPE_DL, FRAMEWORK_PYTORCH
 
 console = Console()
 
@@ -47,15 +47,22 @@ class ConfigEngine:
         workspace_conf = self.config.get("workspace", {})
         
         project_name = project_conf.get("name")
-        target_dir = self.root_path / project_name
         
-        # 1. Root Project Handling
-        # If we are NOT already in the project dir (checking name), we might need to create it
-        # Or if we are running in the root of where `viperx init` is called.
+        # 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)
         
-        # Heuristic: Are we already in a folder named 'project_name'?
-        if self.root_path.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(
@@ -69,27 +76,69 @@ class ConfigEngine:
                     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
                 )
-                 # generate() expects parent dir, and will operate on parent/name (which is self.root_path)
                  gen.generate(self.root_path.parent)
             else:
                 console.print(Panel(f"♻️  [bold blue]Syncing Project:[/bold blue] {project_name}", border_style="blue"))
-            current_root = self.root_path
+                
         else:
-            # We are outside, check if it exists
+            # 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}", border_style="blue"))
-                current_root = target_dir
+                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"))
-                else:
-                     console.print(Panel(f"🚀 [bold green]Creating New Project:[/bold green] {project_name}", border_style="green"))
                 
-                # Create Root (or Hydrate)
+                # 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,
+                    name=project_name, # Raw name
                     description=project_conf.get("description", ""),
                     type=settings_conf.get("type", TYPE_CLASSIC),
                     author=project_conf.get("author", None),
@@ -99,10 +148,19 @@ class ConfigEngine:
                     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)
-                current_root = target_dir
+                
+                # 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
@@ -115,7 +173,7 @@ class ConfigEngine:
         # 3. Handle Workspace Packages
         packages = workspace_conf.get("packages", [])
         if packages:
-            console.print(f"\n📦 [bold]Processing {len(packages)} workspace packages...[/bold]")
+            console.print(f"\\n📦 [bold]Processing {len(packages)} workspace packages...[/bold]")
             
             for pkg in packages:
                 pkg_name = pkg.get("name")
@@ -129,7 +187,7 @@ class ConfigEngine:
                     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", 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
@@ -138,4 +196,4 @@ class ConfigEngine:
                 # 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"))
+        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.5 → viperx-0.9.49}/src/viperx/constants.py

@@ -33,3 +33,8 @@ PROJECT_TYPES = [TYPE_CLASSIC, TYPE_ML, TYPE_DL]
 FRAMEWORK_PYTORCH = "pytorch"
 FRAMEWORK_TENSORFLOW = "tensorflow"
 DL_FRAMEWORKS = [FRAMEWORK_PYTORCH, FRAMEWORK_TENSORFLOW]
+
+# Builders
+BUILDER_UV = "uv"
+BUILDER_HATCH = "hatch"
+SUPPORTED_BUILDERS = [BUILDER_UV, BUILDER_HATCH]

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

@@ -34,12 +34,32 @@ class ProjectGenerator:
                  license: str = DEFAULT_LICENSE, 
                  builder: str = DEFAULT_BUILDER, 
                  framework: str = "pytorch",
+                 scripts: Optional[dict] = None,
+                 dependency_context: Optional[dict] = None,
                  verbose: bool = False):
         self.raw_name = name
         self.project_name = sanitize_project_name(name)
         self.description = description or name
         self.type = type
         self.framework = framework
+        self.scripts = scripts or {}
+        # Dependency Context (Global workspace features)
+        self.dependency_context = dependency_context or {
+            "has_config": use_config,
+            "has_env": use_env,
+            "is_ml_dl": type in ["ml", "dl"],
+            "is_dl": type == "dl",
+            "frameworks": [framework] if type == "dl" else []
+        }
+        
+        # Default script for the main package if none provided (and it's a root project mostly)
+        self.scripts = scripts or {}
+        # Default script for the main package if none provided (and it's a root project mostly)
+        if not self.scripts:
+             # Key = Raw Name (CLI command, e.g. test-classic)
+             # Value = Sanitized Path (Module, e.g. test_classic.main:main)
+             self.scripts = {self.raw_name: f"{self.project_name}.main:main"}
+             
         self.author = author
         if not self.author or self.author == "Your Name":
              self.author, self.author_email = get_author_from_git()
@@ -54,9 +74,39 @@ class ProjectGenerator:
         self.use_tests = use_tests
         self.verbose = verbose
         
-        # Detect System Python
-        self.python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+        # Detect System Python (For logging/diagnostics)
+        self.system_python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
+        
+        # Project Python Version (For requires-python in pyproject.toml)
+        # Driven by package constants to ensure compatibility/evolution
+        from viperx.constants import DEFAULT_PYTHON_VERSION
+        self.python_version = DEFAULT_PYTHON_VERSION
+        
+        
+        # Validate Choices
+        from viperx.utils import validate_choice, check_builder_installed
+        from viperx.constants import PROJECT_TYPES, DL_FRAMEWORKS, TYPE_DL
         
+        try:
+            validate_choice(self.type, PROJECT_TYPES, "project type")
+            if self.type == TYPE_DL:
+                validate_choice(self.framework, DL_FRAMEWORKS, "framework")
+            
+            # Validate Builder Existence & Support
+            if not check_builder_installed(self.builder):
+                 from viperx.constants import SUPPORTED_BUILDERS
+                 if self.builder not in SUPPORTED_BUILDERS:
+                      console.print(f"[bold red]Error:[/bold red] Invalid builder '[bold]{self.builder}[/bold]'.")
+                      console.print(f"Supported builders: [green]{', '.join(SUPPORTED_BUILDERS)}[/green]")
+                 else:
+                      console.print(f"[bold red]Error:[/bold red] The builder '[bold]{self.builder}[/bold]' is not installed or not in PATH.")
+                      console.print(f"Please install it (e.g., `pip install {self.builder}` or `curl -LsSf https://astral.sh/uv/install.sh | sh` for uv).")
+                 sys.exit(1)
+                 
+        except ValueError as e:
+            console.print(f"[bold red]Configuration Error:[/bold red] {e}")
+            sys.exit(1)
+
         # Jinja Setup
         self.env = Environment(
             loader=PackageLoader("viperx", "templates"),
@@ -67,26 +117,10 @@ class ProjectGenerator:
         if self.verbose:
             console.print(f"  [{style}]{message}[/{style}]")
 
-    def generate(self, target_dir: Optional[Path] = None):
-        """Main generation flow using uv init."""
-        if target_dir is None:
-            target_dir = Path.cwd()
-
-        project_dir = target_dir / self.raw_name
-        
-        if project_dir.exists():
-            console.print(f"[bold red]Error:[/bold red] Directory {project_dir} already exists.")
-            return
-
-        console.print(f"[bold green]Creating project {self.raw_name} ({self.type})...[/bold green]")
-        
-        self.log(f"Target directory: {project_dir}")
-        self.log(f"Python version: {self.python_version}")
-
-
     def generate(self, target_dir: Path, is_subpackage: bool = False):
         """Main generation flow using uv init."""
-        project_dir = target_dir / self.raw_name
+        # STRICT DIRECTORY NAMING: Always use sanitized name
+        project_dir = target_dir / self.project_name
         
         # 1. Scaffolding with uv init
         try:
@@ -102,8 +136,13 @@ class ProjectGenerator:
                 )
             else:
                 # Create new
+                # STRICT DIR NAMING: Use self.project_name (underscores) for directory
+                # But use self.raw_name (hyphens) for the package Name metadata if possible?
+                # uv init [NAME] creates directory NAME.
+                # If we want dir=test_classic but name=test-classic:
+                # uv init test_classic --name test-classic
                 subprocess.run(
-                    ["uv", "init", "--package", "--no-workspace", self.raw_name], 
+                    ["uv", "init", "--package", "--no-workspace", self.project_name, "--name", self.raw_name], 
                     check=True, cwd=target_dir, capture_output=True
                 )
             console.print("  [blue]✓ Scaffolding created with uv init[/blue]")
@@ -112,20 +151,23 @@ class ProjectGenerator:
              return
 
         # 2. Restructure / Clean up
-        # If is_subpackage, convert to Flat Layout
+        # If is_subpackage, convert to Ultra-Flat Layout (Code at Root)
+        # Target: root/__init__.py (and siblings) 
+        # Source: root/src/pkg/__init__.py (from uv init --lib)
         if is_subpackage:
-            src_path = project_dir / "src" / self.project_name
-            flat_path = project_dir / self.project_name
-            if src_path.exists():
-                if flat_path.exists():
-                     import shutil
-                     shutil.rmtree(flat_path)
-                src_path.rename(flat_path)
-                # Remove empty src
-                import shutil
-                if (project_dir / "src").exists():
-                    shutil.rmtree(project_dir / "src")
-                self.log("Converted to Flat Layout (Subpackage)")
+            src_pkg_path = project_dir / "src" / self.project_name
+            import shutil
+            
+            if src_pkg_path.exists():
+                # Move children of src/pkg to root
+                for item in src_pkg_path.iterdir():
+                    shutil.move(str(item), str(project_dir))
+                
+                # Cleanup src/pkg and src
+                shutil.rmtree(src_pkg_path)
+                if (project_dir / "src").exists() and not any((project_dir / "src").iterdir()):
+                     shutil.rmtree(project_dir / "src")
+                self.log("Converted to Ultra-Flat Layout (Code at Root)")
 
         # 3. Create extra directories (First, so templates have target dirs)
         self._create_extra_dirs(project_dir, is_subpackage)
@@ -133,12 +175,26 @@ class ProjectGenerator:
         # 4. Overwrite/Add Files
         self._generate_files(project_dir, is_subpackage)
         
+        
+        # Cleanup extra files for subpackages
+        if is_subpackage:
+            for f in [".gitignore", ".python-version"]:
+                if (project_dir / f).exists():
+                    (project_dir / f).unlink()
+        
         # 5. Git & Final Steps
-        console.print(f"\n[bold green]✓ Project {self.raw_name} created successfully![/bold green]")
+        console.print(f"\n[bold green]✓ Project {self.raw_name} created in {self.project_name}/ successfully![/bold green]")
         if not is_subpackage:
-            console.print(f"  [dim]cd {self.raw_name} && uv sync[/dim]")
+            console.print(f"  [dim]cd {self.project_name} && uv sync[/dim]")
 
     def _create_extra_dirs(self, root: Path, is_subpackage: bool = False):
+        if is_subpackage:
+            # Ultra-Flat Layout: root IS the package root
+            pkg_root = root
+        else:
+            # Standard Layout: root / src / package_name
+            pkg_root = root / SRC_DIR / self.project_name
+            
         # Notebooks for ML/DL (Only for Root Project usually)
         if not is_subpackage and self.type in [TYPE_ML, TYPE_DL]:
             (root / NOTEBOOKS_DIR).mkdir(exist_ok=True)
@@ -149,11 +205,10 @@ class ProjectGenerator:
             # For Flat Layout (Subpackage), tests usually go to `tests/` at root
             # For Src Layout (Root), inside `src/pkg/tests`? 
             # User request: "create dossier tests ... que ce soit au init general ou pour sous package"
-            # Standard practice: `tests/` at project root.
-            # ViperX old behavior: `src/pkg/tests` (Line 137).
-            # Changing to standard `tests/` at project root for BOTH.
-            tests_dir = root / TESTS_DIR
-            tests_dir.mkdir(exist_ok=True)
+            # User request: "tests/ pour le package principal est dans src/name_package/ tout est isolé"
+            # So tests are INSIDE the package.
+            tests_dir = pkg_root / TESTS_DIR
+            tests_dir.mkdir(parents=True, exist_ok=True)
             
             with open(tests_dir / "__init__.py", "w") as f:
                 pass
@@ -177,16 +232,21 @@ class ProjectGenerator:
             "has_config": self.use_config,
             "use_readme": self.use_readme,
             "use_env": self.use_env,
+            "use_env": self.use_env,
             "framework": self.framework,
+            "scripts": self.scripts,
         }
+        # Merge dependency context overrides
+        context.update(self.dependency_context)
         
         # pyproject.toml (Overwrite uv's basic one to add our specific deps)
+        # Even subpackages need this if they are Workspace Members (which they are in our model)
         self._render("pyproject.toml.j2", root / "pyproject.toml", context)
         
         # Determine Package Root
         if is_subpackage:
-            # Flat Layout: root / package_name
-            pkg_root = root / self.project_name
+            # Ultra-Flat Layout: root IS the package root
+            pkg_root = root
         else:
             # Standard Layout: root / src / package_name
             pkg_root = root / SRC_DIR / self.project_name
@@ -201,19 +261,33 @@ class ProjectGenerator:
         self._render("__init__.py.j2", pkg_root / "__init__.py", context)
         
         # README.md
-        if self.use_readme:
-             self._render("README.md.j2", root / "README.md", context)
+        # README.md
+        if not is_subpackage:
+            # Root Project: Respect use_readme
+            if self.use_readme:
+                 self._render("README.md.j2", root / "README.md", context)
+            else:
+                 if (root / "README.md").exists():
+                     (root / "README.md").unlink()
+                     self.log("Removed default README.md (requested --no-readme)")
         else:
-             if (root / "README.md").exists():
+             # Subpackage: Default False, but if True, generate it
+             if self.use_readme:
+                  self._render("README.md.j2", root / "README.md", context)
+             elif (root / "README.md").exists():
+                 # Cleanup default README from uv init if we didn't request one
                  (root / "README.md").unlink()
-                 self.log("Removed default README.md (requested --no-readme)")
+
         
         # LICENSE
-        license_text = LICENSES.get(self.license, LICENSES["MIT"])
-        license_text = license_text.format(year=datetime.now().year, author=self.author)
-        with open(root / "LICENSE", "w") as f:
-            f.write(license_text)
-        self.log(f"Generated LICENSE ({self.license})")
+        if not is_subpackage:
+            license_text = LICENSES.get(self.license, LICENSES["MIT"])
+            license_text = license_text.format(year=datetime.now().year, author=self.author)
+            with open(root / "LICENSE", "w") as f:
+                f.write(license_text)
+            self.log(f"Generated LICENSE ({self.license})")
+        elif (root / "LICENSE").exists():
+            (root / "LICENSE").unlink()
 
         # Config files
         if self.use_config:
@@ -240,10 +314,12 @@ class ProjectGenerator:
             self.log(f"Created .env and .env.example in {pkg_root.relative_to(root)}")
                 
         # .gitignore
-        with open(root / ".gitignore", "a") as f:
-            # Add data/ to gitignore but allow .gitkeep
-            f.write("\n# ViperX specific\n.ipynb_checkpoints/\n# Isolated Env\nsrc/**/.env\n# Data (Local)\ndata/*\n!data/.gitkeep\n")
-        self.log("Updated .gitignore")
+        # Only for Root
+        if not is_subpackage: 
+            with open(root / ".gitignore", "a") as f:
+                # Add data/ to gitignore but allow .gitkeep
+                f.write("\n# ViperX specific\n.ipynb_checkpoints/\n# Isolated Env\nsrc/**/.env\n# Data (Local)\ndata/*\n!data/.gitkeep\n")
+            self.log("Updated .gitignore")
 
     def _render(self, template_name: str, target_path: Path, context: dict):
         template = self.env.get_template(template_name)
@@ -256,57 +332,9 @@ class ProjectGenerator:
         """Add a new package to an existing workspace."""
         console.print(f"[bold green]Adding package {self.raw_name} to workspace...[/bold green]")
         
-        pyproject_path = workspace_root / "pyproject.toml"
-        if not pyproject_path.exists():
-            console.print("[red]Error: Not in a valid project root (pyproject.toml missing).[/red]")
-            return
-            
-        # Read pyproject.toml
-        with open(pyproject_path, "r") as f:
-            content = f.read()
-
-        # Check if it's already a workspace
-        is_workspace = "[tool.uv.workspace]" in content
-        
-        if not is_workspace:
-            console.print("[yellow]Upgrading project to Workspace...[/yellow]")
-            # Append workspace definition
-            with open(pyproject_path, "a") as f:
-                f.write(f"\n[tool.uv.workspace]\nmembers = [\"src/{self.raw_name}\"]\n")
-            self.log("Added [tool.uv.workspace] section")
-        else:
-            # Add member to specific list if it exists
-            # We use a simple regex approach to find 'members = [...]'
-            import re
-            members_pattern = r'members\s*=\s*\[(.*?)\]'
-            match = re.search(members_pattern, content, re.DOTALL)
-            
-            if match:
-                current_members = match.group(1)
-                # Check if already present
-                if f'"{self.raw_name}"' in current_members or f"'{self.raw_name}'" in current_members:
-                    self.log(f"Package {self.raw_name} is already in workspace members.")
-                else:
-                    # Append new member
-                    # We inject it into the list
-                    self.log("Adding member to existing workspace list")
-                    # Naively replace the closing bracket
-                    # Better: parse, but for now robust string insertion
-                    # Cleanest way without breaking formatting involves finding the last element
-                    # Cleanest way without breaking formatting involves finding the last element
-                    new_member = f', "src/{self.raw_name}"'
-                    # Warning: This regex replace is basic. `uv` handles toml well, maybe we should just edit safely.
-                    # Let's try to append to the end of the content of the list
-                    new_content = re.sub(members_pattern, lambda m: f'members = [{m.group(1)}{new_member}]', content, flags=re.DOTALL)
-                    with open(pyproject_path, "w") as f:
-                        f.write(new_content)
-            else:
-                 # Section exists but members key might be missing? Or weird formatting.
-                 # Append to section?
-                 # Safe fallback
-                 console.print("[yellow]Warning: Could not parse members list. Adding manually at end.[/yellow]")
-                 with open(pyproject_path, "a") as f:
-                     f.write(f"\n# Added by viperx\n[tool.uv.workspace]\nmembers = [\"{self.raw_name}\"]\n")
+        # User Request: Do not modify root pyproject.toml to add workspace members.
+        # "uv est assez intelligent"
+        pass
 
         # Generate the package in the root IF it doesn't exist
         pkg_dir = workspace_root / SRC_DIR / self.raw_name

{viperx-0.9.5 → viperx-0.9.49}/src/viperx/main.py

@@ -14,9 +14,14 @@ from viperx.constants import (
     DL_FRAMEWORKS,
     FRAMEWORK_PYTORCH,
 )
-
-HELP_TEXT = """
-[bold green]ViperX[/bold green]: Professional Python Project Initializer
+import importlib.metadata
+try:
+    version = importlib.metadata.version("viperx")
+except importlib.metadata.PackageNotFoundError:
+    version = "unknown"
+    
+HELP_TEXT = f"""
+[bold green]ViperX[/bold green] (v{version}): Professional Python Project Initializer
 .
     
     Automates the creation of professional-grade Python projects using `uv`.
@@ -28,18 +33,30 @@ app = typer.Typer(
     add_completion=False,
     no_args_is_help=True,
     rich_markup_mode="markdown",
-    epilog="Made with ❤️ by KpihX"
+    epilog="Made with ❤️  by KpihX"
 )
 
 # Global state for verbose flag
 state = {"verbose": False}
 console = Console(force_terminal=True)
 
-@app.callback()
+def version_callback(value: bool):
+    if value:
+        console.print(f"ViperX CLI Version: [bold green]{version}[/bold green]")
+        raise typer.Exit()
+
+@app.callback(invoke_without_command=True)
 def cli_callback(
+    ctx: typer.Context,
     verbose: bool = typer.Option(
         False, "-v", "--verbose", 
         help="Enable verbose logging."
+    ),
+    version: bool = typer.Option(
+        None, "--version", "-V",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit."
     )
 ):
     """
@@ -51,10 +68,21 @@ def cli_callback(
     if verbose:
         state["verbose"] = True
         console.print("[dim]Verbose mode enabled[/dim]")
+        
+
+
+
+# Config Management Group (The Main Entry Point)
+config_app = typer.Typer(
+    help="Manage Declarative Configuration (viperx.yaml).",
+    no_args_is_help=False,  # Allow running without subcommands (acts as apply)
+)
+app.add_typer(config_app, name="config")
 
 
-@app.command()
-def init(
+@config_app.callback(invoke_without_command=True)
+def config_main(
+    ctx: typer.Context,
     # --- Config Driven Mode ---
     config: Path = typer.Option(
         None, "--config", "-c",
@@ -84,14 +112,21 @@ def init(
         help=f"DL Framework ({'|'.join(DL_FRAMEWORKS)}). Defaults to pytorch."
     ),
     use_env: bool = typer.Option(True, "--env/--no-env", help="Generate .env file"),
-    use_config: bool = typer.Option(True, "--config/--no-config", help="Generate embedded config"),
+    use_config: bool = typer.Option(True, "--embed-config/--no-embed-config", help="Generate embedded config"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
 ):
     """
-    Initialize a new Python project.
+    **Configure & Initialize**: Apply configuration to create or update a project.
     
-    Can stem from a config file (Declarative) or CLI arguments (Imperative).
+    usage: [bold]viperx config [OPTIONS][/bold]
+           [bold]viperx config get[/bold]
     """
+    # Check if a subcommand (like 'get') is invoked
+    if ctx.invoked_subcommand is not None:
+        return
+
+    # --- Apply Logic (Former Init) ---
+    
     # 1. Declarative Mode
     if config:
         if not config.exists():
@@ -104,6 +139,10 @@ def init(
 
     # 2. Imperative Mode (Validation)
     if not name:
+         # Implicitly show help if no options provided?
+         # Or error out. User expects correct run.
+         # If user runs `viperx config` with NO args, and NO config, what happens?
+         # "Missing option name".
          console.print("[bold red]Error:[/bold red] Missing option '--name' / '-n'. Required in manual mode.")
          raise typer.Exit(code=1)
 
@@ -113,6 +152,13 @@ def init(
 
     console.print(Panel(f"Initializing [bold blue]{name}[/bold blue]", border_style="blue"))
     
+    # Check if target directory (sanitized) exists
+    from viperx.utils import sanitize_project_name
+    name_clean = sanitize_project_name(name)
+    target_dir = Path.cwd() / name_clean
+    if target_dir.exists():
+         console.print(f"[bold yellow]Warning:[/bold yellow] Directory {name_clean} already exists. Updating.")
+    
     generator = ProjectGenerator(
         name=name,
         description=description,
@@ -129,19 +175,15 @@ def init(
     # Generate in current directory
     generator.generate(Path.cwd())
 
-# Config Management Group
-config_app = typer.Typer(
-    help="Manage Declarative Configuration (viperx.yaml).",
-    no_args_is_help=True
-)
-app.add_typer(config_app, name="config")
 
-@config_app.command("init")
-def config_init(
+
+
+@config_app.command("get")
+def config_get(
     filename: Path = typer.Option("viperx.yaml", "--output", "-o", help="Output filename")
 ):
     """
-    Generate a template viperx.yaml configuration file.
+    Get the default configuration template (viperx.yaml).
     Use this to start a 'Project as Code' workflow.
     """
     from viperx.constants import TEMPLATES_DIR
@@ -184,8 +226,8 @@ def package_add(
         help=f"DL Framework ({'|'.join(DL_FRAMEWORKS)}). Defaults to pytorch."
     ),
     use_env: bool = typer.Option(True, "--env/--no-env", help="Generate .env file"),
-    use_config: bool = typer.Option(True, "--config/--no-config", help="Generate embedded config"),
-    use_readme: bool = typer.Option(True, "--readme/--no-readme", help="Generate README.md"),
+    use_config: bool = typer.Option(True, "--embed-config/--no-embed-config", help="Generate embedded config"),
+    use_readme: bool = typer.Option(False, "--readme/--no-readme", help="Generate README.md"),
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable verbose logging"),
 ):
     """
@@ -248,4 +290,18 @@ def package_update(
     generator.update_package(Path.cwd())
 
 if __name__ == "__main__":
-    app()
+    try:
+        app()
+    except SystemExit as e:
+        if e.code != 0:
+            # On error (non-zero exit), display help as requested
+            from typer.main import get_command
+            import click
+            cli = get_command(app)
+            # Create a dummy context to render help
+            # We print it to stderr or stdout? Console prints to stdout usually.
+            # User wants it displayed immediately.
+            with click.Context(cli) as ctx:
+                 console.print("\n")
+                 console.print(cli.get_help(ctx))
+            raise

viperx-0.9.49/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.5 → viperx-0.9.49}/src/viperx/templates/config.py.j2

@@ -28,6 +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' %}
 def get_dataset_path(notebook_name: str, key: str = "datasets", extension: str = ".csv") -> str | None:
     """
     Helper for notebook data loading.
@@ -38,3 +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 %}

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

@@ -1,3 +1,6 @@
+# Global Project Configuration
+project_name: "{{ project_name }}"
+
 {% if project_type in ['ml', 'dl'] %}
 data_urls:
   iris: "https://raw.githubusercontent.com/mwaskom/seaborn-data/master/iris.csv"

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

@@ -0,0 +1,13 @@
+{%- if has_config %}
+from {{ package_name }} import SETTINGS
+{%- endif %}
+
+def main():
+    {%- if has_config %}
+    print(f"Hi from {SETTINGS['project_name']}!")
+    {%- else %}
+    print("Hi from viperx!")
+    {%- endif %}
+
+if __name__ == "__main__":
+    main()

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

@@ -11,10 +11,14 @@ authors = [
 ]
 license = { text = "{{ license }}" }
 dependencies = [
+    {%- if has_config %}
     "pyyaml>=6.0",
+    {%- endif %}
+    {%- if has_env %}
     "python-dotenv>=1.0.0",
+    {%- endif %}
+    {%- if is_ml_dl %}
     "kagglehub>=0.2.0",
-    {% if project_type == 'ml' %}
     "numpy>=1.24.0",
     "pandas>=2.0.0",
     "scikit-learn>=1.3.0",
@@ -22,29 +26,32 @@ dependencies = [
     "seaborn>=0.12.0",
     "requests>=2.30.0",
     "tqdm>=4.65.0",
-    {% elif project_type == 'dl' %}
-    {% if framework == 'pytorch' %}
+    {%- endif %}
+    {%- if is_dl %}
+    {%- if 'pytorch' in frameworks %}
     "torch>=2.0.0",
     "torchvision>=0.15.0",
-    {% elif framework == 'tensorflow' %}
+    {%- endif %}
+    {%- if 'tensorflow' in frameworks %}
     "tensorflow>=2.13.0",
     # "keras>=3.0.0", # Optional, included in tf usually
-    {% endif %}
-    "numpy>=1.24.0",
-    "pandas>=2.0.0",
-    "matplotlib>=3.7.0",
-    "seaborn>=0.12.0",
-    "requests>=2.30.0",
-    "tqdm>=4.65.0",
-    {% endif %}
+    {%- endif %}
+    {%- endif %}
 ]
 
+[project.scripts]
+{%- for name, entry in scripts.items() %}
+{{ name }} = "{{ entry }}"
+{%- endfor %}
+
 [build-system]
+{%- if builder == 'hatch' %}
 requires = ["hatchling"]
 build-backend = "hatchling.build"
+{%- else %}
+# Default: uv native build backend
+requires = ["uv_build>=0.9.21,<0.10.0"]
+build-backend = "uv_build"
+{%- endif %}
 
-{% if use_uv %}
-[tool.uv]
-managed = true
-{% endif %}
 

{viperx-0.9.5 → viperx-0.9.49}/src/viperx/templates/viperx_config.yaml.j2

@@ -10,7 +10,7 @@ project:
   
   # [Optional] Defaults (Inferred from git/system if omitted)
   # description: "My robust project"
-  # author: "KpihX"
+  # author: "Nameless"
   # license: "MIT"
   # builder: "uv"
 
@@ -36,14 +36,11 @@ workspace:
   # Define workspace members (Monorepo / Utility Packages).
   # These are minimal packages created at the workspace root (Flat Layout).
   packages:
-    # --- Example 1: Shared Utilities ---
-    # - name: "shared-utils"
-    #   description: "Common tools"
-    #   # Defaults: use_env=false, use_config=true, use_tests=true
-      
-    # --- Example 2: AI Submodule ---
-    # - name: "vision-core"
-    #   type: "dl"
-    #   framework: "pytorch"
-    #   use_env: true  # Override default
+    # --- Example 1: Preprocess Package ---
+    # - name: "preprocess"
+    #   description: "reprocessing utilities"
+    #   use_env: false
+    #   use_config: true
+    #   use_tests: true
+    #   use_readme: false
 

viperx-0.9.49/src/viperx/utils.py

@@ -0,0 +1,78 @@
+import re
+import shutil
+from rich.console import Console
+
+console = Console()
+
+def check_uv_installed() -> bool:
+    """Check if 'uv' is installed and accessible."""
+    return shutil.which("uv") is not None
+
+def sanitize_project_name(name: str) -> str:
+    """
+    Sanitize the project name to be a valid Python package name.
+    Replaces hyphens with underscores and removes invalid characters.
+    """
+    # Replace - with _
+    name = name.replace("-", "_")
+    # Remove any characters that aren't alphanumerics or underscores
+    name = re.sub(r"[^a-zA-Z0-9_]", "", name)
+    # Ensure it starts with a letter or underscore
+    if not re.match(r"^[a-zA-Z_]", name):
+        name = f"_{name}"
+    return name.lower()
+
+def validate_project_name(ctx, param, value):
+    """
+    Typer callback to validate project name.
+    """
+    if not re.match(r"^[a-zA-Z0-9_-]+$", value):
+        from typer import BadParameter
+        raise BadParameter("Project name must contain only letters, numbers, underscores, and hyphens.")
+    return value
+
+from viperx.constants import SUPPORTED_BUILDERS
+
+def validate_choice(value: str, choices: list[str], name: str):
+    """
+    Validate that a value is within the allowed choices.
+    Raises ValueError with a friendly message if invalid.
+    """
+    if value not in choices:
+        raise ValueError(f"Invalid {name} '{value}'. Allowed: {', '.join(choices)}")
+    return value
+
+def check_builder_installed(builder: str) -> bool:
+    """
+    Check if the specified builder is valid AND installed.
+    Uses shutil.which() for robust path detection.
+    """
+    # 1. Validate against supported list
+    if builder not in SUPPORTED_BUILDERS:
+        return False
+        
+    # 2. Check existence
+    return shutil.which(builder) is not None
+
+def get_author_from_git() -> tuple[str, str]:
+    """
+    Attempt to get author name and email from git config.
+    Returns (name, email) or defaults.
+    """
+    try:
+        # Check if git is installed first
+        if not shutil.which("git"):
+             return "Nameless", "nameless@example.com"
+             
+        import git
+        # Robust way using git command wrapper
+        reader = git.Git().config
+        name = reader("--global", "--get", "user.name")
+        email = reader("--global", "--get", "user.email")
+        
+        # strip newlines if any
+        return (name.strip() if name else "Nameless", 
+                email.strip() if email else "nameless@example.com")
+    except Exception:
+        # Fallback if git call fails
+        return "Nameless", "nameless@example.com"

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

@@ -1,8 +0,0 @@
-{% if has_config %}
-from .config import SETTINGS, get_config, get_dataset_path
-{% endif %}
-
-__version__ = "{{ version }}"
-
-def hello():
-    print(f"Hello from {{ project_name }} v{__version__}!")

viperx-0.9.5/src/viperx/templates/main.py.j2

@@ -1,13 +0,0 @@
-from {{ package_name }} import hello
-{% if has_config %}
-from {{ package_name }} import SETTINGS
-{% endif %}
-
-def main():
-    hello()
-    {% if has_config %}
-    print(f"Project config loaded: {SETTINGS['project_name']}")
-    {% endif %}
-
-if __name__ == "__main__":
-    main()

viperx-0.9.5/src/viperx/utils.py

@@ -1,47 +0,0 @@
-import re
-import shutil
-import subprocess
-from rich.console import Console
-
-console = Console()
-
-def check_uv_installed() -> bool:
-    """Check if 'uv' is installed and accessible."""
-    return shutil.which("uv") is not None
-
-def sanitize_project_name(name: str) -> str:
-    """
-    Sanitize the project name to be a valid Python package name.
-    Replaces hyphens with underscores and removes invalid characters.
-    """
-    # Replace - with _
-    name = name.replace("-", "_")
-    # Remove any characters that aren't alphanumerics or underscores
-    name = re.sub(r"[^a-zA-Z0-9_]", "", name)
-    # Ensure it starts with a letter or underscore
-    if not re.match(r"^[a-zA-Z_]", name):
-        name = f"_{name}"
-    return name.lower()
-
-def validate_project_name(ctx, param, value):
-    """
-    Typer callback to validate project name.
-    """
-    if not re.match(r"^[a-zA-Z0-9_-]+$", value):
-        from typer import BadParameter
-        raise BadParameter("Project name must contain only letters, numbers, underscores, and hyphens.")
-    return value
-
-def get_author_from_git() -> tuple[str, str]:
-    """
-    Attempt to get author name and email from git config.
-    Returns (name, email) or defaults.
-    """
-    try:
-        import git
-        config = git.GitConfigParser(git.GitConfigParser.get_global_config(), read_only=True)
-        name = config.get("user", "name", fallback="Your Name")
-        email = config.get("user", "email", fallback="your.email@example.com")
-        return name, email
-    except Exception:
-        return "Your Name", "your.email@example.com"