Update app.py

app.py

@@ -1,11 +1,10 @@
 #!/usr/bin/env python
 """
-Kovaaks PNG Metadata Cloner — v2
-↓ Improvements
-   • enforces PNG chunk order (IHDR → sRGB → gAMA → pHYs → eXIf → (…) → IDAT → IEND)
-   • keeps only a single instance of each ancillary chunk (no duplicates)
-   • validates / auto-converts target to 50 × 50 RGBA if the user ticks a checkbox
-   • warns when resulting file > 256 B (Kovaaks soft limit)
+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
@@ -20,12 +19,13 @@ import gradio as gr
 from PIL import Image
 
 PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
-# ancillary chunks Kovaaks cares about, in desired order
+
+# Kovaaks ancillary order we preserve
 ANCILLARY_ORDER = (
     b"sRGB",
     b"gAMA",
     b"pHYs",
-    b"eXIf",  # empty container in template crosshair
+    b"eXIf",  # usually empty
     b"iTXt",
     b"tEXt",
     b"zTXt",
@@ -40,9 +40,9 @@ def _read_chunks(fp: BinaryIO) -> Iterator[tuple[bytes, bytes]]:
     while True:
         length_bytes = fp.read(4)
         if not length_bytes:
-            break  # EOF
+            break
         if len(length_bytes) != 4:
-            raise ValueError("Corrupted PNG: could not read length")
+            raise ValueError("Corrupted PNG: bad length field")
 
         length = struct.unpack(">I", length_bytes)[0]
         chunk_type = fp.read(4)
@@ -56,61 +56,52 @@ def _read_chunks(fp: BinaryIO) -> Iterator[tuple[bytes, bytes]]:
 
 
 def _clean_ancillary(src_chunks: list[tuple[bytes, bytes]]) -> list[bytes]:
-    """Return at most one instance of each ordered ancillary chunk."""
-    kept: dict[bytes, 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 kept:
-            kept[tp] = raw
-    # return in canonical order
-    return [kept[tag] for tag in ANCILLARY_ORDER if tag in kept]
+        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 (overwrites file)."""
+    """Ensure 50 × 50 RGBA; optionally fix in-place."""
     img = Image.open(path)
     if img.size == (50, 50) and img.mode == "RGBA":
-        return  # already good
+        return
 
     if not auto_fix:
-        raise ValueError("Target must be 50×50 px, RGBA (enable auto-fix to convert).")
+        raise ValueError("Target must be 50×50 px, RGBA (enable auto-fix).")
 
-    # auto-convert
-    img = img.convert("RGBA")
-    img = img.resize((50, 50), Image.LANCZOS)
+    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
+    src_path: str, tgt_path: str, out_path: str, *, auto_fix: bool = True
 ) -> str:
-    """Clone cleaned ancillary chunks from src → tgt. Save to out_path."""
+    """Clone cleaned ancillary chunks from src → tgt and save out_path."""
     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 uploads must be valid PNG images.")
+            raise ValueError("Both inputs must be valid PNG files.")
 
         src_chunks = list(_read_chunks(fs))
         tgt_chunks = list(_read_chunks(ft))
 
-    ancillary = _clean_ancillary(src_chunks)
+    ancillary = _clean_ancillary(src_chunks)          # list[bytes]
+    replace_tags = {raw[4:8] for raw in ancillary}    # slice gives chunk-type
 
-    # Remove from target any ancillary tags we will replace
-    replace_tags = {tp for _, tp in ancillary}
     rebuilt: list[bytes] = []
-
     inserted = False
     for raw, tp in tgt_chunks:
         if tp == b"IHDR":
             rebuilt.append(raw)
-            # insert ordered ancillary exactly once
             if not inserted:
                 rebuilt.extend(ancillary)
                 inserted = True
             continue
-
         if tp in replace_tags:
-            # skip existing duplicate in target
-            continue
-
+            continue  # skip duplicate already provided
         rebuilt.append(raw)
 
     with open(out_path, "wb") as fo:
@@ -118,64 +109,13 @@ def clone_metadata(
         for chunk in rebuilt:
             fo.write(chunk)
 
-    # sanity - size warning
     if os.path.getsize(out_path) > 256:
-        print("⚠️  Output > 256 bytes; Kovaaks may still load it but smaller is safer.")
-
-    # optional validation / resize after writing (pixel data unchanged)
-    _validate_or_resize(out_path, auto_fix=False)  # ensure still 50×50 RGBA
+        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_file or not tgt_file:
-        raise gr.Error("Upload both images first.")
-
-    # optional in-place auto-fix for target
-    try:
-        _validate_or_resize(str(tgt_file), auto_fix)
-    except Exception as e:
-        raise gr.Error(str(e))
-
-    tmp = tempfile.NamedTemporaryFile(suffix=".png", delete=False)
-    tmp.close()
-    try:
-        clone_metadata(str(src_file), str(tgt_file), tmp.name, auto_fix=False)
-    except Exception as e:
-        os.remove(tmp.name)
-        raise gr.Error(str(e))
-
-    return tmp.name
-
-
-with gr.Blocks(title="Kovaaks PNG Metadata Cloner v2") as demo:
-    gr.Markdown(
-        """
-        # 🏹 Kovaaks PNG Metadata Cloner v2
-        1. **Image 1 (source)** – a PNG that already works in-game  
-        2. **Image 2 (target)** – your new crosshair (any size/format)  
-        3. Tick **auto-fix** to force 50 × 50 RGBA conversion  
-        4. Click **Clone** → download the ready file
-
-        Put the result into  
-        `%LOCALAPPDATA%\\FPSAimTrainer\\Saved\\MyImport\\crosshairs`
-        """
-    )
-    with gr.Row():
-        src = gr.File(label="Image 1 — metadata source (PNG)", type="filepath")
-        tgt = gr.File(label="Image 2 — target crosshair", type="filepath")
-    auto = gr.Checkbox(True, label="Auto-fix target to 50×50 RGBA")
-    out = gr.File(label="Output PNG", interactive=False)
-    btn = gr.Button("Clone metadata →")
-
-    btn.click(fn=process, inputs=[src, tgt, auto], outputs=[out])
-
-    gr.Markdown(
-        "Ancillary chunks (sRGB, gAMA, pHYs, eXIf, etc.) are copied verbatim, "
-        "duplicates removed, order normalised. Pixel data comes solely from Image 2."
-    )
-
-if __name__ == "__main__":
-    demo.launch(show_api=False)
+    if not src