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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: freesolo-flash-dev
-Version: 1.2.65
+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.67/flash/_internal/diagnostics.py

@@ -0,0 +1,170 @@
+"""Bounded credential-safe diagnostic rendering."""
+
+from __future__ import annotations
+
+import os
+import re
+import urllib.parse
+from typing import Any
+
+_SECRET_KEY_RE = re.compile(
+    r"(?i)(authorization|api[-_ ]?key|access[-_ ]?token|refresh[-_ ]?token|token|secret|password)"
+    r"(\s*[:=]\s*)(?:bearer\s+)?([^\s,;]+)"
+)
+_BEARER_RE = re.compile(r"(?i)\bbearer\s+[A-Za-z0-9._~+/=-]+")
+_SECRET_ENV_SUFFIXES = ("_API_KEY", "_TOKEN", "_SECRET", "_PASSWORD")
+
+# comma-separated env-variable names whose values are secrets regardless of naming shape: declared
+# runtime secrets can carry any name (AWS_SECRET_ACCESS_KEY, FLASH_TEACHER_CAPABILITY, ...), so the
+# control plane lists them explicitly in the worker env instead of relying on the suffix heuristic.
+SECRET_ENV_KEYS_ENV = "FLASH_SECRET_ENV_KEYS"
+
+# multiline secrets may appear only partially in truncated logs. register long component lines as
+# needles, but ignore short common fragments such as ``}`` that would erase innocent diagnostics.
+_MIN_SECRET_COMPONENT = 8
+_PERCENT_ESCAPE_RE = re.compile(r"%([0-9A-Fa-f]{2})")
+
+
+def _percent_pattern(needle: str) -> str:
+    """Regex for ``needle`` with only percent-escape hex digits matched case-insensitively."""
+    parts: list[str] = []
+    offset = 0
+    for match in _PERCENT_ESCAPE_RE.finditer(needle):
+        parts.append(re.escape(needle[offset : match.start()]))
+        parts.append("%")
+        parts.extend(
+            f"[{char.lower()}{char.upper()}]" if char.isalpha() else char for char in match.group(1)
+        )
+        offset = match.end()
+    parts.append(re.escape(needle[offset:]))
+    return "".join(parts)
+
+
+def _bounded_pattern(needle: str) -> str:
+    """``needle`` anchored so it cannot match as part of a longer word.
+
+    The guard is applied per EDGE, and only where the needle's own edge is a word character. A
+    value with a punctuation edge already separates itself from neighbouring text, and demanding a
+    non-word character beyond it asks the wrong question: ``/a`` inside ``https://host/a/repo`` is
+    preceded by the ``t`` of ``host``, so an unconditional left guard fails and the secret prints
+    verbatim. ``ati`` keeps both guards and so still cannot rewrite ``authentication``.
+    Mirrors flash.providers._lifecycle.bootstrap_secrets._bounded_pattern.
+    """
+    escaped = re.escape(needle)
+    left = r"(?<!\w)" if needle[:1].isalnum() or needle[:1] == "_" else ""
+    right = r"(?!\w)" if needle[-1:].isalnum() or needle[-1:] == "_" else ""
+    return f"{left}{escaped}{right}"
+
+
+_ValueMatcher = tuple[str, bool, bool]
+
+
+def _configured_secrets() -> tuple[tuple[_ValueMatcher, ...], tuple[str, ...], frozenset[str]]:
+    """Credential matchers plus shape-only and exact raw values.
+
+    Each value matcher carries ``(needle, bounded, encoded)`` metadata. Plain values are replaced as
+    substrings. Bounded values are shorter than ``_MIN_SECRET_COMPONENT`` and may only match where
+    they are not adjacent to a word character: a 3-char global needle would mangle every diagnostic
+    containing those characters (the value ``ati`` rewrites ``authentication``).
+
+    A short raw candidate with no alphanumeric or underscore character is shape-only because it is
+    indistinguishable from ordinary punctuation. Explicit percent-octet forms remain bounded and
+    safely distinguishable. Keyed and bearer matching uses the known shape-only value directly.
+
+    Component lines of a multiline value keep the floor as a hard skip: a short component is
+    punctuation such as ``}``, not a credential.
+    """
+    declared = {
+        name.strip().upper()
+        for name in os.environ.get(SECRET_ENV_KEYS_ENV, "").split(",")
+        if name.strip()
+    }
+    matchers: set[_ValueMatcher] = set()
+    shaped: set[str] = set()
+    raw_values: set[str] = set()
+    for key, value in os.environ.items():
+        upper = key.upper()
+        if not value or not (
+            upper in {"AUTHORIZATION", "HF_TOKEN"}
+            or upper in declared
+            or upper.endswith(_SECRET_ENV_SUFFIXES)
+        ):
+            continue
+        raw_values.add(value)
+        candidates = {(value, False)}
+        encoded = urllib.parse.quote(value, safe="")
+        if encoded != value:
+            candidates.add((encoded, True))
+        if len(value) < _MIN_SECRET_COMPONENT and not any(
+            char.isalnum() or char == "_" for char in value
+        ):
+            candidates.add(("".join(f"%{byte:02X}" for byte in value.encode()), True))
+        if len(value) >= _MIN_SECRET_COMPONENT:
+            matchers.update((candidate, False, is_encoded) for candidate, is_encoded in candidates)
+        else:
+            for candidate, is_encoded in candidates:
+                if any(char.isalnum() or char == "_" for char in candidate):
+                    matchers.add((candidate, True, is_encoded))
+                else:
+                    shaped.add(candidate)
+        if "\n" in value:
+            for raw in value.splitlines():
+                if len(line := raw.strip()) >= _MIN_SECRET_COMPONENT:
+                    matchers.add((line, False, False))
+                    encoded_line = urllib.parse.quote(line, safe="")
+                    if encoded_line != line:
+                        matchers.add((encoded_line, False, True))
+    return tuple(matchers), tuple(shaped), frozenset(raw_values)
+
+
+def sanitize_diagnostic(value: Any, *, limit: int = 2000) -> str:
+    """Keep useful failure context while removing credentials and bounding output."""
+    text = f"{type(value).__name__}: {value}" if isinstance(value, BaseException) else str(value)
+    matchers, shaped, raw_values = _configured_secrets()
+    # protect exact punctuation credentials before a separate value can erase their syntax.
+    for secret in sorted(shaped, key=len, reverse=True):
+        escaped = re.escape(secret)
+        text = re.sub(
+            rf"(?i)(authorization|api[-_ ]?key|access[-_ ]?token|refresh[-_ ]?token|token|secret|password)(\s*[:=]\s*)(?:bearer\s+)?{escaped}(?=[\s,;]|$)",
+            lambda match: (
+                "<redacted>"
+                if match.group(1) in raw_values
+                else f"{match.group(1)}{match.group(2)}<redacted>"
+            ),
+            text,
+        )
+        text = re.sub(
+            rf"(?i)\b(bearer)\s+{escaped}(?=[\s,;]|$)",
+            lambda match: "<redacted>" if match.group(1) in raw_values else "Bearer <redacted>",
+            text,
+        )
+    # apply both matcher types in one longest-first order so a shorter plain value cannot consume
+    # the prefix of a longer bounded encoded value.
+    for secret, is_bounded, is_encoded in sorted(
+        matchers, key=lambda item: len(item[0]), reverse=True
+    ):
+        if is_encoded:
+            pattern = _percent_pattern(secret)
+            if is_bounded:
+                left = r"(?<!\w)" if secret[:1].isalnum() or secret[:1] == "_" else ""
+                right = r"(?!\w)" if secret[-1:].isalnum() or secret[-1:] == "_" else ""
+                pattern = f"{left}{pattern}{right}"
+            text = re.sub(pattern, "<redacted>", text)
+        elif is_bounded:
+            text = re.sub(_bounded_pattern(secret), "<redacted>", text)
+        else:
+            text = text.replace(secret, "<redacted>")
+    text = _BEARER_RE.sub("Bearer <redacted>", text)
+    text = _SECRET_KEY_RE.sub(lambda match: f"{match.group(1)}{match.group(2)}<redacted>", text)
+    return text[: max(0, int(limit))]
+
+
+def neutralize_control_chars(value: Any) -> str:
+    """Escape terminal control characters while preserving newlines as separators."""
+    text = str(value)
+    return "".join(
+        char
+        if char == "\n" or 0x20 <= ord(char) < 0x7F or ord(char) >= 0xA0
+        else f"\\x{ord(char):02x}"
+        for char in text
+    )

