LbAPLocal 0.10.0__tar.gz → 0.10.2__tar.gz

{lbaplocal-0.10.0 → lbaplocal-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LbAPLocal
-Version: 0.10.0
+Version: 0.10.2
 Summary: Tool to locally run tests for AnalysisProductions
 Author: LHCb
 Project-URL: Homepage, https://gitlab.cern.ch/lhcb-dpa/analysis-productions/lbaplocal

{lbaplocal-0.10.0 → lbaplocal-0.10.2}/pyproject.toml

@@ -99,17 +99,19 @@ src_paths = ["src", "tests"]
 
 [tool.pixi.workspace]
 channels = ["conda-forge"]
-platforms = ["linux-64"]
+platforms = ["linux-64", "osx-arm64"]
 
 [tool.pixi.dependencies]
 python = ">=3.12,<3.13"
 pip = "*"
-python-gfal2 = "*"
 textual-plotext = "*"
 nodejs = "*"
+quickjs = "*"
+python-gfal2 = "*"
 m2crypto = ">=0.38.0"
+
+[tool.pixi.target.linux-64.dependencies]
 prmon = "*"
-quickjs = "*"
 
 [tool.pixi.pypi-dependencies]
 LbAPLocal = { path = ".", editable = true }
@@ -129,6 +131,14 @@ test = "pytest"
 lint = "pre-commit run --all-files"
 pre-commit-install = "pre-commit install"
 
+[tool.pixi.feature.lint.dependencies]
+python = ">=3.12,<3.13"
+pre-commit = "*"
+ruff = "*"
+
+[tool.pixi.feature.lint.tasks]
+lint = "pre-commit run --all-files"
+
 [tool.pixi.tasks]
 lb-ap = "lb-ap"
 slice-dst = "lb-run LHCb/v58r2 lbexec GaudiConf.mergeDST:dst"
@@ -138,3 +148,4 @@ reslice-fixture = "python tests/reslice_fixture.py"
 [tool.pixi.environments]
 default = { solve-group = "default" }
 testing = { features = ["testing"], solve-group = "default" }
+lint = { features = ["lint"], no-default-feature = true }

{lbaplocal-0.10.0 → lbaplocal-0.10.2}/src/LbAPLocal/cli/main.py

@@ -20,6 +20,7 @@ import importlib.metadata
 import json
 import os
 import random
+import re
 import shlex
 import shutil
 import subprocess
@@ -32,7 +33,6 @@ from typing import Annotated, Optional
 import click
 import typer
 import yaml
-from LbAPCommon import parse_yaml, render_yaml
 from packaging.version import InvalidVersion, Version
 from rich.console import Console
 from rich.live import Live
@@ -44,11 +44,11 @@ from rich.text import Text
 from rich.tree import Tree
 
 from LbAPLocal.job_slice import run_minimal_reproducer
+from LbAPLocal.models import RepoType
 
+from ..handlers import get_handler
 from ..utils import (
     LBAPI_HOST,
-    available_productions,
-    check_production,
     inside_ap_datapkg,
     logging_subprocess_run,
     production_to_versions,
@@ -412,14 +412,6 @@ class CloneType(str, Enum):
     KRB5 = "krb5"
 
 
-class RepoType(str, Enum):
-    """Repository types supported by lb-ap"""
-
-    ANA_PROD = "ana-prod"
-    MC = "mc"
-    RAD = "rad"
-
-
 @dataclass(frozen=True)
 class RepoConfig:
     """Configuration for a datapkg repository"""
@@ -1368,6 +1360,41 @@ def clone(
             new_branch = params["branch_name"]
             clone_type = CloneType(params["clone_type"])
 
+    # Validate argument count: only 0, 1, or 4 positional args are valid
+    n_args = sum(
+        x is not None for x in [branch_or_wg, production_name, version, new_branch]
+    )
+    if n_args == 2:
+        err_console.print(
+            "[bold red]✗ Invalid arguments:[/bold red] clone expects either "
+            "1 argument (branch mode) or 4 arguments (production mode).\n\n"
+            "[cyan]Usage:[/cyan]\n"
+            "  lb-ap clone my-branch                              # Branch mode\n"
+            "  lb-ap clone <wg> <production> <version> <branch>   # Production mode\n"
+            "  lb-ap clone                                        # Interactive wizard"
+        )
+        raise typer.Exit(code=1)
+    if n_args == 3:
+        version_re = re.compile(r"v\d+r\d+(?:p\d+)?$")
+        if version_re.match(branch_or_wg):
+            err_console.print(
+                "[bold red]✗ Invalid arguments:[/bold red] it looks like the "
+                "arguments may be in the wrong order.\n\n"
+                "[cyan]Expected order:[/cyan]\n"
+                "  lb-ap clone <working-group> <production> <version> <new-branch>\n\n"
+                f"[cyan]Did you mean:[/cyan]\n"
+                f"  lb-ap clone {production_name} {version} {branch_or_wg} <new-branch>"
+            )
+        else:
+            err_console.print(
+                "[bold red]✗ Invalid arguments:[/bold red] production mode requires "
+                "4 arguments but only 3 were given.\n\n"
+                "[cyan]Usage:[/cyan]\n"
+                f"  lb-ap clone {branch_or_wg} {production_name} {version} <new-branch>\n\n"
+                "The 4th argument is the name of the new branch to create."
+            )
+        raise typer.Exit(code=1)
+
     # Determine mode: branch clone vs production checkout
     is_production_mode = all([production_name, version, new_branch])
 
@@ -1657,8 +1684,10 @@ def list_productions(
         lb-ap list MyAnalysis
         lb-ap list MyAnalysis --tree
     """
+    handler = get_handler(state.repo_type)
+
     try:
-        inside_ap_datapkg(state.repo_config.xenv_file)
+        handler.check_directory()
     except Exception as e:
         err_console.print(
             f"[bold red]✗ Not in {state.repo_config.name} directory:[/bold red] {e}"
@@ -1667,21 +1696,18 @@ def list_productions(
 
     if production_name:
         # List jobs for specific production
-        try:
-            check_production(production_name)
-        except Exception as e:
-            err_console.print(f"[bold red]✗ Production not found:[/bold red] {e}")
+        productions = handler.list_productions()
+        if production_name not in productions:
+            err_console.print(
+                f"[bold red]✗ Production not found:[/bold red] {production_name}"
+            )
             raise typer.Exit(code=1)
 
-        # Parse info.yaml
-        info_yaml_path = Path(production_name) / "info.yaml"
-        with open(info_yaml_path, "rt") as fp:
-            raw_yaml = fp.read()
-        job_data = parse_yaml(render_yaml(raw_yaml))
+        job_names = handler.list_jobs(production_name)
 
         if show_tree:
             tree = Tree(f"[bold cyan]{production_name}[/bold cyan]")
-            for job_name in job_data:
+            for job_name in job_names:
                 tree.add(f"[green]{job_name}[/green]")
             console.print(tree)
         else:
@@ -1693,24 +1719,19 @@ def list_productions(
             table.add_column("Job Name", style="green", no_wrap=True)
             table.add_column("Status", style="yellow")
 
-            for job_name in job_data:
+            for job_name in job_names:
                 table.add_row(job_name, "✓ Available")
 
             console.print(table)
     else:
         # List all productions
-        productions = list(available_productions())
+        productions = handler.list_productions()
 
         if show_tree:
             tree = Tree(f"[bold cyan]📂 {state.repo_config.name}[/bold cyan]")
             for folder in productions:
-                # Count jobs for tree view
                 try:
-                    info_yaml_path = Path(folder) / "info.yaml"
-                    with open(info_yaml_path, "rt") as fp:
-                        raw_yaml = fp.read()
-                    job_data = parse_yaml(render_yaml(raw_yaml))
-                    job_count = len(job_data)
+                    job_count = len(handler.list_jobs(folder))
                     tree.add(f"[green]{folder}[/green] [dim]({job_count} jobs)[/dim]")
                 except Exception:
                     tree.add(f"[green]{folder}[/green] [dim](? jobs)[/dim]")
@@ -1726,16 +1747,11 @@ def list_productions(
             table.add_column("Status", style="yellow")
 
             for folder in productions:
-                # Count jobs in each production
                 try:
-                    info_yaml_path = Path(folder) / "info.yaml"
-                    with open(info_yaml_path, "rt") as fp:
-                        raw_yaml = fp.read()
-                    job_data = parse_yaml(render_yaml(raw_yaml))
-                    job_count = len(job_data)
+                    job_count = len(handler.list_jobs(folder))
                     table.add_row(folder, str(job_count), "✓ Available")
                 except Exception:
-                    table.add_row(folder, "?", "⚠ Error reading info.yaml")
+                    table.add_row(folder, "?", "⚠ Error reading jobs")
 
             console.print(table)
 
@@ -1835,11 +1851,12 @@ def test(
     """
     # Handle dry-run mode first with custom logic
     if dry_run:
+        handler = get_handler(state.repo_type)
         # Get available productions for wizard
         productions_list = None
         try:
-            inside_ap_datapkg(state.repo_config.xenv_file)
-            productions_list = list(available_productions())
+            handler.check_directory()
+            productions_list = handler.list_productions()
         except Exception:
             pass
 
@@ -1853,8 +1870,9 @@ def test(
             job_name = params["job_name"]
 
         try:
-            inside_ap_datapkg(state.repo_config.xenv_file)
-            check_production(production_name)
+            handler.check_directory()
+            if production_name not in handler.list_productions():
+                raise RuntimeError(f"Can't find production {production_name}")
         except Exception as e:
             err_console.print(f"[bold red]✗ Error:[/bold red] {e}")
             raise typer.Exit(code=1)
@@ -3489,11 +3507,12 @@ def cwl_generate(
         lb-ap cwl generate MyAnalysis MyJob
         lb-ap cwl generate MyAnalysis MyJob -o ./cwl_output
     """
+    handler = get_handler(state.repo_type)
     # Get available productions for wizard
     productions_list = None
     try:
-        inside_ap_datapkg(state.repo_config.xenv_file)
-        productions_list = list(available_productions())
+        handler.check_directory()
+        productions_list = handler.list_productions()
     except Exception:
         pass
 
@@ -3683,11 +3702,12 @@ def cwl_test(
         lb-ap cwl test MyAnalysis MyJob --executor toil-cwl-runner
     """
     executor = "dirac-cwl-run"  # Default executor
+    handler = get_handler(state.repo_type)
     # Get available productions for wizard
     productions_list = None
     try:
-        inside_ap_datapkg(state.repo_config.xenv_file)
-        productions_list = list(available_productions())
+        handler.check_directory()
+        productions_list = handler.list_productions()
     except Exception:
         pass
 
@@ -3704,8 +3724,9 @@ def cwl_test(
         skip_validation = params.get("skip_validation", skip_validation)
 
     try:
-        inside_ap_datapkg(state.repo_config.xenv_file)
-        check_production(production_name)
+        handler.check_directory()
+        if production_name not in handler.list_productions():
+            raise RuntimeError(f"Can't find production {production_name}")
     except Exception as e:
         err_console.print(f"[bold red]✗ Error:[/bold red] {e}")
         raise typer.Exit(code=1)
@@ -3743,108 +3764,18 @@ def cwl_test(
         )
     )
 
-    # Step 1: Generate DIRAC production request YAML using LbAPCommon
+    # Step 1: Generate DIRAC production request YAML
     console.print(
         "\n[bold cyan]Step 1/3: Generating DIRAC production request YAML[/bold cyan]"
     )
 
-    # Read and render the info.yaml to check job exists
-    info_yaml_path = Path(production_name) / "info.yaml"
-    if not info_yaml_path.exists():
-        err_console.print(
-            f"[bold red]✗ info.yaml not found:[/bold red] {info_yaml_path}"
-        )
-        raise typer.Exit(code=1)
-
-    # Quick check that job exists
-    from LbAPCommon import parse_yaml, render_yaml
-
-    raw_yaml = info_yaml_path.read_text()
-    rendered = render_yaml(raw_yaml)
-    jobs_data = parse_yaml(rendered, production_name, None)
-
-    if job_name not in jobs_data:
-        available_jobs = list(jobs_data.keys())
-        err_console.print(
-            f"[bold red]✗ Job '{job_name}' not found in production '{production_name}'[/bold red]\n"
-            f"Available jobs: {', '.join(available_jobs)}"
-        )
-        raise typer.Exit(code=1)
-
-    # Use LbAPCommon's main function to generate proper DIRAC production request
-    # This queries DIRAC for input metadata and creates the full production structure
-    import asyncio
-    import json
-
-    from LbAPCommon.__main__ import main as lbapcommon_main
-
-    console.print("[cyan]Querying DIRAC for job metadata...[/cyan]")
-
-    # Store metadata in output directory for inspection
-    metadata_path = output_dir / "dirac_metadata.json"
-
     try:
-        # Run LbAPCommon main to generate production request
-        # Use --only-include to generate just the job we want
-        asyncio.run(
-            lbapcommon_main(
-                production_name=production_name,
-                ap_pkg_version="v999999999999",  # Test version
-                input_file=info_yaml_path,
-                output_file=metadata_path,
-                server_credentials=None,
-                only_include=job_name,
-                dump_requests=True,  # This creates the YAML file we need
-            )
-        )
-
-        # Read the generated metadata
-        with open(metadata_path, "r") as f:
-            metadata = json.load(f)
-
-        # Find the production request YAML that was dumped
-        # dump_requests creates files named after the production
-        productions = metadata.get("productions", {})
-        if not productions:
-            err_console.print("[bold red]✗ No productions generated[/bold red]")
-            raise typer.Exit(code=1)
-
-        # Get the first (and should be only) production
-        prod_key = list(productions.keys())[0]
-        production_data = productions[prod_key]
-
-        console.print(f"[green]✓ Generated production:[/green] {prod_key}")
-        console.print(
-            f"[dim]Request chain: {' → '.join([s['name'].split('#')[-1] for s in production_data['request']])}[/dim]"
+        prod_yaml_path = handler.generate_request_yaml(
+            production_name, job_name, output_dir
         )
-
-        # The dump_requests option creates a YAML file with the request
-        # Look for it in the current directory (where metadata was written)
-        request_yaml_path = metadata_path.with_name(prod_key).with_suffix(".yaml")
-
-        if not request_yaml_path.exists():
-            # If dump wasn't created, save it ourselves
-            request_yaml_path = output_dir / f"{prod_key}.yaml"
-            with open(request_yaml_path, "w") as f:
-                yaml.dump(
-                    production_data["request"],
-                    f,
-                    default_flow_style=False,
-                    sort_keys=False,
-                )
-        else:
-            # Move the dumped file to output directory if needed
-            if request_yaml_path.parent != output_dir:
-                final_yaml_path = output_dir / f"{prod_key}.yaml"
-                shutil.move(str(request_yaml_path), str(final_yaml_path))
-                request_yaml_path = final_yaml_path
-
-        prod_yaml_path = request_yaml_path
         console.print(
-            f"[green]✓ Saved DIRAC production request:[/green] {prod_yaml_path.name}"
+            f"[green]✓ Generated production request:[/green] {prod_yaml_path.name}"
         )
-        console.print(f"[green]✓ Saved metadata:[/green] {metadata_path.name}")
-
     except Exception as e:
         err_console.print(
             f"[bold red]✗ DIRAC production request generation failed:[/bold red] {e}"
@@ -4076,14 +4007,24 @@ def cwl_test(
 
     # Set up lb-run environment for local AnalysisProductions testing
     # This creates a fake siteroot so lb-run can find AnalysisProductions.v999999999999 locally
+    import asyncio
     import os
 
     from LbAPCommon.hacks import project_uses_cmt, setup_lbrun_environment
 
-    # Parse application info to check if CMT is needed
-    application_name, application_version = jobs_data[job_name]["application"].rsplit(
-        "/", 1
-    )
+    # Parse application info from the generated production request YAML
+    with open(prod_yaml_path) as _f:
+        _prod_request = yaml.safe_load(_f)
+    if isinstance(_prod_request, list):
+        _prod_request = _prod_request[0]
+    # For AP: "application" key in request steps; for Simulation: first step's application
+    if "steps" in _prod_request:
+        _app = _prod_request["steps"][0]["application"]
+        application_name = _app["name"]
+        application_version = _app["version"]
+    else:
+        _app_str = _prod_request.get("application", "Unknown/v1")
+        application_name, application_version = _app_str.rsplit("/", 1)
     if "@" in application_version:
         application_version = application_version.split("@", 1)[0]
     require_cmt = project_uses_cmt(application_name, application_version)
@@ -4120,15 +4061,19 @@ def cwl_test(
             ap_dynamic_dir.unlink()
     ap_dynamic_dir.symlink_to(dynamic_dir.resolve())
 
-    # Create files in dynamic
-    # Note: prod_key may be a grouped name like "job1,job2" while job_name is just "job1"
-    for filename, content in (
-        metadata["productions"][prod_key].get("dynamic_files", {}).items()
-    ):
-        file_path = dynamic_dir / filename
-        file_path.parent.mkdir(parents=True, exist_ok=True)
-        file_path.write_text(content)
-        console.print(f"[green]✓ Created dynamic file:[/green] {file_path}")
+    # Create files in dynamic (AP-specific: from dirac_metadata.json if present)
+    metadata_path = output_dir / "dirac_metadata.json"
+    if metadata_path.exists():
+        import json
+
+        with open(metadata_path) as _mf:
+            _metadata = json.load(_mf)
+        for _pk, _pv in _metadata.get("productions", {}).items():
+            for filename, content in _pv.get("dynamic_files", {}).items():
+                file_path = dynamic_dir / filename
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                file_path.write_text(content)
+                console.print(f"[green]✓ Created dynamic file:[/green] {file_path}")
 
     # Create a custom environment dict with the lb-run setup to pass to subprocess
     # This ensures CMAKE_PREFIX_PATH and other variables are set for the CWL executor

{lbaplocal-0.10.0 → lbaplocal-0.10.2}/src/LbAPLocal/cli/wizards.py

@@ -614,18 +614,16 @@ def generate_wizard(seen_welcome: bool = False) -> dict:
         )
 
     wg_validator = prompt_toolkit.validation.Validator.from_callable(
-        lambda wg: wg.upper() in [k.upper() for k in known_working_groups]
-    )
-    wg_completer = prompt_toolkit.completion.WordCompleter(
-        known_working_groups, ignore_case=True
+        lambda wg: wg in known_working_groups
     )
+    wg_completer = prompt_toolkit.completion.FuzzyWordCompleter(known_working_groups)
 
     wg = prompt_toolkit.prompt(
         "Enter working group: ",
         default=detected_wg,
         completer=wg_completer,
         validator=wg_validator,
-    ).upper()
+    )
 
     console.print(f"\n[bold cyan]Step {step}: Review[/bold cyan]")
 

lbaplocal-0.10.2/src/LbAPLocal/handlers/__init__.py

@@ -0,0 +1,63 @@
+###############################################################################
+# (c) Copyright 2026 CERN for the benefit of the LHCb Collaboration          #
+#                                                                             #
+# This software is distributed under the terms of the GNU General Public      #
+# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".  #
+#                                                                             #
+# In applying this licence, CERN does not waive the privileges and immunities #
+# granted to it by virtue of its status as an Intergovernmental Organization  #
+# or submit itself to any jurisdiction.                                       #
+###############################################################################
+"""Production handler protocol and registry.
+
+Different production types (AnalysisProductions, MC Requests, RadProductions)
+have different repository layouts, config formats, and parsing pipelines.
+Handlers encapsulate these differences behind a common interface so the CLI
+can work with any production type.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Protocol
+
+from LbAPLocal.models import RepoType
+
+from .anaprod import APHandler
+from .mc_request import MCHandler
+
+
+class ProductionHandler(Protocol):
+    """Interface for production-type-specific logic."""
+
+    def check_directory(self) -> None:
+        """Verify CWD is the correct repo type. Raises on failure."""
+        ...
+
+    def list_productions(self) -> list[str]:
+        """Return available production/directory names."""
+        ...
+
+    def list_jobs(self, production: str) -> list[str]:
+        """Return job identifiers within a production."""
+        ...
+
+    def generate_request_yaml(
+        self, production: str, job: str, output_dir: Path
+    ) -> Path:
+        """Generate a Stage 6 DIRAC production request YAML.
+
+        Returns the path to the generated file in output_dir.
+        """
+        ...
+
+
+_HANDLERS: dict[RepoType, ProductionHandler] = {
+    RepoType.ANA_PROD: APHandler(),
+    RepoType.MC: MCHandler(),
+}
+
+
+def get_handler(repo_type: RepoType) -> ProductionHandler:
+    """Return the handler for the given repo type."""
+    return _HANDLERS[repo_type]

lbaplocal-0.10.2/src/LbAPLocal/handlers/anaprod.py

@@ -0,0 +1,100 @@
+###############################################################################
+# (c) Copyright 2026 CERN for the benefit of the LHCb Collaboration          #
+#                                                                             #
+# This software is distributed under the terms of the GNU General Public      #
+# Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".  #
+#                                                                             #
+# In applying this licence, CERN does not waive the privileges and immunities #
+# granted to it by virtue of its status as an Intergovernmental Organization  #
+# or submit itself to any jurisdiction.                                       #
+###############################################################################
+"""AnalysisProductions handler.
+
+Extracts AP-specific logic from cli/main.py: directory validation, production
+discovery via info.yaml, job listing via LbAPCommon parse_yaml, and DIRAC
+production request generation via LbAPCommon.__main__.main().
+"""
+
+from __future__ import annotations
+
+import asyncio
+import glob
+import json
+import shutil
+from os.path import dirname
+from pathlib import Path
+
+import yaml
+
+from LbAPLocal.utils import inside_ap_datapkg
+
+
+class APHandler:
+    """Handler for AnalysisProductions repositories."""
+
+    def __init__(self, xenv_file: str = "AnalysisProductions.xenv"):
+        self.xenv_file = xenv_file
+
+    def check_directory(self) -> None:
+        inside_ap_datapkg(self.xenv_file)
+
+    def list_productions(self) -> list[str]:
+        folders = glob.glob("*/info.yaml")
+        return [dirname(f) for f in folders]
+
+    def list_jobs(self, production: str) -> list[str]:
+        from LbAPCommon import parse_yaml, render_yaml
+
+        info_yaml = Path(production) / "info.yaml"
+        raw = info_yaml.read_text()
+        rendered = render_yaml(raw)
+        jobs = parse_yaml(rendered, production, None)
+        return list(jobs.keys())
+
+    def generate_request_yaml(
+        self, production: str, job: str, output_dir: Path
+    ) -> Path:
+        from LbAPCommon.__main__ import main as lbapcommon_main
+
+        info_yaml_path = Path(production) / "info.yaml"
+        metadata_path = output_dir / "dirac_metadata.json"
+
+        asyncio.run(
+            lbapcommon_main(
+                production_name=production,
+                ap_pkg_version="v999999999999",
+                input_file=info_yaml_path,
+                output_file=metadata_path,
+                server_credentials=None,
+                only_include=job,
+                dump_requests=True,
+            )
+        )
+
+        with open(metadata_path) as f:
+            metadata = json.load(f)
+
+        productions = metadata.get("productions", {})
+        if not productions:
+            raise RuntimeError("No productions generated")
+
+        prod_key = list(productions.keys())[0]
+        production_data = productions[prod_key]
+
+        request_yaml_path = metadata_path.with_name(prod_key).with_suffix(".yaml")
+
+        if not request_yaml_path.exists():
+            request_yaml_path = output_dir / f"{prod_key}.yaml"
+            with open(request_yaml_path, "w") as f:
+                yaml.dump(
+                    production_data["request"],
+                    f,
+                    default_flow_style=False,
+                    sort_keys=False,
+                )
+        elif request_yaml_path.parent != output_dir:
+            final_path = output_dir / f"{prod_key}.yaml"
+            shutil.move(str(request_yaml_path), str(final_path))
+            request_yaml_path = final_path
+
+        return request_yaml_path