physistool 0.1.2__tar.gz → 0.1.4__tar.gz

{physistool-0.1.2 → physistool-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physistool
-Version: 0.1.2
+Version: 0.1.4
 Summary: Open-source PhysisFold client — CLI + SDK for constraint-guided all-atom protein folding via a remote (Nitro Enclave) endpoint.
 Author: MorphoComputing
 License: MIT

{physistool-0.1.2 → physistool-0.1.4}/physis/__init__.py

@@ -29,4 +29,4 @@ from .physis_client import FoldError, fold
 
 __all__ = ["fold", "FoldError"]
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"

{physistool-0.1.2 → physistool-0.1.4}/physis/metering.py

@@ -36,7 +36,7 @@ _TIMEOUT = 15  # seconds
 # in sync with ``build/package.py`` VERSION — this is the version of the shipped
 # wheel. It is *spoofable* by design: the gate is a forced-upgrade lever, not an
 # anti-tamper check — the real enforcement lives server-side.
-CLIENT_VERSION = "0.1.2"
+CLIENT_VERSION = "0.1.3"
 
 
 class MeteringError(Exception):
@@ -52,6 +52,25 @@ class MeteringError(Exception):
         self.detail = detail or message
 
 
+class UpgradeRequiredError(MeteringError):
+    """The server's MIN_CLIENT_VERSION gate refused this build (HTTP 403).
+
+    Enforced server-side on the charge path (reserve) BEFORE any credit moves, so
+    an old or cracked client cannot fold. Carries the required + current versions
+    and a ready-to-print ``pip install -U`` message. Subclasses MeteringError so
+    existing ``except MeteringError`` sites still catch it, but callers may catch
+    this specifically to show a clean forced-upgrade prompt.
+    """
+
+    def __init__(self, min_client_version: str, your_version: str):
+        self.min_client_version = min_client_version
+        self.your_version = your_version
+        msg = (f"this physistool client ({your_version}) is below the minimum "
+               f"supported version ({min_client_version}). "
+               f"Upgrade with: pip install -U physistool")
+        super().__init__(msg, status=403, detail=msg)
+
+
 def _post(base_url: str, path: str, payload: dict) -> dict:
     url = f"{base_url}{path}"
     # client_version rides along on every call (see CLIENT_VERSION); an explicit
@@ -66,7 +85,16 @@ def _post(base_url: str, path: str, payload: dict) -> dict:
             body = resp.read().decode("utf-8")
             return json.loads(body) if body else {}
     except urllib.error.HTTPError as e:
-        detail = _read_error_detail(e)
+        raw, obj = _read_error_body(e)
+        # Forced-upgrade gate: a 403 carrying min_client_version means this build
+        # is below the server's floor. Surface it as a dedicated, actionable error
+        # (the client prints "pip install -U") instead of a generic reserve failure.
+        if e.code == 403 and isinstance(obj, dict) and obj.get("min_client_version"):
+            raise UpgradeRequiredError(
+                str(obj["min_client_version"]),
+                str(obj.get("your_version") or CLIENT_VERSION)) from e
+        detail = (obj.get("error") or obj.get("detail") or raw) if isinstance(obj, dict) \
+            else (raw or e.reason or "unknown error")
         raise MeteringError(f"backend returned HTTP {e.code}: {detail}",
                             status=e.code, detail=detail) from e
     except urllib.error.URLError as e:
@@ -79,13 +107,17 @@ def _post(base_url: str, path: str, payload: dict) -> dict:
                             status=0, detail=str(e)) from e
 
 
-def _read_error_detail(e: "urllib.error.HTTPError") -> str:
+def _read_error_body(e: "urllib.error.HTTPError") -> "tuple[str, object]":
+    """Read an HTTPError body once, returning (raw_text, parsed_json_or_None)."""
+    raw = ""
+    try:
+        raw = e.read().decode("utf-8", "replace")
+    except OSError:
+        return "", None
     try:
-        body = e.read().decode("utf-8")
-        obj = json.loads(body)
-        return obj.get("error") or obj.get("detail") or body
-    except (ValueError, OSError):
-        return e.reason or "unknown error"
+        return raw, json.loads(raw)
+    except ValueError:
+        return raw, None
 
 
 # ── lifecycle calls ─────────────────────────────────────────────────────────

{physistool-0.1.2 → physistool-0.1.4}/physis/physis_client.py

@@ -668,6 +668,10 @@ def fold(
                 backend, api_key, credits=credits,
                 idempotency_key=str(uuid.uuid4()), input_hash=input_hash,
             )
