freesolo-flash-dev 1.2.63__tar.gz → 1.2.65__tar.gz

{freesolo_flash_dev-1.2.63 → freesolo_flash_dev-1.2.65}/CHANGELOG.md

@@ -54,6 +54,10 @@ This file starts at 1.1.35. Earlier releases are not reconstructed here; use
 
 ### Fixed
 
+- Completed verl children now finish each captured W&B run before the W&B service shuts down,
+  avoiding teardown tracebacks, and `flash env setup` now gives every starter config explicit W&B
+  project and folder-derived run metadata.
+
 - An ordered `[gpu] type` list is now priced over every class it declares acceptable, not just the
   first. Allocation cost-ranks the whole set, so quoting the head alone priced a shape the run may
   never be given — an authored `["B200", "H100"]` quoted roughly 3x the H100 the allocator would

{freesolo_flash_dev-1.2.63 → freesolo_flash_dev-1.2.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.63
+Version: 1.2.65
 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.63 → freesolo_flash_dev-1.2.65}/flash/cli/commands/env/setup.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import sys
 import tomllib
+from collections.abc import Mapping
 from pathlib import Path
 
 from flash._internal.channel import CLI_NAME
@@ -13,6 +14,7 @@ from flash.cli.commands.env.retained import (
     _warn_if_environment_form_disagrees,
     _warn_if_retained_starter_files_describe_another_plane,
 )
+from flash.cli.commands.env.setup_wandb import _wandb_block, _wandb_project
 from flash.cli.scaffold import TRAINING_MD
 from flash.cli.ui import render
 from flash.envs.evaluations import _DEFAULT_EVALUATIONS_PATH
