hyperstudy-perception 0.1.2__tar.gz → 0.1.3__tar.gz

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hyperstudy-perception
-Version: 0.1.2
+Version: 0.1.3
 Summary: Video perception pipeline: shots, speech, faces and captions from a video, as a versioned track bundle, run locally, on cloud GPUs or lab servers
 Project-URL: Homepage, https://github.com/hyperstudyio/hyperstudy-perception
 Project-URL: Changelog, https://github.com/hyperstudyio/hyperstudy-perception/releases

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperstudy-perception"
-version = "0.1.2"
+version = "0.1.3"
 description = "Video perception pipeline: shots, speech, faces and captions from a video, as a versioned track bundle, run locally, on cloud GPUs or lab servers"
 readme = "README.md"
 license = "MIT"

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/_pipeline/RELEASE.json

@@ -1,5 +1,5 @@
 {
-"commit": "6301eca468f046c39fbf4a84f05e106ce6b12688",
+"commit": "ba5bb86926a9a7218d908ad5f7dc0371cf87a0c3",
 "files": [
 "cloud/runpod/guard.sh",
 "cloud/runpod/image/Dockerfile",

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/_pipeline/nodes/audio/prosody-captions/node.py

@@ -99,7 +99,7 @@ with Node() as node:
             parsed = sc.parse_caption(arguments)
         except ValueError as e:
             raise NodeError("internal", f"{u['id']}: {e}") from None
-        return {"parsed": parsed, "usage": usage, "prompt": text,
+        return {"parsed": parsed, "usage": usage, "prompt": text, "outside": sc.outside_tags(arguments),
                 "raw": {"model": r.model, "finish_reason": choice.finish_reason, "arguments": arguments,
                         "usage": r.usage.model_dump(mode="json")}}
 
@@ -141,6 +141,8 @@ with Node() as node:
     node.write_json("prosody", "prosody.json", sc.refine(
         prosody, entries, node.producer(timings={"caption_s": caption_s, "tagger_s": tagger_s}, device="OpenAI API"),
         {"file": captions_raw.FILE, "format": "parquet", "description": captions_raw.DESCRIPTION}))
-    node.usage(utterances=len(units), workers=sc.WORKERS,
+    # tags the audio model gave outside the list, dropped from their captions: utterance -> tags
+    outside = {u["id"]: c["outside"] for u, c in zip(units, captions) if c["outside"]}
+    node.usage(utterances=len(units), workers=sc.WORKERS, tags_outside_list=outside,
                usd_by_model={sc.GPT_MODEL: round(sum(c["usage"]["usd"] for c in captions), 4),
                              sc.TAGGER: round(sum(t["usage"]["usd"] for t in tagged), 4)})

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/_pipeline/nodes/audio/prosody-captions/style_captions.py

@@ -137,13 +137,25 @@ def cost(model: str, prompt_tokens: int, audio_tokens: int | None, completion_to
 
 
 def parse_caption(arguments: str) -> dict:
-    """The function call's arguments -> {description, tags, emphasized_words}; ValueError when they are not that."""
+    """The function call's arguments -> {description, tags, emphasized_words}; ValueError when they are not that. Its tags
+    are those of the list only: gpt-audio-1.5 does not hold a function call to the schema's enum (strict or not), so a tag
+    outside it is dropped here (outside_tags says which; the side file keeps the reply as it came)."""
     import json
     out = json.loads(arguments)
     if not (isinstance(out, dict) and set(out) == {"description", "tags", "emphasized_words"}):
         raise ValueError(f"the caption is not {{description, tags, emphasized_words}}: {sorted(out) if isinstance(out, dict) else type(out).__name__}")
-    check_tags(out["tags"])
-    return out
+    if not isinstance(out["tags"], list):
+        check_tags(out["tags"])   # not a list: said as such
+    if not all(isinstance(t, str) for t in out["tags"]):
+        raise ValueError(f"the caption's tags are not strings: {[t for t in out['tags'] if not isinstance(t, str)][:5]}")
+    return {**out, "tags": [t for t in out["tags"] if t in ALL_TAGS]}
+
+
+def outside_tags(arguments: str) -> list[str]:
+    """The tags a caption's reply gave that are not in the list (dropped by parse_caption)."""
+    import json
+    tags = json.loads(arguments).get("tags")
+    return [t for t in tags if t not in ALL_TAGS] if isinstance(tags, list) else []
 
 
 def parse_tags(content: str) -> list[str]:

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/_pipeline/nodes/audio/prosody-captions/test_style_captions.py

@@ -68,8 +68,15 @@ def test_cost_is_the_bakeoffs_at_its_prices():
 def test_replies_must_be_the_schemas_with_tags_from_the_list():
     ok = {"description": "Calm.", "tags": ["calm", "falling-end"], "emphasized_words": []}
     assert sc.parse_caption(json.dumps(ok)) == ok
-    with pytest.raises(ValueError, match="outside the vocabulary"):
-        sc.parse_caption(json.dumps({**ok, "tags": ["calm", "grumpy"]}))
+    # gpt-audio-1.5 does not hold its function call to the schema's tag list (strict or not: "friendly" on an OOO
+    # held-out clip, 2026-10-30): a tag outside it is dropped from that caption and said, not the step's failure
+    assert sc.parse_caption(json.dumps({**ok, "tags": ["calm", "grumpy", "falling-end"]})) == ok
+    assert sc.outside_tags(json.dumps({**ok, "tags": ["calm", "grumpy", "falling-end"]})) == ["grumpy"]
+    assert sc.outside_tags(json.dumps(ok)) == []
+    with pytest.raises(ValueError, match="not strings"):   # not a tag at all: the reply is not the schema's
+        sc.parse_caption(json.dumps({**ok, "tags": ["calm", 3, None]}))
+    with pytest.raises(ValueError, match="outside the vocabulary"):   # the tagger's json_schema holds it to the list
+        sc.parse_tags('{"tags": ["neutral", "grumpy"]}')
     with pytest.raises(ValueError, match="not {description, tags, emphasized_words}"):
         sc.parse_caption(json.dumps({"description": "x"}))
     assert sc.parse_tags('{"tags": ["neutral"]}') == ["neutral"]

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/backends/base.py

@@ -330,9 +330,15 @@ def child_env(requested: list[str], secrets: dict[str, str]) -> dict[str, str]:
 # once, not a download it has no token for. Nor does it load a token stored on the machine (`hf auth login`'s, or
 # HF_TOKEN_PATH's), which huggingface_hub otherwise does even offline
 OFFLINE = {"HF_HUB_OFFLINE": "1", "HF_HUB_DISABLE_IMPLICIT_TOKEN": "1"}
-# a prepare on another machine: the token it was sent, or none, never the machine's own login (its HF_TOKEN in a
-# profile, its stored token): access to a gated model is a person's. A prepare that prepare_first runs has it from OFFLINE
-SENT_TOKEN_ONLY = {"HF_HUB_DISABLE_IMPLICIT_TOKEN": "1"}
+# A prepare is online, with the token it was sent as HF_TOKEN: access to a gated model is a person's. It runs without
+# HF_HUB_DISABLE_IMPLICIT_TOKEN (PREPARE_UNSET), and only when it was sent one: transformers 5.20 fetches a model's
+# config without the token it is given when implicit tokens are off (SAM 3's prepare got a 401 on liquidswords2,
+# 2026-10-30). The implicit token must then be the one it was sent: huggingface_hub (2.3) takes an OIDC identity first
+# (OIDC_LOGINS, unset), then HF_TOKEN (which replaces any other), then a stored token (its path NO_STORED_TOKEN)
+PREPARE_UNSET = ("HF_HUB_OFFLINE", "HF_HUB_DISABLE_IMPLICIT_TOKEN")
+OIDC_LOGINS = ("HF_OIDC_RESOURCE", "HF_OIDC_ID_TOKEN")
+# where a prepare looks for a stored token: a path that cannot exist (below /dev/null)
+NO_STORED_TOKEN = "/dev/null/no-stored-token"
 
 
 def hf_cache_env(home: str) -> dict[str, str]:

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/backends/native.py

@@ -20,7 +20,7 @@ from pathlib import Path
 
 from ..manifests import Manifest, Runner
 from ..store import Artifact
-from .base import GPU_LEASES, LEASE_FOLDER, OFFLINE, Backend, Capabilities, LeaseRefused, gpu_env, holder, lease_command
+from .base import GPU_LEASES, LEASE_FOLDER, OFFLINE, Backend, Capabilities, LeaseRefused, SubmitRefused, gpu_env, holder, lease_command
 from .probe import probe
 
 from ..release import REPO, env_vars
@@ -88,6 +88,11 @@ class NativeBackend(Backend):
             command = [*lease_command(str(self.lease_folder()), gpu, manifest.resources.gpu,
                                       holder(json.loads(request.read_text()))), *command]
         if prepare_secrets is not None and manifest.download_secrets and self.downloads(manifest, runner):
+            if missing := [k for k in manifest.download_secrets if not (prepare_secrets.get(k) or "").strip()]:
+                # refused, not prepared with whatever login this machine has: the plan says so first (missing_secrets),
+                # but a resumed run is not planned again (as a host's submit, remote.py)
+                raise SubmitRefused("input", f"its weights are downloaded with {', '.join(missing)}, which is not set here "
+                                             f"(perception keys set {missing[0]})")
             # its prepare first, with them, then the node (with its lease: no card is held while weights download)
             # without them (prepare_first.py)
             from .. import prepare_first

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/plan.py

@@ -238,7 +238,9 @@ def plan(coord: Coordinator, graph: Graph, allow_downloads: bool = False, allow_
             np.estimates[p.label] = {"estimate_s": seconds, "estimate_basis": basis,
                                      "cost_usd": p.backend.estimate(m, p.runner, {}, video_s).cost_usd, "uploads": sent, "upload_to": to}
         # a download secret is needed only for a download: weights already in the cache are read without it
-        np.missing_secrets = [s for s in (*m.secrets, *(m.download_secrets if np.downloads else ())) if s not in coord.secrets]
+        # an empty value is no key: it is never given to a step (download_for, child_env)
+        np.missing_secrets = [s for s in (*m.secrets, *(m.download_secrets if np.downloads else ()))
+                              if not (coord.secrets.get(s) or "").strip()]
         if placement and not np.cached:
             chosen = np.estimates[placement.label]
             np.estimate_s, np.estimate_basis = chosen["estimate_s"], chosen["estimate_basis"]

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/prepare_first.py

@@ -49,8 +49,14 @@ def main(argv: list[str]) -> int:
     secrets = [s for s in opts["--secrets"].split(",") if s]
     offline = json.loads(opts["--offline"])
     request = Path(node[-1])
-    # online, for the download, and with the token it was sent alone (SENT_TOKEN_ONLY stays)
-    env = {k: v for k, v in os.environ.items() if k != "HF_HUB_OFFLINE"}
+    # online, for the download, with the token it was sent as HF_TOKEN, and implicit tokens on only then: transformers
+    # fetches a model's config without the token it is given when they are off. Its implicit token is then that one: no
+    # OIDC identity (which huggingface_hub takes first) and no stored token (its path where there is none). As
+    # base.PREPARE_UNSET, OIDC_LOGINS and NO_STORED_TOKEN, which this script cannot import
+    env = {k: v for k, v in os.environ.items() if k not in ("HF_HUB_OFFLINE", "HF_OIDC_RESOURCE", "HF_OIDC_ID_TOKEN")}
+    implicit = bool((env.get("HF_TOKEN") or "").strip())
+    prepare_env = {**{k: v for k, v in env.items() if not (implicit and k == "HF_HUB_DISABLE_IMPLICIT_TOKEN")},
+                   "HF_TOKEN_PATH": "/dev/null/no-stored-token", **({} if implicit else {"HF_HUB_DISABLE_IMPLICIT_TOKEN": "1"})}
     if "--sync" in opts:
         print("syncing the node's environment", flush=True)
         done = subprocess.run(json.loads(opts["--sync"]), env={k: v for k, v in env.items() if k not in secrets},
@@ -58,7 +64,7 @@ def main(argv: list[str]) -> int:
         if done.returncode:
             return fail(request, f"syncing the node's environment failed (exit {done.returncode}): see the end of the log")
     print("preparing the node (its weights, into the cache it reads)", flush=True)
-    done = subprocess.run(json.loads(opts["--prepare"]), env=env, stdin=subprocess.DEVNULL)   # its output: the log
+    done = subprocess.run(json.loads(opts["--prepare"]), env=prepare_env, stdin=subprocess.DEVNULL)   # its output: the log
     if done.returncode:
         return fail(request, f"preparing the node failed (exit {done.returncode}): see the end of the log")
     for mark in json.loads(opts.get("--marks", "[]")):

{hyperstudy_perception-0.1.2 → hyperstudy_perception-0.1.3}/src/perception/remote_driver.py

@@ -496,17 +496,27 @@ class Driver:
         from this code's own folder, and only the card the scheduler gave it (CUDA_VISIBLE_DEVICES). A node with download
         secrets reads its account's cache there (hf_home), offline and without them, as does its prepare without the ones
         it was not sent: the host's own (a login's HF_TOKEN in .bashrc, which bash reads under sshd) are never used."""
-        from .backends.base import OFFLINE, SENT_TOKEN_ONLY, gpu_env, hf_cache_env
+        from .backends.base import NO_STORED_TOKEN, OFFLINE, OIDC_LOGINS, PREPARE_UNSET, gpu_env, hf_cache_env
         from .backends.remote import SDK_SOURCE
         q, s = shlex.quote, self.spec
         env = gpu_env(s.get("gpu"))
         if s.get("hf_home"):
             env.update(hf_cache_env(s["hf_home"]))
         unset = [k for k in s.get("download_secrets") or [] if not (prepare and k in self.download)]
-        if s.get("download_secrets"):
-            # the node offline; its prepare online, whatever the host's own profile says, with the token it was sent
-            env.update(SENT_TOKEN_ONLY if prepare else OFFLINE)
-            unset += ["HF_HUB_OFFLINE"] if prepare else []
+        if s.get("download_secrets") and not prepare:
+            env.update(OFFLINE)   # the node offline, with no token: none sent, and not the host's own login either
+            unset += ["HUGGING_FACE_HUB_TOKEN", *OIDC_LOGINS]
+        elif s.get("download_secrets") and "HF_TOKEN" in self.download:
+            # its prepare online, whatever the host's own profile says, with implicit tokens on (PREPARE_UNSET): the
+            # token huggingface_hub takes is the HF_TOKEN it was sent (an assignment that replaces the host's), and no
+            # other login is in reach: the host's OIDC identity (which huggingface_hub would take first) and
+            # HUGGING_FACE_HUB_TOKEN unset, and its stored token's path (HF_TOKEN_PATH) one where there is none
+            unset += [*PREPARE_UNSET, "HUGGING_FACE_HUB_TOKEN", *OIDC_LOGINS]
+            env["HF_TOKEN_PATH"] = NO_STORED_TOKEN
+        elif s.get("download_secrets"):
+            # sent no HF_TOKEN: online, with implicit tokens off, so none of the host's is used
+            unset += ["HF_HUB_OFFLINE", *OIDC_LOGINS]
+            env["HF_HUB_DISABLE_IMPLICIT_TOKEN"] = "1"
         if s["runner_kind"] == "self":
             python = q(s["python"])
         else: