freesolo-flash-dev 1.2.124__tar.gz → 1.2.128__tar.gz

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/CHANGELOG.md

@@ -25,6 +25,16 @@ This file starts at 1.1.35. Earlier releases are not reconstructed here; use
 
 ### Changed
 
+- A Flash run is one seed and may execute several attempts. The provider seed argument threaded
+  beside `spec.seed` is gone, so the spec is the only seed channel and no caller can supply a
+  second one to disagree with it; `Provider.submit_run`/`poll` are now `submit_attempt`/
+  `poll_attempt`; and `runner/supervise/seed_submission.py` is `attempt_supervision.py`. Instance
+  labels drop the redundant seed field (`<run>-s<seed>-a<n>` becomes `<run>-a<n>`), and every
+  RunPod endpoint carries an explicit `-a<n>` ordinal including attempt zero, replacing the `r<n>`
+  retry suffix that made a retry ordinal an identity and left the base name ambiguous between a run
+  and its first attempt. Names that exceed the provider budget now raise rather than truncate,
+  since a clipped ordinal is one two attempts of a run can collide on.
+
 - Run-backed adapters now use only explicit permanent checkpoint identities, `<run_id>/final` and
   `<run_id>/step-N`. Bare run aliases, composite source-revision identities, activation, implicit
   checkpoint fallback, and public artifact provenance have been removed across hosted, managed, and

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.124
+Version: 1.2.128
 Summary: Flash — managed LoRA post-training (SFT/GRPO/OPD) 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.2.128/docs/hosted-inference-load-testing.md

