freesolo-flash-dev 1.0.74__tar.gz → 1.0.76__tar.gz

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: freesolo-flash-dev
-Version: 1.0.74
+Version: 1.0.76
 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.0.74 → freesolo_flash_dev-1.0.76}/flash/catalog.py

@@ -615,8 +615,13 @@ def resolve_model(
     policy: str = "catalog",
     gpu: str | None = None,
     model_revision: str = "",
+    gpu_count: int = 1,
 ) -> ModelInfo:
-    """Resolve a model under the configured policy; "allow" accepts any HF model."""
+    """Resolve a model under the configured policy; "allow" accepts any HF model.
+
+    ``gpu_count`` is the run's card ceiling, forwarded to the open-model fit check so a shardable
+    run is judged on the shape it will be allocated rather than on one card.
+    """
     algo = normalize_algorithm(algorithm)
     if model_id in MODELS:
         info = validate_model_for_algorithm(model_id, algo)
@@ -634,11 +639,18 @@ def resolve_model(
         return info
     if policy != "allow":
         return get_model(model_id)
-    return _resolve_open_model(model_id, algo, gpu, model_revision=model_revision)
+    return _resolve_open_model(
+        model_id, algo, gpu, model_revision=model_revision, gpu_count=gpu_count
+    )
 
 
 def _resolve_open_model(
-    model_id: str, algo: str, gpu: str | None, *, model_revision: str = ""
+    model_id: str,
+    algo: str,
+    gpu: str | None,
+    *,
+    model_revision: str = "",
+    gpu_count: int = 1,
 ) -> ModelInfo:
     """Synthesize a ModelInfo for the open-model "allow" policy via a coarse HF VRAM-fit estimate."""
     from flash.engine.vram import check_fit
@@ -649,6 +661,10 @@ def _resolve_open_model(
         algo,
         resolved_gpu,
         model_revision=model_revision,
+        # judge the run on the shape the allocator may rent. the per-card class chosen for a wide
+        # ceiling is deliberately smaller, so evaluating it as one card rejects exactly the large
+        # models the multi-card path exists to serve.
+        gpu_count=gpu_count,
     )
     if est.verdict == "too_big":
         raise ValueError(

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/cli/TRAINING.md

@@ -848,7 +848,7 @@ with no reward to design. It supports `epochs` like SFT/GRPO and produces a LoRA
 
 - **Pick the teacher with `[train] teacher_model`; the key stays managed.** The teacher defaults to
   the managed **GLM 5.2** and is selectable from a fixed, managed allow-list:
-  `glm-5.2` (default), `deepseek-v4-pro`, `kimi-k2.6`. Every option is
+  `glm-5.2` (default) or `kimi-k2.6`. Every option is
   a Fireworks-hosted model reached with the platform's own key, so there is nothing to export or
   declare — an opd run submits like any other, and a `FIREWORKS_API_KEY` in your shell is ignored.
   Arbitrary bring-your-own teacher models or keys are not supported (the allow-list is curated to
@@ -883,7 +883,7 @@ epochs = 1
 max_examples = 2
 lora_rank = 32
 # teacher_model = "glm-5.2"                             # managed teacher to distil from; one of
-#                                                       # glm-5.2 (default) | deepseek-v4-pro | kimi-k2.6
+#                                                       # glm-5.2 (default) | kimi-k2.6
 #                                                       # (key stays managed)
 # kl_penalty_coef = 1.0                                 # reverse-KL scale
 ```
@@ -1274,14 +1274,13 @@ select:
 [gpu]
 type = "B200"
 count = 4
-# provider must also be pinned: not every provider puts all n cards on ONE machine, and
-# submit names the ones that qualify when it rejects an unpinned multi-gpu spec.
+# provider is optional: allocation compares multi-card shapes across every configured provider
+# and picks the cheapest that can rent n cards on one machine. pin one only to force a choice.
 ```
 
 `flash train configs/grpo.toml --gpus 4` sets the same key from the command line, so a config can
 stay at its authored count while one submit asks for more. The flag is exactly `--set
-gpu.count=4`: the same 1..8 bound rejects a bad value, and the same submit gate still demands a
-provider that rents all n cards on one machine.
+gpu.count=4`, and the same 1..8 bound rejects a bad value.
 
 `gpu.count` is a **ceiling, not an exact count** — by either spelling. Allocation treats it as the
 most cards it may use, and it stops at the first count that fits: a class that fits the run on one

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/cli/__init__.py

@@ -576,8 +576,8 @@ def _build_parser() -> argparse.ArgumentParser:
         metavar="N",
         help=(
             "most cards to run the job on; sets [gpu] count (1-8). a ceiling, not an exact "
-            "count: allocation still picks one card when one fits the run alone. more than one "
-            "also needs an explicit [gpu] provider that rents n cards on one machine"
+            "count: allocation still picks one card when one fits the run alone, and only "
+            "rentable counts (1, 2, 4) are ever provisioned"
         ),
     )
     train.add_argument("--dry-run", action="store_true")

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/cli/env_setup.py

@@ -667,7 +667,7 @@ def cmd_env_setup(args) -> int:
             f"{max_examples_line}"
             "lora_rank = 32\n"
             '# teacher_model = "glm-5.2"   # teacher to distil from: glm-5.2 (default) |\n'
-            "#                             # deepseek-v4-pro | kimi-k2.6 (key stays managed)\n"
+            "#                             # kimi-k2.6 (key stays managed)\n"
             "# GPU and HF 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.0.74 → freesolo_flash_dev-1.0.76}/flash/cli/traces.py

@@ -24,7 +24,7 @@ import json
 import sys
 from pathlib import Path
 
-from flash.client import ApiError, ClientError, export_trace_records, list_trace_projects
+from flash.client import ClientError, export_trace_records, list_trace_projects
 from flash.client.config import load_credentials
 
 from . import render
@@ -92,21 +92,6 @@ def fetch_projects(api_key: str | None = None) -> list[dict]:
     return list_trace_projects(api_key or _require_api_key())
 
 
-def offer_projects() -> list[dict]:
-    """Projects to offer as a starting dataset, or [] when we can't or shouldn't ask.
-
-    Used by `flash env setup`, where traces are an optional head start rather than the point of
-    the command: not being logged in, being offline, or having no traces yet all mean "just
-    scaffold the starter dataset", so every such failure returns [] instead of raising."""
-    _api_url, api_key = load_credentials()
-    if not api_key:
-        return []
-    try:
-        return fetch_projects(api_key)
-    except (ApiError, ClientError, OSError, ValueError):
-        return []
-
-
 def _resolve_project_id(args, api_key: str) -> str:
     project_id = getattr(args, "project", None)
     if project_id:

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/cost/analytical.py

@@ -8,6 +8,7 @@ policy/reference update.
 from __future__ import annotations
 
 from flash.providers.allocator import required_vram_gb, vram_headroom
+from flash.providers.base import largest_rentable_count
 
 from .facts import (
     GPU_COMPUTE_TFLOPS,
@@ -434,8 +435,11 @@ def estimate_cost(config: RunConfig, *, wall_cap_s: float = DEFAULT_WALL_CAP_S)
         gpu, need = select_gpu(config, max_wall_seconds=market_wall_s)
         quote_provider = config.provider
         # no gpu_type pin means no allocate() call and so no combination search; this branch picks a
-        # single class that fits alone, and the run occupies the requested count of it.
-        billed_gpu_count = config.gpu_count
+        # single class that fits alone, and the run occupies that count of it. gpu.count is a CEILING
+        # though, and only rentable powers of two are ever provisioned -- billing the raw ceiling
+        # would charge a `--gpus 3` run for 3 cards when submit rents 2. this quote is persisted at
+        # submit and charged verbatim by _status_estimated_charge, so an over-count here overbills.
+        billed_gpu_count = largest_rentable_count(config.gpu_count)
         # quote the same vram-floored vast market pick_gpu selected under (min_vram_gb=need): without the
         # floor the rate lookup searches from the smallest managed class, letting cheap small-card offers
         # crowd a high-vram selection off the limited page -> it silently falls back to the static rate.

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/engine/recipe.py

@@ -26,8 +26,8 @@ class TeacherModel:
     display_name: str
     # Fireworks serverless list price, $/1M tokens as (input, output). OPD echo-scores completions
     # (max_tokens=0) so only the INPUT column is billed / feeds the estimate, but both are kept so a
-    # mispriced row is obvious. NOTE: the non-GLM entries are best-effort estimates for these next-gen
-    # serverless models — confirm against the live fireworks.ai pricing before relying on the
+    # mispriced row is obvious. note: the non-glm entry is a best-effort estimate for this next-gen
+    # serverless model — confirm against the live fireworks.ai pricing before relying on the
     # `flash train` cost quote.
     usd_per_1m: tuple[float, float]
     supports_images: bool = False
@@ -49,12 +49,6 @@ TEACHER_MODELS: dict[str, TeacherModel] = {
         display_name="GLM 5.2",
         usd_per_1m=(1.40, 4.40),
     ),
-    "deepseek-v4-pro": TeacherModel(
-        alias="deepseek-v4-pro",
-        model_id="accounts/fireworks/models/deepseek-v4-pro",
-        display_name="DeepSeek V4 Pro",
-        usd_per_1m=(1.74, 3.48),
-    ),
     "kimi-k2.6": TeacherModel(
         alias="kimi-k2.6",
         model_id="accounts/fireworks/models/kimi-k2p6",

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/engine/vram.py

@@ -28,8 +28,6 @@ _BASE_OVERHEAD_GB = 4.0
 _ACT_COEF = 0.12
 _SFT_PER_DEVICE_BS_DEFAULT = 4
 _VOCAB_DEFAULT = 248_320
-_OPD_TRAINING_RESERVE_MULTIPLIER = 1.15
-_OPD_ALLOCATOR_MARGIN_MAX_GB = 6.0
 OPD_CE_CHUNK_SIZE = 64
 _OPD_CE_PEAK_BYTES_PER_LOGIT = 16
 
@@ -154,75 +152,6 @@ def _legacy_lora_floor_gb(lora_rank: int, effective_params_b: float) -> float:
     return (lora_rank / 16.0) * (0.3 + 0.04 * effective_params_b)
 
 
-def opd_training_peak_gb(
-    params_b: float,
-    seq_len: int,
-    *,
-    max_tokens: int | None = None,
-    prompts_per_step: int = 1,
-    group_size: int = 1,
-    thinking: bool = False,
-    vocab: int = _VOCAB_DEFAULT,
-    active_params_b: float | None = None,
-) -> float:
-    """Additional OPD loss-forward/backward memory above the resident student model."""
-    eff_b = float(active_params_b) if active_params_b else float(params_b)
-    width = math.sqrt(max(eff_b, 0.1))
-    loss_mb = opd_loss_microbatch(params_b, prompts_per_step, group_size)
-    activations = loss_mb * _ACT_COEF * (seq_len / 1024.0) * width
-    completion = opd_completion_len(max_tokens, thinking)
-    # the backward peak holds both full-sequence bf16 logits and fp32 completion rows plus gradients.
-    dense_logits = 2 * loss_mb * (seq_len * 2 + completion * 4) * vocab / 1e9
-    return activations + dense_logits
-
-
-def opd_training_reserve_gb(
-    params_b: float,
-    seq_len: int,
-    *,
-    max_tokens: int | None = None,
-    prompts_per_step: int = 1,
-    group_size: int = 1,
-    thinking: bool = False,
-    vocab: int = _VOCAB_DEFAULT,
-    active_params_b: float | None = None,
-) -> float:
-    """OPD loss-forward/backward peak with the runtime safety multiplier."""
-    return _OPD_TRAINING_RESERVE_MULTIPLIER * opd_training_peak_gb(
-        params_b,
-        seq_len,
-        max_tokens=max_tokens,
-        prompts_per_step=prompts_per_step,
-        group_size=group_size,
-        thinking=thinking,
-        vocab=vocab,
-        active_params_b=active_params_b,
-    )
-
-
-def opd_allocator_margin_gb(total_vram_gb: float) -> float:
-    """Allocator fragmentation slack protected by the OPD startup budget."""
-    return max(2.0, min(_OPD_ALLOCATOR_MARGIN_MAX_GB, float(total_vram_gb) * 0.05))
-
-
-def opd_post_init_reserve_gb(params_b: float, lora_rank: int) -> float:
-    """Pending LoRA gradient, AdamW state, and persistent post-init growth above model residency.
-
-    OPD trains all linear layers with bf16 LoRA parameters. PyTorch AdamW lazily allocates two
-    parameter-dtype moment tensors on the first step, so each estimated trainable parameter needs
-    2 bytes for its pending gradient plus 4 bytes for optimizer state. Use total model parameters for
-    the rank-linear geometry so MoE experts are not undercounted, then reserve the measured 35B-class
-    first-generation and post-init growth with a size-scaled 12 GB ceiling.
-    """
-    model_params_b = max(0.1, float(params_b))
-    rank = max(1, int(lora_rank))
-    trainable_params_b = (rank / 16.0) * (0.05 + model_params_b / 150.0)
-    gradient_gb = trainable_params_b * 2.0
-    adamw_state_gb = trainable_params_b * 4.0
-    persistent_growth_gb = max(1.0, min(12.0, model_params_b * 0.35))
-    return gradient_gb + adamw_state_gb + persistent_growth_gb
-
-
 def _lora_memory_gb(
     lora_rank: int,
     effective_params_b: float,
@@ -617,12 +546,25 @@ class VramEstimate:
     gpu: str
     gpu_gb: int
     verdict: str  # "fits" | "tight" | "too_big" | "unknown"
+    # cards the run was JUDGED on -- already clamped to a rentable power of two by check_fit, so
+    # describe() reports the shape the verdict was computed against rather than the raw ceiling.
+    gpu_count: int = 1
 
     def describe(self) -> str:
         if self.est_gb is None:
             return f"{self.gpu}: VRAM need unknown (could not read model size)"
+        # name the SHAPE, not just the class: "RTX 5090 (32 GB)" reads as a rejection the user
+        # could fix with a bigger card, when the run was actually judged on 4 of them.
+        shape = f"{self.gpu} ({self.gpu_gb} GB)"
+        if self.gpu_count > 1:
+            from flash.providers.base import combined_vram_gb
+
+            shape = (
+                f"{self.gpu_count}x {self.gpu} "
+                f"({combined_vram_gb(self.gpu_gb, self.gpu_count):.0f} GB combined)"
+            )
         return (
-            f"{self.gpu} ({self.gpu_gb} GB): estimated ~{self.est_gb:.0f} GB needed "
+            f"{shape}: estimated ~{self.est_gb:.0f} GB needed "
             f"({self.params_b:.1f}B params, {self.quant}, {self.algorithm}) -> {self.verdict}"
         )
 
@@ -1252,9 +1194,24 @@ def check_fit(
     quant: str = "bf16",
     params_b: float | None = None,
     model_revision: str = "",
+    gpu_count: int = 1,
 ) -> VramEstimate:
-    """Estimate whether ``model_id`` plausibly trains on ``gpu``; never raises."""
+    """Estimate whether ``model_id`` plausibly trains on ``gpu``; never raises.
+
+    ``gpu_count`` is the run's card ceiling. A run allowed to shard must be judged against the
+    capacity of the shape it will actually be allocated: sizing a multi-card run against one card
+    rejects the large models sharding exists to serve, and the per-card class picked for a wide
+    ceiling is deliberately SMALLER than the single-card one.
+    """
+    from flash.providers.base import combined_vram_gb, largest_rentable_count
+
     gpu_gb = GPU_VRAM_GB.get(gpu, 32)
+    # clamp to what the ceiling actually BUYS before sizing: only powers of two up to the
+    # combination cap are ever rented, so a ceiling of 3 provisions 2 cards and a ceiling of 8
+    # provisions 4. sizing on the raw ceiling would accept a shape submit can never allocate --
+    # the parse/submit divergence this parameter exists to close, inverted.
+    cards = largest_rentable_count(gpu_count)
+    usable_gb = combined_vram_gb(gpu_gb, cards)
     if params_b is None:
         if model_revision:
             try:
@@ -1266,10 +1223,10 @@ def check_fit(
     if params_b is None:
         return VramEstimate(None, algorithm, quant, None, gpu, gpu_gb, "unknown")
     est = estimate_vram_gb(params_b, algorithm, quant)
-    if est > gpu_gb * 1.15:
+    if est > usable_gb * 1.15:
         verdict = "too_big"
-    elif est > gpu_gb * 0.85:
+    elif est > usable_gb * 0.85:
         verdict = "tight"
     else:
         verdict = "fits"
-    return VramEstimate(params_b, algorithm, quant, est, gpu, gpu_gb, verdict)
+    return VramEstimate(params_b, algorithm, quant, est, gpu, gpu_gb, verdict, cards)

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/engine/worker/backend_common.py

@@ -669,6 +669,26 @@ def latest_global_step_dir(local_dir: str) -> tuple[str, int]:
     return best, best_step
 
 
+def stage_verl_resume(resume_dir: str, local_dir: str, *, job_label: str) -> int:
+    """stage a downloaded ``checkpoint-N`` into local_dir where verl looks; return its step.
+
+    the resume artifact is keyed on the run prefix, not the job type, so the control plane hands
+    every trainer the same ``checkpoint-N`` layout. verl finds it via
+    latest_checkpointed_iteration.txt under trainer.default_local_dir once resume_mode=auto.
+
+    ``job_label`` only names the job in the error raised for an unparseable path, which is the sole
+    thing the trainers ever varied here.
+    """
+    match = re.fullmatch(r"checkpoint-(\d+)", os.path.basename(resume_dir))
+    if match is None:
+        raise RuntimeError(f"invalid {job_label} resume checkpoint path {resume_dir!r}")
+    step = int(match.group(1))
+    shutil.copytree(resume_dir, os.path.join(local_dir, f"global_step_{step}"), dirs_exist_ok=True)
+    with open(os.path.join(local_dir, "latest_checkpointed_iteration.txt"), "w") as file:
+        file.write(str(step))
+    return step
+
+
 def export_peft_adapter(
     ckpt_actor_dir: str,
     out_adapter_dir: str,

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/engine/worker/heartbeat.py

@@ -37,11 +37,14 @@ _HB_SETUP_LIVENESS_STAGES = frozenset(
         "sft_configuring",
         "opd_configuring",
         "opd_filtering_prompts",
+        "opd_prompt_scan",
+        "opd_image_prep",
         "sft_initializing",
         "rl_initializing",
         "opd_initializing",
         "sft_finalizing",
         "rl_finalizing",
+        "opd_finalizing",
     }
 )
 # Mid-training the per-step checkpoint upload runs SYNCHRONOUSLY on the trainer thread (dev #445),
@@ -57,11 +60,11 @@ _HB_TIGHT_LIVENESS_STAGES = _HB_SETUP_LIVENESS_STAGES | _HB_UPLOAD_LIVENESS_STAG
 # latest per-step GRPO backlog, exposed so a top-level error heartbeat can preserve it
 # for `flash runs log -f` when a short run raises before the throttled rl_step ping committed
 LATEST_GRPO_METRICS_LAST: list = []
-# Throttled to avoid blowing the 128/hr HF commit cap; terminal transitions are never throttled. Every
-# tight-liveness stage is throttled (⊂) PLUS the per-step training stages: opd_filtering_prompts alone
-# emits a REAL (non-liveness) heartbeat every scan tick — ~120/hr on a large split before model load —
-# so unthrottled the setup stages blow the cap; throttle them exactly like their sft_pretokenizing
-# analogue (codex[bot]). checkpoint_uploading keepalive re-emits every 30s too, so it MUST be throttled.
+# throttle these stages to protect the hf repository commit budget; terminal transitions are never throttled.
+# opd_filtering_prompts emits a real heartbeat on each scan tick, while opd_prompt_scan and
+# opd_image_prep emit one when progress advances. opd_finalizing emits one on every keepalive tick.
+# without throttling, these opd stages can make roughly 120 commit attempts per hour. tight-liveness,
+# per-step training, and checkpoint_uploading keepalive stages share the same throttle.
 _HB_THROTTLED_STAGES = _HB_TIGHT_LIVENESS_STAGES | frozenset({"rl_step", "sft_step", "opd_step"})
 _HB_TERMINAL_STAGES = frozenset({"done", "already_done"})
 # 600s -> ~6 commits/hr; keeps stall detector alive without hitting the HF commit cap.

{freesolo_flash_dev-1.0.74 → freesolo_flash_dev-1.0.76}/flash/engine/worker/opd_train.py

@@ -1859,28 +1859,6 @@ def _read_classified_failure_fallback(base_path: str) -> tuple[str, str] | None:
     return None
 
 
-def _read_mutation_failure_fallback(base_path: str) -> tuple[str, str] | None:
-    return _read_classified_failure_fallback(base_path)
-
-
-def _read_score_delivery_failure_fallback(base_path: str) -> tuple[str, str] | None:
-    return _read_classified_failure_fallback(base_path)
-
-
-def _read_cycle_commit_failure_fallback(base_path: str) -> tuple[str, str] | None:
-    return _read_classified_failure_fallback(base_path)
-
-
-def _read_abandonment_failure_fallback(
-    base_path: str,
-) -> tuple[str, str] | None:
-    return _read_classified_failure_fallback(base_path)
-
-
-def _read_resample_failure_fallback(base_path: str) -> tuple[str, str] | None:
-    return _read_classified_failure_fallback(base_path)
-
-
 def _reconcile_score_delivery_failure(
     bridge: _TeacherAlignmentBridge,
     failure: tuple[str, str] | None,
@@ -2141,6 +2119,7 @@ def run_opd_train(spec=None) -> None:
     model_id = spec.model if spec else RECIPE.hf_model_id
     model_revision = getattr(spec, "model_revision", "") if spec else ""
     from flash.opd_validation import validate_opd_structured_outputs
+    from flash.spec import gpu_count_of
 
     structured_validation = validate_opd_structured_outputs(
         knobs.structured_outputs,
@@ -2148,6 +2127,7 @@ def run_opd_train(spec=None) -> None:
         model_revision=model_revision,
         model_policy=getattr(spec, "model_policy", "catalog") if spec else "catalog",
         gpu=spec.gpu.type if spec else None,
+        gpu_count=gpu_count_of(spec) if spec else 1,
     )
     structured_outputs = structured_validation.constraint
     model_vocab_size = structured_validation.model_vocab_size
@@ -2639,19 +2619,19 @@ def run_opd_train(spec=None) -> None:
         peak_gpu_gb = gpu_sampler.stop_gb()
         score_delivery_failure = _reconcile_score_delivery_failure(
             bridge,
-            _read_score_delivery_failure_fallback(score_delivery_failure_path),
+            _read_classified_failure_fallback(score_delivery_failure_path),
         )
         no_signal_failure = _reconcile_no_signal_notification_failure(
             bridge,
             (
-                _read_resample_failure_fallback(resample_failure_path),
-                _read_abandonment_failure_fallback(abandonment_failure_path),
+                _read_classified_failure_fallback(resample_failure_path),
+                _read_classified_failure_fallback(abandonment_failure_path),
             ),
         )
-        fallback_mutation_failure = _read_mutation_failure_fallback(mutation_failure_path)
+        fallback_mutation_failure = _read_classified_failure_fallback(mutation_failure_path)
         if fallback_mutation_failure is not None:
             bridge._record_mutation_failure(*fallback_mutation_failure)
-        cycle_commit_failure = _read_cycle_commit_failure_fallback(cycle_commit_failure_path)
+        cycle_commit_failure = _read_classified_failure_fallback(cycle_commit_failure_path)
         _raise_verl_failure(
             return_code,
             bridge.teacher_failure,