freesolo-flash-dev 1.2.66__tar.gz → 1.2.67__tar.gz

{freesolo_flash_dev-1.2.66 → freesolo_flash_dev-1.2.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.66
+Version: 1.2.67
 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.66 → freesolo_flash_dev-1.2.67}/flash/engine/worker/sft_train.py

@@ -14,6 +14,7 @@ import sys
 import threading
 import time
 
+from flash._internal.diagnostics import SECRET_ENV_KEYS_ENV
 from flash.adapters.lora_rank import rank_from_adapter_config
 from flash.engine.worker.runtime.pkg_proxy import W as _w
 from flash.engine.worker.verl.checkpoints import resume_checkpoint_is_loadable
@@ -203,6 +204,9 @@ _CHILD_ENV_PREFIXES = (
 
 
 def _build_verl_child_env(*, shim_dir: str, wandb_enabled: bool) -> dict[str, str]:
+    applied_secret_names = frozenset(
+        name.strip() for name in os.environ.get(SECRET_ENV_KEYS_ENV, "").split(",") if name.strip()
+    )
     child = {
         key: value
         for key, value in os.environ.items()
@@ -210,9 +214,16 @@ def _build_verl_child_env(*, shim_dir: str, wandb_enabled: bool) -> dict[str, st
     }
     if wandb_enabled:
         child.update({key: value for key, value in os.environ.items() if key.startswith("WANDB_")})
-    child["PYTHONPATH"] = os.pathsep.join(
-        item for item in (shim_dir, os.environ.get("PYTHONPATH", "")) if item
+    # retained runtime namespaces are filtered by applied-secret provenance. authenticated child-side
+    # wandb logging is the sole secret exception, and only when the existing logger gate enables it.
+    for name in applied_secret_names:
+        child.pop(name, None)
+    if wandb_enabled and "WANDB_API_KEY" in os.environ:
+        child["WANDB_API_KEY"] = os.environ["WANDB_API_KEY"]
+    parent_pythonpath = (
+        os.environ.get("PYTHONPATH", "") if "PYTHONPATH" not in applied_secret_names else ""
     )
+    child["PYTHONPATH"] = os.pathsep.join(item for item in (shim_dir, parent_pythonpath) if item)
     child["PYTHONUNBUFFERED"] = "1"
     child["HYDRA_FULL_ERROR"] = "1"
     child["HF_HUB_OFFLINE"] = "1"

{freesolo_flash_dev-1.2.66 → freesolo_flash_dev-1.2.67}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.2.66"
+version = "1.2.67"
 description ="Flash — managed LoRA post-training (SFT/GRPO/OPD) for Freesolo environments, driven by the `flash` CLI"
 readme = "README.md"
 # RunPod Flash supports Python 3.11-3.12 (not 3.13 yet).
@@ -137,7 +137,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.2.66"
+version = "1.2.67"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]

{freesolo_flash_dev-1.2.66 → freesolo_flash_dev-1.2.67}/tests/test_envs_coverage.py

@@ -49,6 +49,9 @@ def test_env_setup_scaffolds_a_loadable_freesolo_env(tmp_path, monkeypatch) -> N
             "name": "Test",
         },
     )
+    monkeypatch.setattr(
+        "flash.client.config.load_credentials", lambda: ("https://flash.freesolo.co", "key")
+    )
     monkeypatch.chdir(tmp_path)
     assert cmd_env_setup(Namespace()) == 0
 
@@ -94,6 +97,9 @@ def test_scaffolded_env_scores_through_real_task_example(tmp_path, monkeypatch)
             "name": "Test",
         },
     )
+    monkeypatch.setattr(
+        "flash.client.config.load_credentials", lambda: ("https://flash.freesolo.co", "key")
+    )
     monkeypatch.chdir(tmp_path)
     assert cmd_env_setup(Namespace()) == 0
 

{freesolo_flash_dev-1.2.66 → freesolo_flash_dev-1.2.67}/tests/test_flash_worker.py

@@ -236,32 +236,55 @@ def test_build_worker_env_forwards_declared_environment_runtime_secrets():
     assert "UNDECLARED_API_KEY" not in env
 
 
-def test_build_worker_env_lists_declared_secret_names_for_the_redactors():
-    """declared runtime secrets can carry any name (AWS_SECRET_ACCESS_KEY, ...), so the redactors
-    cannot rely on the name-shape heuristic; the env carries the applied names explicitly."""
+def test_build_worker_env_lists_declared_secret_names_for_the_redactors(monkeypatch, tmp_path):
+    """the producer's exact applied-name metadata is also the verl child scrub contract."""
     from flash._internal.diagnostics import SECRET_ENV_KEYS_ENV
     from flash.core.spec import EnvironmentSpec, JobSpec, TrainSpec
+    from flash.engine.worker.sft_train import _build_verl_child_env
     from flash.providers.runpod.serverless import build_worker_env
 
+    declared = (
+        "AWS_SECRET_ACCESS_KEY",
+        "CUDA_SECRET",
+        "FLA_CREDENTIAL",
+        "PYTHONPATH",
+        "WANDB_USER_SECRET",
+    )
     spec = JobSpec(
         model="Qwen/Qwen3.5-4B",
         algorithm="grpo",
-        environment=EnvironmentSpec(id="owner/env", secrets=("AWS_SECRET_ACCESS_KEY",)),
+        environment=EnvironmentSpec(id="owner/env", secrets=declared),
         train=TrainSpec(epochs=1, max_examples=10, hf_repo="owner/runs"),
         seed=0,
     )
-
-    env = build_worker_env(
-        spec,
-        0,
-        runtime_secrets={"AWS_SECRET_ACCESS_KEY": "aws-user", "WANDB_API_KEY": "user-wb"},
-    )
+    supplied = {name: f"synthetic-{name.lower()}" for name in declared}
+    supplied["WANDB_API_KEY"] = "synthetic-wandb-key"
+    env = build_worker_env(spec, 0, runtime_secrets=supplied)
 
     listed = set(env[SECRET_ENV_KEYS_ENV].split(","))
-    assert listed == {"AWS_SECRET_ACCESS_KEY", "WANDB_API_KEY"}
+    assert listed == {*declared, "WANDB_API_KEY"}
+    for name in listed:
+        assert name in env
     # a run with no applied secrets carries no list at all.
     assert SECRET_ENV_KEYS_ENV not in build_worker_env(_spec(), 0)
 
+    for name, value in env.items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "0,1")
+    monkeypatch.setenv("FLA_TILELANG", "0")
+    monkeypatch.setenv("WANDB_MODE", "offline")
+    child = _build_verl_child_env(shim_dir=str(tmp_path), wandb_enabled=True)
+
+    for name in declared:
+        if name != "PYTHONPATH":
+            assert name not in child
+    assert child["PYTHONPATH"] == str(tmp_path)
+    assert SECRET_ENV_KEYS_ENV not in child
+    assert "WANDB_API_KEY" in child
+    assert child["CUDA_VISIBLE_DEVICES"] == "0,1"
+    assert child["FLA_TILELANG"] == "0"
+    assert child["WANDB_MODE"] == "offline"
+
 
 def test_the_redactor_metadata_name_is_reserved_from_declared_secrets():
     """build_worker_env sets FLASH_SECRET_ENV_KEYS last, so a job declaring that exact name would

{freesolo_flash_dev-1.2.66 → freesolo_flash_dev-1.2.67}/tests/test_opd_train.py

@@ -6772,6 +6772,53 @@ def test_child_environment_keeps_bridge_but_excludes_teacher_transport(monkeypat
     assert "FLASH_OPD_THINKING" not in child
 
 
+def test_opd_child_environment_scrubs_declared_prefixed_secrets(monkeypatch, tmp_path):
+    from flash._internal.diagnostics import SECRET_ENV_KEYS_ENV
+
+    declared = (
+        "CUDA_SECRET",
+        "FLA_CREDENTIAL",
+        "PYTHONPATH",
+        "WANDB_USER_SECRET",
+        "WANDB_API_KEY",
+    )
+    for name in declared:
+        monkeypatch.setenv(name, f"synthetic-{name.lower()}")
+    monkeypatch.setenv(SECRET_ENV_KEYS_ENV, ",".join(declared))
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "0,1")
+    monkeypatch.setenv("NCCL_DEBUG", "WARN")
+    monkeypatch.setenv("FLA_TILELANG", "0")
+    monkeypatch.setenv("WANDB_MODE", "offline")
+    child = _build_opd_child_env(
+        shim_dir=str(tmp_path),
+        wandb_enabled=True,
+        bridge_url="http://127.0.0.1:4444",
+        bridge_token="synthetic-bridge-token",
+        seed=42,
+        stop_sequences=(),
+        eos_token_ids=frozenset({1}),
+        structured_outputs=None,
+        model_vocab_size=248320,
+        thinking=False,
+        plugin_config='{"wandb":true}',
+    )
+
+    for name in declared:
+        if name not in {"PYTHONPATH", "WANDB_API_KEY"}:
+            assert name not in child
+    assert child["PYTHONPATH"] == str(tmp_path)
+    assert SECRET_ENV_KEYS_ENV not in child
+    assert "WANDB_API_KEY" in child
+    assert child["WANDB_MODE"] == "offline"
+    assert child["CUDA_VISIBLE_DEVICES"] == "0,1"
+    assert child["NCCL_DEBUG"] == "WARN"
+    assert child["FLA_TILELANG"] == "0"
+    assert "FLASH_OPD_BRIDGE_URL" in child
+    assert "FLASH_OPD_BRIDGE_TOKEN" in child
+    assert child["VERL_USE_EXTERNAL_MODULES"] == "flash_opd_plugin"
+    assert child["FLASH_OPD_PLUGIN_CONFIG"] == '{"wandb":true}'
+
+
 def test_structured_child_environment_carries_only_canonical_replay_inputs(tmp_path):
     child = _build_opd_child_env(
         shim_dir=str(tmp_path),

{freesolo_flash_dev-1.2.66 → freesolo_flash_dev-1.2.67}/tests/test_rl_train.py

@@ -7321,6 +7321,94 @@ def test_the_verl_child_allowlist_keeps_the_kernel_choice_but_drops_credentials(
         assert key not in child
 
 
+def test_grpo_final_driver_env_scrubs_declared_prefixed_secrets_before_ray(monkeypatch, tmp_path):
+    from flash._internal.diagnostics import SECRET_ENV_KEYS_ENV
+
+    declared = (
+        "CUDA_SECRET",
+        "FLA_CREDENTIAL",
+        "PYTHONPATH",
+        "WANDB_USER_SECRET",
+        "WANDB_API_KEY",
+    )
+    for name in declared:
+        monkeypatch.setenv(name, f"synthetic-{name.lower()}")
+    monkeypatch.setenv(SECRET_ENV_KEYS_ENV, ",".join(declared))
+    monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "0,1")
+    monkeypatch.setenv("FLA_TILELANG", "0")
+    monkeypatch.setenv("WANDB_MODE", "offline")
+    files = {
+        "shim_dir": str(tmp_path),
+        "rank_device_claims": str(tmp_path / "rank-device-claims"),
+        "plugin_config_path": str(tmp_path / "plugin-config.json"),
+    }
+    child = rl_train._build_rl_child_env(
+        {"multi_turn": False}, files, ["wandb"], "http://127.0.0.1:9/"
+    )
+
+    for name in declared:
+        if name not in {"PYTHONPATH", "WANDB_API_KEY"}:
+            assert name not in child
+    assert child["PYTHONPATH"] == files["shim_dir"]
+    assert SECRET_ENV_KEYS_ENV not in child
+    assert "WANDB_API_KEY" in child
+    assert child["WANDB_MODE"] == "offline"
+    assert child["CUDA_VISIBLE_DEVICES"] == "0,1"
+    assert child["FLA_TILELANG"] == "0"
+    assert child["FLASH_VERL_REWARD_URL"] == "http://127.0.0.1:9/"
+    assert child["VERL_USE_EXTERNAL_MODULES"] == "flash_grpo_plugin"
+    assert child["FLASH_GRPO_PLUGIN_CONFIG_PATH"] == files["plugin_config_path"]
+    assert child["FLASH_RANK_DEVICE_CLAIMS"] == files["rank_device_claims"]
+
+    captured = {}
+
+    class _EmptyChildStream:
+        def __init__(self, proc, **kwargs):
+            captured["stream_proc"] = proc
+
+        def __iter__(self):
+            return iter(())
+
+        def wait_and_classify(self):
+            return 0
+
+        def terminate(self):
+            raise AssertionError("the successful child should not be terminated")
+
+    process = SimpleNamespace()
+
+    def popen(*args, **kwargs):
+        captured["popen_env"] = kwargs["env"]
+        return process
+
+    monkeypatch.setattr(rl_train.subprocess, "Popen", popen)
+    monkeypatch.setitem(
+        rl_train._execute_rl_child.__globals__, "adopt_orphaned_descendants", lambda: None
+    )
+    monkeypatch.setattr(rl_train, "ChildOutputTail", lambda: object())
+    monkeypatch.setattr(rl_train, "VerlChildSilenceWatchdog", lambda *args, **kwargs: object())
+    monkeypatch.setattr(rl_train, "_GrpoSubprocessStream", _EmptyChildStream)
+    reward_runtime = SimpleNamespace(
+        observability=SimpleNamespace(parent_work=object()), wandb_link={}
+    )
+
+    assert (
+        rl_train._execute_rl_child(
+            python_bin="python",
+            overrides=[],
+            env_for_verl=child,
+            inp={},
+            state=rl_train._StepMetricState(),
+            reward_runtime=reward_runtime,
+            _reward_observability=dict,
+        )
+        == 0
+    )
+    assert captured["popen_env"] is child
+    assert captured["popen_env"]["PYTHONPATH"] == files["shim_dir"]
+    assert captured["stream_proc"] is process
+
+
 def test_grpo_finalization_carries_the_completed_step():
     """Regression (rl_train.py): write_train_meta emits `<phase>_train_done` and then the
     terminal `done`. Called without `step`, both land stepless and overwrite the stepped `rl_trained`