@@ -0,0 +1,224 @@
+# Hosted inference load testing
+
+The `flash.serving.loadtest` package is an operator-only, public-HTTP load harness for the hosted
+inference front door. It is not imported by production serving and it does not create, resize, inspect,
+or destroy provider resources. Operators run it explicitly with the serving extra:
+
+```bash
+uv run --extra serving python -m flash.serving.loadtest validate scenario.json
+uv run --extra serving python -m flash.serving.loadtest discover scenario.json
+uv run --extra serving python -m flash.serving.loadtest run scenario.json results/fake-five-phase
+uv run --extra serving python -m flash.serving.loadtest summarize results/fake-five-phase
+uv run --extra serving python -m flash.serving.loadtest verify results/fake-five-phase
+```
+
+`validate` is allocation-free and performs no HTTP request. `discover` calls only `GET /healthz`.
+`run` calls only `GET /healthz` and `POST /v1/chat/completions`. The credential value is read from the
+environment variable named by `credential_env`; never put a credential value in a scenario file.
+There are no request retries.
+
+## Evidence boundary
+
+The harness verifies exact deployment SHA and deployment id, required capabilities, required base
+models, and immutable adapter response provenance. It checks health before and after every phase and
+at the midpoint of each duration phase. Its evidence remains HTTP-only:
+
+- it cannot prove that a live replica scaled out;
+- it cannot prove that an engine was actually cold or at scale zero;
+- it cannot distinguish a dispatch deadline from the underlying resource constraint;
+- it cannot establish an availability SLA;
+- fake and test runs cannot support production claims.
+
+A `cold_burst` therefore records either `cold_scale_out_intent_http_unattested` or
+`true_scale_zero_intent_http_unattested`. That is an honest statement of the authored intent, not an
+attestation of provider state.
+
+## Strict scenario
+
+Scenarios are strict Pydantic v2 JSON. Unknown fields and fields that belong to another phase kind are
+rejected. The authored `phases` list may contain any subset of the five supported discriminated kinds
+in any order, except that a present `cold_burst` must be the first inference-producing phase. A complete
+five-phase scenario uses `cold_burst`, `warm`, `sustained`, `mixed`, then `overload`.
+
+Dynamic base-model discovery reads `base_models` from `/healthz`, then applies `include`, `exclude`, and
+`require`. `require` is a hard gate.
+
+Explicit adapter targets must name the immutable model id, base model, and checkpoint. The request
+carries `X-Freesolo-Expected-Checkpoint` and the response must match `X-Freesolo-Checkpoint`.
+
+`adapter_revision` and `hf_revision` are optional, because the hosted app does not emit them on every
+deployment. Omitting one verifies checkpoint identity alone rather than passing a header check the
+deployment never answered. Supplying one asserts that the deployment does emit it, so a response that
+omits or changes it is a provenance mismatch, never a skipped assertion. A supplied `hf_revision` must
+still be a canonical 40-character hub commit SHA.
+
+`/healthz` is read for `ok`, deployment identity, capabilities, and `base_models`. `accounting_ok` is
+optional: a deployment that does not report it is not treated as an accounting failure, while an
+explicit `false` stops the run. Note that `/healthz.gpus` is the configured supported-base-model engine
+count, not a live container count, so it can never be read as a replica count.
+
+This fake example covers every phase kind:
+
+```json
+{
+  "schema_version": 1,
+  "name": "fake five-phase hosted inference",
+  "endpoint": "https://example.invalid",
+  "expected_deployment": {
+    "sha": "94210a3",
+    "deployment_id": "fake-deployment-1"
+  },
+  "credential_env": "FAKE_SERVING_TOKEN",
+  "required_capabilities": ["permanent_checkpoint_identity"],
+  "discovery": {
+    "enabled": true,
+    "include": ["model-a", "model-b", "model-c"],
+    "exclude": ["model-b"],
+    "require": ["model-a"]
+  },
+  "targets": [],
+  "profiles": [
+    {
+      "name": "short",
+      "weight": 1.0,
+      "messages": [{ "role": "user", "content": "Return one short sentence." }],
+      "max_tokens": 16,
+      "temperature": 0.0,
+      "top_p": 0.95
+    }
+  ],
+  "client": {
+    "connect_timeout_seconds": 5.0,
+    "read_timeout_seconds": 30.0,
+    "write_timeout_seconds": 10.0,
+    "pool_timeout_seconds": 5.0,
+    "max_in_flight": 8,
+    "max_scheduling_lag_ms": 100.0
+  },
+  "seed": 17,
+  "fake": true,
+  "phases": [
+    {
+      "name": "cold",
+      "kind": "cold_burst",
+      "requests": 4,
+      "burst_window_seconds": 0.2,
+      "cold_intent": "cold_scale_out"
+    },
+    {
+      "name": "warm",
+      "kind": "warm",
+      "requests": 4,
+      "concurrency": 2
+    },
+    {
+      "name": "sustained",
+      "kind": "sustained",
+      "duration_seconds": 2.0,
+      "rate_rps": 2.0
+    },
+    {
+      "name": "mixed",
+      "kind": "mixed",
+      "duration_seconds": 2.0,
+      "rate_rps": 3.0
+    },
+    {
+      "name": "overload",
+      "kind": "overload",
+      "expects_capacity_contract": false,
+      "stages": [
+        { "duration_seconds": 1.0, "rate_rps": 4.0 },
+        { "duration_seconds": 1.0, "rate_rps": 8.0 }
+      ]
+    }
+  ]
+}
+```
+
+`warm` is the only closed-loop phase. Its authored request count is completed with bounded
+concurrency. Every other phase is open-loop. Its dispatch offsets are computed before the phase
+starts. If the client cannot admit an offset within `max_in_flight` and `max_scheduling_lag_ms`, the
+harness writes a terminal `client_admission_missed` record instead of converting that offered request
+into delayed closed-loop work. Overload stages use the same rule and never retry.
+
+## Stream and artifact contract
+
+Streaming requests ask for usage. Every SSE `data:` payload must be valid JSON, followed by exactly
+one `[DONE]`; data after `[DONE]`, a missing terminal finish reason, or a missing `[DONE]` is a protocol
+error. The first nonempty `content` or `reasoning_content` delta defines time to first generated token.
+The first nonempty visible `content` delta is measured separately. Missing usage makes token throughput
+unavailable for that request; the harness never estimates tokens from chunks.
+
+Only HTTP 503 with error code `serving_capacity_unavailable` and `Retry-After: 1` is counted as exact
+capacity rejection. Other 503 responses and 429 responses are separate classes.
+
+An error body can echo the request back, so only a machine error code is read out of it. A code that
+does not look like a slug is recorded as `unrecognized_code`, and a free-text `message` is never
+persisted.
+
+### Overload cannot be demonstrated without a capacity contract
+
+Current Flash `dev` implements no retryable capacity contract. Its engine error mapping returns 504
+for an engine timeout and 502 for other upstream failures; there is no capacity 503 and no
+`Retry-After: 1`. An overload phase run against such a deployment therefore cannot produce a clean
+rejection signal at all.
+
+An overload phase declares this with `expects_capacity_contract`, which defaults to `false`. The flag
+never changes how a response is classified. It only records whether an absence of capacity rejections
+is an accurate description of the deployment or a failed expectation:
+
+| observed                        | `expects_capacity_contract` | verdict                                               |
+| ------------------------------- | --------------------------- | ----------------------------------------------------- |
+| at least one exact capacity 503 | either                      | `capacity_rejection_observed`                         |
+| none                            | `false`                     | `overload_not_demonstrated`                           |
+| none                            | `true`                      | `overload_not_demonstrated_despite_declared_contract` |
+
+**An absence of capacity rejections is never evidence of headroom.** A deployment without a capacity
+contract sheds load in ways this harness cannot distinguish from ordinary failure over public HTTP.
+When any overload phase declares no capacity contract, the summary carries that limitation explicitly.
+No overload phase is ever summarized as a success on the strength of a quiet run.
+
+Each run claims a new result directory and writes:
+
+- `scenario.authored.json`, with prompt content redacted;
+- `scenario.resolved.json`, with discovered targets and cold-intent labels;
+- `events.jsonl`, through one event writer with one terminal row per scheduled request;
+- `summary.json`, atomically;
+- `complete.json`, last, with row counts, byte counts, and SHA-256 hashes.
+
+An interrupted run closes the event stream but never writes `complete.json`. It remains inspectable and
+`verify` rejects it as incomplete. Version 1 has no partial-phase resume.
+
+Artifacts never contain credentials, authorization or request headers, generated text, raw response
+bodies, or per-request prompts. Persisted response headers are limited to content type, retry-after,
+and immutable provenance.
+
+## Metrics
+
+`summary.json` reports overall and per-phase, per-target, and per-profile values:
+
+- scheduled, dispatched, completed, successful, and client-admission-missed counts;
+- offered, dispatch, and completion rates with explicit denominator seconds and basis;
+- scheduling, header, first-generated, first-visible, and total latency p50, p90, p95, p99, and max;
+- usage coverage and token totals, aggregate output token rate, and decode token rate;
+- peak client in-flight, HTTP status and error counts, retry count, exact capacity ratio, and 429 count;
+- authored versus achieved target and profile mix;
+- explicit sustained and mixed authored, scheduling, dispatch, and completion windows.
+
+## B200 owner handoff
+
+The harness does not allocate a B200 and does not attest provider state. The B200 deployment owner must
+complete the provider-side handoff before an operator runs a non-fake scenario:
+
+1. identify the already deployed endpoint, exact release SHA, deployment id, and intended base models;
+2. confirm the B200 resource is owned, budgeted, and governed outside this harness;
+3. decide whether the cold intent is `cold_scale_out` or `true_scale_zero`, and establish that state
+   through the provider control plane without using the harness;
+4. provide only the name of the existing credential environment variable in the scenario;
+5. run `validate`, then `discover`, and confirm the resolved two-of-three or other intended model set;
+6. run into a new result directory, then run `verify` before interpreting `summary.json`;
+7. retain provider-side replica and hardware evidence separately if a scale-out or B200 claim is needed.
+
+A successful HTTP load run is not provider-side proof of B200 identity, replica count, scale-to-zero,
+or autoscaler behavior.

