Add config generator with TUI for training configuration

Implements a config generator tool that helps users create sleap-nn
training configurations from SLP files. Features include:

- Python API with fluent builder pattern (ConfigGenerator class)
- Auto-configuration based on dataset analysis
- Smart pipeline/backbone/parameter recommendations
- Memory estimation for GPU and CPU
- Interactive TUI with 4 tabs (Data, Model, Training, Export)
- CLI command: sleap-nn config <slp_file>

Usage examples:
  # Quick auto-config
  from sleap_nn.config_generator import generate_config
  generate_config("labels.slp", "config.yaml")

  # Fluent API
  ConfigGenerator.from_slp("labels.slp").auto(view="top").batch_size(8).save("config.yaml")

  # CLI
  sleap-nn config labels.slp -o config.yaml
  sleap-nn config labels.slp --interactive

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: gitttt-1234

pyproject.toml

@@ -49,6 +49,7 @@ dependencies = [
     "jupyterlab",
     "pyzmq",
     "rich-click>=1.9.5",
+    "textual>=0.40.0",
 ]
 dynamic = ["version", "readme"]
 

sleap_nn/cli.py

@@ -738,6 +738,112 @@ def system():
     print_system_info()
 
 
+@cli.command()
+@click.argument("slp_path", type=click.Path(exists=True))
+@click.option("-o", "--output", type=str, help="Output config YAML path")
+@click.option(
+    "-v",
+    "--view",
+    type=click.Choice(["side", "top"]),
+    help="Camera view type (affects rotation augmentation)",
+)
+@click.option(
+    "--pipeline",
+    type=click.Choice(
+        [
+            "single_instance",
+            "centroid",
+            "centered_instance",
+            "bottomup",
+            "multi_class_bottomup",
+            "multi_class_topdown",
+        ]
+    ),
+    help="Override pipeline type",
+)
+@click.option("--backbone", type=str, help="Override backbone architecture")
+@click.option("--batch-size", type=int, help="Override batch size")
+@click.option(
+    "-i", "--interactive", is_flag=True, help="Launch interactive TUI mode"
+)
+@click.option("--analyze-only", is_flag=True, help="Only show dataset analysis")
+@click.option("--show-yaml", is_flag=True, help="Print YAML to stdout")
+def config(
+    slp_path, output, view, pipeline, backbone, batch_size, interactive, analyze_only, show_yaml
+):
+    """Generate training configuration from SLP file.
+
+    Analyzes your labeled data and generates an optimized training
+    configuration with sensible defaults.
+
+    \b
+    Examples:
+        # Auto-generate config
+        sleap-nn config labels.slp -o config.yaml
+
+        # Specify camera view for better augmentation defaults
+        sleap-nn config labels.slp -o config.yaml --view top
+
+        # Launch interactive TUI
+        sleap-nn config labels.slp --interactive
+
+        # Override specific parameters
+        sleap-nn config labels.slp -o config.yaml --batch-size 8
+
+        # Just analyze the data
+        sleap-nn config labels.slp --analyze-only
+    """
+    from rich.console import Console
+
+    from sleap_nn.config_generator import ConfigGenerator, analyze_slp
+
+    console = Console()
+
+    if analyze_only:
+        stats = analyze_slp(slp_path)
+        console.print(str(stats))
+
+        # Also show recommendation
+        from sleap_nn.config_generator import recommend_config
+
+        rec = recommend_config(stats)
+        console.print("\n[bold]Recommendation:[/bold]")
+        console.print(f"  Pipeline: {rec.pipeline.recommended}")
+        console.print(f"  Reason: {rec.pipeline.reason}")
+        if rec.pipeline.warnings:
+            console.print("\n[yellow]Warnings:[/yellow]")
+            for w in rec.pipeline.warnings:
+                console.print(f"  * {w}")
+        return
+
+    if interactive:
+        from sleap_nn.config_generator.tui import launch_tui
+
+        launch_tui(slp_path)
+        return
+
+    # Generate config
+    gen = ConfigGenerator.from_slp(slp_path).auto(view=view)
+
+    if pipeline:
+        gen.pipeline(pipeline)
+    if backbone:
+        gen.backbone(backbone)
+    if batch_size:
+        gen.batch_size(batch_size)
+
+    # Print summary
+    console.print(gen.summary())
+
+    if output:
+        gen.save(output)
+        console.print(f"\n[green]Config saved to: {output}[/green]")
+
+    if show_yaml or not output:
+        console.print("\n[bold]YAML Configuration:[/bold]")
+        console.print(gen.to_yaml())
+
+
 cli.add_command(export_command)
 cli.add_command(predict_command)
 

