Update app.py

app.py

@@ -1,121 +1,116 @@
-#!/usr/bin/env python
-"""
-Kovaaks PNG Metadata Cloner — v2.1
-• strict ancillary-chunk order
-• duplicates removed
-• optional auto-resize / RGBA convert to 50 × 50
-• file-size warning
-"""
-
-from __future__ import annotations
-
 import os
 import struct
 import tempfile
-from pathlib import Path
 from typing import BinaryIO, Iterator
 
 import gradio as gr
-from PIL import Image
 
 PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
 
-# Kovaaks ancillary order we preserve
-ANCILLARY_ORDER = (
-    b"sRGB",
-    b"gAMA",
-    b"pHYs",
-    b"eXIf",  # usually empty
-    b"iTXt",
-    b"tEXt",
-    b"zTXt",
-)
-
-# ───────────────────────────────────────────────── helpers ──
+
+# ────────────────────────────────────────────────────────── helpers ──
 def _read_chunks(fp: BinaryIO) -> Iterator[tuple[bytes, bytes]]:
     """
     Yield (raw_chunk_bytes, chunk_type_bytes) for every chunk in *fp*.
-    Caller must have consumed the 8-byte PNG signature already.
+    `raw_chunk_bytes` includes length, type, data and CRC exactly as in file,
+    so we can copy them verbatim later.
+    The PNG signature must already be consumed by the caller.
     """
     while True:
         length_bytes = fp.read(4)
         if not length_bytes:
-            break
+            break  # EOF
         if len(length_bytes) != 4:
-            raise ValueError("Corrupted PNG: bad length field")
+            raise ValueError("Corrupted PNG: unexpected EOF while reading chunk length.")
 
-        length = struct.unpack(">I", length_bytes)[0]
+        length = struct.unpack(">I", length_bytes)[0]          # ← fixed (no stray space)
         chunk_type = fp.read(4)
-        data = fp.read(length)
-        crc = fp.read(4)
+        data       = fp.read(length)
+        crc        = fp.read(4)
 
         if len(chunk_type) != 4 or len(data) != length or len(crc) != 4:
-            raise ValueError("Corrupted PNG: truncated chunk")
+            raise ValueError("Corrupted PNG: truncated chunk.")
 
         yield length_bytes + chunk_type + data + crc, chunk_type
 
 
-def _clean_ancillary(src_chunks: list[tuple[bytes, bytes]]) -> list[bytes]:
-    """Return at most one instance of each ancillary tag in canonical order."""
-    seen: dict[bytes, bytes] = {}
-    for raw, tp in src_chunks:
-        if tp in ANCILLARY_ORDER and tp not in seen:
-            seen[tp] = raw
-    return [seen[tag] for tag in ANCILLARY_ORDER if tag in seen]
-
-
-def _validate_or_resize(path: str, auto_fix: bool) -> None:
-    """Ensure 50 × 50 RGBA; optionally fix in-place."""
-    img = Image.open(path)
-    if img.size == (50, 50) and img.mode == "RGBA":
-        return
-
-    if not auto_fix:
-        raise ValueError("Target must be 50×50 px, RGBA (enable auto-fix).")
-
-    img = img.convert("RGBA").resize((50, 50), Image.LANCZOS)
-    img.save(path, optimize=True)
-
-
-def clone_metadata(
-    src_path: str, tgt_path: str, out_path: str, *, auto_fix: bool = True
-) -> str:
-    """Clone cleaned ancillary chunks from src → tgt and save out_path."""
+def clone_metadata(src_path: str, tgt_path: str, out_path: str) -> str:
+    """
+    Copy all ancillary chunks (anything except IHDR / IDAT / IEND) from *src_path*
+    into *tgt_path* immediately after its IHDR, then save to *out_path*.
+    Pixel data of the target stays untouched.
+    """
     with open(src_path, "rb") as fs, open(tgt_path, "rb") as ft:
         if fs.read(8) != PNG_SIGNATURE or ft.read(8) != PNG_SIGNATURE:
-            raise ValueError("Both inputs must be valid PNG files.")
+            raise ValueError("Both files must be valid PNG images.")
 
         src_chunks = list(_read_chunks(fs))
         tgt_chunks = list(_read_chunks(ft))
 
-    ancillary = _clean_ancillary(src_chunks)          # list[bytes]
-    replace_tags = {raw[4:8] for raw in ancillary}    # slice gives chunk-type
+    # take every non-critical chunk from source
+    ancillary = [
+        raw for raw, tp in src_chunks
+        if tp not in (b"IHDR", b"IDAT", b"IEND")
+    ]
 
-    rebuilt: list[bytes] = []
-    inserted = False
+    out_chunks: list[bytes] = []
     for raw, tp in tgt_chunks:
-        if tp == b"IHDR":
-            rebuilt.append(raw)
-            if not inserted:
-                rebuilt.extend(ancillary)
-                inserted = True
-            continue
-        if tp in replace_tags:
-            continue  # skip duplicate already provided
-        rebuilt.append(raw)
+        out_chunks.append(raw)
+        if tp == b"IHDR":                     # inject right after IHDR
+            out_chunks.extend(ancillary)
 
     with open(out_path, "wb") as fo:
         fo.write(PNG_SIGNATURE)
-        for chunk in rebuilt:
+        for chunk in out_chunks:
             fo.write(chunk)
 
-    if os.path.getsize(out_path) > 256:
-        print("⚠️  Output larger than 256 B — Kovaaks usually still loads it.")
-
-    _validate_or_resize(out_path, auto_fix=False)  # ensure still valid
     return out_path
 
 
-# ────────────────────────────────────────────────── Gradio UI ──
-def process(src_file: Path, tgt_file: Path, auto_fix: bool):
-    if not src
+# ────────────────────────────────────────────────────────── gradio ui ──
+def process(src_file, tgt_file):
+    """Gradio wrapper → returns path to the merged PNG."""
+    if not src_file or not tgt_file:
+        raise gr.Error("Please upload both images.")
+
+    tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
+    tmp.close()  # we only need the path
+    try:
+        clone_metadata(src_file, tgt_file, tmp.name)
+    except Exception as e:
+        os.remove(tmp.name)
+        raise gr.Error(str(e))
+
+    return tmp.name
+
+
+with gr.Blocks(title="Kovaaks PNG Metadata Cloner") as demo:
+    gr.Markdown(
+        """
+        ## Kovaaks PNG Metadata Cloner 🏹
+
+        **Step 1.** Upload a *metadata source* PNG that already works in-game  
+        **Step 2.** Upload your *target* PNG (new 50 × 50 crosshair)  
+        **Step 3.** Click **Clone metadata** and download the result.
+
+        Put the output file into  
+        `%LOCALAPPDATA%\\FPSAimTrainer\\Saved\\MyImport\\crosshairs`
+        """
+    )
+
+    with gr.Row():
+        src = gr.File(label="Image 1 – source (metadata)", type="filepath")
+        tgt = gr.File(label="Image 2 – target (pixels)",   type="filepath")
+
+    out = gr.File(label="Output PNG", interactive=False)
+    btn = gr.Button("Clone metadata →")
+
+    btn.click(fn=process, inputs=[src, tgt], outputs=[out])
+
+    gr.Markdown(
+        "✔️ Ancillary chunks (`sRGB`, `gAMA`, `pHYs`, `eXIf`, `tEXt`, …) are copied verbatim. "
+        "Pixel data from the target image is left untouched."
+    )
+
+if __name__ == "__main__":
+    demo.launch(show_api=False, share=False)