freesolo_flash_dev-1.2.128/flash/_internal/http.py

@@ -0,0 +1,101 @@
+"""authenticated stdlib HTTP that does not let the stdlib replay a credential across a redirect.
+
+`urllib.request.Request` keeps two header bags. `headers` survives a redirect:
+`HTTPRedirectHandler.redirect_request` builds the follow-up request by copying it, stripping only
+content headers. `unredirected_hdrs` does not survive, and `AbstractHTTPHandler.do_open` sends both.
+application code that writes `Request(url, headers={"Authorization": ...})` lands the credential in
+the surviving bag, so the stdlib replays the token against whatever host the `Location` names.
+
+the fix is to move the caller's credential into the bag a redirect cannot copy. it survives any
+transport that forwards the request as it was handed over, so it still holds for a tracing or
+compatibility wrapper that only delegates.
+
+two things it does not cover, both because the credential ends up on an object this module never
+touched:
+
+- a transport that rebuilds the request. `Request.header_items()` merges both bags, so a wrapper
+  that reconstructs with `Request(url, headers=dict(req.header_items()))` puts the credential back
+  in the redirectable bag, and its inner call follows redirects normally.
+- a credential a handler adds mid-open. `redirect_request` builds each hop as a fresh `Request`, so
+  anything scoped to the object we were handed is gone by the second hop; a credentialed
+  `ProxyHandler` re-adds `Proxy-Authorization` to that fresh request and no work on ours reaches it.
+
+containing either is the redirect refusal's job, not this function's.
+
+on top of that the stdlib path refuses the hop outright. no flash or freesolo endpoint answers 3xx,
+so this rejects rather than deciding which hops are safe, and surfaces as an `HTTPError` that every
+caller already classifies.
+"""
+
+from __future__ import annotations
+
+import urllib.request
+from collections.abc import Callable
+from typing import Any
+
+_UrlOpen = Callable[..., Any]
+
+# headers that authenticate the request and must never reach a redirect target.
+_CREDENTIAL_HEADERS = ("authorization", "proxy-authorization", "cookie", "x-api-key")
+
+# the stdlib transport as it was before any test replaced it. comparing against the live
+# `urllib.request.urlopen` instead would defeat the check: a replaced attribute is trivially
+# identical to itself, so every fake would be routed through the opener stack and never called.
+_STDLIB_URLOPEN: _UrlOpen = urllib.request.urlopen
+
+
+class _NoRedirectHandler(urllib.request.HTTPRedirectHandler):
+    """raise 3xx instead of following it."""
+
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def _move_credentials_to_the_unredirected_bag(request: urllib.request.Request) -> None:
+    """move the caller's credential headers into the bag `redirect_request` does not copy.
+
+    `do_open` sends `unredirected_hdrs` and `headers` together, so the request is unchanged on the
+    wire. only the follow-up request a redirect would build loses them.
+    """
+
+    for name in list(request.headers):
+        if name.lower() not in _CREDENTIAL_HEADERS:
+            continue
+        # `do_open` gives `unredirected_hdrs` precedence, so an entry already there is the value
+        # being sent. dropping the redirectable duplicate keeps that principal on the wire;
+        # promoting it instead would silently authenticate as someone else.
+        canonical = request.unredirected_hdrs.get(name)
+        value = request.headers[name]
+        # `remove_header` pops from both bags, so it has to run before the value is re-added.
+        request.remove_header(name)
+        request.add_unredirected_header(name, value if canonical is None else canonical)
+
+
+def _urlopen_no_redirect(
+    request: urllib.request.Request,
+    *,
+    timeout: float,
+    urlopen: _UrlOpen | None = None,
+):
+    """open one authenticated request through a transport that refuses redirects.
+
+    the transport is read at call time rather than bound at import, because many tests replace
+    `urllib.request.urlopen` with a fake. a replaced transport is called directly: it is not the
+    stdlib opener stack, so routing it through a no-redirect opener would not reach it. every
+    authenticated call site in flash passes either nothing or `urllib.request.urlopen` itself, so
+    production always takes the refusing opener below; the direct branch exists for those fakes.
+
+    that makes the refusal guarantee conditional on the transport, and the condition is the global
+    being the one this module imported. rebinding `urllib.request.urlopen` after import - a test
+    fake, an apm shim installed at runtime - routes the call to the direct branch, which does not
+    refuse. relocation still runs first and still holds, so the credential cannot ride a hop the
+    replacement forwards as handed over; what is lost is refusal, and with it containment of the
+    two rebuild-and-handler gaps the module docstring names. a replacement transport owns its own
+    redirect policy.
+    """
+
+    _move_credentials_to_the_unredirected_bag(request)
+    transport = urlopen if urlopen is not None else urllib.request.urlopen
+    if transport is not _STDLIB_URLOPEN:
+        return transport(request, timeout=timeout)
+    return urllib.request.build_opener(_NoRedirectHandler()).open(request, timeout=timeout)

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/flash/cli/commands/env/ops/imports.py