{freesolo_flash_dev-1.2.65 → 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.65 → freesolo_flash_dev-1.2.67}/flash/providers/_lifecycle/bootstrap_secrets.py

@@ -22,6 +22,22 @@ _SECRET_RE = re.compile(
 # component lines are registered as needles too; the floor keeps a common fragment such as ``}``
 # from erasing innocent output. Mirrors flash._internal.diagnostics.
 _MIN_SECRET_COMPONENT = 8
+_PERCENT_ESCAPE_RE = re.compile(r"%([0-9A-Fa-f]{2})")
+
+
+def _percent_pattern(needle: str) -> str:
+    """Regex for ``needle`` with only percent-escape hex digits matched case-insensitively."""
+    parts: list[str] = []
+    offset = 0
+    for match in _PERCENT_ESCAPE_RE.finditer(needle):
+        parts.append(re.escape(needle[offset : match.start()]))
+        parts.append("%")
+        parts.extend(
+            f"[{char.lower()}{char.upper()}]" if char.isalpha() else char for char in match.group(1)
+        )
+        offset = match.end()
+    parts.append(re.escape(needle[offset:]))
+    return "".join(parts)
 
 
 def _bounded_pattern(needle: str) -> str:
@@ -39,37 +55,86 @@ def _bounded_pattern(needle: str) -> str:
     return f"{left}{escaped}{right}"
 
 
-def _needles(values: set[str]) -> tuple[set[str], set[str]]:
-    """The ``(plain, bounded)`` needle sets for ``values``.
+_ValueMatcher = tuple[str, bool, bool]
+
+
+def _needles(values: set[str]) -> tuple[set[_ValueMatcher], set[str]]:
+    """The typed value matchers and shape-only needles for ``values``.
 
-    plain = replaced as a substring. bounded = values under the floor, replaced only where not
-    adjacent to a word character: dropping them leaked them verbatim, and replacing them plainly
-    would rewrite innocent text (``ati`` inside ``authentication``). encoded forms are registered
-    too. component lines of a MULTILINE value keep the floor as a hard skip -- a short one is
+    each value matcher carries ``(needle, bounded, encoded)`` metadata. plain needles are replaced as
+    substrings. bounded needles are values under the floor, replaced only where not adjacent to a word
+    character. a short raw candidate with no alphanumeric or underscore character is shape-only
+    because it is indistinguishable from ordinary punctuation; explicit percent-octet forms remain
+    bounded. component lines of a multiline value keep the floor as a hard skip: a short one is
     punctuation such as ``}``, not a credential.
     """
-    plain: set[str] = set()
-    bounded: set[str] = set()
+    matchers: set[_ValueMatcher] = set()
+    shaped: set[str] = set()
     for secret in values:
-        target = plain if len(secret) >= _MIN_SECRET_COMPONENT else bounded
-        target.update({secret, urllib.parse.quote(secret, safe="")})
+        candidates = {(secret, False)}
+        encoded = urllib.parse.quote(secret, safe="")
+        if encoded != secret:
+            candidates.add((encoded, True))
+        if len(secret) < _MIN_SECRET_COMPONENT and not any(
+            char.isalnum() or char == "_" for char in secret
+        ):
+            candidates.add(("".join(f"%{byte:02X}" for byte in secret.encode()), True))
+        if len(secret) >= _MIN_SECRET_COMPONENT:
+            matchers.update((candidate, False, is_encoded) for candidate, is_encoded in candidates)
+        else:
+            for candidate, is_encoded in candidates:
+                if any(char.isalnum() or char == "_" for char in candidate):
+                    matchers.add((candidate, True, is_encoded))
+                else:
+                    shaped.add(candidate)
         if "\n" in secret:
             for raw in secret.splitlines():
                 if len(line := raw.strip()) >= _MIN_SECRET_COMPONENT:
-                    plain.update({line, urllib.parse.quote(line, safe="")})
-    return plain, bounded
+                    matchers.add((line, False, False))
+                    encoded_line = urllib.parse.quote(line, safe="")
+                    if encoded_line != line:
+                        matchers.add((encoded_line, False, True))
+    return matchers, shaped
 
 
 def _redact_values(text: str, values: set[str]) -> str:
     """Replace every credential value in ``text``; see ``_needles`` for how each form is matched.
 
