[bugfix] [4/n] Fix profile loading bugs: shared mutable state, error swallowing, version sort

- deepcopy profile defaults to prevent shared mutable list references
  between SamplingParam instances (e.g. ltx2_stg_blocks_video, sigmas)
- narrow bare except Exception to (ValueError, RuntimeError) in
  _from_profile() so real errors aren't silently swallowed
- use numeric-aware version sorting in get_profile() to handle
  multi-segment versions correctly (e.g. "2" > "10" string sort bug)
- remove dead get_sampling_param_cls_for_name fallback from
  from_pretrained() since all sampling_param_cls are now None
- update test_ltx2_registry.py for profile-based behavior

Author: SolitaryThinker

fastvideo/api/profiles.py

@@ -124,7 +124,7 @@ def get_profile(
             f"{model_family!r}; "
             f"registered: {_format_registered(model_family)}",
         )
-    candidates.sort(key=lambda p: p.version)
+    candidates.sort(key=lambda p: [int(x) if x.isdigit() else x for x in p.version.split(".")])
     return candidates[-1]
 
 

fastvideo/api/sampling_param.py

@@ -1,4 +1,5 @@
 # SPDX-License-Identifier: Apache-2.0
+import copy
 from dataclasses import dataclass, field
 from typing import Any
 
@@ -130,13 +131,8 @@ def from_pretrained(cls, model_path: str) -> "SamplingParam":
         if sampling_param is not None:
             return sampling_param
 
-        from fastvideo.registry import get_sampling_param_cls_for_name
-        sampling_cls = get_sampling_param_cls_for_name(model_path)
-        if sampling_cls is not None:
-            return sampling_cls()
-
         logger.warning(
-            "Couldn't find an optimal sampling param for %s."
+            "Couldn't find a profile for %s."
             " Using the default sampling param.",
             model_path,
         )