@@ -17,6 +17,7 @@ from pathlib import Path
 
 from flash.cli.commands.env.ops.push import (
     _ENV_EVALUATIONS_SIDECAR,
+    _decode_env_entrypoint_source,
     _ignore_env_push_path,
     _raise_walk_error,
 )
@@ -149,6 +150,18 @@ def _imported_module_names(tree, *, relative_names_are_siblings: bool = True) ->
     return names
 
 
+def _read_env_module_source(path: Path) -> str:
+    """Read one packaged Python file under the interpreter's own encoding contract.
+
+    the publish path decodes the entrypoint with `tokenize.detect_encoding`, so a file carrying a
+    non-utf-8 encoding cookie is publishable. reading it as utf-8 here raises instead, and every
+    caller below treats that as "no imports" -- so the sibling helpers never enter the archive and
+    `env push` exits 0 with an environment that only fails once a gpu has been rented. one decoder
+    for both paths is what keeps "publishable" and "walked for imports" the same set of files.
+    """
+    return _decode_env_entrypoint_source(path.read_bytes())[0]
+
+
 def _helper_imports(helper: Path, *, env_root: Path) -> set[str]:
     """Return imports needed by a packaged helper.
 
@@ -160,7 +173,7 @@ def _helper_imports(helper: Path, *, env_root: Path) -> set[str]:
         return set()
     try:
         return _imported_module_names(
-            ast.parse(helper.read_text(encoding="utf-8"), filename=str(helper)),
+            ast.parse(_read_env_module_source(helper), filename=str(helper)),
             relative_names_are_siblings=helper.parent == env_root,
         )
     except (OSError, SyntaxError, UnicodeDecodeError):
@@ -295,7 +308,7 @@ def _iter_env_sidecar_files(
         # GPU has been rented and the worker imports the module. parsed with the same reader as
         # every other module here, so a lazily imported helper (inside load_environment) counts.
         try:
-            entry_tree = ast.parse(entrypoint.read_text(encoding="utf-8"), filename=str(entrypoint))
+            entry_tree = ast.parse(_read_env_module_source(entrypoint), filename=str(entrypoint))
         except (OSError, SyntaxError, UnicodeDecodeError):
             # the entrypoint is validated for syntax on its own path, and a push that cannot read
             # it fails there with a better message. an unreadable file here just means no closure.
@@ -325,7 +338,7 @@ def _iter_env_sidecar_files(
                 yielded.add(sidecar)
                 yield sidecar, sidecar.relative_to(env_root)
             try:
-                tree = ast.parse(sidecar.read_text(encoding="utf-8"), filename=str(sidecar))
+                tree = ast.parse(_read_env_module_source(sidecar), filename=str(sidecar))
             except SyntaxError as exc:
                 raise ValueError(
                     f"{sidecar}: invalid evaluation sidecar syntax: {exc.msg}"

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/flash/cli/commands/env/ops/push.py

@@ -382,15 +382,40 @@ def _env_name_error(raw: str) -> str:
     return f"env name invalid: {text!r} has no usable characters"
 
 
+def _validate_env_entrypoint_source(source: bytes) -> None:
+    """Reject exact Python bytes that cannot execute as an environment module."""
+    compile(source, _ENV_ENTRYPOINT, "exec")
+
+
+def _decode_env_entrypoint_source(source: bytes) -> tuple[str, str]:
+    """Decode Python bytes with the interpreter's encoding-cookie and BOM contract."""
+    import io
+    import tokenize
+
+    encoding, _ = tokenize.detect_encoding(io.BytesIO(source).readline)
+    return source.decode(encoding), encoding
+
+
+def _python_preamble_lines(lines: list[str]) -> int:
+    """Return the shebang and encoding-cookie lines that must remain first."""
+    if not lines:
+        return 0
+    encoding_cookie = re.compile(r"^[ \t\f]*#.*?coding[:=][ \t]*[-\w.]+", re.ASCII)
+    blank_or_comment = re.compile(r"^[ \t\f]*(?:#|[\r\n]|$)", re.ASCII)
+    if encoding_cookie.match(lines[0]):
+        return 1
+    if len(lines) > 1 and blank_or_comment.match(lines[0]) and encoding_cookie.match(lines[1]):
+        return 2
+    return 1 if lines[0].startswith("#!") else 0
+
+
 def _with_syspath_bootstrap(env_source: str) -> str:
