dexverse-cli 0.0.2__py3-none-any.whl

dexverse/downloader/state.py

@@ -0,0 +1,263 @@
+"""Per-task state: the ``<out>/.dexverse/tasks/<taskId>/`` directory.
+
+State is kept strictly under the out root so it never pollutes the dataset
+tree (doc §6). ``download-state.json`` records per-file status so verify,
+repair and resume all share one source of truth.
+"""
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from ..manifest import Manifest, resolve_dest
+
+
+STATE_DIRNAME = ".dexverse"
+TASKS_DIRNAME = "tasks"
+TASK_INSTRUCTIONS_DIRNAME = "task-instructions"
+
+# file statuses
+PENDING = "pending"
+DOWNLOADED = "downloaded"
+SKIPPED = "skipped"  # already present + size matched before download
+FAILED = "failed"
+VERIFIED = "verified"
+CORRUPT = "corrupt"  # present but failed size/sha check
+
+
+def dexverse_root(out: Path) -> Path:
+    return Path(out) / STATE_DIRNAME
+
+
+def task_dir(out: Path, task_id: str) -> Path:
+    return dexverse_root(out) / TASKS_DIRNAME / task_id
+
+
+def task_instructions_dir(out: Path) -> Path:
+    return dexverse_root(out) / TASK_INSTRUCTIONS_DIRNAME
+
+
+def task_instruction_path(out: Path, relpath: str) -> Path:
+    """Hidden metadata path for one downloaded dataset file."""
+    return resolve_dest(task_instructions_dir(out), f"{relpath}.json")
+
+
+def state_file_path(out: Path, task_id: str) -> Path:
+    return task_dir(out, task_id) / "download-state.json"
+
+
+def manifest_copy_path(out: Path, task_id: str) -> Path:
+    return task_dir(out, task_id) / "manifest.json"
+
+
+def s5cmd_file_path(out: Path, task_id: str) -> Path:
+    return task_dir(out, task_id) / "download.s5cmd"
+
+
+def log_file_path(out: Path, task_id: str) -> Path:
+    return task_dir(out, task_id) / "download.log"
+
+
+def ensure_task_dir(out: Path, task_id: str) -> Path:
+    d = task_dir(out, task_id)
+    d.mkdir(parents=True, exist_ok=True)
+    # Best-effort restrictive perms (POSIX; no-op on Windows). The task dir
+    # holds a manifest copy that may include S3 creds / presigned URLs.
+    try:
+        os.chmod(d, 0o700)
+    except OSError:
+        pass
+    return d
+
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+class FileState:
+    __slots__ = (
+        "fileId", "objectKey", "relpath", "status", "localSize",
+        "expectedSize", "sha256", "error",
+    )
+
+    def __init__(self, fileId: str, objectKey: str, relpath: str,
+                 status: str = PENDING, localSize: Optional[int] = None,
+                 expectedSize: Optional[int] = None, sha256: Optional[str] = None,
+                 error: Optional[str] = None):
+        self.fileId = fileId
+        self.objectKey = objectKey
+        self.relpath = relpath
+        self.status = status
+        self.localSize = localSize
+        self.expectedSize = expectedSize
+        self.sha256 = sha256
+        self.error = error
+
+    def to_dict(self) -> Dict[str, object]:
+        return {
+            "fileId": self.fileId,
+            "objectKey": self.objectKey,
+            "relpath": self.relpath,
+            "status": self.status,
+            "localSize": self.localSize,
+            "expectedSize": self.expectedSize,
+            "sha256": self.sha256,
+            "error": self.error,
+        }
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, object]) -> "FileState":
+        return cls(
+            fileId=str(d.get("fileId", "")),
+            objectKey=str(d.get("objectKey", "")),
+            relpath=str(d.get("relpath", "")),
+            status=str(d.get("status", PENDING)),
+            localSize=d.get("localSize"),  # type: ignore[arg-type]
+            expectedSize=d.get("expectedSize"),  # type: ignore[arg-type]
+            sha256=d.get("sha256"),  # type: ignore[arg-type]
+            error=d.get("error"),  # type: ignore[arg-type]
+        )
+
+
+class TaskState:
+    """In-memory mutable state for a task, persisted as download-state.json."""
+
+    def __init__(self, out: Path, task_id: str):
+        self.out = Path(out)
+        self.task_id = task_id
+        self.started_at: Optional[str] = None
+        self.finished_at: Optional[str] = None
+        self.backend: Optional[str] = None
+        self.parallel: Optional[int] = None
+        self.files: Dict[str, FileState] = {}  # keyed by objectKey
+
+    # ---- construction --------------------------------------------------- #
+
+    @classmethod
+    def for_manifest(cls, out: Path, manifest: Manifest) -> "TaskState":
+        task_id = manifest.effective_task_id()
+        state = cls(out, task_id)
+        for f in manifest.files:
+            key = f.effective_key()
+            state.files[key] = FileState(
+                fileId=f.fileId or key,
+                objectKey=key,
+                relpath=f.relpath(),
+                expectedSize=f.size,
+                sha256=f.sha256,
+            )
+        return state
+
+    # ---- mutation ------------------------------------------------------- #
+
+    def mark(self, objectKey: str, status: str, *,
+             localSize: Optional[int] = None,
+             expectedSize: Optional[int] = None,
+             error: Optional[str] = None) -> None:
+        fs = self.files.get(objectKey)
+        if fs is None:
+            return
+        fs.status = status
+        if localSize is not None:
+            fs.localSize = localSize
+        if expectedSize is not None:
+            fs.expectedSize = expectedSize
+        fs.error = error
+
+    def start(self, backend: str, parallel: int) -> None:
+        self.backend = backend
+        self.parallel = parallel
+        if self.started_at is None:
+            self.started_at = _now_iso()
+
+    def finish(self) -> None:
+        self.finished_at = _now_iso()
+
+    # ---- summary -------------------------------------------------------- #
+
+    def counts(self) -> Dict[str, int]:
+        out: Dict[str, int] = {}
+        for fs in self.files.values():
+            out[fs.status] = out.get(fs.status, 0) + 1
+        return out
+
+    def pending_or_bad(self) -> List[str]:
+        """objectKeys that still need (re)downloading."""
+        bad = {FAILED, CORRUPT, PENDING}
+        return [k for k, fs in self.files.items() if fs.status in bad]
+
+    # ---- persistence ---------------------------------------------------- #
+
+    def to_dict(self) -> Dict[str, object]:
+        return {
+            "taskId": self.task_id,
+            "out": str(self.out),
+            "backend": self.backend,
+            "parallel": self.parallel,
+            "startedAt": self.started_at,
+            "finishedAt": self.finished_at,
+            "files": [fs.to_dict() for fs in self.files.values()],
+        }
+
+    def save(self) -> Path:
+        ensure_task_dir(self.out, self.task_id)
+        path = state_file_path(self.out, self.task_id)
+        path.write_text(
+            json.dumps(self.to_dict(), indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+        return path
+
+    @classmethod
+    def load(cls, out: Path, task_id: str) -> "TaskState":
+        path = state_file_path(out, task_id)
+        data = json.loads(path.read_text(encoding="utf-8"))
+        state = cls(out, data.get("taskId", task_id))
+        state.backend = data.get("backend")
+        state.parallel = data.get("parallel")
+        state.started_at = data.get("startedAt")
+        state.finished_at = data.get("finishedAt")
+        for fd in data.get("files", []):
+            fs = FileState.from_dict(fd)
+            state.files[fs.objectKey] = fs
+        return state
+
+    @classmethod
+    def load_or_create(cls, out: Path, manifest: Manifest) -> "TaskState":
+        task_id = manifest.effective_task_id()
+        path = state_file_path(out, task_id)
+        state: Optional["TaskState"]
+        if path.exists():
+            try:
+                state = cls.load(out, task_id)
+            except Exception:
+                state = cls.for_manifest(out, manifest)
+                return state
+        else:
+            return cls.for_manifest(out, manifest)
+
+        # Reconcile against the current manifest: any file added since the last
+        # run must be tracked (and carry expectedSize/sha256 for verify), else
+        # mark() silently no-ops on it and it never reaches download-state.json.
+        for f in manifest.files:
+            key = f.effective_key()
+            if key not in state.files:
+                state.files[key] = FileState(
+                    fileId=f.fileId or key,
+                    objectKey=key,
+                    relpath=f.relpath(),
+                    expectedSize=f.size,
+                    sha256=f.sha256,
+                )
+            else:
+                fs = state.files[key]
+                fs.fileId = f.fileId or key
+                fs.relpath = f.relpath()
+                if f.size is not None:
+                    fs.expectedSize = f.size
+                if f.sha256 is not None:
+                    fs.sha256 = f.sha256
+        return state

dexverse/downloader/verify.py

@@ -0,0 +1,114 @@
+"""Verification: size check (fast) and optional sha256 deep check (doc §17).
+
+A file is *good* when it exists on disk and its size matches the manifest
+(and, under ``--deep`` or when a sha256 is recorded, its hash matches). Any
+mismatch is reported so repair can re-fetch just those objects.
+"""
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, List
+
+from ..manifest import FileSpec, resolve_dest
+
+
+# 64 MiB chunks — large enough to stay fast on big HDF5/MP4, small enough to
+# keep memory bounded when hashing multi-GB videos.
+_CHUNK = 64 * 1024 * 1024
+
+
+def sha256_of(path: Path) -> str:
+    h = hashlib.sha256()
+    with path.open("rb") as fh:
+        for chunk in iter(lambda: fh.read(_CHUNK), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+@dataclass
+class VerifyResult:
+    fileId: str
+    objectKey: str
+    relpath: str
+    dest: Path
+    ok: bool
+    reason: str  # "ok" | "missing" | "size" | "sha256"
+
+    @property
+    def missing(self) -> bool:
+        return self.reason == "missing"
+
+
+def verify_file(file: FileSpec, out: Path, *, deep: bool = False,
+                force_hash: bool = False) -> VerifyResult:
+    """Check one file on disk.
+
+    deep        : always hash when a sha256 is recorded.
+    force_hash  : hash even when the manifest has no sha256 (returns reason
+                  "ok" since there is nothing to compare against — used by the
+                  deep CLI flag on manifests without hashes).
+    """
+    relpath = file.relpath()
+    dest = resolve_dest(Path(out), relpath)
+    key = file.effective_key()
+    fid = file.fileId or key
+
+    if not dest.exists():
+        return VerifyResult(fid, key, relpath, dest, False, "missing")
+
+    local_size = dest.stat().st_size
+    if file.size is not None and local_size != file.size:
+        return VerifyResult(fid, key, relpath, dest, False, "size")
+
+    want_hash = file.sha256
+    if want_hash and (deep or force_hash):
+        if sha256_of(dest).lower() != want_hash.lower():
+            return VerifyResult(fid, key, relpath, dest, False, "sha256")
+    elif force_hash and not want_hash:
+        # Nothing to compare; size already matched, so treat as ok.
+        pass
+
+    return VerifyResult(fid, key, relpath, dest, True, "ok")
+
+
+def verify_files(files: Iterable[FileSpec], out: Path, *,
+                 deep: bool = False) -> List[VerifyResult]:
+    return [verify_file(f, out, deep=deep) for f in files]
+
+
+@dataclass
+class VerifySummary:
+    total: int
+    ok: int
+    missing: int
+    size_mismatch: int
+    sha256_mismatch: int
+    results: List[VerifyResult]
+
+    @property
+    def all_ok(self) -> bool:
+        return self.ok == self.total
+
+    @property
+    def bad_results(self) -> List[VerifyResult]:
+        return [r for r in self.results if not r.ok]
+
+
+def summarize(results: List[VerifyResult]) -> VerifySummary:
+    counts = {"missing": 0, "size": 0, "sha256": 0}
+    ok = 0
+    for r in results:
+        if r.ok:
+            ok += 1
+        else:
+            counts[r.reason] = counts.get(r.reason, 0) + 1
+    return VerifySummary(
+        total=len(results),
+        ok=ok,
+        missing=counts["missing"],
+        size_mismatch=counts["size"],
+        sha256_mismatch=counts["sha256"],
+        results=results,
+    )

dexverse/manifest.py

@@ -0,0 +1,284 @@
+"""Manifest data model — the core protocol of the DexVerse downloader.
+
+The manifest is shared by the CLI, the Python SDK, the mock backend and the
+production backend. Field names deliberately match the on-the-wire JSON exactly
+(camelCase) so the model round-trips without alias gymnastics.
+
+Path rule (doc §2, §6, §18):
+
+    localPath = out / (file.relativePath || file.originalPath || file.objectKey)
+
+The manifest only ever carries POSIX relative paths; the absolute local path is
+derived purely from the user-supplied ``--out``. Manifests must never embed a
+local absolute path. Raw DexVerse backend payloads use ``storage_path`` for the
+remote object key and ``file_name`` for the desired local landing name.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path, PurePosixPath
+from typing import Any, Dict, List, Optional
+
+from pydantic import AliasChoices, BaseModel, ConfigDict, Field, model_validator
+
+
+# --------------------------------------------------------------------------- #
+# Path helpers
+# --------------------------------------------------------------------------- #
+
+# A segment that is (or starts with) a Windows drive letter, e.g. "C:" or "C:foo".
+# On Windows, pathlib joinpath with such a segment resets the drive and escapes
+# the out root, so they are stripped as a traversal defense.
+_DRIVE_RE = re.compile(r"^[A-Za-z]:")
+
+
+def normalize_relpath(raw: str) -> str:
+    """Normalize a manifest relative path to portable POSIX form.
+
+    - backslashes → forward slashes (defensive; manifest should already be POSIX)
+    - drop a leading ``/`` (it is *relative*, not absolute)
+    - strip Windows drive-letter prefixes (``C:`` or ``C:foo``) per segment —
+      on Windows pathlib treats these as a drive reset that escapes the out root
+    - drop ``.`` and ``..`` segments so a path can never escape the out root
+    """
+    if raw is None:
+        return ""
+    posix = str(raw).replace("\\", "/")
+    parts = []
+    for seg in posix.split("/"):
+        if _DRIVE_RE.match(seg):        # strip a leading "X:" drive prefix
+            seg = seg[2:]
+        if seg not in ("", ".", ".."):
+            parts.append(seg)
+    return "/".join(parts)
+
+
+def resolve_relpath(
+    relativePath: Optional[str],
+    originalPath: Optional[str],
+    objectKey: Optional[str],
+) -> str:
+    """Apply the priority rule: relativePath || originalPath || objectKey."""
+    chosen = relativePath or originalPath or objectKey or ""
+    return normalize_relpath(chosen)
+
+
+def resolve_dest(out, relpath_posix: str) -> Path:
+    """Join an out root with a POSIX relative path, guaranteed to stay under out.
+
+    The relpath is treated as POSIX and re-joined onto the local ``Path``, which
+    works on both Linux and Windows. As an authoritative backstop (defense in
+    depth on top of ``normalize_relpath``), the destination is checked to live
+    under ``out``. This check is **lexical** by design: ``normalize_relpath``
+    already strips ``..``, drive letters, and absolute anchors, so a lexical
+    ``relative_to`` test fully contains the threat model. We deliberately avoid
+    ``Path.resolve()`` here — on Windows, resolving through temp-dir junctions
+    while sibling download threads create directories made the check flaky and
+    raised false "escapes the out root" errors for ordinary paths like a/1.bin.
+    """
+    parts = [seg for seg in relpath_posix.split("/") if seg not in ("", ".", "..")]
+    out_path = Path(out)
+    dest = out_path.joinpath(*parts)
+    try:
+        dest.relative_to(out_path)
+    except ValueError:
+        raise ValueError(
+            f"unsafe relative path escapes the out root: {relpath_posix!r}"
+        )
+    return dest
+
+
+# --------------------------------------------------------------------------- #
+# Models
+# --------------------------------------------------------------------------- #
+
+class StorageCredentials(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    type: str = "dev"  # "temporary" | "dev" | "static" | "env"
+    accessKey: Optional[str] = None
+    secretKey: Optional[str] = None
+    sessionToken: Optional[str] = ""
+    expiresAt: Optional[str] = None
+
+    def is_populated(self) -> bool:
+        """True when the manifest carries real (non-env) credentials."""
+        return bool(self.accessKey and self.secretKey)
+
+
+class Storage(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    type: str = "s3"
+    endpoint: Optional[str] = None
+    region: Optional[str] = "us-east-1"
+    bucket: Optional[str] = None
+    addressingStyle: str = "path"
+    credentials: StorageCredentials = Field(default_factory=StorageCredentials)
+
+    def resolved_bucket(self, file_bucket: Optional[str]) -> Optional[str]:
+        return file_bucket or self.bucket
+
+
+class DownloadOptions(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    defaultParallel: int = 16
+    verify: str = "size"  # "size" | "sha256" | "none"
+    preserveOriginalPath: bool = True
+
+
+class FileSpec(BaseModel):
+    # Accept the canonical manifest field names AND the DexVerse backend's
+    # native field names (download_url / storage_path / storage_bucket /
+    # file_name / file_size) so a manifest can be the backend's raw output.
+    # populate_by_name keeps the canonical names working too; serialization
+    # (model_dump) always emits canonical names, so the on-disk task manifest
+    # stays in the canonical contract regardless of input dialect.
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    fileId: Optional[str] = Field(
+        None, validation_alias=AliasChoices("fileId", "file_name", "file_id", "id"))
+    uri: Optional[str] = None
+    bucket: Optional[str] = Field(
+        None, validation_alias=AliasChoices("bucket", "storage_bucket"))
+    # objectKey is optional for the http/presigned path: a presigned URL +
+    # landing file_name is enough to download. s5cmd/python still need it.
+    # When absent, effective_key() falls back to file_name / presignedUrl.
+    objectKey: Optional[str] = Field(
+        None, validation_alias=AliasChoices("objectKey", "storage_path", "key", "object_key"))
+    relativePath: Optional[str] = Field(
+        None, validation_alias=AliasChoices("relativePath", "relative_path", "file_name"))
+    originalPath: Optional[str] = Field(
+        None, validation_alias=AliasChoices("originalPath", "original_path"))
+    size: Optional[int] = Field(
+        None, validation_alias=AliasChoices("size", "file_size", "bytes"))
+    sha256: Optional[str] = Field(
+        None, validation_alias=AliasChoices("sha256", "sha"))
+    # A short-lived, self-authenticating HTTPS download URL (doc reality: the
+    # DexVerse platform issues presigned URLs instead of temporary S3 creds).
+    # Consumed only by the ``http`` backend; ignored by s5cmd/python.
+    presignedUrl: Optional[str] = Field(
+        None, validation_alias=AliasChoices("presignedUrl", "download_url", "url", "downloadUrl"))
+    taskInstruction: Optional[Dict[str, Any]] = Field(
+        None,
+        validation_alias=AliasChoices("taskInstruction", "task_instruction"),
+    )
+
+    def relpath(self) -> str:
+        """The local landing path relative to out (POSIX, normalized)."""
+        return resolve_relpath(self.relativePath, self.originalPath, self.objectKey)
+
+    def effective_key(self) -> str:
+        """A stable identifier for result maps / logs.
+
+        objectKey when present; otherwise fall back to the landing file_name,
+        then the presignedUrl. The http/presigned path only needs the URL +
+        file_name, so manifests with no objectKey stay usable.
+        """
+        if self.objectKey:
+            return self.objectKey
+        if self.relativePath:
+            return self.relativePath
+        if self.presignedUrl:
+            return self.presignedUrl
+        raise ValueError("file has no objectKey, file_name, or download_url to identify it")
+
+    def resolved_bucket(self, default_bucket: Optional[str]) -> Optional[str]:
+        return self.bucket or default_bucket
+
+    def resolved_uri(self, default_bucket: Optional[str]) -> str:
+        """s3://bucket/objectKey, materialized even when ``uri`` was absent."""
+        if self.uri:
+            return self.uri
+        bucket = self.resolved_bucket(default_bucket)
+        if not bucket:
+            # Fall back to a bare s3:///key form; callers validate bucket first.
+            return f"s3:///{self.objectKey.lstrip('/')}"
+        return f"s3://{bucket}/{self.objectKey.lstrip('/')}"
+
+
+class Manifest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    manifestVersion: str = "1.0"
+    taskId: Optional[str] = None
+    createdAt: Optional[str] = None
+    expiresAt: Optional[str] = None
+    storage: Optional[Storage] = None
+    download: DownloadOptions = Field(default_factory=DownloadOptions)
+    files: List[FileSpec] = Field(default_factory=list)
+
+    # ---- convenience ---------------------------------------------------- #
+
+    @model_validator(mode="after")
+    def keep_first_file_per_local_path(self) -> "Manifest":
+        """Drop later files that would overwrite the same local destination.
+
+        Backend-native manifests commonly provide only ``file_name`` as the
+        landing path. Keeping the first occurrence makes duplicate names
+        deterministic and ensures the downloaded file and its task instruction
+        always come from the same manifest entry.
+        """
+        seen = set()
+        unique_files = []
+        for file_spec in self.files:
+            relpath = file_spec.relpath()
+            if relpath in seen:
+                continue
+            seen.add(relpath)
+            unique_files.append(file_spec)
+        self.files = unique_files
+        return self
+
+    def effective_task_id(self) -> str:
+        """taskId for the state dir; falls back to a stable hash if absent."""
+        if self.taskId:
+            return self.taskId
+        import hashlib
+        digest = hashlib.sha1(
+            "|".join(f.effective_key() for f in self.files).encode("utf-8")
+        ).hexdigest()[:12]
+        return f"local_{digest}"
+
+    def has_credentials(self) -> bool:
+        return bool(self.storage and self.storage.credentials.is_populated())
+
+    @classmethod
+    def from_payload(cls, data) -> "Manifest":
+        """Validate a manifest from a dict or list.
+
+        A bare list ``[{...}, {...}]`` (e.g. the backend's raw per-file response)
+        is coerced into ``{"files": [...]}``.
+        """
+        import json
+        if isinstance(data, str):
+            data = json.loads(data)
+        if isinstance(data, list):
+            data = {"files": data}
+        return cls.model_validate(data)
+
+    @classmethod
+    def parse_file(cls, path: Path) -> "Manifest":
+        import json
+        text = Path(path).read_text(encoding="utf-8")
+        return cls.from_payload(json.loads(text))
+
+    @classmethod
+    def parse_stdin(cls, stream=None) -> "Manifest":
+        """Parse a manifest piped on stdin (``--manifest -``).
+
+        Lets the platform frontend hand users a self-contained command —
+        ``echo '<json>' | dexverse-dl download --manifest - ...`` — so they
+        don't have to save a JSON file first (presigned URLs expire fast).
+        ``stream`` defaults to ``sys.stdin``; tests pass a ``StringIO``.
+        """
+        import json
+        import sys
+        stream = stream if stream is not None else sys.stdin
+        text = stream.read()
+        if not text.strip():
+            raise ValueError(
+                "no manifest received on stdin (pass --manifest PATH or pipe JSON)"
+            )
+        return cls.from_payload(json.loads(text))

dexverse/mock/__init__.py

@@ -0,0 +1,2 @@
+"""DexVerse mock backend (FastAPI). See server.py."""
+from __future__ import annotations

dexverse/mock/mock_tasks.json

@@ -0,0 +1,22 @@
+{
+  "dl_demo_001": {
+    "files": [
+      {
+        "fileId": "episode_000001",
+        "bucket": "dexverse",
+        "objectKey": "datasets/aaa_test/v1/episodes/episode_000001.hdf5",
+        "relativePath": "datasets/aaa_test/v1/episodes/episode_000001.hdf5",
+        "size": 14994636,
+        "sha256": ""
+      },
+      {
+        "fileId": "camera_head_left_000001",
+        "bucket": "dexverse",
+        "objectKey": "datasets/aaa_test/v1/videos/camera_head_left.mp4",
+        "relativePath": "datasets/aaa_test/v1/videos/camera_head_left.mp4",
+        "size": 1234567890,
+        "sha256": ""
+      }
+    ]
+  }
+}