freesolo-flash-dev 1.4.11__tar.gz → 1.4.12__tar.gz

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/.github/workflows/bake-kernel-cache.yml

@@ -218,11 +218,11 @@ jobs:
           # marks the whole job red even though the bake + push already succeeded.
           enable-cache: false
 
-      - name: Sync deps (flash + modal + hf)
+      - name: Sync bake dependencies
         if: steps.gate.outputs.run == 'true'
         run: uv sync --extra server
 
-      # MODAL_TOKEN_ID + MODAL_TOKEN_SECRET (the warmup GPU sandbox) + HF_TOKEN (the temp dataset that ferries code/cache) are
+      # MODAL_TOKEN_ID + MODAL_TOKEN_SECRET (the warmup GPU sandbox) + HF_TOKEN (upstream model/tokenizer downloads) are
       # native repo Actions secrets, synced from Infisical (prod:/flash-ci) by the github-ci-flash
       # Secret Sync. No Infisical CLI/login at job time -- Infisical stays the source of truth and
       # rotations propagate via the sync. BASE_IMAGE

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/CHANGELOG.md

@@ -18,6 +18,10 @@ This file starts at 1.1.35. Earlier releases are not reconstructed here; use
 
 ## Unreleased
 
+- Correct artifact diagnostics, generated training guidance, and internal documentation to name
+  Azure storage. Upstream model/tokenizer downloads and explicit Hugging Face exports remain
+  supported; legacy serialized storage-field names remain compatible.
+
 ### Removed
 
 - Removed built-in OPD completely: training workers, managed teacher API and ledger, configuration,

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.4.11
+Version: 1.4.12
 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.11 → freesolo_flash_dev-1.4.12}/docker/bake_kernel_cache.py

@@ -7,11 +7,10 @@ import json
 import os
 import shutil
 import tarfile
+import tempfile
 import time
 import uuid
 
