chore: rename templates to distributions (#3035)

As the title says. Distributions is in, Templates is out.

`llama stack build --template` --> `llama stack build --distro`. For
backward compatibility, the previous option is kept but results in a
warning.

Updated `server.py` to remove the "config_or_template" backward
compatibility since it has been a couple releases since that change.

scripts/distro_codegen.py

@@ -34,39 +34,39 @@ class ChangedPathTracker:
         return self._changed_paths
 
 
-def find_template_dirs(templates_dir: Path) -> Iterable[Path]:
-    """Find immediate subdirectories in the templates folder."""
-    if not templates_dir.exists():
-        raise FileNotFoundError(f"Templates directory not found: {templates_dir}")
+def find_distro_dirs(distro_dir: Path) -> Iterable[Path]:
+    """Find immediate subdirectories in the distributions folder."""
+    if not distro_dir.exists():
+        raise FileNotFoundError(f"Distributions directory not found: {distro_dir}")
 
-    return sorted(d for d in templates_dir.iterdir() if d.is_dir() and d.name != "__pycache__")
+    return sorted(d for d in distro_dir.iterdir() if d.is_dir() and d.name != "__pycache__")
 
 
-def process_template(template_dir: Path, progress, change_tracker: ChangedPathTracker) -> None:
-    """Process a single template directory."""
-    progress.print(f"Processing {template_dir.name}")
+def process_distro(distro_dir: Path, progress, change_tracker: ChangedPathTracker) -> None:
+    """Process a single distribution directory."""
+    progress.print(f"Processing {distro_dir.name}")
 
     try:
         # Import the module directly
-        module_name = f"llama_stack.templates.{template_dir.name}"
+        module_name = f"llama_stack.distributions.{distro_dir.name}"
         module = importlib.import_module(module_name)
 
         # Get and save the distribution template
         if template_func := getattr(module, "get_distribution_template", None):
-            template = template_func()
+            distro = template_func()
 
-            yaml_output_dir = REPO_ROOT / "llama_stack" / "templates" / template.name
-            doc_output_dir = REPO_ROOT / "docs/source/distributions" / f"{template.distro_type}_distro"
+            yaml_output_dir = REPO_ROOT / "llama_stack" / "distributions" / distro.name
+            doc_output_dir = REPO_ROOT / "docs/source/distributions" / f"{distro.distro_type}_distro"
             change_tracker.add_paths(yaml_output_dir, doc_output_dir)
-            template.save_distribution(
+            distro.save_distribution(
                 yaml_output_dir=yaml_output_dir,
                 doc_output_dir=doc_output_dir,
             )
         else:
-            progress.print(f"[yellow]Warning: {template_dir.name} has no get_distribution_template function")
+            progress.print(f"[yellow]Warning: {distro_dir.name} has no get_distribution_template function")
 
     except Exception as e:
-        progress.print(f"[red]Error processing {template_dir.name}: {str(e)}")
+        progress.print(f"[red]Error processing {distro_dir.name}: {str(e)}")
         raise e
 
 
@@ -85,38 +85,38 @@ def check_for_changes(change_tracker: ChangedPathTracker) -> bool:
     return has_changes
 
 
-def pre_import_templates(template_dirs: list[Path]) -> None:
-    # Pre-import all template modules to avoid deadlocks.
-    for template_dir in template_dirs:
-        module_name = f"llama_stack.templates.{template_dir.name}"
+def pre_import_distros(distro_dirs: list[Path]) -> None:
+    # Pre-import all distro modules to avoid deadlocks.
+    for distro_dir in distro_dirs:
+        module_name = f"llama_stack.distributions.{distro_dir.name}"
         importlib.import_module(module_name)
 
 
 def main():
-    templates_dir = REPO_ROOT / "llama_stack" / "templates"
+    distros_dir = REPO_ROOT / "llama_stack" / "distributions"
     change_tracker = ChangedPathTracker()
 
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
     ) as progress:
-        template_dirs = list(find_template_dirs(templates_dir))
-        task = progress.add_task("Processing distribution templates...", total=len(template_dirs))
+        distro_dirs = list(find_distro_dirs(distros_dir))
+        task = progress.add_task("Processing distribution templates...", total=len(distro_dirs))
 
-        pre_import_templates(template_dirs)
+        pre_import_distros(distro_dirs)
 
         # Create a partial function with the progress bar
-        process_func = partial(process_template, progress=progress, change_tracker=change_tracker)
+        process_func = partial(process_distro, progress=progress, change_tracker=change_tracker)
 
-        # Process templates in parallel
+        # Process distributions in parallel
         with concurrent.futures.ThreadPoolExecutor() as executor:
             # Submit all tasks and wait for completion
-            list(executor.map(process_func, template_dirs))
-            progress.update(task, advance=len(template_dirs))
+            list(executor.map(process_func, distro_dirs))
+            progress.update(task, advance=len(distro_dirs))
 
     if check_for_changes(change_tracker):
         print(
-            "Distribution template changes detected. Please commit the changes.",
+            "Distribution changes detected. Please commit the changes.",
             file=sys.stderr,
         )
         sys.exit(1)