-    """Prepend a sys.path bootstrap so a published env can resolve shipped sibling helpers."""
+    """Insert the sys.path bootstrap after the Python module preamble."""
     import ast
 
-    try:
-        tree = ast.parse(env_source)
-    except SyntaxError:
-        return _ENV_SYSPATH_BOOTSTRAP + env_source
-    insert_after = 0
+    tree = ast.parse(env_source, filename=_ENV_ENTRYPOINT)
+    lines = env_source.splitlines(keepends=True)
+    insert_after = _python_preamble_lines(lines)
     body = tree.body
     i = 0
     if (
@@ -399,13 +424,27 @@ def _with_syspath_bootstrap(env_source: str) -> str:
         and isinstance(getattr(body[0], "value", None), ast.Constant)
         and isinstance(body[0].value.value, str)
     ):
-        insert_after = body[0].end_lineno or 0
+        insert_after = max(insert_after, body[0].end_lineno or 0)
         i = 1
     while i < len(body) and isinstance(body[i], ast.ImportFrom) and body[i].module == "__future__":
-        insert_after = body[i].end_lineno or insert_after
+        insert_after = max(insert_after, body[i].end_lineno or 0)
         i += 1
-    lines = env_source.splitlines(keepends=True)
-    return "".join(lines[:insert_after]) + _ENV_SYSPATH_BOOTSTRAP + "".join(lines[insert_after:])
+    prefix = "".join(lines[:insert_after])
+    if prefix and not prefix.endswith(("\n", "\r")):
+        prefix += "\n"
+    published_source = prefix + _ENV_SYSPATH_BOOTSTRAP + "".join(lines[insert_after:])
+    if not env_source.endswith(("\n", "\r")):
+        published_source = published_source.removesuffix("\n")
+    return published_source
+
+
+def _prepare_env_entrypoint_source(env_source: bytes) -> bytes:
+    """Validate the authored bytes and return the exact validated archive bytes."""
+    _validate_env_entrypoint_source(env_source)
+    decoded_source, encoding = _decode_env_entrypoint_source(env_source)
+    published_source = _with_syspath_bootstrap(decoded_source).encode(encoding)
+    _validate_env_entrypoint_source(published_source)
+    return published_source
 
 
 def _raise_walk_error(error: OSError) -> None:
@@ -674,6 +713,18 @@ def cmd_env_push(args) -> int:
     except ValueError as exc:
         return _err(str(exc))
 
+    try:
+        published_source = _prepare_env_entrypoint_source(entrypoint.read_bytes())
+    except (SyntaxError, UnicodeError, ValueError) as exc:
+        location = (
+            f"line {exc.lineno}" if getattr(exc, "lineno", None) is not None else "unknown line"
+        )
+        return _err(
+            f"cannot publish {src}: environment entrypoint has invalid Python syntax ({location})"
+        )
+    except OSError:
+        return _err(f"cannot publish {src}: environment entrypoint could not be read")
+
     try:
         _check_env_push_limits(
             env_root,
@@ -686,8 +737,7 @@ def cmd_env_push(args) -> int:
 
     with tempfile.TemporaryDirectory(prefix="flash-env-push-") as tmp:
         pkg = Path(tmp)
-        module_source = entrypoint.read_text()
-        (pkg / _ENV_ENTRYPOINT).write_text(_with_syspath_bootstrap(module_source))
+        (pkg / _ENV_ENTRYPOINT).write_bytes(published_source)
         _write_entrypoint_alias(pkg, entrypoint=entrypoint)
         _copy_env_sidecars(
             env_root,

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/flash/cli/scaffold/TRAINING.md

@@ -255,7 +255,7 @@ model = "Qwen/Qwen3.5-9B"   # see `flash models list`
 project = "PROJECT_UUID"  # required UUID from `flash projects create`
 algorithm = "sft"           # "sft" (supervised), "grpo" (RL), or "opd" (on-policy distillation)
 # thinking = true           # opt-in reasoning mode, for models that support it
-# seed = 42                 # reproducible per-run seed; omitted defaults to 42
+# seed = 42                 # the run's one seed; omitted defaults to 42
 
 [environment]
 id = "your-org/your-project/my-env"      # the id printed by `flash env push`
@@ -364,7 +364,9 @@ remove that failover, and cannot be combined with `providers`. An unknown name i
 time and the error lists the names your plane accepts. `[gpu] type` pins one exact active
 validated GPU class. Run artifacts are stored in a
 private environment-scoped repo with content-addressed Flash code snapshots. Set `seed` only at the
-top level. Compose or tweak configs without editing files: `--config extra.toml` (deep-merge) and
+top level: a run has exactly one seed, and if a host fails Flash executes another attempt of that
+same run rather than a new one, so every attempt trains on the seed you set here.
+Compose or tweak configs without editing files: `--config extra.toml` (deep-merge) and
 `--set key=value` (e.g. `--set train.epochs=3`). `--gpus N` is
 shorthand for `--set gpu.count=N`; both land in one override list, so repeats resolve left to
 right.

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/flash/cli/ui/heartbeat.py

@@ -69,7 +69,7 @@ def live_attempt(obj: dict) -> int | None:
 def heartbeat_is_current_attempt(obj: dict, heartbeat: dict) -> bool:
     """False only when the heartbeat provably belongs to a superseded retry attempt.
 
-    Retries reuse the seed's heartbeat path, so a recovered run flips back to ``running`` for the
+    Every attempt of a run shares one heartbeat path, so a recovered run flips back to ``running`` for the
     replacement worker while ``last_heartbeat`` can still be the previous attempt's setup ping until
     the new worker publishes one. ``remote.attempt`` is the live attempt; ``last_heartbeat.attempt``
     is the one that produced the ping. When the live attempt is known, keep the reassurance only for a

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/flash/client/freesolo_api.py

@@ -9,6 +9,7 @@ import urllib.request
 from typing import Any
 
 from flash._internal.channel import CLI_NAME
+from flash._internal.http import _urlopen_no_redirect
 from flash.client.http import (
     FREESOLO_AUTH_VERIFY_PATH,
     FREESOLO_EVAL_RUNS_PATH,
@@ -34,7 +35,7 @@ def verify_freesolo_key(api_key: str, base_url: str | None = None) -> None:
         headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
     )
     try:
-        with urllib.request.urlopen(req, timeout=30) as resp:
+        with _urlopen_no_redirect(req, timeout=30) as resp:
             resp.read()
     except urllib.error.HTTPError as exc:
         if exc.code in (401, 403):
@@ -77,7 +78,7 @@ def _freesolo_request(
         headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
     )
     try:
-        with urllib.request.urlopen(req, timeout=timeout) as resp:
+        with _urlopen_no_redirect(req, timeout=timeout) as resp:
             raw = resp.read()
     except urllib.error.HTTPError as exc:
         if exc.code == 401:

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/flash/client/http.py

@@ -15,6 +15,7 @@ from collections.abc import Iterator, Mapping
 from typing import Any
 
 from flash._internal.channel import CLI_NAME
+from flash._internal.http import _urlopen_no_redirect
 from flash._internal.openai_sse import (
     DeltaEvent,
     ErrorEvent,
@@ -408,7 +409,7 @@ class ApiClient:
         deadline = time.monotonic() + body_deadline if body_deadline is not None else None
         with (
             self._translate_http_errors(),
-            urllib.request.urlopen(
+            _urlopen_no_redirect(
                 req, timeout=_capped_timeout(timeout or self.timeout, deadline)
             ) as resp,
         ):
@@ -435,7 +436,7 @@ class ApiClient:
         )
         with (
             self._translate_http_errors(),
-            urllib.request.urlopen(req, timeout=timeout or self.timeout) as resp,
+            _urlopen_no_redirect(req, timeout=timeout or self.timeout) as resp,
         ):
             if max_bytes is not None:
                 return _read_capped_response(resp, max_bytes)
@@ -804,7 +805,7 @@ class ApiClient:
         decoder = codecs.getincrementaldecoder("utf-8")()
         with (
             self._translate_http_errors(),
-            urllib.request.urlopen(req, timeout=30 * 60) as resp,
+            _urlopen_no_redirect(req, timeout=30 * 60) as resp,
         ):
             content_type = resp.headers.get("Content-Type", "")
             media_type = content_type.partition(";")[0].strip().lower()

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/flash/core/spec.py

@@ -268,18 +268,6 @@ CONTROL_PLANE_OWNED_ENV_KEYS = frozenset(
 TRAINER_BACKEND = "verl"
 
 
-def require_matching_seed(spec: JobSpec, seed: Any) -> int:
-    """Require the retained provider seed argument to match the authoritative JobSpec seed."""
-    provided = parse_seed(seed)
-    canonical = parse_seed(spec.seed)
-    if provided != canonical:
-        raise ValueError(
-            f"provider seed {provided} does not match JobSpec.seed {canonical}; "
-            "use spec.seed as the provider seed"
-        )
-    return canonical
-
-
 def _model_revision(value: Any) -> str:
     """parse an optional exact model-repository revision."""
     if not isinstance(value, str):

{freesolo_flash_dev-1.2.124 → freesolo_flash_dev-1.2.128}/flash/cost/spec.py

@@ -134,7 +134,7 @@ def _rollout_batch_for_quote(spec) -> int:
 
 
 def spec_steps(spec) -> int:
-    """Per-seed optimizer steps implied by a train spec (mirrors the worker).
+    """Per-run optimizer steps implied by a train spec (mirrors the worker).
 
     sft reads the horizon its workload profile measured: the profile already resolved epochs,
     retained rows, realized batch, and ``max_steps`` against the exact tokenized dataset, so