@@ -358,22 +360,14 @@ _REASONING_OPTIONS = [
 _SKIP_TRACES = ""  # sentinel option value: scaffold the starter rows instead of importing
 
 
-def _require_setup_project(args) -> str:
+def _require_setup_project(args, *, api_url: str | None, api_key: str) -> Mapping[str, object]:
     """Resolve and validate the one explicit project used by the whole scaffold."""
-    from flash.client import ClientError, list_projects, resolve_project_id
-    from flash.client.config import load_credentials
+    from flash.client import ClientError, list_projects, resolve_project
     from flash.client.http import has_freesolo_backend
 
-    api_url, api_key = load_credentials()
-    if not api_key:
-        raise ClientError(
-            f"not logged in. Run `{CLI_NAME} login` before `{CLI_NAME} env setup` "
-            "so the project can be validated"
-        )
-
     supplied = str(getattr(args, "project", "") or "").strip()
     if supplied:
-        return resolve_project_id(supplied, api_key, api_url)
+        return resolve_project(supplied, api_key, api_url)
     if not _setup_interactive(args):
         raise ClientError(
             "--project PROJECT_UUID is required in noninteractive mode, with redirected stdin, or with --yes"
@@ -395,7 +389,7 @@ def _require_setup_project(args) -> str:
             f"`{CLI_NAME} projects create NAME`"
         )
     selected = render.select_required("Choose the Freesolo project for this environment", options)
-    return resolve_project_id(selected, api_key, api_url)
+    return resolve_project(selected, api_key, api_url)
 
 
 # Guidance the starter .py docstrings carry, per plane kind. The templates hold placeholders
@@ -450,7 +444,7 @@ def _render_starter(template: str, project_id: str, *, can_publish: bool) -> str
     return template.replace("PROJECT_UUID", project_id)
 
 
-def _plane_can_publish_environments() -> bool:
+def _plane_can_publish_environments(api_url: str | None) -> bool:
     """Whether `flash env push` can actually publish for the logged-in plane.
 
     Publishing uploads to the plane, which commits into the managed environment hub
@@ -462,10 +456,8 @@ def _plane_can_publish_environments() -> bool:
     operator-run Freesolo-compatible backend has a project directory (which is what that helper
     answers) but still cannot publish to the hub.
     """
-    from flash.client.config import load_credentials
     from flash.serve.urls import is_freesolo_hosted_url
 
-    api_url, _ = load_credentials()
     # Unset means the built-in default, which is the managed plane.
     return api_url is None or is_freesolo_hosted_url(api_url)
 
@@ -553,7 +545,7 @@ def _existing_reasoning(configs: tuple[Path, ...]) -> bool | None:
     return next(iter(found.values()), None)
 
 
-def _traces_dataset(args, project_id: str) -> str | None:
+def _traces_dataset(args, project_id: str, api_key: str) -> str | None:
     """Optionally export traces from the already-selected project."""
     if not _setup_interactive(args):
         return None
@@ -568,7 +560,7 @@ def _traces_dataset(args, project_id: str) -> str | None:
     if use_traces == _SKIP_TRACES:
         return None
     try:
-        exported = traces.fetch_records(project_id)
+        exported = traces.fetch_records(project_id, api_key)
     except Exception as exc:  # trace import is optional after project validation succeeds
         _warn(f"could not export traces from {project_id} ({exc}); using the starter dataset")
         return None
@@ -692,6 +684,7 @@ def _write_rl_config(
     rl: Path,
     project_line: str,
     thinking_line: str,
+    wandb_block: str,
     env_comment: str,
     max_examples_line: str,
     rl_reasoning_train: str,
@@ -704,6 +697,7 @@ def _write_rl_config(
             'algorithm = "grpo"\n'
             f"{thinking_line}"
             "\n"
+            f"{wandb_block}"
             f"{env_comment}"
             "[train]\n"
             "epochs = 1\n"
@@ -722,6 +716,7 @@ def _write_sft_config(
     sft: Path,
     project_line: str,
     thinking_line: str,
+    wandb_block: str,
     env_comment: str,
     max_examples_line: str,
     sft_reasoning_note: str,
@@ -734,6 +729,7 @@ def _write_sft_config(
             'algorithm = "sft"\n'
             f"{thinking_line}"
             "\n"
+            f"{wandb_block}"
             f"{env_comment}"
             "[train]\n"
             "epochs = 1\n"
@@ -766,6 +762,7 @@ def _write_opd_config(
     project_line: str,
     project_id: str,
     thinking_line: str,
+    wandb_block: str,
     max_examples_line: str,
     *,
     can_publish: bool = True,
@@ -788,6 +785,7 @@ def _write_opd_config(
             'algorithm = "opd"   # on-policy distillation from a managed parasail teacher (default glm 5.2)\n'
             f"{thinking_line}"
             "\n"
+            f"{wandb_block}"
             + _environment_comment(
                 project_id,
                 can_publish=can_publish,
@@ -816,15 +814,34 @@ def _write_training_guide(training: Path, project_id: str) -> None:
         )
 
 
+def _resolve_setup_identity(args) -> tuple[str, str, str, str, str]:
+    """Resolve the credential, project, and folder identity used by every setup phase."""
+    from flash.client import ClientError
+    from flash.client.config import load_credentials
+
+    api_url, api_key = load_credentials()
+    if not api_key:
+        raise ClientError(
+            f"not logged in. Run `{CLI_NAME} login` before `{CLI_NAME} env setup` "
+            "so the project can be validated"
+        )
+    project = _require_setup_project(args, api_url=api_url, api_key=api_key)
+    project_id = str(project["id"])
+    folder_name = Path.cwd().name
+    if not folder_name.strip():
+        raise ClientError("the current environment folder name must be nonblank")
+    return api_url, api_key, project_id, _wandb_project(project), folder_name
+
+
 def cmd_env_setup(args) -> int:
-    project_id = _require_setup_project(args)
+    api_url, api_key, project_id, project_name, folder_name = _resolve_setup_identity(args)
     _validate_existing_config_projects(project_id)
     starter_env = Path("environment.py")
     starter_evaluations = Path(_DEFAULT_EVALUATIONS_PATH)
     dataset = Path("dataset/train.jsonl")
     # trace import is optional and can only read the selected project. an existing dataset is never
     # overwritten, so importing into it would be a silently discarded download.
-    traces_jsonl = None if dataset.exists() else _traces_dataset(args, project_id)
+    traces_jsonl = None if dataset.exists() else _traces_dataset(args, project_id, api_key)
     multi_turn, starter_env_exists = _resolve_turn_mode(args, starter_env, dataset)
 
     rl = Path("configs/rl.toml")
@@ -837,7 +854,7 @@ def cmd_env_setup(args) -> int:
     reasoning_configs = (rl, opd, sft)
     reasoning = _resolve_reasoning_mode(args, reasoning_configs)
 
-    can_publish = _plane_can_publish_environments()
+    can_publish = _plane_can_publish_environments(api_url)
     _warn_if_environment_form_disagrees(reasoning_configs, can_publish=can_publish, warn=_warn)
     env_py = _render_starter(
         _STARTER_ENV_MULTITURN_PY if multi_turn else _STARTER_ENV_PY,
@@ -908,6 +925,7 @@ def cmd_env_setup(args) -> int:
         rl,
         project_line,
         thinking_line,
+        _wandb_block(project_name, f"{folder_name}-grpo"),
         env_comment,
         max_examples_line,
         rl_reasoning_train,
@@ -916,6 +934,7 @@ def cmd_env_setup(args) -> int:
         sft,
         project_line,
         thinking_line,
+        _wandb_block(project_name, f"{folder_name}-sft"),
         env_comment,
         max_examples_line,
         sft_reasoning_note,
@@ -927,6 +946,7 @@ def cmd_env_setup(args) -> int:
         project_line,
         project_id,
         thinking_line,
+        _wandb_block(project_name, f"{folder_name}-opd"),
         max_examples_line,
         can_publish=can_publish,
     )

freesolo_flash_dev-1.2.65/flash/cli/commands/env/setup_wandb.py

@@ -0,0 +1,30 @@
+"""W&B metadata helpers for environment scaffolds."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+
+_WANDB_PROJECT_MAX_LENGTH = 128
+_WANDB_PROJECT_FORBIDDEN = frozenset("/\\#?%:")
+
+
+def _wandb_project(project: Mapping[str, object]) -> str:
+    """Adapt a resolved canonical project to a W&B-safe project name."""
+    project_id = str(project["id"])
+    name = project.get("name")
+    if not isinstance(name, str) or not name.strip():
+        return project_id
+    if len(name) > _WANDB_PROJECT_MAX_LENGTH or any(
+        character in _WANDB_PROJECT_FORBIDDEN for character in name
+    ):
+        return project_id
+    return name
+
+
+def _wandb_block(project_name: str, run_name: str) -> str:
+    return (
+        "[wandb]\n"
+        f"project = {json.dumps(project_name, ensure_ascii=False)}\n"
+        f"run_name = {json.dumps(run_name, ensure_ascii=False)}\n\n"
+    )

{freesolo_flash_dev-1.2.63 → freesolo_flash_dev-1.2.65}/flash/cli/commands/traces.py

@@ -77,8 +77,8 @@ def fetch_records(
 ) -> dict:
     """A project's traces in the requested shape, converted server-side.
 
-    Omitting `api_key` reads the stored credential, which is right for `env_setup`'s call: it holds
-    no snapshot this key has to agree with.
+    Omitting `api_key` reads the stored credential. Callers that already resolved configuration
+    should pass the key from that snapshot so a concurrent login cannot change the request identity.
     """
     key = _require_api_key(api_key or load_credentials()[1])
     return export_trace_records(project_id, key, export_format=export_format)

{freesolo_flash_dev-1.2.63 → freesolo_flash_dev-1.2.65}/flash/cli/scaffold/TRAINING.md

@@ -272,8 +272,10 @@ lora_rank = 32              # lora_alpha defaults to 2 x lora_rank; set it to ov
 # All knobs live under [train]. Do not add [sft], [grpo], or [opd] tables.
 
 [wandb]
-# project  = "my-project"   # the table allows exactly `project` and `run_name`;
-# run_name = "sft-run-1"    # `name` is rejected
+# new scaffolds set `project` from the selected Freesolo project and `run_name` from the folder
+# plus algorithm. edit either value as needed; only `project` and `run_name` are allowed.
+# project  = "my-project"
+# run_name = "sft-run-1"
 ```
 
 **Knobs are scoped by algorithm.** `[train]` is one flat table shared by all three algorithms,

{freesolo_flash_dev-1.2.63 → freesolo_flash_dev-1.2.65}/flash/client/__init__.py

@@ -1,5 +1,7 @@
 """HTTP client for the managed Flash control plane (used by the CLI)."""
 
+from collections.abc import Mapping
+
 from flash._internal.channel import CLI_NAME
 from flash.client.config import load_credentials, save_credentials
 from flash.client.http import (
@@ -20,8 +22,10 @@ from flash.client.http import (
 from flash.core.spec import require_project_id
 
 
-def resolve_project_id(project_id: str, api_key: str, api_url: str | None = None) -> str:
-    """Resolve one project id, turning "not yours / not there" into the actionable CLI refusal.
+def resolve_project(
+    project_id: str, api_key: str, api_url: str | None = None
+) -> Mapping[str, object]:
+    """Resolve one project, turning "not yours / not there" into the actionable CLI refusal.
 
     403 and 404 are the same answer to a CLI user -- this project is not one you can record against
     -- and neither is distinguishable from a typo, so they collapse into one message naming the way
@@ -48,9 +52,9 @@ def resolve_project_id(project_id: str, api_key: str, api_url: str | None = None
     at call time, which is the binding the CLI tests patch.
     """
     if api_url is not None and not has_freesolo_backend(api_url):
-        return require_project_id(project_id)
+        return {"id": require_project_id(project_id)}
     try:
-        return str(get_project(project_id, api_key)["id"])
+        return get_project(project_id, api_key)
     except ApiError as exc:
         if exc.status not in {403, 404}:
             raise
@@ -60,6 +64,11 @@ def resolve_project_id(project_id: str, api_key: str, api_url: str | None = None
         ) from exc
 
 
+def resolve_project_id(project_id: str, api_key: str, api_url: str | None = None) -> str:
+    """Resolve and return one canonical project id."""
+    return str(resolve_project(project_id, api_key, api_url)["id"])
+
+
 __all__ = [
     "ApiClient",
     "ApiError",
@@ -72,6 +81,7 @@ __all__ = [
     "list_projects",
     "list_trace_projects",
     "load_credentials",
+    "resolve_project",
     "resolve_project_id",
     "save_credentials",
     "upload_eval_run",

{freesolo_flash_dev-1.2.63 → freesolo_flash_dev-1.2.65}/flash/engine/worker/__init__.py

@@ -18,7 +18,7 @@ import traceback
 
 from flash._internal.diagnostics import sanitize_diagnostic
 from flash.adapters.fused_experts import lora_target_parameters
-from flash.core.spec import FIXED_SEED, load_job_spec_from_env
+from flash.core.spec import FIXED_SEED, gpu_count_of, load_job_spec_from_env
 from flash.engine.result.accounting import RunMetrics
 from flash.engine.worker.backend_common import collect_ray_failure_logs
 from flash.engine.worker.entry.opd import run_opd
@@ -80,7 +80,7 @@ from flash.engine.worker.perf import (
     grad_checkpointing_on,
     grpo_use_reentrant,
     is_cuda_oom,
-    preflight_free_vram,
+    preflight_gpu_occupancy,
     wait_for_gpu,
 )
 from flash.engine.worker.runtime.kernel_warmup import _current_cuda_sm, load_mega_cache
@@ -221,22 +221,16 @@ def _worker_failure_flags(exc: BaseException) -> dict[str, bool]:
     return {"retriable": retriable, "oom": (not retriable and is_cuda_oom(exc))}
 
 
-def _preflight_free_vram_for_spec() -> None:
-    """Reject a card that arrived already occupied by another tenant.
+def _preflight_gpu_occupancy_for_spec() -> None:
+    """Screen every GPU in the allocator-resolved worker allocation for substantial occupancy.
 
-    Nothing about the spec is read. An earlier draft re-derived the run's requirement here and
-    compared free bytes against it, which is a second sizing model competing with the allocator's
-    and wrong in both directions -- see ``preflight_free_vram``. Occupancy needs no requirement, so
-    it runs on any shape without reimplementing ``combined_vram_gb``'s non-linear multi-card fit.
+    The allocator stamps the chosen count onto ``JOB_SPEC`` before provider launch, so this passes
+    only the cards rented for this worker. It does not re-derive required VRAM or claim exact fit.
 
-    It samples device 0 only. On a multi-card node that leaves a tenant sitting on device 3 alone
-    undetected, which is a gap and not a false alarm -- device 0 occupancy is still evidence of a
-    shared host.
-
-    Must stay the first CUDA-adjacent call in boot: the reading is only trustworthy while this
+    This must stay the first CUDA-adjacent call in boot. The reading is trustworthy only while this
     process has no context of its own, and ``_force_fla_triton_gdn_on_sm100`` below creates one.
     """
-    preflight_free_vram()
+    preflight_gpu_occupancy(gpu_count_of(JOB_SPEC))
 
 
 THINKING = JOB_SPEC.thinking if JOB_SPEC else False
@@ -347,14 +341,14 @@ def _run_worker_mode() -> None:
     # FIRST, and specifically before `_force_fla_triton_gdn_on_sm100`: that reads
     # `get_device_capability`, which initializes CUDA in this process, and from that moment the
     # driver's "used" includes our own context with no sound way to subtract it -- the occupancy
-    # check declines to run rather than guess (see `preflight_free_vram`), so calling it later means
-    # never calling it at all. This is also before `_ensure_fla_fastpath_on_hopper`, whose repair
+    # check declines to run rather than guess (see `preflight_gpu_occupancy`), so calling it later
+    # means never calling it at all. this is also before `_ensure_fla_fastpath_on_hopper`, whose repair
     # path runs pip installs with 600s timeouts: a card handed over with a co-tenant's ~18GB still
     # resident fails the run either way, and the only question is whether that happens now or after
     # dependency repair, the model download and FSDP init have spent paid GPU on the same
     # conclusion. NVML answers without a context, so nothing here dirties the reading for the code
     # below.
-    _preflight_free_vram_for_spec()
+    _preflight_gpu_occupancy_for_spec()
     # run before model imports: sm100 tilelang GDN computes wrong gradients, so use Triton.
     _force_fla_triton_gdn_on_sm100()
     _ensure_fla_fastpath_on_hopper()

{freesolo_flash_dev-1.2.63 → freesolo_flash_dev-1.2.65}/flash/engine/worker/opd_train_runner.py

@@ -124,6 +124,31 @@ def _validate_teacher_transport() -> tuple[str, str]:
     return capability, control_panel_url
 
 
+def _prepare_prompt_messages(
+    example: dict,
+    messages: list[dict],
+    *,
+    multi_turn: bool,
+    package_root: str | None,
+) -> tuple[list[dict], tuple[str, ...]]:
+    from flash.content.multimodal import normalize_prompt_images, record_has_images
+
+    if record_has_images(example, messages):
+        normalized = normalize_prompt_images(example, messages, package_root)
+        if multi_turn:
+            _opd_train.validate_transcript_messages(
+                normalized.messages,
+                source="environment initial prompt",
+                allow_content_blocks=True,
+            )
+        return normalized.messages, tuple(normalized.descriptors)
+    if multi_turn:
+        messages = _opd_train.validate_transcript_messages(
+            messages, source="environment initial prompt"
+        )
+    return messages, ()
+
+
 def _prepare_prompts(
     request: _OpdRequest,
     prompt_rows: list[tuple[Any, Any]],
@@ -131,11 +156,7 @@ def _prepare_prompts(
     capability: str,
     control_panel_url: str,
 ) -> _PromptState:
-    from flash.content.multimodal import (
-        image_teacher_prompt_messages,
-        normalize_prompt_images,
-        record_has_images,
-    )
+    from flash.content.multimodal import image_teacher_prompt_messages
     from flash.engine.worker.teacher.client import TeacherClient
 
     teacher = TeacherClient(capability, control_panel_url, request.knobs.teacher_model)
@@ -187,15 +208,14 @@ def _prepare_prompts(
     with _opd_train.liveness_heartbeat("opd_image_prep", progress=lambda: prepped[0]):
         for example, messages in prompt_rows:
             prepped[0] += 1
-            if request.multi_turn:
-                messages = _opd_train.validate_transcript_messages(
-                    messages, source="environment initial prompt"
-                )
-            if record_has_images(example, messages):
+            student_messages, image_descriptors = _prepare_prompt_messages(
+                example,
+                messages,
+                multi_turn=request.multi_turn,
+                package_root=package_root,
+            )
+            if image_descriptors:
                 assert processor is not None
-                normalized = normalize_prompt_images(example, messages, package_root)
-                student_messages = normalized.messages
-                image_descriptors = tuple(normalized.descriptors)
                 teacher_messages = image_teacher_prompt_messages(
                     student_messages, len(image_descriptors)
                 )
@@ -207,9 +227,7 @@ def _prepare_prompts(
                     enable_thinking=bool(_opd_train._w.THINKING),
                 )
             else:
-                student_messages = messages
-                teacher_messages = messages
-                image_descriptors = ()
+                teacher_messages = student_messages
                 if processor is not None:
                     # mixed job: the verl child tokenizes EVERY row through the multimodal dataset
                     # path (the processor), so text-only rows must freeze via the same path or the
@@ -224,7 +242,7 @@ def _prepare_prompts(
                 else:
                     prompt_ids = _opd_train._normalize_prompt_ids(
                         tokenizer.apply_chat_template(
-                            messages,
+                            student_messages,
                             tokenize=True,
                             add_generation_prompt=True,
                             enable_thinking=_opd_train._w.THINKING,

{freesolo_flash_dev-1.2.63 → freesolo_flash_dev-1.2.65}/flash/engine/worker/perf/__init__.py

@@ -28,7 +28,7 @@ from flash.engine.worker.perf.lifecycle import (
     RetriableInfraError,
     free_vram_gb,
     is_cuda_oom,
-    preflight_free_vram,
+    preflight_gpu_occupancy,
     total_vram_gb,
     wait_for_gpu,
 )
@@ -403,7 +403,7 @@ __all__ = [
     "grad_checkpointing_on",
     "grpo_use_reentrant",
     "is_cuda_oom",
-    "preflight_free_vram",
+    "preflight_gpu_occupancy",
     "total_vram_gb",
     "wait_for_gpu",
 ]