freesolo-flash-dev 1.4.20__tar.gz → 1.4.21__tar.gz

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.4.20
+Version: 1.4.21
 Summary: Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI
 Project-URL: Homepage, https://github.com/freesolo-co/flash
 Project-URL: Repository, https://github.com/freesolo-co/flash

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/flash/serving/app/modal_app.py

@@ -13,7 +13,7 @@ from typing import TYPE_CHECKING, Any
 import modal
 
 from flash.schema import parse_checkpoint_ref
-from flash.serving.app.rollout import LEGACY_ENGINE_KEYS, model_engine_name, warm_active_models
+from flash.serving.app.rollout import model_engine_name, warm_active_models
 from flash.serving.app.timeouts import (
     REQUEST_TIMEOUT_SECONDS,
     ROUTER_TIMEOUT_SECONDS,
@@ -350,29 +350,17 @@ def _engine_concurrency(base_model: str) -> tuple[int, int]:
     return max_inputs, max_inputs
 
 
-def _engine_class_name(gpu: str, max_inputs: int) -> str:
-    """Deterministic, Modal-safe class name for a (GPU tier, concurrency) engine — e.g.
-    ('A100-80GB', 16) -> 'LoraEngine_A100_80GB_c16'. The concurrency is part of the identity because
-    ``modal.concurrent`` is fixed per class, so tiers sharing a GPU but needing different max_inputs
-    must be distinct classes."""
-    base = "LoraEngine_" + "".join(ch if ch.isalnum() else "_" for ch in gpu)
-    return f"{base}_c{max_inputs}"
-
-
 def _build_engine(
     gpu: str,
     class_name: str,
     max_inputs: int,
     target_inputs: int,
-    *,
-    legacy: bool = False,
 ) -> Any:
     """Register one Modal ``@app.cls`` LoraEngine pinned to ``gpu``.
 
     Modal fixes a class's GPU at decoration time, so the H200 35B model and the L4 models need
-    distinct classes. Each model now has a stable class; tier classes remain for draining old
-    routers. The Modal entrypoints are defined fresh here (so each class owns its own method
-    objects) and forward to the shared ``_``-prefixed impl on ``_LoraEngineImpl``.
+    distinct classes. Each model has a stable class. The Modal entrypoints are defined
+    fresh here (so each class owns its own method objects) and forward to the shared ``_``-prefixed impl on ``_LoraEngineImpl``.
 
     Class identity (name/qualname + module-global binding) is fixed BEFORE the class-level decorators
     run. With the real Modal SDK ``@modal.concurrent`` returns a wrapper that holds the user class
@@ -467,7 +455,7 @@ def _build_engine(
         region="us",
         secrets=engine_secrets,
         volumes={HOSTING_CACHE_MOUNT: hf_cache_volume},
-        scaledown_window=60 if legacy else scaledown_window_for(gpu),
+        scaledown_window=scaledown_window_for(gpu),
         startup_timeout=STARTUP_TIMEOUT_SECONDS,
         timeout=REQUEST_TIMEOUT_SECONDS,
         min_containers=MIN_CONTAINERS,
@@ -480,15 +468,6 @@ def _build_engine(
     return engine
 
 
-# Keep the deployed tier identities callable while pre-migration routers drain.
-# These are compatibility pools, never selected for new inference. Their zero floor
-# lets them disappear after old traffic stops; do not derive this list from the catalog.
-ENGINE_BY_KEY: dict[tuple[str, int], Any] = {
-    (gpu, mi): _build_engine(gpu, _engine_class_name(gpu, mi), mi, mi, legacy=True)
-    for (gpu, mi) in dict.fromkeys(LEGACY_ENGINE_KEYS.values())
-}
-
-
 # GPU and concurrency may change without deleting the identity old routers call.
 ENGINE_BY_MODEL: dict[str, Any] = {
     bm: _build_engine(gpu_for(bm), model_engine_name(bm), *_engine_concurrency(bm))
@@ -513,7 +492,6 @@ class _ModalEnginePool:
     async def start(self):
         await warm_active_models(
             {bm: cls(base_model=bm) for bm, cls in ENGINE_BY_MODEL.items()},
-            {bm: ENGINE_BY_KEY[key](base_model=bm) for bm, key in LEGACY_ENGINE_KEYS.items()},
         )
 
     async def aclose(self):

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/flash/serving/app/rollback.py

@@ -18,14 +18,11 @@ from typing import Any
 
 
 def engine_manifest(source_sha: str) -> dict[str, Any]:
-    from flash.serving.app.rollout import LEGACY_ENGINE_KEYS, model_engine_name
+    from flash.serving.app.rollout import model_engine_name
     from flash.serving.app.timeouts import ROUTER_TIMEOUT_SECONDS
     from flash.serving.src.engine.model_config import base_models
 
     classes: dict[str, list[str]] = {}
-    for model, (gpu, concurrency) in LEGACY_ENGINE_KEYS.items():
-        safe_gpu = "".join(ch if ch.isalnum() else "_" for ch in gpu)
-        classes.setdefault(f"LoraEngine_{safe_gpu}_c{concurrency}", []).append(model)
     for model in base_models():
         classes[model_engine_name(model)] = [model]
     return validate_manifest(

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/flash/serving/app/rollout.py

@@ -8,19 +8,6 @@ from typing import Any
 
 from flash.serving.app.timeouts import ROUTER_TIMEOUT_SECONDS
 
-# The identities served by main before model-scoped classes were introduced.
-# Old router containers retain these handles until their requests finish. Removing
-# a class at deployment deletes the handle immediately, even in a rolling deploy.
-# Keep this frozen rather than recomputing it when GPU or concurrency settings change.
-LEGACY_ENGINE_KEYS: dict[str, tuple[str, int]] = {
-    "Qwen/Qwen3.5-0.8B": ("L4", 64),
-    "Qwen/Qwen3.5-4B": ("L40S", 8),
-    "Qwen/Qwen3.5-9B": ("L40S", 64),
-    "Qwen/Qwen3.5-9B-Base": ("L40S", 64),
-    "Qwen/Qwen3.8-27B": ("H100", 8),
-    "Qwen/Qwen3.6-35B-A3B": ("H200", 8),
-}
-
 
 def model_engine_name(base_model: str) -> str:
     """Hardware changes must update a function, never replace its dispatch name."""
@@ -47,11 +34,12 @@ async def _warm_model(model: str, engine: Any, legacy: Any | None) -> None:
         raise RuntimeError(f"Replacement engine is not healthy for {model}")
 
 
-async def warm_active_models(engines: dict[str, Any], legacy: dict[str, Any]) -> None:
+async def warm_active_models(engines: dict[str, Any], legacy: dict[str, Any] | None = None) -> None:
     """Finish before ASGI startup succeeds and Modal admits traffic to this router.
 
-    Keep old routers serving during first migration to model-scoped pools. Later
-    deploys keep each pool's identity stable, allowing Modal's rolling strategy to
+    Production supplies only model-scoped pools. The isolated rollout qualification
+    may supply legacy handles to exercise migration readiness. Deploys keep each
+    pool's identity stable, allowing Modal's rolling strategy to
     drain its old replicas. Health may reach a still-serving old replica during
     that transition; this is an availability gate, not a release-identity canary.
     Stats/readiness failures fail startup rather than declaring an unready router
@@ -59,4 +47,4 @@ async def warm_active_models(engines: dict[str, Any], legacy: dict[str, Any]) ->
     """
     async with asyncio.timeout(ROUTER_TIMEOUT_SECONDS), asyncio.TaskGroup() as tasks:
         for model, engine in engines.items():
-            tasks.create_task(_warm_model(model, engine, legacy.get(model)))
+            tasks.create_task(_warm_model(model, engine, (legacy or {}).get(model)))

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/flash/serving/src/engine/boot.py

@@ -73,6 +73,10 @@ def _multimodal_args(
 ) -> dict[str, Any]:
     image_limit = image_limit_for(base_model)
     if image_limit is None:
+        # Preserve the qualified vLLM startup path for text-only Qwen tiers.
+        # Disabling both modalities switches profiling to input_ids with no
+        # inputs_embeds; the current compiled Qwen3Next path crashes on None.size.
+        # Request validation still rejects image inputs for these catalog tiers.
         return {}
     return {
         # Hosted requests accept text and images, never video. Leaving video unspecified

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.4.20"
+version = "1.4.21"
 description ="Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI"
 # The training and serving stack is validated on Python 3.11 and 3.12.
 requires-python = ">=3.11,<3.13"
@@ -210,7 +210,7 @@ artifacts = ["flash/py.typed"]
 # auto-published by .github/workflows/publish-dev.yml: a push to `dev` whose version isn't yet on
 # PyPI publishes it; pushes that don't change it find it already published and no-op. So cutting a
 # dev-channel release = bump this (and [project].version) and merge to `dev`.
-version = "1.4.20"
+version = "1.4.21"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/tests/serving/test_model_config.py

@@ -74,9 +74,8 @@ def test_tool_parser_is_qualified_only_for_exact_qwen35() -> None:
 
 
 def test_no_model_runs_language_model_only() -> None:
-    # No tier sets language_model_only: flash adapters adapt the FULL multimodal tree, so their
-    # vision-tower LoRA keys need the vision encoder loaded to bind to. Every base loads the whole
-    # VL model (the 35B included) — none carries the text-only skip.
+    # Retain the qualified multimodal architecture for vLLM startup. The catalog
+    # and request validation determine which tiers accept image inputs.
     assert "language_model_only" not in engine_overrides_for("Qwen/Qwen3.6-35B-A3B")
     assert "language_model_only" not in engine_overrides_for("Qwen/Qwen3.5-9B")
 

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/tests/serving/test_per_model_gpu.py

@@ -434,22 +434,17 @@ def test_deployed_timeouts_use_the_shared_serving_budget(modal_app_module):
     )
 
 
-def test_legacy_engine_keys_are_retained_for_draining_routers(modal_app_module):
-    """A catalog edit must not delete handles held by pre-migration routers."""
-    assert set(modal_app_module.ENGINE_BY_KEY) == {
-        ("L4", 64),
-        ("L40S", 8),
-        ("L40S", 64),
-        ("H100", 8),
-        ("H200", 8),
-    }
+def test_only_model_scoped_engines_are_registered(modal_app_module):
+    registered = {name for name in vars(modal_app_module) if name.startswith("LoraEngine_")}
+    assert registered == {modal_app_module.model_engine_name(model) for model in base_models()}
+    assert modal_app_module.app.cls.call_count == len(base_models())
 
 
 def test_rollback_manifest_retains_every_registered_engine(modal_app_module):
     from flash.serving.app.rollback import engine_manifest
 
     manifest = engine_manifest("a" * 40)
-    classes = [*modal_app_module.ENGINE_BY_KEY.values(), *modal_app_module.ENGINE_BY_MODEL.values()]
+    classes = list(modal_app_module.ENGINE_BY_MODEL.values())
     assert set(manifest["classes"]) == {cls.__name__ for cls in classes}
     for model, cls in modal_app_module.ENGINE_BY_MODEL.items():
         assert manifest["classes"][cls.__name__] == [model]
@@ -471,14 +466,6 @@ def test_engine_concurrency_rejects_malformed_catalog_values(modal_app_module, m
         mod._engine_concurrency("malformed")
 
 
-def test_class_names_are_distinct_and_modal_safe(modal_app_module):
-    """Each tier registers under an app-unique, alnum/underscore-only class name that encodes both
-    the GPU and its concurrency (max_inputs is part of the class identity)."""
-    assert modal_app_module._engine_class_name("L4", 64) == "LoraEngine_L4_c64"
-    assert modal_app_module._engine_class_name("L4", 16) == "LoraEngine_L4_c16"
-    assert modal_app_module._engine_class_name("A100-80GB", 16) == "LoraEngine_A100_80GB_c16"
-
-
 @pytest.mark.parametrize(
     ("model", "gpu", "sequences"),
     [
@@ -508,7 +495,7 @@ def test_unknown_base_model_is_rejected_before_engine_dispatch(modal_app_module)
 def test_tier_classes_inherit_the_shared_impl(modal_app_module):
     """Each tier class subclasses _LoraEngineImpl (so _load/_generate/etc resolve) and defines the
     public Modal entrypoints itself (so Modal collects them per class)."""
-    tier = modal_app_module.ENGINE_BY_KEY[("H200", 8)]
+    tier = modal_app_module.ENGINE_BY_MODEL["Qwen/Qwen3.6-35B-A3B"]
     assert issubclass(tier, modal_app_module._LoraEngineImpl)
     for impl in ("_load", "_register", "_generate", "_stream_generate", "_unregister", "_health"):
         assert hasattr(tier, impl)
@@ -519,11 +506,8 @@ def test_tier_classes_inherit_the_shared_impl(modal_app_module):
 def test_each_tier_class_records_its_pinned_gpu(modal_app_module):
     """Each per-tier class records the GPU it was actually pinned to in _build_engine, so health/ops
     can detect a base model misrouted onto the wrong tier instead of trusting the derived lookup."""
-    by_key = modal_app_module.ENGINE_BY_KEY
-    # Every class records the GPU half of its (gpu, max_inputs) key.
-    for (gpu, _max_inputs), cls in by_key.items():
-        assert cls.pinned_gpu == gpu
-    assert by_key[("H200", 8)].pinned_gpu == "H200"
+    for model, cls in modal_app_module.ENGINE_BY_MODEL.items():
+        assert cls.pinned_gpu == gpu_for(model)
 
 
 def test_tier_class_identity_is_fixed_before_decoration(modal_app_module):
@@ -532,9 +516,6 @@ def test_tier_class_identity_is_fixed_before_decoration(modal_app_module):
     REAL class BEFORE ``@modal.concurrent`` wraps it — otherwise (renaming after the decorator) every tier
     would register under ``_Engine`` and the ``<locals>`` qualname would fail Modal's global-scope check."""
     classes = [
-        (modal_app_module._engine_class_name(gpu, mi), cls)
-        for (gpu, mi), cls in modal_app_module.ENGINE_BY_KEY.items()
-    ] + [
         (modal_app_module.model_engine_name(model), cls)
         for model, cls in modal_app_module.ENGINE_BY_MODEL.items()
     ]
@@ -899,15 +880,19 @@ def test_every_catalog_model_forwards_its_reasoning_parser(
 
 
 @pytest.mark.parametrize("base_model", base_models())
-def test_hosted_multimodal_args_preserve_images_without_reserving_video(
+def test_hosted_multimodal_args_preserve_qualified_startup(
     modal_app_module, monkeypatch, tmp_path, base_model: str
 ):
     from flash.serving.src.engine.model_config import image_limit_for
 
     args = _capture_engine_args(modal_app_module, monkeypatch, tmp_path, base_model)
     image_limit = image_limit_for(base_model)
-    expected = None if image_limit is None else {"image": image_limit, "video": 0}
-    assert args.limit_mm_per_prompt == expected
+    if image_limit is None:
+        assert args.limit_mm_per_prompt is None
+    else:
+        assert args.limit_mm_per_prompt == {"image": image_limit, "video": 0}
+    assert args.enable_lora is True
+    assert args.enable_tower_connector_lora is (image_limit is not None)
 
 
 def test_hosted_hot_pools_remain_unpinned(modal_app_module, monkeypatch, tmp_path):
@@ -995,7 +980,7 @@ def test_modal_stream_entrypoint_uses_regular_call(modal_app_module, monkeypatch
 
     from flash.serving.src.stream_channel import engine as channel_engine
 
-    engine = modal_app_module.ENGINE_BY_KEY[("H200", 8)]()
+    engine = modal_app_module.ENGINE_BY_MODEL["Qwen/Qwen3.6-35B-A3B"]()
     run = AsyncMock(return_value={"terminal_kind": "event"})
     monkeypatch.setattr(channel_engine, "stream_generate_call", run)
     assert not inspect.isasyncgenfunction(engine.stream_generate_call)

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/tests/serving/test_rollback_compatibility.py

@@ -225,8 +225,8 @@ def test_prepare_refuses_an_unknown_router_before_changing_source(tmp_path):
     assert not (tmp_path / "flash/serving/_rollback_compat.py").exists()
 
 
-def test_manifest_captures_current_models_and_all_compatibility_names():
-    from flash.serving.app.rollout import LEGACY_ENGINE_KEYS, model_engine_name
+def test_manifest_captures_only_current_model_identities():
+    from flash.serving.app.rollout import model_engine_name
     from flash.serving.src.engine.model_config import base_models
 
     manifest = json.loads(json.dumps(engine_manifest("b" * 40)))
@@ -235,5 +235,4 @@ def test_manifest_captures_current_models_and_all_compatibility_names():
     )
     for model in base_models():
         assert manifest["classes"][model_engine_name(model)] == [model]
-    for model, (gpu, cap) in LEGACY_ENGINE_KEYS.items():
-        assert model in manifest["classes"][f"LoraEngine_{gpu}_c{cap}"]
+    assert set(manifest["classes"]) == {model_engine_name(model) for model in base_models()}

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/tests/serving/test_rollout_readiness.py

@@ -7,6 +7,7 @@ from unittest.mock import AsyncMock
 import pytest
 
 from flash.serving.app import rollout
+from flash.serving.src.engine.model_config import base_models
 from flash.serving.src.http.router import _lifespan_for
 
 
@@ -26,7 +27,7 @@ def _engine(model="base", *, runners=0, running=0, backlog=0):
 
 
 def test_model_identity_is_distinct_and_independent_of_hardware():
-    names = [rollout.model_engine_name(model) for model in rollout.LEGACY_ENGINE_KEYS]
+    names = [rollout.model_engine_name(model) for model in base_models()]
     assert len(set(names)) == len(names)
     assert all(name.replace("_", "").isalnum() for name in names)
     # Normalization must not merge different public model IDs.
@@ -52,7 +53,7 @@ def test_active_or_queued_models_require_readiness(activity, migrating):
 
 def test_first_deployment_does_not_need_a_legacy_pool():
     current = _engine()
-    asyncio.run(rollout.warm_active_models({"base": current}, {}))
+    asyncio.run(rollout.warm_active_models({"base": current}))
     current.health.remote.aio.assert_not_awaited()
 
 
@@ -63,7 +64,7 @@ def test_unhealthy_replacements_cannot_pass_startup(health):
     current = _engine(runners=1)
     current.health.remote.aio.return_value = health
     with pytest.raises(ExceptionGroup, match="TaskGroup") as error:
-        asyncio.run(rollout.warm_active_models({"base": current}, {}))
+        asyncio.run(rollout.warm_active_models({"base": current}))
     assert isinstance(error.value.exceptions[0], RuntimeError)
 
 
@@ -71,7 +72,7 @@ def test_stats_failure_does_not_silently_mark_a_pool_inactive():
     current = _engine()
     current.health.get_current_stats.aio.side_effect = RuntimeError("stats unavailable")
     with pytest.raises(ExceptionGroup) as error:
-        asyncio.run(rollout.warm_active_models({"base": current}, {}))
+        asyncio.run(rollout.warm_active_models({"base": current}))
     assert str(error.value.exceptions[0]) == "stats unavailable"
     current.health.remote.aio.assert_not_awaited()
 

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/tests/serving/test_usage_reporter.py

@@ -96,21 +96,15 @@ def test_lora_engine_scales_to_zero_by_default(modal_app_module):
     assert modal_app_module.MIN_CONTAINERS == 0
 
     cls_calls = [call.kwargs for call in modal_app_module.app.cls.call_args_list]
-    assert len(cls_calls) == (
-        len(modal_app_module.ENGINE_BY_KEY) + len(modal_app_module.ENGINE_BY_MODEL)
-    )
+    assert len(cls_calls) == len(modal_app_module.ENGINE_BY_MODEL)
     # asserted on the kwargs modal is actually CALLED with, not on the constant: the floor is only
     # real if it reaches `app.cls`. `AutoscalerSettings.min_containers` is an `optional` proto field
     # (has_presence), so omitting it and sending 0 are distinguishable on the wire -- an omitted
     # field leaves the floor to whatever the server defaults to, which is not ours to assume.
     assert all(kwargs["min_containers"] == modal_app_module.MIN_CONTAINERS for kwargs in cls_calls)
-    # Compatibility pools drain promptly; current pools retain the qualified idle window.
-    legacy_count = len(modal_app_module.ENGINE_BY_KEY)
-    assert all(kwargs["scaledown_window"] == 60 for kwargs in cls_calls[:legacy_count])
-    cls_calls = cls_calls[legacy_count:]
     assert {kwargs["gpu"]: kwargs["scaledown_window"] for kwargs in cls_calls} == {
         ("H100!" if gpu == "H100" else gpu): modal_app_module.scaledown_window_for(gpu)
-        for gpu, _mi in modal_app_module.ENGINE_BY_KEY
+        for gpu in modal_app_module.SUPPORTED_GPUS
     }
 
     assert modal_app_module.app.function.call_count == 1
@@ -124,9 +118,7 @@ def test_gpu_engines_scale_from_demand_without_a_paid_spare(modal_app_module):
     assert modal_app_module.ROUTER_BUFFER_CONTAINERS == 1
 
     cls_calls = [call.kwargs for call in modal_app_module.app.cls.call_args_list]
-    assert len(cls_calls) == (
-        len(modal_app_module.ENGINE_BY_KEY) + len(modal_app_module.ENGINE_BY_MODEL)
-    )
+    assert len(cls_calls) == len(modal_app_module.ENGINE_BY_MODEL)
     assert all(kwargs["max_containers"] == 2 for kwargs in cls_calls)
     # An active, lightly loaded model must not reserve a second GPU.
     assert all(kwargs["buffer_containers"] == 0 for kwargs in cls_calls)
@@ -166,14 +158,13 @@ def test_modal_concurrency_is_per_engine_key(modal_app_module):
     assert modal_app_module.TARGET_INPUTS == 48
     # One @modal.concurrent per distinct engine key plus one on the router.
     calls = [call.kwargs for call in modal_app_module.modal.concurrent.call_args_list]
-    assert (
-        len(calls)
-        == (len(modal_app_module.ENGINE_BY_KEY) + len(modal_app_module.ENGINE_BY_MODEL)) + 1
-    )
+    assert len(calls) == len(modal_app_module.ENGINE_BY_MODEL) + 1
     seen = {(c["max_inputs"], c["target_inputs"]) for c in calls}
     # Check the actual decorators: changing only _engine_concurrency must not leave
     # a second target calculation deploying the old 75% threshold.
-    expected = {(mi, mi) for (_gpu, mi) in modal_app_module.ENGINE_BY_KEY}
+    expected = {
+        modal_app_module._engine_concurrency(model) for model in modal_app_module.ENGINE_BY_MODEL
+    }
     expected.add((modal_app_module.MAX_INPUTS, modal_app_module.TARGET_INPUTS))
     assert seen == expected
 

{freesolo_flash_dev-1.4.20 → freesolo_flash_dev-1.4.21}/uv.lock

@@ -1297,7 +1297,7 @@ wheels = [
 
 [[package]]
 name = "freesolo-flash"
-version = "1.4.20"
+version = "1.4.21"
 source = { editable = "." }
 
 [package.optional-dependencies]