+        except metering_mod.UpgradeRequiredError as exc:
+            # Forced-upgrade gate (server MIN_CLIENT_VERSION). Not a reserve/credit
+            # problem — the build is too old to fold. Surface the pip command as-is.
+            raise FoldError(exc.detail, status=exc.status, error="please_upgrade") from exc
         except metering_mod.MeteringError as exc:
             raise FoldError(
                 f"could not reserve {credits} credit(s): {exc.detail}",
@@ -825,10 +829,17 @@ def fold(
         if not pdb_b64:
             raise FoldError("server reported ok but returned no pdb_b64", status=status)
         pdb_bytes = base64.b64decode(pdb_b64)
+        # Create the --out directory if the customer pointed at a new subfolder
+        # (e.g. --out run1/fold.pdb). open() alone would raise on a missing dir;
+        # batch mode already does this per-job, so match that behaviour here.
+        os.makedirs(os.path.dirname(os.path.abspath(out_path)) or ".", exist_ok=True)
         with open(out_path, "wb") as fh:
             fh.write(pdb_bytes)
         if report_path is None:
             report_path = os.path.splitext(out_path)[0] + ".json"
+        # --report-json may point at its own (possibly missing) subfolder; create it
+        # too. Harmless when it is the same dir as --out (already made above).
+        os.makedirs(os.path.dirname(os.path.abspath(report_path)) or ".", exist_ok=True)
         with open(report_path, "w", encoding="utf-8") as fh:
             json.dump(report_json, fh, indent=2)
         # Value layer (§2.3): interactive .html + .md/.pml/CSVs/trajectory/ensemble/
@@ -952,6 +963,41 @@ _MANIFEST_EVIDENCE = {dest: kwarg for _f, dest, kwarg, *_ in _EVIDENCE_FLAGS}
 _MANIFEST_EVIDENCE["input_af2"] = _MANIFEST_EVIDENCE["input_ai"]
 
 
+def _job_override(spec: "dict", key: str, default):
+    """Per-job manifest override: the job's own value when present (non-null),
+    else the batch-global ``default``.
+
+    Lets a manifest set ``best_of`` / ``seed`` / ``helix_prior`` / evidence knobs /
+    ``out`` per job instead of one value shared by every job. A ``null`` (or absent)
+    field falls back to the global flag, so mixed manifests stay concise."""
+    if not isinstance(spec, dict):
+        return default
+    v = spec.get(key)
+    return default if v is None else v
+
+
+def _job_best_of(spec: "dict", global_best_of) -> int:
+    """A job's effective ``best_of`` (its own override, else the global), ≥ 1.
+    Used for the credit total and worker sizing as well as the fold itself."""
+    return max(1, int(_job_override(spec, "best_of", global_best_of)))
+
+
+def _job_out_path(override: "str | None", out_dir: str, jid: str) -> str:
+    """Resolve a job's output PDB path.
+
+    Default (no manifest ``out``): ``out_dir/<jid>/<jid>.pdb``. A manifest ``out``
+    field overrides it, with the same feel as the single-fold ``--out``: a *file*
+    path (``run1/my.pdb``) sets the directory + stem for the whole bundle (report,
+    HTML, CSVs re-stem to it); a *directory* (trailing separator or no extension)
+    drops ``<jid>.pdb`` inside. Relative paths resolve against the batch ``out_dir``."""
+    if not override:
+        return os.path.join(out_dir, jid, f"{jid}.pdb")
+    p = override if os.path.isabs(override) else os.path.join(out_dir, override)
+    if override.endswith(("/", "\\")) or not os.path.splitext(p)[1]:
+        return os.path.join(p, f"{jid}.pdb")
+    return p
+
+
 def fold_batch(
     manifest_path: str,
     out_dir: str,
@@ -979,8 +1025,14 @@ def fold_batch(
     an optional ``distogram_artifact``, any ``input_<name>`` evidence fields
     (path or list; relative paths resolve against the manifest dir), and an optional
     ``held_out_input`` path (independent contacts scored post-fold into that job's
-    report — §C5). Global flags (``best_of`` / ``seed`` / ``disto_max_bin`` / helix /
-    evidence params / held-out threshold+neff / ``encrypt``) apply to every job. Outputs go to
+    report — §C5). The function arguments (``best_of`` / ``seed`` / ``disto_max_bin`` /
+    helix / evidence params / held-out threshold+neff / ``encrypt``) are the batch-wide
+    DEFAULTS; **any job may override them per-id** by carrying the same-named field
+    (``best_of``, ``seed``, ``helix_prior``, ``helix_prior_ensemble``, ``disto_max_bin``,
+    ``template_sigma``, ``noe_mode``, ``soi_fill``, ``held_out_threshold``,
+    ``held_out_msa_neff``, ``encrypt``). A per-job ``out`` field further overrides where
+    that job writes (a file path sets the whole bundle's dir+stem; a directory drops
+    ``<id>.pdb`` inside; relative to ``out_dir``). Absent overrides default to
     ``out_dir/<id>/<id>.{pdb,json}``; the batch aggregate is returned.
 
     Metering mirrors the single fold, per job: each sequence reserves ``best_of``
@@ -1034,9 +1086,14 @@ def fold_batch(
     if held_out_msa_neff is not None:
         held_out_params["msa_neff"] = float(held_out_msa_neff)
 
-    env = _import_envelope() if encrypt else None
+    # Encryption may be global (``--encrypt``) OR requested by any single job (a
+    # manifest ``encrypt: true`` field). Load the envelope + enclave key if EITHER
+    # asks for it; each job then seals (or not) per its own effective flag.
+    any_encrypt = encrypt or any(
+        isinstance(s, dict) and bool(s.get("encrypt")) for s in jobs_spec)
+    env = _import_envelope() if any_encrypt else None
     enclave_pub = None
-    if encrypt:
+    if any_encrypt:
         if not trusted_pub:
             raise FoldError("attestation is missing enclave_pubkey; cannot encrypt")
         enclave_pub = env.load_public_key_b64(trusted_pub)
@@ -1044,6 +1101,7 @@ def fold_batch(
     batch: list[dict] = []
     cust_keys: dict[str, object] = {}   # jid -> customer private key (encrypt)
     reservations: dict[str, str] = {}   # jid -> reservation_id (metering)
+    job_out_paths: dict[str, str] = {}  # jid -> resolved output PDB path
     try:
         for idx, spec in enumerate(jobs_spec):
             if not isinstance(spec, dict) or not spec.get("sequence"):
@@ -1078,30 +1136,55 @@ def fold_batch(
                     f"job '{jid}': blind (FASTA) input needs evidence "
                     "(an input_<name> field) or a distogram_artifact")
 
+            # ── Per-job overrides (a manifest field beats the batch-global flag) ──
+            job_best_of = _job_best_of(spec, best_of)
+            job_seed = _job_override(spec, "seed", seed)
+            job_helix = bool(_job_override(spec, "helix_prior", helix_prior))
+            job_helix_ens = bool(_job_override(
+                spec, "helix_prior_ensemble", helix_prior_ensemble))
+            job_disto_max_bin = _job_override(spec, "disto_max_bin", disto_max_bin)
+            job_encrypt = bool(_job_override(spec, "encrypt", encrypt))
+            # Evidence / held-out knobs: start from the batch-global dict, then let
+            # the job override individual keys.
+            job_ev_params = dict(evidence_params)
+            if spec.get("template_sigma") is not None:
+                job_ev_params["template_sigma"] = float(spec["template_sigma"])
+            if spec.get("noe_mode") is not None:
+                job_ev_params["noe_mode"] = spec["noe_mode"]
+            if spec.get("soi_fill") is not None:
+                job_ev_params["soi_fill"] = spec["soi_fill"]
+            job_ho_params = dict(held_out_params)
+            if spec.get("held_out_threshold") is not None:
+                job_ho_params["threshold"] = float(spec["held_out_threshold"])
+            if spec.get("held_out_msa_neff") is not None:
+                job_ho_params["msa_neff"] = float(spec["held_out_msa_neff"])
+            job_out_paths[jid] = _job_out_path(
+                _job_override(spec, "out", None), out_dir, jid)
+
             args_obj = {
-                "best_of": int(best_of),
+                "best_of": job_best_of,
                 "distogram_artifact_b64": distogram_b64,
-                "helix_prior": bool(helix_prior),
-                "helix_prior_ensemble": bool(helix_prior and helix_prior_ensemble),
+                "helix_prior": job_helix,
+                "helix_prior_ensemble": bool(job_helix and job_helix_ens),
             }
-            if seed is not None:
-                args_obj["seed"] = int(seed)
-            if disto_max_bin is not None:
-                args_obj["disto_max_bin"] = str(disto_max_bin)
-            if evidence_params:
-                args_obj["evidence_params"] = evidence_params
-            if held_out_params:
-                args_obj["held_out_params"] = held_out_params
+            if job_seed is not None:
+                args_obj["seed"] = int(job_seed)
+            if job_disto_max_bin is not None:
+                args_obj["disto_max_bin"] = str(job_disto_max_bin)
+            if job_ev_params:
+                args_obj["evidence_params"] = job_ev_params
+            if job_ho_params:
+                args_obj["held_out_params"] = job_ho_params
 
             fold_token = None
             if metering_on:
                 try:
                     res = metering_mod.reserve(
-                        backend, api_key, credits=int(best_of),
+                        backend, api_key, credits=job_best_of,
                         idempotency_key=str(uuid.uuid4()), input_hash=input_hash)
                 except metering_mod.MeteringError as exc:
                     raise FoldError(
-                        f"job '{jid}': could not reserve {best_of} credit(s): "
+                        f"job '{jid}': could not reserve {job_best_of} credit(s): "
                         f"{exc.detail}", status=exc.status, error=str(exc)) from exc
                 fold_token = res.get("fold_token")
                 rid = res.get("reservation_id")
@@ -1112,7 +1195,7 @@ def fold_batch(
                 reservations[jid] = rid
 
             job_el: dict = {"id": jid, "fold_token": fold_token}
-            if encrypt:
+            if job_encrypt:
                 cust_priv, _pub = env.generate_keypair()
                 cust_keys[jid] = cust_priv
                 job_el["customer_pubkey"] = env.public_b64(cust_priv)
@@ -1157,7 +1240,8 @@ def fold_batch(
         jid = r.get("id") or "job"
         st = r.get("status")
         if st == "ok":
-            if encrypt and r.get("result_envelope") is not None:
+            # Decrypt per job: only jobs that sealed their input carry a private key.
+            if r.get("result_envelope") is not None and jid in cust_keys:
                 blob = _join_envelope(r["result_envelope"])
                 inner = json.loads(env.decrypt(blob, cust_keys[jid]).decode("utf-8"))
                 pdb_b64 = inner.get("pdb_b64")
@@ -1173,14 +1257,15 @@ def fold_batch(
                 n_failed += 1
                 print(f"[batch] {jid}: ok but no PDB — skipping write", file=sys.stderr)
                 continue
-            job_out = os.path.join(out_dir, jid)
-            os.makedirs(job_out, exist_ok=True)
-            job_pdb = os.path.join(job_out, f"{jid}.pdb")
+            # Per-job output path (manifest ``out`` field) or the default subdir;
+            # its directory is created if it does not exist (like the single fold).
+            job_pdb = job_out_paths.get(jid) or os.path.join(out_dir, jid, f"{jid}.pdb")
+            os.makedirs(os.path.dirname(os.path.abspath(job_pdb)) or ".", exist_ok=True)
             with open(job_pdb, "wb") as fh:
                 fh.write(base64.b64decode(pdb_b64))
-            with open(os.path.join(job_out, f"{jid}.json"), "w", encoding="utf-8") as fh:
+            with open(os.path.splitext(job_pdb)[0] + ".json", "w", encoding="utf-8") as fh:
                 json.dump(report_json, fh, indent=2)
-            # Value layer for this job (re-stemmed to <jid>.*, written into job_out).
+            # Value layer for this job (re-stemmed to the job PDB name, same dir).
             _write_artifacts(artifacts, artifacts_stem, job_pdb)
             n_ok += 1
         else:
@@ -1267,10 +1352,14 @@ TYPED EVIDENCE (all repeatable; different types combine freely)
   (a pre-built --distogram-artifact is used as-is and skips all of the above.)
 
 BATCH MANIFEST (jobs.json) - a JSON array; paths resolve against the manifest dir:
-  [ { "id": "P1", "sequence": "p1.pdb", "input_template": ["h.pdb"] },
+  [ { "id": "P1", "sequence": "p1.pdb", "input_template": ["h.pdb"],
+      "best_of": 8, "helix_prior": true, "out": "hard/P1.pdb" },
     { "sequence": "p2.fasta", "distogram_artifact": "p2.distogram.json" } ]
-  Global flags (--best-of/--seed/--helix-prior/evidence knobs/--encrypt) apply to
-  every job; outputs go to <--out>/<id>/<id>.{pdb,json}.
+  The CLI flags (--best-of/--seed/--helix-prior/evidence knobs/--encrypt) are the
+  batch-wide DEFAULTS; any job may override them per-id with a same-named field
+  (best_of, seed, helix_prior, helix_prior_ensemble, disto_max_bin, template_sigma,
+  noe_mode, soi_fill, held_out_threshold, held_out_msa_neff, encrypt). A per-job
+  "out" also overrides where that job writes. Default output: <--out>/<id>/<id>.{pdb,json}.
 
 GOOD TO KNOW
   - Billing is enforced server-side: the enclave refuses any fold without a
@@ -1339,11 +1428,18 @@ BATCH (many sequences, one request)
 
     fold_batch(
         "jobs.json", "results/",         # manifest + results root
-        best_of=2, encrypt=False,        # global flags apply to every job
+        best_of=2, encrypt=False,        # batch-wide DEFAULTS (any job may override)
     )
     # Manifest is a JSON array; per-job keys: sequence, id, distogram_artifact,
     # input_<name> evidence fields, held_out_input. Paths resolve against the
     # manifest dir. Outputs go to results/<id>/<id>.{pdb,json}.
+    #
+    # PER-JOB OVERRIDES — a job may carry any of these to beat the batch default:
+    #   best_of, seed, helix_prior, helix_prior_ensemble, disto_max_bin,
+    #   template_sigma, noe_mode, soi_fill, held_out_threshold, held_out_msa_neff,
+    #   encrypt, and `out` (a file path -> that job's dir+stem, or a directory).
+    #   e.g. {"id":"hard","sequence":"h.fasta","input_msa":"h.a3m",
+    #         "best_of":8,"helix_prior":true,"out":"hard/h.pdb"}
 
 NOTES
   - The dispatcher (default-on for the CLI) is a CLI-layer convenience; the SDK
@@ -1717,18 +1813,22 @@ def _print_batch_preview(manifest_path: str, args) -> None:
     except (OSError, ValueError) as exc:
         print(f"[error] cannot read manifest {manifest_path}: {exc}", file=sys.stderr)
         return
-    n = len(jobs) if isinstance(jobs, list) else 0
-    credits = n * max(1, int(args.best_of))
+    job_list = jobs if isinstance(jobs, list) else []
+    n = len(job_list)
+    credits = sum(_job_best_of(s, args.best_of) for s in job_list)
     metered = not args.no_metering
     print("Physis Fold — BATCH DRY RUN (nothing folded, no credits charged)")
     print(f"  manifest     : {manifest_path}  ({n} job(s))")
-    for i, spec in enumerate(jobs if isinstance(jobs, list) else []):
+    for i, spec in enumerate(job_list):
         jid = (spec.get("id") if isinstance(spec, dict) else None) or f"job_{i}"
         seq = spec.get("sequence", "?") if isinstance(spec, dict) else "?"
-        print(f"    - {jid:<14} {seq}")
+        bo = _job_best_of(spec, args.best_of)
+        out_ov = spec.get("out") if isinstance(spec, dict) else None
+        extra = f"best-of {bo}" + (f", out {out_ov}" if out_ov else "")
+        print(f"    - {jid:<14} {seq:<28} ({extra})")
     print(f"  out (root)   : {args.out or '<--out required to run>'}")
-    print(f"  best-of      : {args.best_of} seed(s)")
-    print(f"  credit cost  : {credits} credit(s) ({n} × {args.best_of})"
+    print(f"  best-of      : {args.best_of} seed(s)  (global default; per-job overrides apply)")
+    print(f"  credit cost  : {credits} credit(s)  (sum of per-job best-of)"
           + ("" if metered else "   [metering off - no charge]"))
     print("  --> Re-run with --run to execute for real.")
 
@@ -1745,10 +1845,12 @@ def _command_foldings(args) -> int:
         try:
             with open(args.batch, encoding="utf-8") as fh:
                 jobs = json.load(fh)
-            n = len(jobs) if isinstance(jobs, list) else 1
         except (OSError, ValueError):
-            n = 1
-        return best_of * max(1, n)
+            return best_of
+        if not isinstance(jobs, list) or not jobs:
+            return best_of
+        # Per-job best_of may differ; sum the effective foldings across all jobs.
+        return sum(_job_best_of(s, best_of) for s in jobs)
     return best_of
 
 

{physistool-0.1.2 → physistool-0.1.4}/physistool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physistool
-Version: 0.1.2
+Version: 0.1.4
 Summary: Open-source PhysisFold client — CLI + SDK for constraint-guided all-atom protein folding via a remote (Nitro Enclave) endpoint.
 Author: MorphoComputing
 License: MIT

{physistool-0.1.2 → physistool-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "physistool"
-version = "0.1.2"
+version = "0.1.4"
 description = "Open-source PhysisFold client — CLI + SDK for constraint-guided all-atom protein folding via a remote (Nitro Enclave) endpoint."
 readme = "README.md"
 requires-python = ">=3.9"