freesolo-flash-dev 1.4.9__tar.gz → 1.4.10__tar.gz

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.4.9
+Version: 1.4.10
 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.9 → freesolo_flash_dev-1.4.10}/flash/custom/backend.py

@@ -336,6 +336,12 @@ def load_backend(
             "exclude_modules": surface.exclude_modules,
             "target_parameters": surface.target_parameters,
         }
+    if init_adapter and _uses_language_model_layout(init_adapter):
+        # SFT and GRPO adapt Qwen3.5 text modules under model.language_model even for text-only
+        # runs; load that same layout so the source's module paths and exclusions resolve.
+        from transformers import AutoModelForImageTextToText
+
+        model_class = AutoModelForImageTextToText
     model = model_class.from_pretrained(
         model_id,
         revision=revision,
@@ -362,6 +368,15 @@ def load_backend(
     return TorchBackend(model, tokenizer, checkpoint_dir=checkpoint_dir, max_tokens=max_tokens)
 
 
+def _uses_language_model_layout(adapter_dir):
+    """Whether a source adapter's tensors address the multimodal class's language_model."""
+    from safetensors import safe_open
+
+    with safe_open(str(Path(adapter_dir) / "adapter_model.safetensors"), "np") as weights:
+        names = weights.keys()  # a safetensors handle, not a dict
+    return any(".language_model." in name for name in names)
+
+
 def _warm_start(model, adapter_dir, lora_rank, lora_alpha):
     """Continue a verified source LoRA: its exact modules and weights, with fresh optimizer state.
 

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/flash/runner/lifecycle/preparation.py

@@ -344,6 +344,15 @@ def _preparation_digest(
             and not stored_train.get("init_from_adapter")
         ):
             public_payload["train"].pop("lora_alpha", None)
+        # a custom run's public `train` is filtered to `flash.schema.custom.TRAIN_KEYS`, so adding a
+        # key there (`init_from_adapter` in 1.4.9) makes `to_dict()` emit it, empty, for every
+        # custom run prepared before -- and their digests then fail. replay the omission the same
+        # way: drop a key only when the STORED spec lacks it and its value is empty, so a set value
+        # stays bound and a run prepared with the key keeps hashing it.
+        if public_spec.algorithm == "custom" and isinstance(stored_train, Mapping):
+            for key in [k for k, v in public_payload["train"].items() if k not in stored_train]:
+                if not public_payload["train"][key]:
+                    public_payload["train"].pop(key)
     worker_payload = worker_spec.to_internal_dict()
     # NORMALIZATION, not legacy replay: this is the canonical shape `dev` hashes TODAY (1.2.88), and
     # it is unconditional -- it reads nothing off the stored record and applies to every run this

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/flash/serving/promotion/evidence.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 import math
 import re
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Any
 
 _SHA_PATTERN = re.compile(r"^[0-9a-f]{40}$")
@@ -76,6 +76,9 @@ ACCOUNTING_UNSETTLED = "accounting_canary_unsettled"
 class PromotionVerdict:
     ok: bool
     reason: str = ""
+    # diagnostic only (e.g. the error behind an unreadable accounting snapshot); never compared, so
+    # verdicts stay equal by outcome and reason.
+    detail: str = field(default="", compare=False)
 
 
 PASS = PromotionVerdict(ok=True)

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/flash/serving/promotion/gate.py

@@ -199,6 +199,22 @@ async def _await_health(
     return verdict
 
 
+def _error_detail(error: Exception) -> str:
+    """name the failure behind an unreadable snapshot without request headers or credentials.
+
+    an RPC failure (for example a postgres statement timeout, SQLSTATE 57014) otherwise reads as
+    schema drift, because both surface as accounting_malformed.
+    """
+    response = getattr(error, "response", None)
+    if response is not None and getattr(response, "status_code", None) is not None:
+        try:
+            body = response.text
+        except Exception:
+            body = ""
+        return f"{type(error).__name__}: HTTP {response.status_code} {body[:300]}".strip()
+    return f"{type(error).__name__}: {str(error)[:300]}".rstrip(": ")
+
+
 async def _await_accounting(
     loader: AccountingLoader,
     *,
@@ -215,8 +231,10 @@ async def _await_accounting(
             snapshot = await asyncio.wait_for(loader(), timeout=remaining)
         except TimeoutError:
             return verdict
-        except Exception:
-            verdict = PromotionVerdict(ok=False, reason=ACCOUNTING_MALFORMED)
+        except Exception as error:
+            verdict = PromotionVerdict(
+                ok=False, reason=ACCOUNTING_MALFORMED, detail=_error_detail(error)
+            )
         else:
             # even a successful response arriving at the deadline cannot promote the release.
             if clock() >= deadline:
@@ -385,7 +403,8 @@ def main(argv: list[str] | None = None) -> int:
     if verdict.ok:
         print("promotion gate passed")
         return 0
-    print(f"promotion gate failed: {verdict.reason}", file=sys.stderr)
+    detail = f" ({verdict.detail})" if verdict.detail else ""
+    print(f"promotion gate failed: {verdict.reason}{detail}", file=sys.stderr)
     return 1
 
 

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.4.9"
+version = "1.4.10"
 description ="Flash — managed LoRA post-training (SFT/GRPO) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # The training and serving stack is validated on Python 3.11 and 3.12.
@@ -209,7 +209,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.9"
+version = "1.4.10"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/tests/serving/test_promotion_gate.py

@@ -8,6 +8,7 @@ import pathlib
 import time
 from unittest import mock
 
+import httpx
 import pytest
 
 from flash.serving.promotion import gate as gate_module
@@ -23,6 +24,7 @@ from flash.serving.promotion.evidence import (
     HEALTH_DEPLOYMENT_ID_MISMATCH,
     HEALTH_SHA_MISMATCH,
     STREAM_NO_CONTENT,
+    PromotionVerdict,
     StreamEvidence,
 )
 from flash.serving.promotion.gate import (
@@ -368,6 +370,46 @@ def test_an_unreadable_snapshot_never_passes_as_settled():
     assert verdict.reason == ACCOUNTING_MALFORMED
 
 
+def _statement_timeout() -> httpx.HTTPStatusError:
+    request = httpx.Request(
+        "POST",
+        "https://project.supabase.co/rest/v1/rpc/serving_promotion_accounting_snapshot",
+        headers={"apikey": "service-role-secret", "Authorization": "Bearer service-role-secret"},
+    )
+    response = httpx.Response(
+        500,
+        request=request,
+        json={"code": "57014", "message": "canceling statement due to statement timeout"},
+    )
+    return httpx.HTTPStatusError("server error", request=request, response=response)
+
+
+def test_an_rpc_failure_names_its_cause_without_changing_the_verdict():
+    """A statement timeout and schema drift share a reason code; the detail tells them apart."""
+    verdict, _ = _evaluate(
+        health=_health(),
+        stream=_good_stream(),
+        accounting=_statement_timeout(),
+        accounting_deadline_seconds=1,
+    )
+    assert verdict == PromotionVerdict(ok=False, reason=ACCOUNTING_MALFORMED)
+    assert "HTTP 500" in verdict.detail
+    assert "57014" in verdict.detail
+    assert "service-role-secret" not in verdict.detail
+
+
+def test_the_failure_line_carries_the_detail(monkeypatch, capsys):
+    detail = "HTTPStatusError: HTTP 500 statement timeout"
+
+    async def failed(plan):
+        return PromotionVerdict(ok=False, reason=ACCOUNTING_MALFORMED, detail=detail)
+
+    monkeypatch.setattr(gate_module, "_resolve", lambda base_url, env: object())
+    monkeypatch.setattr(gate_module, "_run", failed)
+    assert gate_module.main([]) == 1
+    assert f"promotion gate failed: {ACCOUNTING_MALFORMED} ({detail})" in capsys.readouterr().err
+
+
 def test_promotion_passes_only_when_all_three_layers_prove_themselves():
     verdict, calls = _evaluate(health=_health(), stream=_good_stream(), accounting=_Snapshot())
     assert verdict.ok

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/tests/test_custom_worker.py

@@ -94,3 +94,25 @@ def test_warm_start_downloads_verified_source_before_loading_backend(monkeypatch
     assert calls == [("Qwen/Qwen3.5-0.8B", 32, 64, multimodal)]
     assert load.call_args.kwargs["init_adapter"] == "/tmp/evdl/source/adapter"
     assert load.call_args.kwargs["lora_rank"] == 32
+
+
+def test_warm_start_detects_the_source_adapters_module_layout(tmp_path):
+    import numpy as np
+    from safetensors.numpy import save_file
+
+    from flash.custom.backend import _uses_language_model_layout
+
+    for name, key, expected in (
+        (
+            "multimodal",
+            "base_model.model.model.language_model.layers.0.mlp.up_proj.lora_A.weight",
+            True,
+        ),
+        ("text", "base_model.model.model.layers.0.mlp.up_proj.lora_A.weight", False),
+    ):
+        adapter = tmp_path / name
+        adapter.mkdir()
+        save_file(
+            {key: np.zeros((2, 2), dtype=np.float32)}, str(adapter / "adapter_model.safetensors")
+        )
+        assert _uses_language_model_layout(adapter) is expected

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/tests/test_warmstart_cross_repo.py

@@ -1558,3 +1558,91 @@ def test_a_snapshot_written_before_the_version_key_still_recovers(monkeypatch, t
         validate_persisted_spec_envelope({"version": "1"})
     with pytest.raises(ValueError, match="unsupported persisted preparation envelope version"):
         validate_persisted_spec_envelope({"version": PREPARATION_ENVELOPE_VERSION + 1})
+
+
+def _custom_run_status(monkeypatch, tmp_path, *, legacy_train_keys=False):
+    """A provisioned custom run as `submit` persists it, optionally as a pre-1.4.9 build wrote it.
+
+    A pre-1.4.9 build filtered custom `train` through `TRAIN_KEYS` without `init_from_adapter`, so
+    its stored public spec and its digest both lack the key. `model_revision_auto` puts the run on
+    the digest branch of `effective_spec_from_status`, as every auto-pinned custom run is.
+    """
+    import flash.schema.custom as custom_schema
+    from flash.core.spec import JobSpec
+
+    monkeypatch.setattr(runner_state, "RUNS_DIR", str(tmp_path / "runs"))
+    raw = {
+        "run_id": "custom-run",
+        "model": "Qwen/Qwen3.5-9B",
+        "algorithm": "custom",
+        "gpu": {"type": "H200"},
+        "train": {
+            "max_steps": 10,
+            "max_context_tokens": 4096,
+            "save_every": 10,
+            "lora_rank": 32,
+            "lora_alpha": 64,
+        },
+        "custom": {"file": "loop.py", "idle_seconds": 900, "max_wall_seconds": 3600},
+    }
+    public = JobSpec.from_dict(raw)
+    worker = JobSpec.from_dict(
+        {**public.to_internal_dict(), "model_revision": "a" * 40, "model_revision_auto": True}
+    )
+    with monkeypatch.context() as legacy:
+        if legacy_train_keys:
+            legacy.setattr(
+                custom_schema, "TRAIN_KEYS", custom_schema.TRAIN_KEYS - {"init_from_adapter"}
+            )
+        stored_public = public.to_dict()
+        snapshot = runner_submit._effective_preparation_snapshot(public, worker, None)
+    runner_state._save_status(
+        runner_state.RunStatus(
+            run_id=public.run_id, state="done", spec=stored_public, effective_preparation=snapshot
+        )
+    )
+    return stored_public
+
+
+def test_custom_run_prepared_before_init_from_adapter_still_verifies(monkeypatch, tmp_path):
+    """Adding `init_from_adapter` to custom `TRAIN_KEYS` must not invalidate older custom runs.
+
+    `to_dict()` now emits the key, empty, for every custom run, so rehashing one prepared before
+    hashed bytes it never had: resume and deploy of every earlier custom checkpoint failed with
+    "persisted effective preparation failed integrity validation".
+    """
+    from flash.core.spec import JobSpec
+
+    stored = _custom_run_status(monkeypatch, tmp_path, legacy_train_keys=True)
+    assert "init_from_adapter" not in stored["train"]
+    assert "init_from_adapter" in JobSpec.from_dict(stored).to_dict()["train"]
+
+    recovered = runner_status.effective_spec_from_status(runner_status.get_status("custom-run"))
+    assert recovered.algorithm == "custom"
+    assert recovered.train.lora_rank == 32
+
+
+def test_custom_digest_replay_drops_only_empty_omitted_train_keys():
+    """The replay may drop a key only when it is empty; a set source adapter stays hashed."""
+    from flash.core.spec import JobSpec
+
+    raw = {
+        "run_id": "custom-run",
+        "model": "Qwen/Qwen3.5-9B",
+        "algorithm": "custom",
+        "train": {"max_steps": 10, "lora_rank": 32, "lora_alpha": 64},
+        "custom": {"file": "loop.py"},
+    }
+    plain = JobSpec.from_dict(raw)
+    warm = replace(plain, train=replace(plain.train, init_from_adapter="flash-1/final"))
+    stored_without_key = plain.to_dict()
+    stored_without_key["train"].pop("init_from_adapter")
+
+    def digest(spec, stored):
+        return runner_preparation._preparation_digest(spec, spec, None, stored_public=stored)
+
+    # an empty, omitted key hashes like the older serialization that never had it
+    assert digest(plain, stored_without_key) != digest(plain, plain.to_dict())
+    # a set value is never dropped, whatever the stored record claims
+    assert digest(warm, stored_without_key) == digest(warm, warm.to_dict())
+    assert digest(warm, stored_without_key) != digest(plain, stored_without_key)

{freesolo_flash_dev-1.4.9 → freesolo_flash_dev-1.4.10}/uv.lock

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