-ARTIFACT_NAMESPACE = "Freesolo-Co"
-
 # One Modal GPU per compiler architecture; the worker verifies the requested SM.
 GPU_BY_SM = {
     "sm80": "A100-80GB",
@@ -27,31 +26,30 @@ def log(msg: str) -> None:
     print(f"[bake-ci] {msg}", flush=True)
 
 
-def _upload_flash_code(api, repo: str, token: str) -> None:
-    """Mirror the worker's upload_code: push the running flash package to code/flash (exact mirror)."""
-    import flash
+async def _collect_bake(sandbox, out, arch: str, deadline: int) -> None:
+    """Run warmup while the sandbox stays alive, then stream its outputs before teardown."""
+    from flash.providers.modal import api as modal_api
 
-    pkg_dir = os.path.realpath(os.path.dirname(os.path.abspath(flash.__file__)))
-    api.create_repo(repo_id=repo, repo_type="dataset", private=True, exist_ok=True)
-    # mirror upload_code: force private even if the id pre-existed as a public repo, before any
-    # flash source is uploaded.
-    api.update_repo_settings(repo_id=repo, repo_type="dataset", private=True)
-    api.upload_folder(
-        folder_path=pkg_dir,
-        path_in_repo="code/flash",
-        repo_id=repo,
-        repo_type="dataset",
-        ignore_patterns=["__pycache__/*", "*.pyc"],
-        delete_patterns=["**"],
+    process = await sandbox.exec.aio("python", "-u", "/opt/flash/bake.py", timeout=deadline)
+    returncode = await process.wait.aio()
+    if returncode != 0:
+        raise modal_api.ModalApiError(
+            f"Kernel warmup exited with code {returncode}; "
+            f"inspect Modal sandbox {sandbox.object_id}"
+        )
+    status = await sandbox.filesystem.read_text.aio("/out/STATUS")
+    if status != f"rc=0\narch={arch}\n":
+        raise modal_api.ModalApiError("kernel warmup finished without a valid completion marker")
+    await sandbox.filesystem.copy_to_local.aio(
+        "/out/kernel_cache.tar.gz", out / "kernel_cache.tar.gz"
     )
-    log(f"uploaded flash code -> {repo}:code/flash (from {pkg_dir})")
+    await sandbox.filesystem.copy_to_local.aio("/out/warmup.log", out / "bake-warmup.log")
 
 
 def main() -> int:
     from pathlib import Path
 
-    from huggingface_hub import HfApi, snapshot_download
-
+    import flash
     from flash.providers.modal import api as modal_api
 
     parser = argparse.ArgumentParser(description="Bake worker kernels on Modal")
@@ -65,11 +63,7 @@ def main() -> int:
     if not 1 <= args.deadline_min <= 1440:
         parser.error("deadline must be between 1 and 1440 minutes")
     token = os.environ["HF_TOKEN"]
-    hf = HfApi(token=token)
     suffix = args.run_id or f"{int(time.time())}-{uuid.uuid4().hex[:8]}"
-    repo = (
-        f"{os.environ.get('FLASH_HF_NAMESPACE', ARTIFACT_NAMESPACE)}/kernel-bake-{args.sm}-{suffix}"
-    )
     entry = Path(__file__).with_name("bake_sandbox_entry.py")
 
     async def bake(modal, client):
@@ -79,74 +73,51 @@ def main() -> int:
             create_if_missing=True,
             client=client,
         )
-        image = modal.Image.from_registry(args.image).add_local_file(
-            str(entry), "/opt/flash/bake.py", copy=True
+        image = (
+            modal.Image.from_registry(args.image)
+            .add_local_dir(
+                Path(flash.__file__).parent,
+                "/runcode/code/flash",
+                copy=True,
+                ignore=["**/__pycache__/**", "**/*.pyc"],
+            )
+            .add_local_file(str(entry), "/opt/flash/bake.py", copy=True)
         )
         sandbox = await modal.Sandbox.create.aio(
-            "python",
-            "-u",
-            "/opt/flash/bake.py",
+            "sleep",
+            "infinity",
             app=app,
             image=image,
             name=f"bake-{args.sm}-{suffix}",
             gpu=GPU_BY_SM[args.sm],
-            timeout=args.deadline_min * 60,
+            timeout=min(86400, args.deadline_min * 60 + 600),
             cpu=(4, 8),
             # Keep the reservation at 32 GiB, but allow compiler memory to burst. The
             # H100 warmup was evicted for thrashing at the previous 64 GiB limit.
             memory=(32768, 131072),
-            secrets=[
-                modal.Secret.from_dict(
-                    {"BAKE_HF_REPO": repo, "BAKE_ARCH": args.arch, "HF_TOKEN": token}
-                )
-            ],
+            secrets=[modal.Secret.from_dict({"BAKE_ARCH": args.arch, "HF_TOKEN": token})],
             client=client,
         )
         try:
-            await sandbox.wait.aio()
-            returncode = await sandbox.poll.aio()
-            if returncode != 0:
-                # The provider wrapper sanitizes ordinary exceptions. Preserve this
-                # credential-free diagnostic so CI names the failed sandbox and exit.
-                raise modal_api.ModalApiError(
-                    f"Kernel warmup exited with code {returncode}; "
-                    f"inspect Modal sandbox {sandbox.object_id}"
-                )
+            await _collect_bake(sandbox, staging, args.arch, args.deadline_min * 60)
         finally:
             await sandbox.terminate.aio(wait=True)
 
-    try:
-        _upload_flash_code(hf, repo, token)
-        modal_api.call(bake, timeout=args.deadline_min * 60 + 120)
-        if not _status_present(hf, repo, retries=3):
-            raise RuntimeError("kernel warmup finished without its completion marker")
-        import tempfile
-
-        with tempfile.TemporaryDirectory(prefix="flash-kernel-") as temp:
-            snapshot_download(
-                repo_id=repo,
-                repo_type="dataset",
-                allow_patterns=["out/**"],
-                local_dir=temp,
-                token=token,
-            )
-            shutil.copytree(Path(temp) / "out", args.out, dirs_exist_ok=True)
-            archive = Path(args.out) / "kernel_cache.tar.gz"
-            if archive.exists():
-                _extract_cache_archive(archive, Path(args.out))
-                archive.unlink()
-            # The base image can contain an older warmup.log inside its cache tree. Keep the
-            # current subprocess log authoritative after archive extraction.
-            log_path = Path(temp) / "out" / "bake-warmup.log"
-            if log_path.exists():
-                shutil.copy2(log_path, Path(args.out) / "bake-warmup.log")
-                shutil.copy2(log_path, Path(args.out) / "warmup.log")
-        return _verify(args.out, args.sm)
-    finally:
-        try:
-            hf.delete_repo(repo_id=repo, repo_type="dataset")
-        except Exception:
-            log(f"WARNING: could not delete temporary repository {repo}; remove it manually")
+    # Never let leftovers from a previous bake satisfy this run's verification.
+    with tempfile.TemporaryDirectory(prefix="flash-kernel-") as temp:
+        staging = Path(temp)
+        modal_api.call(bake, timeout=args.deadline_min * 60 + 600)
+        archive = staging / "kernel_cache.tar.gz"
+        # Preserve the current log even if an older log exists inside the exported cache.
+        current_log = (staging / "bake-warmup.log").read_bytes()
+        _extract_cache_archive(archive, staging)
+        archive.unlink()
+        (staging / "bake-warmup.log").write_bytes(current_log)
+        (staging / "warmup.log").write_bytes(current_log)
+        result = _verify(str(staging), args.sm)
+        if result == 0:
+            shutil.copytree(staging, args.out, dirs_exist_ok=True)
+        return result
 
 
 def _extract_cache_archive(archive_path, destination) -> None:
@@ -167,19 +138,6 @@ def _extract_cache_archive(archive_path, destination) -> None:
         archive.extractall(root, members=members, filter="data")
 
 
-def _status_present(api, repo: str, retries: int = 1) -> bool:
-    """Authoritative out/STATUS check, retried to ride out a transient HF list error."""
-    for i in range(retries):
-        try:
-            if "out/STATUS" in api.list_repo_files(repo, repo_type="dataset"):
-                return True
-        except Exception as e:
-            log(f"hf list err (status recheck {i + 1}/{retries}): {str(e)[:100]}")
-        if i < retries - 1:
-            time.sleep(5)
-    return False
-
-
 def _verify(out: str, sm: str) -> int:
     """Confirm the artifact actually landed and its metadata matches the requested arch."""
     from flash.engine.worker.runtime.kernel_warmup import CACHE_META_FILENAME, has_raw_kernel_cache

freesolo_flash_dev-1.4.12/docker/bake_sandbox_entry.py

@@ -0,0 +1,90 @@
+"""Warm and verify kernels inside the GPU sandbox, writing outputs for direct Modal transfer.
+
+The CI helper mounts the Flash package at /runcode/code/flash. The worker image supplies
+its dependencies. HF_TOKEN is retained only for upstream model/tokenizer downloads;
+BAKE_ARCH selects the compiler architecture. /out/STATUS is written last.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import tarfile
+import time
+
+CACHE_DIR = "/opt/flash/kernelcache"
+OUT_DIR = "/out"
+CACHE_ARCHIVE = "/out/kernel_cache.tar.gz"
+
+
+def _replace_cache_with_exported_copy(cache_dir: str, archive_path: str) -> None:
+    """Archive the cache, delete the originals, and restore files at the same absolute paths."""
+    with tarfile.open(archive_path, "w:gz", compresslevel=1) as archive:
+        archive.add(cache_dir, arcname=".")
+    shutil.rmtree(cache_dir)
+    with tarfile.open(archive_path, "r:gz") as archive:
+        archive.extractall(cache_dir, filter="data")
+
+
+def main() -> int:
+    os.environ["HF_HUB_DISABLE_XET"] = "1"
+    arch = os.environ.get("BAKE_ARCH", "")
+    os.makedirs(OUT_DIR, exist_ok=True)
+    with open(os.path.join(OUT_DIR, "STARTED"), "w") as marker:
+        marker.write(f"started arch={arch}\n")
+
+    env = {**os.environ, "PYTHONPATH": "/runcode/code"}
+    python_bin = os.environ.get("FLASH_VERL_PYTHON", "/opt/verl-venv/bin/python")
+    if not os.path.isfile(python_bin):
+        raise RuntimeError(f"training interpreter missing: {python_bin}")
+    cache_dir = CACHE_DIR
+    # An already-baked input image must not supply stale artifacts or validation receipts.
+    shutil.rmtree(cache_dir, ignore_errors=True)
+    os.makedirs(cache_dir)
+    cmd = [
+        python_bin,
+        "-m",
+        "flash.engine.worker.runtime.kernel_warmup",
+        "--out",
+        cache_dir,
+    ]
+    if arch:
+        cmd += ["--arch", arch]
+    print(f"[bake] running: {' '.join(cmd)}", flush=True)
+    # capture the warmup output into /out so it ships back with the cache -- lets the CI helper show
+    # which warm steps ran and why a bake failed to produce compiled kernel files.
+    os.makedirs(OUT_DIR, exist_ok=True)
+    started = time.monotonic()
+    with open(os.path.join(OUT_DIR, "warmup.log"), "wb") as lf:
+        rc = subprocess.call(cmd, env=env, stdout=lf, stderr=subprocess.STDOUT)
+    first_seconds = time.monotonic() - started
+    validation = {"first_process_seconds": first_seconds, "first_exit_code": rc}
+    if rc == 0:
+        # Remove the compiler outputs and restore only the exported archive. A fresh process
+        # alone could otherwise reuse files that never make it into the shipped artifact.
+        _replace_cache_with_exported_copy(cache_dir, CACHE_ARCHIVE)
+        started = time.monotonic()
+        with open(os.path.join(OUT_DIR, "warmup.log"), "ab") as lf:
+            lf.write(b"\n[bake] fresh-process cache reload validation\n")
+            rc = subprocess.call(
+                [*cmd, "--verify-cache"], env=env, stdout=lf, stderr=subprocess.STDOUT
+            )
+        validation.update(
+            reload_process_seconds=time.monotonic() - started,
+            reload_exit_code=rc,
+            exported_cache_replayed=True,
+        )
+    with open(os.path.join(cache_dir, "cache_validation.json"), "w") as output:
+        json.dump(validation, output)
+    print(f"[bake] kernel_warmup rc={rc}", flush=True)
+    # Preserve hidden compiler directories and the exact cache layout in one streamed archive.
+    with tarfile.open(CACHE_ARCHIVE, "w:gz", compresslevel=1) as archive:
+        archive.add(cache_dir, arcname=".")
+    with open(os.path.join(OUT_DIR, "STATUS"), "w") as marker:
+        marker.write(f"rc={rc}\narch={arch}\n")
+    print(f"[bake] ENTRY_DONE rc={rc}", flush=True)
+    return rc
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/adapters/artifacts.py

@@ -115,7 +115,7 @@ def _index_shard_names(names: set[str], suffix: str) -> set[str]:
 
 
 # The largest attempt identity any artifact name may carry. An attempt number reaches a filename and
-# an HF path, so it is bounded rather than merely nonnegative: an unbounded int would still format,
+# an artifact path, so it is bounded rather than merely nonnegative: an unbounded int would still format,
 # and the resulting name is the one thing a later reader has to match exactly.
 MAX_ATTEMPT_ID = (1 << 63) - 1
 

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/adapters/config.py

@@ -6,7 +6,7 @@ actually serve? Answering it separately let them drift -- customer-owned resolut
 config that hosted admission accepted, so the same artifact was refused before provisioning on one
 path and refused inside the paid container on the other.
 
-Every rule here is decidable from the config alone. Nothing in this module reads the hub, the
+Every rule here is decidable from the config alone. Nothing in this module reads artifact storage, the
 filesystem, or a provider, so a verdict costs a caller nothing beyond the bytes it already holds.
 That is why it sits beside the rank and target rules rather than under a deployment path: the
 GPU-side materializer revalidates a cache entry it already holds, and it needs the same verdict
@@ -44,7 +44,7 @@ class _DuplicateConfigKey(AdapterConfigError):
 def parse_declared_adapter_config(raw: bytes, *, source: str) -> DeclaredAdapterConfig:
     """read one adapter's declared provenance, or refuse the bytes.
 
-    ``source`` names the file in every message, so a caller that fetched the config from the hub and
+    ``source`` names the file in every message, so a caller that fetched the config from artifact storage and
     one that read it off disk both report a location the reader can go look at.
     """
 

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/adapters/lora_rank.py

@@ -105,13 +105,9 @@ def _positive_int(value: Any, *, source: str, field: str) -> int:
 
 
 def _file_identity(file_info: Any) -> str:
-    # the producer is `ArtifactStore.list_repo_tree`, which yields `ArtifactFile` -- whose `__init__` always
-    # sets `path`/`size`/`blob_id` and builds `lfs` as a `BlobLfsInfo` (field `sha256`, no `oid`).
-    # verified at the declared floor `huggingface-hub>=1.2.0` and at the installed 1.27.0, so the
-    # mapping-shaped `lfs` and the `lfs.oid` spelling have no producer in the supported range.
-    # `getattr` stays only on `lfs` itself, which is legitimately optional (non-LFS files), and on
-    # the entry object, because a listing also yields `RepoFolder` -- no size, no blob_id -- which
-    # must fail closed rather than hash to a folder's tree id.
+    # Azure ArtifactFile entries carry path, size and the content digest in blob_id.
+    # lfs.sha256 remains accepted for saved source metadata from before the migration.
+    # reject entries without file identity rather than hashing a folder or missing metadata.
     lfs = getattr(file_info, "lfs", None)
     oid = getattr(lfs, "sha256", None)
     size = getattr(lfs, "size", None)
@@ -487,7 +483,7 @@ def inspect_adapter_config(
 def load_artifact_adapter_config(
     adapter_ref: str, token: str | None = None, revision: str | None = None
 ) -> Mapping[str, Any]:
-    """Read ``adapter_config.json`` for a Flash adapter ref from Hugging Face datasets."""
+    """Read ``adapter_config.json`` for a Flash adapter ref from private Azure storage."""
     repo, filename = adapter_config_path_from_ref(adapter_ref)
     try:
         from flash.artifacts.api import download_file

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/cli/commands/env/ops/setup.py

@@ -696,7 +696,7 @@ def _write_rl_config(
             "# Constrain every rollout with guided decoding (a JSON schema is shown; regex and\n"
             "# choice forms also parse) — see `flash train --doc`:\n"
             '# structured_outputs = \'{"type": "object", "properties": {"answer": {"type": "string"}}, "required": ["answer"]}\'\n'
-            "# GPU and HF artifacts are managed automatically by the platform: the GPU is\n"
+            "# GPU and Azure artifacts are managed automatically by the platform: the GPU is\n"
             "# the cheapest fitting managed class, and artifacts live in a private environment-scoped repo.\n"
         )
 
@@ -725,7 +725,7 @@ def _write_sft_config(
             f"{max_examples_line}"
             "lora_rank = 32\n"
             f"{sft_reasoning_note}"
-            "# GPU and HF artifacts are managed automatically by the platform: the GPU is\n"
+            "# GPU and Azure artifacts are managed automatically by the platform: the GPU is\n"
             "# the cheapest fitting managed class, and artifacts live in a private environment-scoped repo.\n"
         )
 

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/cli/parsing/serve_parser.py

@@ -16,7 +16,7 @@ def _positive_finite_seconds(raw: str) -> float:
 
     Without this, `--timeout 0`, a negative, `nan`, or `inf` parses fine and only fails inside the
     provider's `validate_deadline`, which raises `ValueError` outside the lifecycle error handling
-    -- so the CLI prints a traceback *after* resolving and downloading the Hub inputs, instead of
+    -- so the CLI prints a traceback *after* resolving and downloading the model and artifact inputs, instead of
     the ordinary argument error the user should get before any work happens.
     """
     value = float(raw)
@@ -31,8 +31,8 @@ def _positive_int(raw: str) -> int:
     """reject a nonpositive integer before deployment input resolution.
 
     a bare `type=int` accepts `0` and negatives, while downstream validation runs only after
-    `resolve_adapter` has already resolved and downloaded the hub inputs. argparse can reject these
-    values before they cost a hub round trip.
+    `resolve_adapter` has already resolved and downloaded the model and artifact inputs. argparse can reject these
+    values before they cost a storage round trip.
     """
     value = int(raw)
     if value <= 0:
@@ -73,18 +73,19 @@ def _add_deployment_arguments(command: argparse.ArgumentParser) -> None:
         required=True,
         help="digest-qualified serving image reference (name@sha256:...)",
     )
-    command.add_argument("--artifact-repo", required=True, help="hub repo holding the adapter")
+    command.add_argument(
+        "--artifact-repo", required=True, help="Azure artifact namespace holding the adapter"
+    )
     command.add_argument(
         "--artifact-subfolder", required=True, help="path within the repo holding the adapter"
     )
-    # flash runs publish adapters into dataset repos, so that stays the default. the override
-    # exists for an adapter published as a model repo, where resolution would otherwise fail
-    # against the wrong repo type rather than reporting that the repo is a different kind.
+    # keep serialized type labels compatible with existing deployment manifests.
+    # both labels resolve through Azure artifact storage, never an upstream model repository.
     command.add_argument(
         "--artifact-repo-type",
         choices=("dataset", "model"),
         default="dataset",
-        help="hub repo type holding the adapter (default: dataset, as flash runs publish)",
+        help="legacy artifact type label (default: dataset; storage uses Azure)",
     )
     command.add_argument(
         "--lora-rank", type=_positive_int, required=True, help="the adapter's lora rank"
@@ -156,7 +157,7 @@ def _add_existing_deployment_identity(command: argparse.ArgumentParser) -> None:
         "--deployment-identity",
         default="",
         help=(
-            "immutable identity printed by deploy; avoids Hub resolution when checking or removing "
+            "immutable identity printed by deploy; avoids artifact resolution when checking or removing "
             "an existing deployment"
         ),
     )

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/cli/scaffold/TRAINING.md

@@ -351,7 +351,7 @@ There is no "all" sentinel, so this number is duplicated from the data into the
 **can drift**: if the dataset later grows, a stale `max_examples` silently trains on a
 subset instead of erroring. Re-check it whenever the dataset or the params change.
 
-GPU allocation and HF artifacts are **managed by default**: leave `[gpu] type` unset to
+GPU allocation and Azure artifacts are **managed by default**: leave `[gpu] type` unset to
 let the allocator pick the cheapest fitting validated class, while `train.hf_repo` remains
 platform-managed. `[gpu] providers` takes an ordered list of provider names and prefers them in
 that order: the preference ranks ahead of cost, so a preferred provider wins even when a cheaper

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/core/spec.py

@@ -349,7 +349,7 @@ class TrainSpec:
     # internal: immutable source dataset commit used for a prepared warm-start. parsed only from
     # control-plane jobspec payloads; the public config schema does not accept this key.
     init_from_adapter_revision: str = ""
-    # PLATFORM-MANAGED: control-plane-assigned HF artifact repo. Not a user config key: it has no
+    # PLATFORM-MANAGED: Azure artifact namespace. Not a user config key: it has no
     # ``introduced_in`` so it is absent from TRAIN_SCHEMA_KEYS and ``[train] hf_repo`` is rejected.
     # JobSpec.from_dict still round-trips the control-plane-assigned value; to_dict() omits it.
     # Legacy serialized spelling retained so existing preparation digests remain valid.

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/engine/worker/entry/worker.py

@@ -94,7 +94,7 @@ def _run_worker_mode(*, context: WorkerContext) -> None:
                 "already_done", gpu=worker_perf.gpu_diagnostics(), context=context
             )
             # DONE is written only AFTER metrics.json uploads (required=True), so a failed read here