sleap_nn/config_generator/__init__.py

@@ -0,0 +1,133 @@
+"""Config generator for SLEAP-NN training configurations.
+
+This module provides tools for automatically generating training configurations
+from SLP label files with sensible defaults based on data analysis.
+
+Quick Start
+-----------
+One-liner to generate config::
+
+    from sleap_nn.config_generator import generate_config
+    generate_config("labels.slp", "config.yaml")
+
+With customization::
+
+    from sleap_nn.config_generator import ConfigGenerator
+    config = (
+        ConfigGenerator.from_slp("labels.slp")
+        .auto(view="top")
+        .batch_size(8)
+        .save("config.yaml")
+    )
+
+Just analyze the data::
+
+    from sleap_nn.config_generator import analyze_slp
+    stats = analyze_slp("labels.slp")
+    print(stats)
+
+Interactive TUI::
+
+    sleap-nn config labels.slp --interactive
+"""
+
+from omegaconf import DictConfig
+
+from sleap_nn.config_generator.analyzer import DatasetStats, ViewType, analyze_slp
+from sleap_nn.config_generator.generator import ConfigGenerator
+from sleap_nn.config_generator.memory import MemoryEstimate, estimate_memory
+from sleap_nn.config_generator.recommender import (
+    BackboneType,
+    ConfigRecommendation,
+    PipelineRecommendation,
+    PipelineType,
+    recommend_config,
+    recommend_pipeline,
+)
+
+__all__ = [
+    # Core classes
+    "ConfigGenerator",
+    "DatasetStats",
+    "MemoryEstimate",
+    "PipelineRecommendation",
+    "ConfigRecommendation",
+    # Type aliases
+    "PipelineType",
+    "BackboneType",
+    "ViewType",
+    # Functions
+    "analyze_slp",
+    "recommend_pipeline",
+    "recommend_config",
+    "estimate_memory",
+    "generate_config",
+]
+
+
+def generate_config(
+    slp_path: str,
+    output_path: str = None,
+    *,
+    view: str = None,
+    pipeline: str = None,
+    backbone: str = None,
+    batch_size: int = None,
+    **kwargs,
+) -> DictConfig:
+    """Generate a training configuration from an SLP file.
+
+    This is a convenience function for quick config generation.
+    For more control, use the ConfigGenerator class directly.
+
+    Args:
+        slp_path: Path to the .slp label file.
+        output_path: Optional path to save YAML config.
+        view: Camera view type ("side" or "top") for augmentation defaults.
+        pipeline: Override auto-detected pipeline type.
+        backbone: Override auto-detected backbone.
+        batch_size: Override auto-detected batch size.
+        **kwargs: Additional parameters to override.
+
+    Returns:
+        Training configuration as OmegaConf DictConfig.
+
+    Examples:
+        Auto-generate and save::
+
+            generate_config("labels.slp", "config.yaml")
+
+        Auto-generate with view hint::
+
+            config = generate_config("labels.slp", view="top")
+
+        With overrides::
+
+            config = generate_config(
+                "labels.slp",
+                "config.yaml",
+                pipeline="bottomup",
+                batch_size=8
+            )
+    """
+    gen = ConfigGenerator.from_slp(slp_path).auto(view=view)
+
+    # Apply overrides
+    if pipeline:
+        gen.pipeline(pipeline)
+    if backbone:
+        gen.backbone(backbone)
+    if batch_size:
+        gen.batch_size(batch_size)
+
+    # Apply any additional kwargs
+    for key, value in kwargs.items():
+        if value is not None and hasattr(gen, key):
+            getattr(gen, key)(value)
+
+    config = gen.build()
+
+    if output_path:
+        gen.save(output_path)
+
+    return config