-    Longest-first, so one secret containing another cannot leave a suffix of the longer one behind.
+    Longest-first across both matcher types, so one secret containing another cannot leave a suffix
+    of the longer one behind.
     """
-    plain, bounded = _needles(values)
-    for needle in sorted(plain, key=len, reverse=True):
-        text = text.replace(needle, "<redacted>")
-    for needle in sorted(bounded, key=len, reverse=True):
-        text = re.sub(_bounded_pattern(needle), "<redacted>", text)
+    matchers, shaped = _needles(values)
+    # protect exact punctuation credentials before a separate value can erase their syntax.
+    for needle in sorted(shaped, key=len, reverse=True):
+        escaped = re.escape(needle)
+        text = re.sub(
+            rf"(?i)(authorization|api[-_ ]?key|access[-_ ]?token|token|secret|password)(\s*[:=]\s*)(?:bearer\s+)?{escaped}(?=[\s,;]|$)",
+            lambda match: (
+                "<redacted>"
+                if match.group(1) in values
+                else f"{match.group(1)}{match.group(2)}<redacted>"
+            ),
+            text,
+        )
+        text = re.sub(
+            rf"(?i)\b(bearer)\s+{escaped}(?=[\s,;]|$)",
+            lambda match: "<redacted>" if match.group(1) in values else "Bearer <redacted>",
+            text,
+        )
+    for needle, is_bounded, is_encoded in sorted(
+        matchers, key=lambda item: len(item[0]), reverse=True
+    ):
+        if is_encoded:
+            pattern = _percent_pattern(needle)
+            if is_bounded:
+                left = r"(?<!\w)" if needle[:1].isalnum() or needle[:1] == "_" else ""
+                right = r"(?!\w)" if needle[-1:].isalnum() or needle[-1:] == "_" else ""
+                pattern = f"{left}{pattern}{right}"
+            text = re.sub(pattern, "<redacted>", text)
+        elif is_bounded:
+            text = re.sub(_bounded_pattern(needle), "<redacted>", text)
+        else:
+            text = text.replace(needle, "<redacted>")
     return text
 
 

{freesolo_flash_dev-1.2.65 → freesolo_flash_dev-1.2.67}/flash/providers/runpod/serverless/endpoints.py

@@ -62,31 +62,49 @@ def _train_body(input_data: dict) -> dict:
 
     from huggingface_hub import snapshot_download
 
+    def _percent_pattern(needle):
+        """Regex matching only percent-escape hex digits case-insensitively."""
+        escape_re = re.compile(r"%([0-9A-Fa-f]{2})")
+        parts = []
+        offset = 0
+        for match in escape_re.finditer(needle):
+            parts.append(re.escape(needle[offset : match.start()]))
+            parts.append("%")
+            parts.extend(
+                f"[{char.lower()}{char.upper()}]" if char.isalpha() else char
+                for char in match.group(1)
+            )
+            offset = match.end()
+        parts.append(re.escape(needle[offset:]))
+        return "".join(parts)
+
     def _needles(secrets=None):
-        """The (plain, bounded) credential needle sets for os.environ plus ``secrets``.
-
-        a value at or above the floor is a plain needle, replaced as a substring; a SHORTER one is
-        bounded, matched only where it is not adjacent to a word character. short values used to be
-        dropped outright, which leaked them verbatim -- [environment] secrets accepts any name and
-        any value. plain replacement is not the alternative: a 3-char needle corrupts every
-        diagnostic that merely contains those letters (the value "ati" rewrites "authentication").
-
-        a multiline secret (a PEM key) never appears whole in any single call: the child's stdout is
-        sanitized one line at a time, so only a component line is ever seen. component lines keep
-        the floor as a hard skip -- a short one is punctuation such as "}", not a credential.
-        Mirrors flash.providers._lifecycle.bootstrap_secrets._needles.
+        """Typed value matchers, shape-only needles, and raw values for all known secrets.
+
+        each value matcher carries ``(needle, bounded, encoded)`` metadata. a value at or above the
+        floor is plain and replaced as a substring; a shorter one is bounded, matched only where it is
+        not adjacent to a word character. short values used to be dropped outright, which leaked them
+        verbatim. plain replacement is not the alternative: a 3-char needle corrupts every diagnostic
+        that merely contains those letters (the value "ati" rewrites "authentication"). a short raw
+        candidate with no alphanumeric or underscore character is shape-only because it is
+        indistinguishable from ordinary punctuation. explicit percent-octet forms remain bounded.
+
+        a multiline secret never appears whole in any single call: the child's stdout is sanitized one
+        line at a time, so only a component line is ever seen. component lines keep the floor as a hard
+        skip: a short one is punctuation such as "}", not a credential. mirrors
+        flash.providers._lifecycle.bootstrap_secrets._needles.
         """
         import urllib.parse
 
         mapping = {**os.environ, **(secrets or {})}
         # declared runtime secrets can carry any name, so the control plane lists them in