-            # is a transient HF blip, never a missing file. Retry, then signal RETRIABLE (reschedule)
+            # is a transient artifact read failure, never a missing file. Retry, then signal RETRIABLE (reschedule)
             # rather than SystemExit — a BaseException that bypasses the retriable-stamping handler
             # below and would report a genuinely-succeeded run as a fatal failure.
             last_err: Exception | None = None
@@ -129,7 +129,7 @@ def _run_worker_mode(*, context: WorkerContext) -> None:
             error_kind = type(last_err).__name__ if last_err is not None else "unknown error"
             raise worker_perf.RetriableInfraError(
                 "DONE present but metrics.json unreadable after retries "
-                f"(transient HF; {error_kind})"
+                f"(transient artifact read; {error_kind})"
             )
     # these setups run in the parent; verl trains in FLASH_VERL_PYTHON.
     # only _force_fla_triton_gdn_on_sm100 propagates through FLA_* env vars. the install and the
@@ -159,7 +159,7 @@ def _run_worker_mode(*, context: WorkerContext) -> None:
         handler()
     finally:
         context.close()
-    # hard-exit: colocated vllm can deadlock on nccl/cuda teardown; all artifacts are already on hf.
+    # hard-exit: colocated vllm can deadlock on nccl/cuda teardown; all artifacts are already in Azure.
     sys.stdout.flush()
     sys.stderr.flush()
     os._exit(0)

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/engine/worker/io/artifacts.py

@@ -1,4 +1,4 @@
-"""hf artifact channel for code delivery, adapters, metrics, and checkpoints."""
+"""Azure artifact channel for code delivery, adapters, metrics, and checkpoints."""
 
 from __future__ import annotations
 
@@ -106,9 +106,9 @@ def _sleep_with_artifact_deadline(delay: float, *, context: WorkerContext) -> bo
 def _artifact_upload(
     do_upload, repo_subpath: str, required: bool, label: str, *, context: WorkerContext
 ) -> bool:
-    """HF upload loop: retries + raises on required artifacts; warn-only on optional.
+    """Artifact upload loop: retries + raises on required artifacts; warn-only on optional.
 
-    Returns True when a commit landed (or HF_REPO is unset), False on best-effort failure.
+    Returns True when a commit landed (or the artifact namespace is unset), False on best-effort failure.
     """
     if not context.config.hf_repo:
         return True
@@ -145,7 +145,7 @@ def _artifact_upload(
 def upload_artifact_file(
     local_path: str, repo_subpath: str, required: bool = False, *, context: WorkerContext
 ) -> bool:
-    """Upload one file to the run's HF prefix. Returns True on success (see ``_artifact_upload``)."""
+    """Upload one file to the run's artifact prefix. Returns True on success (see ``_artifact_upload``)."""
     return _artifact_upload(
         lambda: artifact_api().upload_file(
             path_or_fileobj=local_path,
@@ -177,7 +177,7 @@ def _resume_checkpoint_upload_slot(timeout_s: float | None = None, *, context: W
 def upload_artifact_folder(
     local_dir: str, repo_subpath: str, required: bool = False, *, context: WorkerContext
 ) -> bool:
-    """Upload a folder to the run's HF prefix. Returns True on success (see ``_artifact_upload``)."""
+    """Upload a folder to the run's artifact prefix. Returns True on success (see ``_artifact_upload``)."""
     return _artifact_upload(
         lambda: artifact_api().upload_folder(
             folder_path=local_dir,

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/engine/worker/io/heartbeat.py

@@ -68,7 +68,7 @@ _HB_THROTTLED_STAGES = _HB_TIGHT_LIVENESS_STAGES | frozenset({"rl_step", "sft_st
 # swallow it. the wrap that follows re-emits with liveness=True and stays throttled.
 _HB_MODEL_LOAD_STAGES = frozenset({"sft_model_load", "custom_model_load"})
 _HB_SUCCESS_TERMINAL_STAGES = frozenset({"done", "already_done"})
-# 600s -> ~6 commits/hr; keeps stall detector alive without hitting the HF commit cap.
+# 600s -> ~6 commits/hr; keeps the stall detector alive while bounding storage writes.
 _HB_TERMINAL_ONLY_INTERVAL_S = 600.0
 
 
@@ -99,22 +99,22 @@ def _is_critical_stage(stage: str) -> bool:
 
     `_failed` earns this as much as the `error_` prefix does: a failure heartbeat is emitted once, at
     the moment the failure is known, and nothing later restates it. `checkpoint_upload_failed` is
-    raised from inside a long HF upload, which is precisely when `_HB_UPLOAD_IN_FLIGHT` is set and an
+    raised from inside a long artifact upload, which is precisely when `_HB_UPLOAD_IN_FLIGHT` is set and an
     unforced ping is dropped -- so the one report of the failure would be discarded exactly in the
     case that produces it.
     """
     return _is_terminal_stage(stage) or stage.endswith("_failed")
 
 
-# Guards throttle bookkeeping; slow HF commit runs outside this lock so heartbeat and liveness
+# Guards throttle bookkeeping; slow artifact commit runs outside this lock so heartbeat and liveness
 # threads don't block on the network.
-# Serializes HF commits to prevent reorder; each thread uploads its own per-call temp file.
+# Serializes artifact commits to prevent reorder; each thread uploads its own per-call temp file.
 # Terminal/error commits wait longer — no later heartbeat can repair them.
 _HB_UPLOAD_LOCK_TIMEOUT_S = 30.0
 _HB_CRITICAL_UPLOAD_LOCK_TIMEOUT_S = 120.0
-# True while a thread holds _HB_UPLOAD_LOCK and is inside the HF commit. Read under _HB_LOCK.
+# True while a thread holds _HB_UPLOAD_LOCK and is inside the artifact commit. Read under _HB_LOCK.
 #
-# The throttle clock (_HB_LAST_UPLOAD) only advances AFTER a commit lands, so during a slow HF
+# The throttle clock (_HB_LAST_UPLOAD) only advances AFTER a commit lands, so during a slow artifact
 # commit every other throttled caller still computes upload_due=True, walks into
 # _HB_UPLOAD_LOCK.acquire() and blocks there for up to the acquire timeout -- 30s, or 120s on a
 # critical stage. That stalls the liveness daemon, and `liveness_heartbeat`'s join delays leaving
@@ -141,7 +141,7 @@ def _dump_thread_stacks(reason: str) -> None:
 def _console_heartbeat_snapshot(
     payload: dict, payload_committed: bool = True, upload_due: bool = False
 ) -> str:
-    """render one bounded console record with explicit hf commit state."""
+    """render one bounded console record with explicit artifact commit state."""
     console_payload = dict(payload)
     metrics_last = console_payload.pop("metrics_last", None)
     if isinstance(metrics_last, list):
@@ -155,7 +155,7 @@ def _console_heartbeat_snapshot(
 
 
 def _set_upload_in_flight(value: bool, *, context: WorkerContext) -> None:
-    """Mark whether an HF heartbeat commit is running. Call with _HB_LOCK held."""
+    """Mark whether an artifact heartbeat commit is running. Call with _HB_LOCK held."""
 
     context.heartbeat_state.upload_in_flight = value
 
@@ -248,7 +248,7 @@ def heartbeat(
             context.heartbeat_state.last_progress_ts = ts
             context.heartbeat_state.progress_seq += 1
         elif context.heartbeat_state.progress_seq > context.heartbeat_state.progress_uploaded_seq:
-            # carry real progress that has not reached hf yet.
+            # carry real progress that has not reached artifact storage yet.
             liveness = False
         latest_progress_ts = float(context.heartbeat_state.last_progress_ts or 0.0)
         my_progress_seq = context.heartbeat_state.progress_seq

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/engine/worker/model/adapter.py

@@ -158,8 +158,8 @@ def _download_adapter(adapter_prefix: str | None, *, context: WorkerContext) ->
                     "the prepared warm-start source adapter could not be downloaded"
                 ) from None
         else:
-            # a returned snapshot can still be incomplete: an interrupted transfer, or hf falling
-            # back to a partial local_dir when a throttled metadata call cannot confirm the file set.
+            # a returned snapshot can still be incomplete: an interrupted transfer can leave
+            # a partial local_dir, so validate both config and weights before accepting it.
             if _warmstart_adapter_is_loadable(adir):
                 return adir
         # discard partial local_dir materialization so the next attempt cannot reuse stale files.

{freesolo_flash_dev-1.4.11 → freesolo_flash_dev-1.4.12}/flash/engine/worker/train/entry/sft_train.py

@@ -130,7 +130,7 @@ def _durable_required_save_steps(
             )
         except Exception as error:
             raise _worker_perf.RetriableInfraError(
-                f"could not verify required SFT save step {step} on hf"
+                f"could not verify required SFT save step {step} in artifact storage"
             ) from error
         if exists:
             durable.add(step)
@@ -535,7 +535,7 @@ def _publish_sft_result(
         _worker_hf.upload_artifact_folder(adapter_dir, "adapter", required=True, context=context)
         # only a durably published adapter may suppress the final publish. the seeded resume step no
         # longer needs excluding by hand: it is credited as deployable_published only when its
-        # adapter was actually found on hf, so a resume that carried resumable state without a
+        # adapter was actually found in artifact storage, so a resume that carried resumable state without a
         # servable adapter falls through to this publish instead of being skipped.
         if (
             final_save_due(final_step, options.save_at_steps)