bactopia 2.1.0__tar.gz → 2.1.2__tar.gz

{bactopia-2.1.0 → bactopia-2.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bactopia
-Version: 2.1.0
+Version: 2.1.2
 Summary: A Python package for working with Bactopia
 License: MIT
 License-File: LICENSE

{bactopia-2.1.0 → bactopia-2.1.2}/bactopia/cli/catalog.py

@@ -82,13 +82,11 @@ def _parse_output_fields(raw_lines: list[str]) -> dict[str, list[str]]:
     return channels
 
 
-def _infer_scope(channels: list[str]) -> str:
-    """Infer subworkflow scope from emit channel names."""
-    has_sample = "sample_outputs" in channels
-    has_run = "run_outputs" in channels
-    if has_sample:
+def _infer_scope(emits: dict[str, list[str]]) -> str:
+    """Infer subworkflow scope from emit channels and their documented fields."""
+    if emits.get("sample_outputs"):
         return "sample"
-    if has_run:
+    if "run_outputs" in emits:
         return "run"
     return "custom"
 
@@ -137,8 +135,8 @@ def _extract_tool_info(ext: dict) -> dict | None:
     if "::" in pkg:
         pkg = pkg.split("::", 1)[1]
     if "=" in pkg:
-        name, version = pkg.rsplit("=", 1)
-        return {"name": name, "version": version}
+        parts = pkg.split("=")
+        return {"name": parts[0], "version": parts[1]}
     return {"name": pkg, "version": "unknown"}
 
 
@@ -240,7 +238,12 @@ def _build_subworkflow_entry(
         channel_fields = _parse_output_fields(groovydoc.get("raw_lines", []))
         # Build dict: every declared channel gets an entry, even if no fields documented
         entry["emits"] = {ch: channel_fields.get(ch, []) for ch in channel_names}
-        entry["scope"] = _infer_scope(channel_names)
+        entry["scope"] = _infer_scope(entry["emits"])
+
+    # Merlin dynamically dispatches to species-specific subworkflows so its
+    # sample_outputs has no fixed field names to document, but it is sample scope.
+    if component_name == "merlin":
+        entry["scope"] = "sample"
 
     # Calls
     calls = {}

{bactopia-2.1.0 → bactopia-2.1.2}/bactopia/cli/lint.py

@@ -28,6 +28,8 @@ click.rich_click.OPTION_GROUPS = {
                 "--subworkflows",
                 "--workflows",
                 "--module",
+                "--subworkflow",
+                "--workflow",
             ],
         },
         {
@@ -142,6 +144,18 @@ def print_rich(
     default=None,
     help="Lint a single module by name (e.g. 'mlst', 'bakta/run')",
 )
+@click.option(
+    "--subworkflow",
+    "subworkflow_filter",
+    default=None,
+    help="Lint a single subworkflow by name (e.g. 'mlst')",
+)
+@click.option(
+    "--workflow",
+    "workflow_filter",
+    default=None,
+    help="Lint a single workflow by name (e.g. 'mlst', 'bactopia-tools/mlst')",
+)
 @click.option(
     "-q",
     "--quiet",
@@ -159,6 +173,8 @@ def lint(
     subworkflows,
     workflows,
     module_filter,
+    subworkflow_filter,
+    workflow_filter,
     quiet,
     use_json,
     pretty,
@@ -189,8 +205,8 @@ def lint(
         logging.error(f"No main.nf found in {bp}, is this a valid Bactopia repository?")
         sys.exit(1)
 
-    # If filtering by module, only lint modules
-    if module_filter:
+    # If filtering by module, only lint modules (unless other filters also set)
+    if module_filter and not subworkflow_filter and not workflow_filter:
         subworkflows = False
         workflows = False
 
@@ -201,6 +217,8 @@ def lint(
         lint_subworkflows=subworkflows,
         lint_workflows=workflows,
         module_filter=module_filter,
+        subworkflow_filter=subworkflow_filter,
+        workflow_filter=workflow_filter,
     )
 
     # Build serializable output

bactopia-2.1.2/bactopia/cli/scaffold.py

@@ -0,0 +1,376 @@
+"""Scaffold Bactopia components from bioconda/conda-forge packages."""
+
+import json
+import logging
+import sys
+from pathlib import Path
+
+import rich
+import rich.console
+import rich.traceback
+import rich_click as click
+from rich.logging import RichHandler
+
+import bactopia
+from bactopia.conda import (
+    check_component_exists,
+    construct_container_refs,
+    get_latest_info_with_fallback,
+)
+from bactopia.scaffold import (
+    FIELD_PATTERNS,
+    discover_test_data,
+    render_all_files,
+    render_module_files,
+    render_subworkflow_files,
+    render_workflow_files,
+    validate_config,
+    write_files,
+)
+
+# Set up Rich
+stderr = rich.console.Console(stderr=True)
+rich.traceback.install(console=stderr, width=200, word_wrap=True, extra_lines=1)
+click.rich_click.USE_RICH_MARKUP = True
+click.rich_click.OPTION_GROUPS = {
+    "bactopia-scaffold": [
+        {"name": "Commands", "options": []},
+        {
+            "name": "Additional Options",
+            "options": ["--verbose", "--silent", "--version", "--help"],
+        },
+    ],
+    "bactopia-scaffold lookup": [
+        {"name": "Required Options", "options": ["--bactopia-path"]},
+        {
+            "name": "Query Options",
+            "options": ["--channel", "--max-retry"],
+        },
+        {
+            "name": "Output Options",
+            "options": ["--json", "--pretty"],
+        },
+        {
+            "name": "Additional Options",
+            "options": ["--verbose", "--silent", "--help"],
+        },
+    ],
+    "bactopia-scaffold test-data": [
+        {"name": "Required Options", "options": ["--input-type", "--bactopia-path"]},
+        {
+            "name": "Output Options",
+            "options": ["--json", "--pretty"],
+        },
+        {
+            "name": "Additional Options",
+            "options": ["--verbose", "--silent", "--help"],
+        },
+    ],
+}
+
+
+def _setup_logging(verbose: bool, silent: bool) -> None:
+    logging.basicConfig(
+        format="%(asctime)s:%(name)s:%(levelname)s - %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S",
+        handlers=[
+            RichHandler(rich_tracebacks=True, console=rich.console.Console(stderr=True))
+        ],
+    )
+    logging.getLogger().setLevel(
+        logging.ERROR if silent else logging.DEBUG if verbose else logging.INFO
+    )
+
+
+@click.group()
+@click.version_option(bactopia.__version__, "--version")
+def scaffold():
+    """Scaffold Bactopia components from bioconda/conda-forge packages."""
+    pass
+
+
+@scaffold.command()
+@click.argument("package")
+@click.option(
+    "--bactopia-path",
+    required=True,
+    help="Directory where Bactopia repository is stored.",
+)
+@click.option(
+    "--channel",
+    default=None,
+    help="Force a specific channel (bioconda or conda-forge). Default: try bioconda first, then conda-forge.",
+)
+@click.option(
+    "--max-retry",
+    default=3,
+    help="Maximum times to attempt API queries. (Default: 3)",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output flat JSON.")
+@click.option("--pretty", is_flag=True, help="Output pretty-printed JSON.")
+@click.option("--verbose", is_flag=True, help="Print debug related text.")
+@click.option("--silent", is_flag=True, help="Only critical errors will be printed.")
+def lookup(
+    package, bactopia_path, channel, max_retry, output_json, pretty, verbose, silent
+):
+    """Look up package info from Anaconda and check for existing components."""
+    _setup_logging(verbose, silent)
+
+    bactopia_path = str(Path(bactopia_path).absolute())
+    logging.debug(f"Using bactopia path: {bactopia_path}")
+
+    if channel:
+        from bactopia.conda import get_latest_info
+
+        info = get_latest_info(package, max_retry=max_retry, channel=channel)
+        if info:
+            info["channel"] = channel
+    else:
+        info = get_latest_info_with_fallback(package, max_retry=max_retry)
+
+    if info is None:
+        logging.error(f"Package '{package}' not found on bioconda or conda-forge.")
+        sys.exit(1)
+
+    refs = construct_container_refs(package, info["version"], info["build"])
+    existing = check_component_exists(bactopia_path, package)
+
+    result = {
+        "package": package,
+        "channel": info.get("channel", "bioconda"),
+        "version": info["version"],
+        "build": info["build"],
+        "summary": info.get("summary", ""),
+        "home": info.get("home", ""),
+        "container_refs": refs,
+        "existing_components": existing,
+    }
+
+    if output_json:
+        print(json.dumps(result))
+    elif pretty:
+        print(json.dumps(result, indent=2))
+    else:
+        print(f"Package:    {result['package']}")
+        print(f"Channel:    {result['channel']}")
+        print(f"Version:    {result['version']}")
+        print(f"Build:      {result['build']}")
+        print(f"Summary:    {result['summary']}")
+        print(f"Home:       {result['home']}")
+        print()
+        print("Container References:")
+        print(f"  toolName: {refs['toolName']}")
+        print(f"  docker:   {refs['docker']}")
+        print(f"  image:    {refs['image']}")
+        print()
+        print("Existing Components:")
+        for component, exists in existing.items():
+            status = "EXISTS" if exists else "not found"
+            print(f"  {component}: {status}")
+
+
+@scaffold.command("test-data")
+@click.option(
+    "--input-type",
+    required=True,
+    type=click.Choice(sorted(FIELD_PATTERNS.keys())),
+    help="Input type to search for in existing tests.",
+)
+@click.option(
+    "--bactopia-path",
+    required=True,
+    help="Directory where Bactopia repository is stored.",
+)
+@click.option("--json", "output_json", is_flag=True, help="Output flat JSON.")
+@click.option("--pretty", is_flag=True, help="Output pretty-printed JSON.")
+@click.option("--verbose", is_flag=True, help="Print debug related text.")
+@click.option("--silent", is_flag=True, help="Only critical errors will be printed.")
+def test_data(input_type, bactopia_path, output_json, pretty, verbose, silent):
+    """Discover test data paths from existing module tests."""
+    _setup_logging(verbose, silent)
+    bactopia_path = Path(bactopia_path).absolute()
+
+    results = discover_test_data(bactopia_path, input_type)
+
+    output = {"input_type": input_type, "test_data": results}
+
+    if output_json:
+        print(json.dumps(output))
+    elif pretty:
+        print(json.dumps(output, indent=2))
+    else:
+        print(f"Input type: {input_type}")
+        print(f"Found {len(results)} species/accession combinations:\n")
+        for entry in results:
+            print(f"  {entry['species']}/{entry['accession']}")
+            print(f"    Used by: {', '.join(entry['modules_using'])}")
+            print(f"    compressed:   {'yes' if entry['has_compressed'] else 'no'}")
+            print(f"    uncompressed: {'yes' if entry['has_uncompressed'] else 'no'}")
+            print(f"    test_data_path:        {entry['test_data_path']}")
+            print(f"    test_uncompressed_path: {entry['test_uncompressed_path']}")
+            if entry["datasets"]:
+                print(f"    datasets: {', '.join(entry['datasets'])}")
+            print()
+
+
+def _run_generate(
+    config_path,
+    bactopia_path,
+    dry_run,
+    output_json,
+    pretty,
+    verbose,
+    silent,
+    tier,
+    render_fn,
+):
+    """Shared logic for module/subworkflow/tool subcommands."""
+    _setup_logging(verbose, silent)
+    bactopia_path = Path(bactopia_path).absolute()
+
+    with open(config_path) as f:
+        config = json.load(f)
+
+    errors = validate_config(config, tier)
+    if errors:
+        for err in errors:
+            logging.error(err)
+        sys.exit(1)
+
+    # Inject container_refs if not already present
+    if "container_refs" not in config:
+        config["container_refs"] = construct_container_refs(
+            config["package"], config["version"], config.get("build")
+        )
+
+    files = render_fn(config, bactopia_path)
+    created = write_files(files, bactopia_path, dry_run=dry_run)
+
+    result = {"tier": tier, "created_files": created, "dry_run": dry_run}
+    if output_json:
+        print(json.dumps(result))
+    elif pretty:
+        print(json.dumps(result, indent=2))
+    else:
+        action = "Would create" if dry_run else "Created"
+        print(f"{action} {len(created)} files:")
+        for path in created:
+            print(f"  {path}")
+
+
+@scaffold.command()
+@click.option(
+    "--config",
+    "config_path",
+    required=True,
+    type=click.Path(exists=True),
+    help="JSON design config file.",
+)
+@click.option(
+    "--bactopia-path",
+    required=True,
+    help="Directory where Bactopia repository is stored.",
+)
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be created without writing files."
+)
+@click.option("--json", "output_json", is_flag=True, help="Output flat JSON.")
+@click.option("--pretty", is_flag=True, help="Output pretty-printed JSON.")
+@click.option("--verbose", is_flag=True, help="Print debug related text.")
+@click.option("--silent", is_flag=True, help="Only critical errors will be printed.")
+def module(config_path, bactopia_path, dry_run, output_json, pretty, verbose, silent):
+    """Generate module files from a design config."""
+    _run_generate(
+        config_path,
+        bactopia_path,
+        dry_run,
+        output_json,
+        pretty,
+        verbose,
+        silent,
+        "module",
+        render_module_files,
+    )
+
+
+@scaffold.command()
+@click.option(
+    "--config",
+    "config_path",
+    required=True,
+    type=click.Path(exists=True),
+    help="JSON design config file.",
+)
+@click.option(
+    "--bactopia-path",
+    required=True,
+    help="Directory where Bactopia repository is stored.",
+)
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be created without writing files."
+)
+@click.option("--json", "output_json", is_flag=True, help="Output flat JSON.")
+@click.option("--pretty", is_flag=True, help="Output pretty-printed JSON.")
+@click.option("--verbose", is_flag=True, help="Print debug related text.")
+@click.option("--silent", is_flag=True, help="Only critical errors will be printed.")
+def subworkflow(
+    config_path, bactopia_path, dry_run, output_json, pretty, verbose, silent
+):
+    """Generate subworkflow files from a design config."""
+    _run_generate(
+        config_path,
+        bactopia_path,
+        dry_run,
+        output_json,
+        pretty,
+        verbose,
+        silent,
+        "subworkflow",
+        render_subworkflow_files,
+    )
+
+
+@scaffold.command()
+@click.option(
+    "--config",
+    "config_path",
+    required=True,
+    type=click.Path(exists=True),
+    help="JSON design config file.",
+)
+@click.option(
+    "--bactopia-path",
+    required=True,
+    help="Directory where Bactopia repository is stored.",
+)
+@click.option(
+    "--dry-run", is_flag=True, help="Show what would be created without writing files."
+)
+@click.option("--json", "output_json", is_flag=True, help="Output flat JSON.")
+@click.option("--pretty", is_flag=True, help="Output pretty-printed JSON.")
+@click.option("--verbose", is_flag=True, help="Print debug related text.")
+@click.option("--silent", is_flag=True, help="Only critical errors will be printed.")
+def tool(config_path, bactopia_path, dry_run, output_json, pretty, verbose, silent):
+    """Generate all three tiers (module + subworkflow + workflow) for a bactopia-tool."""
+    _run_generate(
+        config_path,
+        bactopia_path,
+        dry_run,
+        output_json,
+        pretty,
+        verbose,
+        silent,
+        "tool",
+        render_all_files,
+    )
+
+
+def main():
+    if len(sys.argv) == 1:
+        scaffold.main(["--help"])
+    else:
+        scaffold()
+
+
+if __name__ == "__main__":
+    main()

{bactopia-2.1.0 → bactopia-2.1.2}/bactopia/cli/sysinfo.py

@@ -13,7 +13,7 @@ stderr = rich.console.Console(stderr=True)
 rich.traceback.install(console=stderr, width=200, word_wrap=True, extra_lines=1)
 click.rich_click.USE_RICH_MARKUP = True
 
-MEM_CAP = 32
+MEM_CAP = 144
 MEM_FLOOR = 4
 CPU_CAP = 12
 
@@ -70,9 +70,6 @@ def sysinfo(ctx, args):
       - both `--max_memory` and `--max_cpus` are already set by the user
       - the invocation is informational (`--help`, `--help_all`, `--list_wfs`)
     """
-    if not args or args == ("--help",) or args == ("-h",):
-        click.echo(ctx.get_help())
-        return
     if args == ("--version",) or args == ("-V",):
         click.echo(f"bactopia-sysinfo {bactopia.__version__}")
         return
@@ -94,7 +91,8 @@ def sysinfo(ctx, args):
         total_gb = psutil.virtual_memory().total // (1024**3)
         mem = min(total_gb - 1, MEM_CAP)
         if mem >= MEM_FLOOR:
-            additions.append(f"--max_memory {mem}.GB")
+            if mem != MEM_CAP:
+                additions.append(f"--max_memory {mem}.GB")
         else:
             click.echo(
                 f"[bactopia-sysinfo] detected only {total_gb} GB RAM "
@@ -104,12 +102,14 @@ def sysinfo(ctx, args):
 
     if not _has_flag(args, "--max_cpus"):
         cpus = min(psutil.cpu_count(logical=True) or 1, CPU_CAP)
-        additions.append(f"--max_cpus {cpus}")
+        if cpus != CPU_CAP:
+            additions.append(f"--max_cpus {cpus}")
 
     if additions:
         line = " ".join(additions)
-        click.echo(line)
-        click.echo(f"[bactopia-sysinfo] auto-detected: {line}", err=True)
+        if line:
+            click.echo(line)
+            click.echo(f"[bactopia-sysinfo] auto-detected: {line}", err=True)
 
 
 def main():

{bactopia-2.1.0 → bactopia-2.1.2}/bactopia/cli/update.py

@@ -4,7 +4,6 @@ import sys
 import time
 from pathlib import Path
 
-import requests
 import rich
 import rich.console
 import rich.traceback
@@ -12,6 +11,7 @@ import rich_click as click
 from rich.logging import RichHandler
 
 import bactopia
+from bactopia.conda import construct_container_refs, get_latest_info
 from bactopia.nf import parse_all_conda_tools
 
 # Set up Rich
@@ -47,48 +47,6 @@ click.rich_click.OPTION_GROUPS = {
         },
     ]
 }
-ANACONDA_API = "https://api.anaconda.org/package/bioconda"
-
-
-def get_latest_info(tool: str, max_retry: int) -> dict | None:
-    """Query Anaconda API for the latest version and build of a bioconda tool.
-
-    Args:
-        tool: The bioconda package name (e.g. "bakta").
-        max_retry: Maximum number of query attempts.
-
-    Returns:
-        Dict with 'version' and 'build' keys, or None on failure.
-    """
-    attempt = 1
-    url = f"{ANACONDA_API}/{tool}"
-    while attempt <= max_retry:
-        logging.debug(f"Querying {url} (attempt {attempt} of {max_retry})")
-        r = requests.get(url)
-        if r.status_code == requests.codes.ok:
-            data = r.json()
-            version = data.get("latest_version") or data.get("versions", [None])[-1]
-
-            # Find the latest linux-64 build string from the files array
-            # Bioconda publishes separate builds per platform (linux-64,
-            # osx-64, linux-aarch64, etc.) and Bactopia only targets linux-64.
-            build = None
-            if "files" in data:
-                for f in reversed(data["files"]):
-                    attrs = f.get("attrs", {})
-                    if (
-                        f.get("version") == version
-                        and attrs.get("subdir") == "linux-64"
-                    ):
-                        build = attrs.get("build")
-                        break
-
-            return {"version": version, "build": build}
-        else:
-            attempt += 1
-            time.sleep(5)
-    logging.warning(f"Unable to query {url} after {max_retry} attempts.")
-    return None
 
 
 @click.command(
@@ -243,14 +201,12 @@ def update(
             }
 
             if latest and latest["build"]:
-                version = latest["version"]
-                build = latest["build"]
-                entry["latest_toolName"] = f"bioconda::{tool_name}={version}"
-                entry["latest_docker"] = f"biocontainers/{tool_name}:{version}--{build}"
-                entry["latest_image"] = (
-                    f"https://depot.galaxyproject.org/singularity/"
-                    f"{tool_name}:{version}--{build}"
+                refs = construct_container_refs(
+                    tool_name, latest["version"], latest["build"]
                 )
+                entry["latest_toolName"] = refs["toolName"]
+                entry["latest_docker"] = refs["docker"]
+                entry["latest_image"] = refs["image"]
 
             results.append(entry)
 

{bactopia-2.1.0 → bactopia-2.1.2}/bactopia/cli/workflows.py

@@ -102,7 +102,7 @@ def download(
         workflows = catalog["workflows"]
     else:
         logging.error(
-            f"'catalog.json' could not be found in {bactopia_path}/data/, is this a valid Bactopia installation?"
+            f"'catalog.json' could not be found in {bactopia_path}, is this a valid Bactopia installation?"
         )
         sys.exit(1)