-        # FLASH_SECRET_ENV_KEYS; the name-shape rule stays as the fail-closed fallback.
+        # flash_secret_env_keys; the name-shape rule stays as the fail-closed fallback.
         declared = {
             name.strip().upper()
             for name in str(mapping.get("FLASH_SECRET_ENV_KEYS") or "").split(",")
             if name.strip()
         }
-        plain, bounded = set(), set()
+        matchers, shaped, raw_values = set(), set(), set()
         for key, secret in mapping.items():
             upper = str(key).upper()
             if not secret or not (
@@ -96,34 +114,78 @@ def _train_body(input_data: dict) -> dict:
             ):
                 continue
             value_str = str(secret)
-            target = plain if len(value_str) >= 8 else bounded
-            target.update({value_str, urllib.parse.quote(value_str, safe="")})
+            raw_values.add(value_str)
+            candidates = {(value_str, False)}
+            encoded = urllib.parse.quote(value_str, safe="")
+            if encoded != value_str:
+                candidates.add((encoded, True))
+            if len(value_str) < 8 and not any(char.isalnum() or char == "_" for char in value_str):
+                candidates.add(("".join(f"%{byte:02X}" for byte in value_str.encode()), True))
+            if len(value_str) >= 8:
+                matchers.update(
+                    (candidate, False, is_encoded) for candidate, is_encoded in candidates
+                )
+            else:
+                for candidate, is_encoded in candidates:
+                    if any(char.isalnum() or char == "_" for char in candidate):
+                        matchers.add((candidate, True, is_encoded))
+                    else:
+                        shaped.add(candidate)
             if "\n" in value_str:
                 for raw in value_str.splitlines():
                     if len(line := raw.strip()) >= 8:
-                        plain.update({line, urllib.parse.quote(line, safe="")})
-        return plain, bounded
+                        matchers.add((line, False, False))
+                        encoded_line = urllib.parse.quote(line, safe="")
+                        if encoded_line != line:
+                            matchers.add((encoded_line, False, True))
+        return matchers, shaped, raw_values
 
     def _safe_detail(value, secrets=None, limit=1000):
         text = (
             f"{type(value).__name__}: {value}" if isinstance(value, BaseException) else str(value)
         )
-        plain, bounded = _needles(secrets)
-        # longest-first so one secret containing another cannot leave a suffix of the longer
-        # one behind; encoded forms cover the percent-encoded urls http and git errors print.
-        for needle in sorted(plain, key=len, reverse=True):
-            text = text.replace(needle, "<redacted>")
-        for needle in sorted(bounded, key=len, reverse=True):
-            # the word guard is applied per EDGE, and only where the needle's own edge is a word
-            # character. a value with a punctuation edge already separates itself from neighbouring
-            # text, and demanding a non-word character beyond it asks the wrong question: "/a"
-            # inside "https://host/a/repo" is preceded by the "t" of "host", so an unconditional
-            # left guard fails and the secret prints verbatim. "ati" keeps both guards and so still
-            # cannot rewrite "authentication".
-            # Mirrors flash.providers._lifecycle.bootstrap_secrets._bounded_pattern.
-            left = r"(?<!\w)" if needle[:1].isalnum() or needle[:1] == "_" else ""
-            right = r"(?!\w)" if needle[-1:].isalnum() or needle[-1:] == "_" else ""
-            text = re.sub(f"{left}{re.escape(needle)}{right}", "<redacted>", text)
+        matchers, shaped, raw_values = _needles(secrets)
+        # protect exact punctuation credentials before a separate value can erase their syntax.
+        for needle in sorted(shaped, key=len, reverse=True):
+            escaped = re.escape(needle)
+            text = re.sub(
+                rf"(?i)(authorization|api[-_ ]?key|access[-_ ]?token|token|secret|password)(\s*[:=]\s*)(?:bearer\s+)?{escaped}(?=[\s,;]|$)",
+                lambda match: (
+                    "<redacted>"
+                    if match.group(1) in raw_values
+                    else f"{match.group(1)}{match.group(2)}<redacted>"
+                ),
+                text,
+            )
+            text = re.sub(
+                rf"(?i)\b(bearer)\s+{escaped}(?=[\s,;]|$)",
+                lambda match: "<redacted>" if match.group(1) in raw_values else "Bearer <redacted>",
+                text,
+            )
+        # longest-first across both matcher types so a shorter plain value cannot consume the prefix
+        # of a longer bounded encoded value; encoded forms cover urls http and git errors print.
+        for needle, is_bounded, is_encoded in sorted(
+            matchers, key=lambda item: len(item[0]), reverse=True
+        ):
+            if is_encoded:
+                pattern = _percent_pattern(needle)
+                if is_bounded:
+                    left = r"(?<!\w)" if needle[:1].isalnum() or needle[:1] == "_" else ""
+                    right = r"(?!\w)" if needle[-1:].isalnum() or needle[-1:] == "_" else ""
+                    pattern = f"{left}{pattern}{right}"
+                text = re.sub(pattern, "<redacted>", text)
+            elif is_bounded:
+                # the word guard is applied per edge, and only where the needle's own edge is a word
+                # character. a value with a punctuation edge already separates itself from
+                # neighbouring text, and demanding a non-word character beyond it asks the wrong
+                # question: "/a" inside "https://host/a/repo" is preceded by the "t" of "host", so
+                # an unconditional left guard fails and the secret prints verbatim. "ati" keeps both
+                # guards and so still cannot rewrite "authentication".
+                left = r"(?<!\w)" if needle[:1].isalnum() or needle[:1] == "_" else ""
+                right = r"(?!\w)" if needle[-1:].isalnum() or needle[-1:] == "_" else ""
+                text = re.sub(f"{left}{re.escape(needle)}{right}", "<redacted>", text)
+            else:
+                text = text.replace(needle, "<redacted>")
         text = re.sub(r"(?i)\bbearer\s+[A-Za-z0-9._~+/=-]+", "Bearer <redacted>", text)
         text = re.sub(
             r"(?i)(authorization|api[-_ ]?key|access[-_ ]?token|token|secret|password)"

{freesolo_flash_dev-1.2.65 → freesolo_flash_dev-1.2.67}/flash/runner/supervise/seed_submission.py

@@ -475,13 +475,13 @@ def _pinned_to_resume_width(allocation, resume_world_size: int | None):
     the one the attempt runs at: it refuses to train rather than restart from step 0, because the
     control-plane gate authorized this replacement only to continue from exactly that checkpoint.
     Allocation, though, re-ranks every retry from scratch -- capacity and live pricing move, and
-    2x/4x of a class are distinct rentable shapes -- so a 2-card attempt can legitimately be
-    re-ranked onto 4 cards and then permanently reject the only checkpoint it may resume from.
+    rentable shapes can carry more cards than the ranks that join the run. Comparing the checkpoint
+    width with the rented count can reject a loadable shape or admit one the worker cannot load.
 
-    Narrowing the candidates is what closes that gap, and it is done HERE rather than by passing a
+    Narrowing the candidates is what closes that gap, and it is done here rather than by passing a
     count into ``allocate()``: ``max_gpu_count`` is a ceiling, not an exact width, so a ceiling of 2
-    still admits a 1-card shape. Every candidate already carries its own ``gpu_count``, so the
-    exact-width rule is one filter over the ranked list, leaving the ranking itself untouched.
+    still admits a 1-card shape. Allocator-stamped candidates carry their executed rank count while
+    unstamped candidates fall back to their rented count. The filter leaves ranking and shapes intact.
 
     An empty result is left empty deliberately: the caller reports no-capacity and retries, which is
     the truthful outcome when the only loadable shape is unavailable. Restarting from step 0 instead
@@ -489,11 +489,17 @@ def _pinned_to_resume_width(allocation, resume_world_size: int | None):
     """
     if not resume_world_size:
         return allocation
-    loadable = tuple(
-        candidate
-        for candidate in allocation.candidates
-        if int(getattr(candidate, "gpu_count", 1)) == resume_world_size
-    )
+    loadable = []
+    for candidate in allocation.candidates:
+        executed_gpu_count = getattr(candidate, "executed_gpu_count", None)
+        width = (
+            executed_gpu_count
+            if type(executed_gpu_count) is int and executed_gpu_count > 0
+            else int(getattr(candidate, "gpu_count", 1))
+        )
+        if width == resume_world_size:
+            loadable.append(candidate)
+    loadable = tuple(loadable)
     if loadable == allocation.candidates:
         return allocation
     if not loadable:
@@ -520,16 +526,16 @@ def _build_candidate_plan(
     if not candidates:
         # an exhausted list has two causes and they need different words. attributing the pinned-
         # width one to OOM would send an operator to raise VRAM when the run is not out of memory
-        # at all: no fitting shape has the card count its resume checkpoint can be loaded on.
+        # at all: no fitting candidate executes at the resume checkpoint's world size.
         if prepared.resume_world_size and not allocation.candidates:
             width = prepared.resume_world_size
             ctx.last_detail = (
-                f"no fitting {width}-card shape is available, and this retry must resume from a "
-                f"checkpoint written at {width} cards"
+                f"no candidate executing at checkpoint world size {width} is available, and this "
+                "retry must preserve that executed rank width"
             )
             print(
-                f"seed={ctx.seed} no {width}-card candidate for the pinned OPD resume checkpoint; "
-                "not retrying",
+                f"seed={ctx.seed} no candidate executes at pinned OPD checkpoint world size "
+                f"{width}; not retrying",
                 file=ctx.log,
                 flush=True,
             )

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

@@ -1,6 +1,6 @@
 [project]
 name = "freesolo-flash-dev"
-version = "1.2.65"
+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.65"
+version = "1.2.67"
 
 [tool.pytest.ini_options]
 pythonpath = ["."]