@@ -160,7 +156,7 @@ def _from_profile(
 
         try:
             profile_name = get_default_profile(model_path)
-        except Exception:
+        except (ValueError, RuntimeError):
             return None
         if profile_name is None:
             return None
@@ -175,7 +171,7 @@ def _from_profile(
         sp = cls()
         for key, value in profile.defaults.items():
             if hasattr(sp, key):
-                setattr(sp, key, value)
+                setattr(sp, key, copy.deepcopy(value))
         sp.__post_init__()
         return sp
 

tests/local_tests/test_ltx2_registry.py

@@ -1,42 +1,18 @@
 # SPDX-License-Identifier: Apache-2.0
 import json
-import importlib
-import sys
-import types
 from pathlib import Path
 
 import pytest
 
 pytest.importorskip("torchvision")
 
 
-def _bootstrap_fastvideo_namespace() -> None:
-    """Avoid importing fastvideo/__init__.py during local registry tests."""
-    if "fastvideo" in sys.modules:
-        return
-
-    repo_root = Path(__file__).resolve().parents[2]
-    package_dir = repo_root / "fastvideo"
-    fastvideo_pkg = types.ModuleType("fastvideo")
-    fastvideo_pkg.__path__ = [str(package_dir)]  # type: ignore[attr-defined]
-    fastvideo_pkg.__file__ = str(package_dir / "__init__.py")
-    sys.modules["fastvideo"] = fastvideo_pkg
-
-
-def _get_registry_test_symbols() -> tuple[type, type, type, object, object]:
-    _bootstrap_fastvideo_namespace()
-
-    pipeline_module = importlib.import_module("fastvideo.configs.pipelines.ltx2")
-    sample_module = importlib.import_module("fastvideo.configs.sample.ltx2")
-    registry_module = importlib.import_module("fastvideo.registry")
-
-    return (
-        pipeline_module.LTX2T2VConfig,
-        sample_module.LTX2BaseSamplingParam,
-        sample_module.LTX2DistilledSamplingParam,
-        registry_module.get_pipeline_config_cls_from_name,
-        registry_module.get_sampling_param_cls_for_name,
-    )
+from fastvideo.api.sampling_param import SamplingParam
+from fastvideo.registry import (
+    get_pipeline_config_cls_from_name,
+    get_sampling_param_cls_for_name,
+)
+from fastvideo.configs.pipelines.ltx2 import LTX2T2VConfig
 
 
 @pytest.mark.parametrize(
@@ -47,12 +23,23 @@ def _get_registry_test_symbols() -> tuple[type, type, type, object, object]:
         ("FastVideo/LTX2-Distilled-Diffusers", "distilled"),
     ],
 )
-def test_ltx2_sampling_registry_exact_ids(model_id: str,
-                                          expected_variant: str) -> None:
-    _, base_cls, distilled_cls, _, get_sampling_param_cls_for_name = _get_registry_test_symbols()
-    expected_cls = base_cls if expected_variant == "base" else distilled_cls
-    resolved_cls = get_sampling_param_cls_for_name(model_id)
-    assert resolved_cls is expected_cls
+def test_ltx2_sampling_registry_exact_ids(
+    model_id: str,
+    expected_variant: str,
+) -> None:
+    # All sampling_param_cls are None after profile migration.
+    assert get_sampling_param_cls_for_name(model_id) is None
+
+    # Profile-based path should return correct defaults.
+    sp = SamplingParam.from_pretrained(model_id)
+    if expected_variant == "base":
+        assert sp.num_inference_steps == 40
+        assert sp.height == 512
+        assert sp.width == 768
+    else:
+        assert sp.num_inference_steps == 8
+        assert sp.height == 1024
+        assert sp.width == 1536
 
 
 @pytest.mark.parametrize(
@@ -64,45 +51,48 @@ def test_ltx2_sampling_registry_exact_ids(model_id: str,
     ],
 )
 def test_ltx2_pipeline_registry_exact_ids(model_id: str) -> None:
-    pipeline_cls, _, _, get_pipeline_config_cls_from_name, _ = _get_registry_test_symbols()
     resolved_cls = get_pipeline_config_cls_from_name(model_id)
-    assert resolved_cls is pipeline_cls
+    assert resolved_cls is LTX2T2VConfig
 
 
-def _write_minimal_diffusers_repo(model_dir: Path, class_name: str) -> None:
+def _write_minimal_diffusers_repo(
+    model_dir: Path, class_name: str
+) -> None:
     model_dir.mkdir(parents=True, exist_ok=True)
     (model_dir / "transformer").mkdir(exist_ok=True)
     (model_dir / "vae").mkdir(exist_ok=True)
-    with (model_dir / "model_index.json").open("w", encoding="utf-8") as f:
+    with (model_dir / "model_index.json").open(
+        "w", encoding="utf-8"
+    ) as f:
         json.dump(
             {
                 "_class_name": class_name,
                 "_diffusers_version": "0.33.0.dev0",
-                "transformer": ["diffusers", "LTX2Transformer3DModel"],
+                "transformer": [
+                    "diffusers",
+                    "LTX2Transformer3DModel",
+                ],
                 "vae": ["diffusers", "CausalVideoAutoencoder"],
             },
             f,
         )
 
 
 def test_ltx2_ambiguous_local_path_has_no_sampling_fallback(
-        tmp_path: Path) -> None:
-    _, _, _, _, get_sampling_param_cls_for_name = _get_registry_test_symbols()
-    # Simulate a user-local converted LTX2 path that might be either base or
-    # distilled. Registry must not assume a variant for local converted paths.
+    tmp_path: Path,
+) -> None:
     model_dir = tmp_path / "converted" / "ltx2_diffusers"
     _write_minimal_diffusers_repo(model_dir, "LTX2Pipeline")
-
     resolved_cls = get_sampling_param_cls_for_name(str(model_dir))
     assert resolved_cls is None
 
 
-def test_ltx2_ambiguous_local_path_has_no_pipeline_mapping(
-        tmp_path: Path) -> None:
-    _, _, _, get_pipeline_config_cls_from_name, _ = _get_registry_test_symbols()
+def test_ltx2_ambiguous_local_path_resolves_via_detector(
+    tmp_path: Path,
+) -> None:
+    # Both base and distilled share LTX2T2VConfig, so the
+    # "ltx2" detector correctly resolves ambiguous local paths.
     model_dir = tmp_path / "converted" / "ltx2_diffusers"
     _write_minimal_diffusers_repo(model_dir, "LTX2Pipeline")
-
-    with pytest.raises(ValueError,
-                       match="No match found for pipeline .*check the pipeline name or path"):
-        get_pipeline_config_cls_from_name(str(model_dir))
+    resolved_cls = get_pipeline_config_cls_from_name(str(model_dir))
+    assert resolved_cls is LTX2T2VConfig