{freesolo_flash_dev-1.2.66 → freesolo_flash_dev-1.2.67}/tests/test_sft_train.py

@@ -2166,6 +2166,74 @@ def test_child_environment_excludes_provider_and_control_plane_secrets(monkeypat
     assert with_wandb["WANDB_API_KEY"] == "wandb-secret"
 
 
+def test_shared_child_environment_scrubs_declared_prefixed_secrets(monkeypatch, tmp_path):
+    from flash._internal.diagnostics import SECRET_ENV_KEYS_ENV
+
+    declared_secrets = (
+        "CUDA_SECRET",
+        "NCCL_CREDENTIAL",
+        "TORCH_PRIVATE_TOKEN",
+        "PYTORCH_AUTH",
+        "VERL_USER_SECRET",
+        "FLA_CREDENTIAL",
+        "PYTHONPATH",
+        "WANDB_USER_SECRET",
+        "CUSTOM_USER_SECRET",
+        "WANDB_API_KEY",
+    )
+    runtime_controls = {
+        "CUDA_VISIBLE_DEVICES": "0,1",
+        "NCCL_DEBUG": "WARN",
+        "TORCH_LOGS": "+dynamo",
+        "PYTORCH_CUDA_ALLOC_CONF": "max_split_size_mb:256",
+        "VERL_LOGGING_LEVEL": "INFO",
+        "FLA_TILELANG": "0",
+        "OMP_NUM_THREADS": "4",
+        "MKL_NUM_THREADS": "4",
+        "OPENBLAS_NUM_THREADS": "4",
+        "LC_ALL": "C.UTF-8",
+        "HF_HOME": "/cache/hf",
+        "FLASH_VERL_PYTHON": "/verl/python",
+    }
+    for name in declared_secrets:
+        monkeypatch.setenv(name, f"synthetic-{name.lower()}")
+    for name, value in runtime_controls.items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.setenv("WANDB_MODE", "offline")
+    monkeypatch.setenv(
+        SECRET_ENV_KEYS_ENV,
+        f"  {','.join(declared_secrets[:4])},, {','.join(declared_secrets[4:])}  ",
+    )
+
+    without_wandb = _build_verl_child_env(shim_dir=str(tmp_path), wandb_enabled=False)
+    for name, value in runtime_controls.items():
+        assert without_wandb[name] == value
+    for name in declared_secrets:
+        if name != "PYTHONPATH":
+            assert name not in without_wandb
+    assert without_wandb["PYTHONPATH"] == str(tmp_path)
+    assert "WANDB_MODE" not in without_wandb
+    assert SECRET_ENV_KEYS_ENV not in without_wandb
+
+    with_wandb = _build_verl_child_env(shim_dir=str(tmp_path), wandb_enabled=True)
+    for name, value in runtime_controls.items():
+        assert with_wandb[name] == value
+    for name in declared_secrets:
+        if name not in {"PYTHONPATH", "WANDB_API_KEY"}:
+            assert name not in with_wandb
+    assert with_wandb["PYTHONPATH"] == str(tmp_path)
+    assert "WANDB_API_KEY" in with_wandb
+    assert with_wandb["WANDB_MODE"] == "offline"
+    assert SECRET_ENV_KEYS_ENV not in with_wandb
+
+    monkeypatch.setenv(
+        SECRET_ENV_KEYS_ENV,
+        ",".join(name for name in declared_secrets if name != "PYTHONPATH"),
+    )
+    inherited = _build_verl_child_env(shim_dir=str(tmp_path), wandb_enabled=False)
+    assert inherited["PYTHONPATH"] == os.pathsep.join((str(tmp_path), "synthetic-pythonpath"))
+
+
 def test_checkpoint_watcher_exports_and_uploads_required_step(monkeypatch, tmp_path):
     import flash.engine.worker as worker
     from flash.engine.worker import sft_train
@@ -2838,8 +2906,11 @@ def test_sft_collapse_warning_stays_quiet_for_structured_singleturn_targets(monk
 
 
 def test_run_sft_train_orchestrates_exact_dataset_and_resume_accounting(monkeypatch):
+    from flash._internal.diagnostics import SECRET_ENV_KEYS_ENV
     from flash.engine.worker import sft_train
 
+    monkeypatch.setenv("PYTHONPATH", "synthetic-sft-parent-path")
+    monkeypatch.setenv(SECRET_ENV_KEYS_ENV, "PYTHONPATH")
     spec, captured = _stub_sft_run(monkeypatch)
 
     def fake_training(command, *, env, on_step, on_line, heartbeat):
@@ -2871,7 +2942,7 @@ def test_run_sft_train_orchestrates_exact_dataset_and_resume_accounting(monkeypa
         if value.startswith("data.custom_cls.path=")
     )
     assert os.path.isfile(custom_path)
-    assert captured["child_env"]["PYTHONPATH"].split(os.pathsep)[0].endswith("/shim")
+    assert captured["child_env"]["PYTHONPATH"] == os.path.dirname(captured["child"].shim_markers)
     assert captured["child_env"]["HF_HUB_OFFLINE"] == "1"
     assert captured["uploads"][0][1:] == ("adapter", True)
     assert captured["published"][0][1] == 2

{freesolo_flash_dev-1.2.66 → freesolo_flash_dev-1.2.67}/uv.lock

@@ -1052,7 +1052,7 @@ wheels = [
 
 [[package]]
 name = "freesolo-flash"
-version = "1.2.66"
+version = "1.2.67"
 source = { editable = "." }
 
 [package.optional-dependencies]