Upload hf_x_nodes.py

hf_x_nodes.py

@@ -0,0 +1,763 @@
+# hf_private_repo_nodes.py
+#
+# ComfyUI Custom Nodes (single file):
+#   1) HF_PrivateRepo_Uploader     (IMAGE -> upload ZIP of PNG(s))
+#   2) HF_PrivateRepo_Downloader   (download ZIP of PNG(s) -> IMAGE) with polling + trigger
+#   3) HF_Data_BAM_Uploader        (STRING -> upload Data/BAM.txt)
+#   4) HF_Data_BAM_Downloader      (download Data/BAM.txt -> STRING)
+#
+# Repo layout:
+#   Images ZIP: {Version}/{ID}/{Category}/{Direction}/{Filename}.zip
+#   Text:       {Version}/{ID}/Data/BAM.txt
+#
+# ZIP behavior:
+#   - One uploaded image batch becomes one ZIP file in the repo.
+#   - The ZIP filename NEVER gets an image-count suffix.
+#       Example: "Walk" -> "Walk.zip" even if it contains 50 images.
+#   - The downloader only looks for that exact ZIP filename.
+#       Example: "Walk" -> download "Walk.zip" (not "Walk_50.zip").
+#   - PNG files inside the ZIP are ordered and named from the ZIP base name:
+#       Walk.zip -> Walk.png                 (single image)
+#       Walk.zip -> Walk_00.png..Walk_49.png (batch)
+#
+# Logging:
+#   - A local append-only log file is written next to this node file.
+#   - The log file is created automatically if it does not exist.
+#
+# IMPORTANT (per your request):
+#   Hardcoded placeholder token. Replace safely later.
+#     Secret_Token = "hf_???"
+#
+# Dependencies:
+#   pip install huggingface_hub pillow numpy
+#
+# Put this file into:
+#   ComfyUI/custom_nodes/hf_private_repo_nodes.py
+# then restart ComfyUI.
+
+import os
+import io
+import re
+import time
+import zipfile
+from typing import List, Tuple, Optional
+
+import numpy as np
+import torch
+from PIL import Image
+
+# --- Hardcoded per your request (replace safely later) ---
+Secret_Token = "hf_???"
+
+# --- Hardcoded repo + version ---
+REPO_ID = "saliacoel/v1"
+REPO_TYPE = "model"  # keep for upload APIs
+Version = "1"
+
+ALLOWED_CATEGORIES = ["HD", "Unity", "RpgMaker", "Misc"]
+ALLOWED_DIRECTIONS = [
+    "Front",
+    "Side_Right",
+    "Side_Left",
+    "Rear",
+    "Diagonal_Front_Right",
+    "Diagonal_Front_Left",
+    "Diagonal_Rear_Left",
+    "Diagonal_Rear_Right",
+    "Misc",
+]
+
+# Poll schedule (absolute seconds since start):
+#  - 1 immediate poll (t=0)
+#  - 5 polls every 2 sec for 10 sec (t=2,4,6,8,10)
+#  - wait 80 sec (next at t=90)
+#  - 4 polls every 5 sec (t=90,95,100,105)
+#  - wait 30 sec (next at t=135)
+#  - 3 polls every 5 sec (t=135,140,145)
+#  - wait 20 sec (next at t=165)
+#  - 2 polls every 5 sec (t=165,170)
+#  - wait 15 sec (next at t=185)
+#  - 2 polls every 5 sec (t=185,190) final
+POLL_TIMES_SECONDS = [0, 2, 4, 6, 8, 10, 90, 95, 100, 105, 135, 140, 145, 165, 170, 185, 190]
+
+LOG_FILENAME = "hf_private_repo_nodes.log"
+LOG_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), LOG_FILENAME)
+
+
+def _append_log(message: str) -> None:
+    """
+    Append a line to the local log file.
+    The file is created automatically if it does not exist.
+    Logging must never break node execution, so all errors are swallowed.
+    """
+    try:
+        log_dir = os.path.dirname(LOG_PATH)
+        if log_dir:
+            os.makedirs(log_dir, exist_ok=True)
+
+        timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+        line = f"[{timestamp}] {str(message).rstrip()}\n"
+
+        with open(LOG_PATH, "a", encoding="utf-8") as f:
+            f.write(line)
+    except Exception:
+        pass
+
+
+def _sanitize_component(s: str) -> str:
+    """Sanitize a single path component so it cannot create unintended subfolders."""
+    s = str(s).strip()
+    s = s.replace("\\", "_").replace("/", "_")
+    while ".." in s:
+        s = s.replace("..", "_")
+    return s
+
+
+def _normalize_id(id_int: int, id_str: str) -> str:
+    if id_str is not None and str(id_str).strip() != "":
+        return _sanitize_component(str(id_str))
+    return _sanitize_component(str(int(id_int)))
+
+
+def _normalize_category(category: str) -> str:
+    return category if category in ALLOWED_CATEGORIES else "Misc"
+
+
+def _normalize_direction(direction: str) -> str:
+    return direction if direction in ALLOWED_DIRECTIONS else "Misc"
+
+
+def _normalize_zip_filename(name: str) -> str:
+    """
+    Normalize a user-entered filename into a repo ZIP filename.
+
+    Behavior:
+      ""            -> "_.zip"
+      "Walk"        -> "Walk.zip"
+      "Walk.zip"    -> "Walk.zip"
+      "Walk.png"    -> "Walk.zip"
+      "folder/Walk" -> "Walk.zip"
+    """
+    name = "" if name is None else str(name)
+    name = os.path.basename(name).strip()
+    name = _sanitize_component(name)
+
+    if name == "":
+        return "_.zip"
+
+    base, ext = os.path.splitext(name)
+    if ext.lower() in (".zip", ".png", ".jpg", ".jpeg", ".webp"):
+        name = base.strip()
+    else:
+        name = name.strip()
+
+    if name == "":
+        name = "_"
+
+    return f"{name}.zip"
+
+
+def _zip_base_name(zip_filename: str) -> str:
+    base = os.path.splitext(_normalize_zip_filename(zip_filename))[0].strip()
+    return base if base else "_"
+
+
+def _make_png_entry_names_for_zip(zip_filename: str, batch_size: int) -> List[str]:
+    """
+    Internal ZIP entry names.
+      - single image: base.png
+      - batch: base_00.png, base_01.png, ...
+    """
+    if batch_size < 1:
+        raise ValueError(f"batch_size must be >= 1, got {batch_size}")
+
+    base = _zip_base_name(zip_filename)
+    if batch_size == 1:
+        return [f"{base}.png"]
+
+    width = max(2, len(str(batch_size - 1)))
+    joiner = "" if base.endswith("_") else "_"
+    return [f"{base}{joiner}{i:0{width}d}.png" for i in range(batch_size)]
+
+
+def _ensure_batch(images: torch.Tensor) -> torch.Tensor:
+    """Ensure IMAGES is 4D [B,H,W,C] or [B,C,H,W]. If 3D, wrap to batch size 1."""
+    if not isinstance(images, torch.Tensor):
+        raise TypeError(f"IMAGES must be a torch.Tensor, got {type(images)}")
+    if images.ndim == 3:
+        return images.unsqueeze(0)
+    if images.ndim == 4:
+        return images
+    raise ValueError(f"IMAGES must have 3 or 4 dims. Got shape {tuple(images.shape)}")
+
+
+def _select_first_as_single_image(images: torch.Tensor) -> torch.Tensor:
+    """Return a batch with exactly 1 image (4D)."""
+    if not isinstance(images, torch.Tensor):
+        raise TypeError(f"dummy_image must be a torch.Tensor, got {type(images)}")
+    if images.ndim == 3:
+        return images.unsqueeze(0)
+    if images.ndim == 4:
+        return images[:1]
+    raise ValueError(f"dummy_image must have 3 or 4 dims. Got shape {tuple(images.shape)}")
+
+
+def _tensor_to_png_bytes(img: torch.Tensor) -> bytes:
+    """
+    Convert a single image tensor to PNG bytes.
+    Supports:
+      - HWC with C=3 or C=4
+      - CHW with C=3 or C=4
+    Values are clamped to [0,255]. If values look like [0,1], they are scaled.
+    """
+    if not isinstance(img, torch.Tensor):
+        raise TypeError(f"Expected torch.Tensor, got {type(img)}")
+
+    t = img.detach()
+    if t.device.type != "cpu":
+        t = t.to("cpu")
+
+    if t.ndim != 3:
+        raise ValueError(f"Expected 3D tensor for single image, got shape {tuple(t.shape)}")
+
+    # Detect HWC vs CHW
+    if t.shape[-1] in (3, 4):
+        arr = t.numpy()
+        c = arr.shape[-1]
+    elif t.shape[0] in (3, 4):
+        arr = np.transpose(t.numpy(), (1, 2, 0))
+        c = arr.shape[-1]
+    else:
+        raise ValueError(
+            f"Cannot infer channel dimension. Got shape {tuple(t.shape)}; expected HWC or CHW with C=3 or C=4."
+        )
+
+    if c not in (3, 4):
+        raise ValueError(f"Unsupported channel count: {c}. Only RGB(3) or RGBA(4) supported.")
+
+    if arr.dtype != np.uint8:
+        maxv = float(np.nanmax(arr)) if arr.size else 0.0
+        if maxv <= 1.0 + 1e-6:
+            arr = arr * 255.0
+        arr = np.rint(arr)
+        arr = np.clip(arr, 0, 255).astype(np.uint8)
+
+    mode = "RGBA" if c == 4 else "RGB"
+    pil = Image.fromarray(arr, mode=mode)
+
+    buf = io.BytesIO()
+    pil.save(buf, format="PNG")
+    return buf.getvalue()
+
+
+def _images_to_zip_bytes(batch: torch.Tensor, zip_filename: str) -> Tuple[bytes, List[str]]:
+    """
+    Convert a batch of images to one ZIP file containing PNG files.
+    Returns (zip_bytes, zip_entry_names).
+    """
+    batch = _ensure_batch(batch)
+    batch_size = int(batch.shape[0])
+    entry_names = _make_png_entry_names_for_zip(zip_filename, batch_size)
+
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+        for i, entry_name in enumerate(entry_names):
+            zf.writestr(entry_name, _tensor_to_png_bytes(batch[i]))
+
+    return buf.getvalue(), entry_names
+
+
+def _natural_sort_key(s: str):
+    return [int(part) if part.isdigit() else part for part in re.split(r"(\d+)", s.lower())]
+
+
+def _zip_bytes_to_png_bytes_list(zip_bytes: bytes) -> Tuple[List[bytes], List[str]]:
+    """
+    Extract PNG files from ZIP bytes.
+    Returns (png_bytes_list, entry_names) ordered by natural filename sort.
+    """
+    try:
+        with zipfile.ZipFile(io.BytesIO(zip_bytes), mode="r") as zf:
+            infos = [
+                info
+                for info in zf.infolist()
+                if not info.is_dir() and info.filename.lower().endswith(".png")
+            ]
+            infos.sort(key=lambda info: _natural_sort_key(info.filename))
+
+            if not infos:
+                raise ValueError("ZIP contains no PNG files.")
+
+            png_bytes_list: List[bytes] = []
+            entry_names: List[str] = []
+            for info in infos:
+                png_bytes_list.append(zf.read(info.filename))
+                entry_names.append(info.filename)
+
+            return png_bytes_list, entry_names
+    except zipfile.BadZipFile as e:
+        raise ValueError(f"Downloaded file is not a valid ZIP: {e}")
+
+
+def _build_image_path_in_repo(_id: str, category: str, direction: str, filename: str) -> str:
+    # {Version}/{ID}/{Category}/{Direction}/{Filename}
+    return f"{Version}/{_id}/{category}/{direction}/{filename}".replace("\\", "/")
+
+
+def _build_bam_path_in_repo(_id: str) -> str:
+    # {Version}/{ID}/Data/BAM.txt
+    return f"{Version}/{_id}/Data/BAM.txt".replace("\\", "/")
+
+
+def _resolve_main_url(path_in_repo: str) -> str:
+    # Matches what you described:
+    # https://huggingface.co/saliacoel/v1/resolve/main/<path_in_repo>
+    # NOTE: Do NOT include any token in the URL. Token is sent via Authorization header.
+    from urllib.parse import quote
+
+    safe_path = quote(path_in_repo, safe="/")
+    return f"https://huggingface.co/{REPO_ID}/resolve/main/{safe_path}"
+
+
+def _http_get_bytes(url: str, token: str, timeout_sec: float = 30.0) -> Tuple[bool, Optional[bytes], str, Optional[int]]:
+    """
+    Minimal HTTP GET (supports private repo via Bearer token).
+    Returns: (ok, bytes, err_msg, status_code)
+    """
+    from urllib.request import Request, urlopen
+    from urllib.error import HTTPError, URLError
+
+    req = Request(url, method="GET")
+    req.add_header("Authorization", f"Bearer {token}")
+    req.add_header("User-Agent", "ComfyUI-HF-PrivateRepo-Nodes/2.0")
+
+    try:
+        with urlopen(req, timeout=timeout_sec) as resp:
+            data = resp.read()
+            return True, data, "", getattr(resp, "status", 200)
+    except HTTPError as e:
+        try:
+            body = e.read()
+            snippet = body[:200].decode("utf-8", errors="replace") if body else ""
+        except Exception:
+            snippet = ""
+        msg = f"HTTP {e.code}"
+        if snippet:
+            msg += f" | {snippet}"
+        return False, None, msg, int(e.code)
+    except URLError as e:
+        return False, None, f"URL error: {e}", None
+    except Exception as e:
+        return False, None, str(e), None
+
+
+def _try_download_file_bytes(path_in_repo: str) -> Tuple[bool, Optional[bytes], str]:
+    """
+    Download file bytes for a repo path.
+    Strategy:
+      1) Direct GET on /resolve/main/... (avoids commit-hash caching issues during polling)
+      2) Fallback to huggingface_hub hf_hub_download (force_download) if direct fails
+         with non-404 errors.
+    Returns: (ok, bytes, err_msg)
+    """
+    url = _resolve_main_url(path_in_repo)
+    ok, data, err, status = _http_get_bytes(url, Secret_Token, timeout_sec=30.0)
+    if ok and data is not None:
+        return True, data, ""
+
+    if status == 404:
+        return False, None, err
+
+    try:
+        from huggingface_hub import hf_hub_download
+    except Exception as e:
+        return False, None, f"{err} | fallback huggingface_hub missing: {e}"
+
+    try:
+        local_path = hf_hub_download(
+            repo_id=REPO_ID,
+            filename=path_in_repo,
+            repo_type=REPO_TYPE,
+            token=Secret_Token,
+            revision="main",
+            force_download=True,
+        )
+        with open(local_path, "rb") as f:
+            return True, f.read(), ""
+    except Exception as e:
+        return False, None, f"{err} | fallback failed: {e}"
+
+
+def _png_bytes_list_to_batch(png_bytes_list: List[bytes]) -> torch.Tensor:
+    """
+    Decode PNG bytes -> IMAGE batch tensor [B,H,W,C], float32 in [0,1].
+    If any image has alpha, all are output as RGBA (C=4) to keep batch consistent.
+    """
+    if not png_bytes_list:
+        raise ValueError("No PNG bytes to decode.")
+
+    any_alpha = False
+    pil_images: List[Image.Image] = []
+    for b in png_bytes_list:
+        im = Image.open(io.BytesIO(b))
+        im.load()
+        pil_images.append(im)
+
+        if im.mode in ("RGBA", "LA"):
+            any_alpha = True
+        elif im.mode == "P" and "transparency" in im.info:
+            any_alpha = True
+
+    tensors = []
+    for im in pil_images:
+        im2 = im.convert("RGBA" if any_alpha else "RGB")
+        arr = np.asarray(im2).astype(np.float32) / 255.0
+        tensors.append(torch.from_numpy(arr))
+
+    return torch.stack(tensors, dim=0)
+
+
+# -------------------------------------------------------------------------------------
+# 1) IMAGE ZIP UPLOADER
+# -------------------------------------------------------------------------------------
+class HF_X_Uploader:
+    """
+    Upload IMAGES to HF repo as one ZIP at:
+      {Version}/{ID}/{Category}/{Direction}/{Filename}.zip
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "IMAGES": ("IMAGE",),
+                "ID_int": ("INT", {"default": 0, "min": 0, "max": 2147483647, "step": 1}),
+                "ID_str": ("STRING", {"default": "", "multiline": False}),
+                "Category": (ALLOWED_CATEGORIES,),
+                "Direction": (ALLOWED_DIRECTIONS,),
+                "Filename": ("STRING", {"default": "", "multiline": False}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "STRING")
+    RETURN_NAMES = ("IMAGES", "uploaded_paths")
+    FUNCTION = "upload"
+    CATEGORY = "hf"
+    OUTPUT_NODE = True
+
+    @classmethod
+    def IS_CHANGED(cls, **kwargs):
+        return float("nan")
+
+    def upload(self, IMAGES, ID_int, ID_str, Category, Direction, Filename):
+        try:
+            from huggingface_hub import HfApi, CommitOperationAdd
+        except Exception as e:
+            msg = (
+                "Missing dependency: huggingface_hub. Install it in your ComfyUI environment:\n"
+                "  pip install huggingface_hub\n"
+                f"Original import error: {e}"
+            )
+            _append_log(f"UPLOAD FAIL import_error repo={REPO_ID} error={e}")
+            raise ImportError(msg)
+
+        _id = _normalize_id(ID_int, ID_str)
+        _cat = _normalize_category(Category)
+        _dir = _normalize_direction(Direction)
+        zip_filename = _normalize_zip_filename(Filename)
+
+        batch = _ensure_batch(IMAGES)
+        batch_size = int(batch.shape[0])
+
+        try:
+            zip_bytes, entry_names = _images_to_zip_bytes(batch, zip_filename)
+        except Exception as e:
+            report = f"FAIL could not build ZIP for upload: {e}"
+            _append_log(f"UPLOAD FAIL zip_build_error repo={REPO_ID} id={_id} cat={_cat} dir={_dir} file={zip_filename} error={e}")
+            raise RuntimeError(report)
+
+        path_in_repo = _build_image_path_in_repo(_id, _cat, _dir, zip_filename)
+
+        api = HfApi(token=Secret_Token)
+        try:
+            commit_info = api.create_commit(
+                repo_id=REPO_ID,
+                repo_type=REPO_TYPE,
+                operations=[
+                    CommitOperationAdd(
+                        path_in_repo=path_in_repo,
+                        path_or_fileobj=io.BytesIO(zip_bytes),
+                    )
+                ],
+                commit_message=f"Upload ZIP with {batch_size} image(s) to {Version}/{_id}/{_cat}/{_dir}",
+                token=Secret_Token,
+            )
+        except Exception as e:
+            report = (
+                "Hugging Face upload failed.\n"
+                f"Repo: {REPO_ID} (type={REPO_TYPE})\n"
+                f"Target: {path_in_repo}\n"
+                f"Error: {e}"
+            )
+            _append_log(f"UPLOAD FAIL repo={REPO_ID} target={path_in_repo} error={e}")
+            raise RuntimeError(report)
+
+        commit_url = getattr(commit_info, "commit_url", None)
+        out_lines = []
+        if commit_url:
+            out_lines.append(f"commit_url: {commit_url}")
+        out_lines.append(f"zip_path: {path_in_repo}")
+        out_lines.append(f"zip_entries_count: {len(entry_names)}")
+        out_lines.append("zip_entries:")
+        out_lines.extend(entry_names)
+        out_text = "\n".join(out_lines)
+
+        _append_log(
+            f"UPLOAD OK repo={REPO_ID} target={path_in_repo} images={len(entry_names)}"
+            + (f" commit_url={commit_url}" if commit_url else "")
+        )
+
+        return {
+            "ui": {"text": [out_text]},
+            "result": (IMAGES, out_text),
+        }
+
+
+# -------------------------------------------------------------------------------------
+# 2) IMAGE ZIP DOWNLOADER (with polling + trigger)
+# -------------------------------------------------------------------------------------
+class HF_X_Downloader:
+    """
+    Download a ZIP from:
+      {Version}/{ID}/{Category}/{Direction}/{Filename}.zip
+
+    No expected_count input is needed.
+    The downloader polls for exactly one ZIP filename and decodes every PNG inside it.
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "dummy_image": ("IMAGE",),
+                "trigger_string": ("STRING", {"forceInput": True}),
+                "ID_int": ("INT", {"default": 0, "min": 0, "max": 2147483647, "step": 1}),
+                "ID_str": ("STRING", {"default": "", "multiline": False}),
+                "Category": (ALLOWED_CATEGORIES,),
+                "Direction": (ALLOWED_DIRECTIONS,),
+                "Filename": ("STRING", {"default": "", "multiline": False}),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE", "STRING")
+    RETURN_NAMES = ("IMAGES", "report")
+    FUNCTION = "download"
+    CATEGORY = "hf"
+    OUTPUT_NODE = True
+
+    @classmethod
+    def IS_CHANGED(cls, **kwargs):
+        return float("nan")
+
+    def download(
+        self,
+        dummy_image,
+        trigger_string,
+        ID_int,
+        ID_str,
+        Category,
+        Direction,
+        Filename,
+    ):
+        if trigger_string is None or str(trigger_string).strip() == "":
+            dummy_one = _select_first_as_single_image(dummy_image)
+            report = "FAIL trigger_string missing/empty (node did not attempt download)"
+            _append_log(f"DOWNLOAD FAIL trigger_missing repo={REPO_ID}")
+            return {"ui": {"text": [report]}, "result": (dummy_one, report)}
+
+        _id = _normalize_id(ID_int, ID_str)
+        _cat = _normalize_category(Category)
+        _dir = _normalize_direction(Direction)
+        zip_filename = _normalize_zip_filename(Filename)
+        path_in_repo = _build_image_path_in_repo(_id, _cat, _dir, zip_filename)
+
+        zip_bytes: Optional[bytes] = None
+        last_error: str = ""
+        total_attempts = 0
+        start = time.time()
+
+        for poll_t in POLL_TIMES_SECONDS:
+            target_time = start + float(poll_t)
+            now = time.time()
+            if target_time > now:
+                time.sleep(target_time - now)
+
+            ok, data, err = _try_download_file_bytes(path_in_repo)
+            total_attempts += 1
+            if ok and data is not None:
+                zip_bytes = data
+                break
+
+            last_error = err
+
+        if zip_bytes is not None:
+            try:
+                png_bytes_list, entry_names = _zip_bytes_to_png_bytes_list(zip_bytes)
+                batch = _png_bytes_list_to_batch(png_bytes_list)
+            except Exception as e:
+                dummy_one = _select_first_as_single_image(dummy_image)
+                report = (
+                    f"FAIL downloaded ZIP but failed to decode PNG(s): {e}\n"
+                    f"zip_path: {path_in_repo}"
+                )
+                _append_log(f"DOWNLOAD FAIL decode_error repo={REPO_ID} target={path_in_repo} error={e}")
+                return {"ui": {"text": [report]}, "result": (dummy_one, report)}
+
+            report = (
+                f"OK downloaded ZIP with {len(entry_names)} image(s) "
+                f"from {path_in_repo} in {int(time.time() - start)}s; attempts={total_attempts}\n"
+                f"zip_entries:\n" + "\n".join(entry_names)
+            )
+            _append_log(f"DOWNLOAD OK repo={REPO_ID} target={path_in_repo} images={len(entry_names)} attempts={total_attempts}")
+            return {"ui": {"text": [report]}, "result": (batch, report)}
+
+        dummy_one = _select_first_as_single_image(dummy_image)
+        report = (
+            f"FAIL ZIP not found; path={path_in_repo}; attempts={total_attempts}; last_error={last_error}"
+        )
+        _append_log(f"DOWNLOAD FAIL repo={REPO_ID} target={path_in_repo} attempts={total_attempts} error={last_error}")
+        return {"ui": {"text": [report]}, "result": (dummy_one, report)}
+
+
+# -------------------------------------------------------------------------------------
+# 3) TEXT UPLOADER -> {Version}/{ID}/Data/BAM.txt
+# -------------------------------------------------------------------------------------
+class HF_BAM_Uploader:
+    """
+    Upload a string to:
+      {Version}/{ID}/Data/BAM.txt
+    Outputs "OK" or "FAIL ..."
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "ID": ("INT", {"default": 0, "min": 0, "max": 2147483647, "step": 1}),
+                "BAM": ("STRING", {"default": "my car is red", "multiline": True}),
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("status",)
+    FUNCTION = "upload_bam"
+    CATEGORY = "hf"
+
+    @classmethod
+    def IS_CHANGED(cls, **kwargs):
+        return float("nan")
+
+    def upload_bam(self, ID, BAM):
+        try:
+            from huggingface_hub import HfApi, CommitOperationAdd
+        except Exception as e:
+            status = f"FAIL missing huggingface_hub: {e}"
+            _append_log(f"BAM UPLOAD FAIL import_error repo={REPO_ID} id={ID} error={e}")
+            return {"ui": {"text": [status]}, "result": (status,)}
+
+        _id = _sanitize_component(str(int(ID)))
+        path_in_repo = _build_bam_path_in_repo(_id)
+
+        content = "" if BAM is None else str(BAM)
+        data = content.encode("utf-8")
+
+        api = HfApi(token=Secret_Token)
+        try:
+            api.create_commit(
+                repo_id=REPO_ID,
+                repo_type=REPO_TYPE,
+                operations=[
+                    CommitOperationAdd(
+                        path_in_repo=path_in_repo,
+                        path_or_fileobj=io.BytesIO(data),
+                    )
+                ],
+                commit_message=f"Upload BAM.txt to {Version}/{_id}/Data",
+                token=Secret_Token,
+            )
+            status = "OK"
+            _append_log(f"BAM UPLOAD OK repo={REPO_ID} target={path_in_repo} bytes={len(data)}")
+        except Exception as e:
+            status = f"FAIL {e}"
+            _append_log(f"BAM UPLOAD FAIL repo={REPO_ID} target={path_in_repo} error={e}")
+
+        return {"ui": {"text": [status]}, "result": (status,)}
+
+
+# -------------------------------------------------------------------------------------
+# 4) TEXT DOWNLOADER -> {Version}/{ID}/Data/BAM.txt (single attempt, no polling)
+# -------------------------------------------------------------------------------------
+class HF_BAM_Downloader:
+    """
+    Download:
+      {Version}/{ID}/Data/BAM.txt
+    Single attempt, no polling.
+    Outputs the file content as STRING (or "" on failure).
+    """
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "ID": ("INT", {"default": 0, "min": 0, "max": 2147483647, "step": 1}),
+            }
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("BAM",)
+    FUNCTION = "download_bam"
+    CATEGORY = "hf"
+
+    @classmethod
+    def IS_CHANGED(cls, **kwargs):
+        return float("nan")
+
+    def download_bam(self, ID):
+        _id = _sanitize_component(str(int(ID)))
+        path_in_repo = _build_bam_path_in_repo(_id)
+
+        ok, data, err = _try_download_file_bytes(path_in_repo)
+        if not ok or data is None:
+            out = ""
+            report = f"FAIL {err}"
+            _append_log(f"BAM DOWNLOAD FAIL repo={REPO_ID} target={path_in_repo} error={err}")
+            return {"ui": {"text": [report]}, "result": (out,)}
+
+        try:
+            out = data.decode("utf-8", errors="replace")
+            report = "OK"
+            _append_log(f"BAM DOWNLOAD OK repo={REPO_ID} target={path_in_repo} bytes={len(data)}")
+            return {"ui": {"text": [report]}, "result": (out,)}
+        except Exception as e:
+            out = ""
+            report = f"FAIL {e}"
+            _append_log(f"BAM DOWNLOAD FAIL repo={REPO_ID} target={path_in_repo} decode_error={e}")
+            return {"ui": {"text": [report]}, "result": (out,)}
+
+
+# -------------------------------------------------------------------------------------
+# Node registration
+# -------------------------------------------------------------------------------------
+NODE_CLASS_MAPPINGS = {
+    "HF_X_Uploader": HF_X_Uploader,
+    "HF_X_Downloader": HF_X_Downloader,
+    "HF_BAM_Uploader": HF_BAM_Uploader,
+    "HF_BAM_Downloader": HF_BAM_Downloader,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "HF_X_Uploader": "HF X Uploader (ZIP of PNGs)",
+    "HF_X_Downloader": "HF X (ZIP of PNGs, Polling)",
+    "HF_BAM_Uploader": "HF_BAM_Uploader",
+    "HF_BAM_Downloader": "HF_BAM_Downloader",
+}