sync project

cli.py

@@ -0,0 +1,42 @@
+import argparse
+import json
+
+import storage
+from ingest import ingest_video
+from match import check_video
+
+
+def main():
+    parser = argparse.ArgumentParser(prog="copyrightgpt", description="Video dataset + copyright match checker")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_ingest = sub.add_parser("ingest", help="Add a video to the dataset")
+    p_ingest.add_argument("path")
+    p_ingest.add_argument("--title", default=None)
+    p_ingest.add_argument("--rate", type=float, default=1.0, help="samples per second")
+    p_ingest.add_argument("--id", default=None, help="append a new patch to this existing video id")
+
+    p_check = sub.add_parser("check", help="Check a video against the dataset")
+    p_check.add_argument("path")
+    p_check.add_argument("--rate", type=float, default=1.0, help="samples per second")
+    p_check.add_argument("--threshold", type=float, default=0.5, help="match ratio to call it a match (0-1)")
+
+    sub.add_parser("list", help="List videos in the dataset")
+
+    args = parser.parse_args()
+
+    if args.command == "ingest":
+        meta = ingest_video(args.path, title=args.title, samples_per_second=args.rate, video_id=args.id)
+        print(json.dumps(meta, indent=2))
+
+    elif args.command == "check":
+        result = check_video(args.path, match_ratio_threshold=args.threshold, samples_per_second=args.rate)
+        print(json.dumps(result, indent=2))
+
+    elif args.command == "list":
+        for meta in storage.list_videos():
+            print(f"{meta['id']}  {meta['duration_seconds']:>8.1f}s  {meta['total_hashes']:>4} hashes  {meta['num_patches']} patch(es)  {meta['title']}")
+
+
+if __name__ == "__main__":
+    main()

fingerprint.py

@@ -0,0 +1,44 @@
+"""Extract a perceptual-hash fingerprint (sequence of frame hashes) from a video."""
+
+import cv2
+import imagehash
+from PIL import Image
+
+
+def extract_fingerprint(video_path: str, samples_per_second: float = 1.0, hash_size: int = 8):
+    """Sample frames from a video and compute a perceptual hash for each.
+
+    Returns a list of {"t": timestamp_seconds, "hash": hex_hash_string}.
+    """
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise ValueError(f"Could not open video: {video_path}")
+
+    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    frame_interval = max(1, round(fps / samples_per_second))
+
+    frames = []
+    idx = 0
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            break
+        if idx % frame_interval == 0:
+            rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            img = Image.fromarray(rgb)
+            h = imagehash.phash(img, hash_size=hash_size)
+            frames.append({"t": round(idx / fps, 2), "hash": str(h)})
+        idx += 1
+
+    cap.release()
+    return frames
+
+
+def video_duration_seconds(video_path: str) -> float:
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return 0.0
+    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT) or 0
+    cap.release()
+    return round(frame_count / fps, 2) if fps else 0.0

idgen.py

@@ -0,0 +1,10 @@
+import os
+import base64
+
+
+def new_video_id(length: int = 11) -> str:
+    """Generate a YouTube-style random id, e.g. 'dQw4w9WgXcQ'."""
+    raw = os.urandom(length)
+    b64 = base64.urlsafe_b64encode(raw).decode("ascii")
+    b64 = b64.replace("=", "")
+    return b64[:length]

ingest.py

@@ -0,0 +1,28 @@
+"""Add a video to the dataset: fingerprint it and store it under an id."""
+
+import os
+
+import storage
+from fingerprint import extract_fingerprint, video_duration_seconds
+from idgen import new_video_id
+
+
+def ingest_video(source_path: str, title: str | None = None, samples_per_second: float = 1.0, video_id: str | None = None) -> dict:
+    """Ingest a video. Pass video_id to append a new patch to an existing
+    entry instead of creating a new one."""
+    if not os.path.isfile(source_path):
+        raise FileNotFoundError(source_path)
+
+    fingerprint = extract_fingerprint(source_path, samples_per_second=samples_per_second)
+    duration = video_duration_seconds(source_path)
+    title = title or os.path.basename(source_path)
+    video_id = video_id or new_video_id()
+
+    meta = storage.add_video_patch(
+        video_id=video_id,
+        title=title,
+        source_path=os.path.abspath(source_path),
+        duration_seconds=duration,
+        fingerprint=fingerprint,
+    )
+    return meta

match.py

@@ -0,0 +1,56 @@
+"""Check a video against the dataset to guess whether it matches something already stored."""
+
+import imagehash
+
+import storage
+from fingerprint import extract_fingerprint
+
+# hash_size=8 -> 64-bit phash, so distances range 0-64.
+DEFAULT_HAMMING_THRESHOLD = 10
+DEFAULT_MATCH_RATIO = 0.5
+
+
+def _hex_to_hash(h: str):
+    return imagehash.hex_to_hash(h)
+
+
+def compare_to_video(query_hashes: list, stored_hashes: list, hamming_threshold: int) -> float:
+    """Fraction of query frames that have a close match somewhere in the stored video."""
+    if not query_hashes or not stored_hashes:
+        return 0.0
+
+    stored_decoded = [_hex_to_hash(f["hash"]) for f in stored_hashes]
+    hits = 0
+    for qf in query_hashes:
+        qh = _hex_to_hash(qf["hash"])
+        best = min(qh - sh for sh in stored_decoded)
+        if best <= hamming_threshold:
+            hits += 1
+    return hits / len(query_hashes)
+
+
+def check_video(
+    query_path: str,
+    hamming_threshold: int = DEFAULT_HAMMING_THRESHOLD,
+    match_ratio_threshold: float = DEFAULT_MATCH_RATIO,
+    samples_per_second: float = 1.0,
+) -> dict:
+    query_hashes = extract_fingerprint(query_path, samples_per_second=samples_per_second)
+
+    candidates = []
+    for meta in storage.list_videos():
+        video_id = meta["id"]
+        stored_hashes = storage.load_all_hashes(video_id)
+        ratio = compare_to_video(query_hashes, stored_hashes, hamming_threshold)
+        candidates.append({"id": video_id, "title": meta["title"], "match_ratio": round(ratio, 3)})
+
+    candidates.sort(key=lambda c: c["match_ratio"], reverse=True)
+    best = candidates[0] if candidates else None
+    is_match = bool(best and best["match_ratio"] >= match_ratio_threshold)
+
+    return {
+        "query_path": query_path,
+        "is_likely_copyrighted": is_match,
+        "best_match": best,
+        "top_candidates": candidates[:5],
+    }

requirements.txt

@@ -0,0 +1,5 @@
+opencv-python
+imagehash
+Pillow
+numpy
+huggingface_hub

sample_videos/duplicate_reencoded.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3062c3fb8b8c4460fdfdc77cec0017f6cb12286c36853ae7e722c4a8fa6bed57
+size 81142

sample_videos/original.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3062c3fb8b8c4460fdfdc77cec0017f6cb12286c36853ae7e722c4a8fa6bed57
+size 81142

sample_videos/unrelated.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39dd37a1c41344ef52d860514977f5d2d82cb21f385ef33c2ee759ab6ab4b02d
+size 81021

scripts/make_test_videos.py

@@ -0,0 +1,28 @@
+"""Generate a couple of tiny synthetic .mp4 files to smoke-test the pipeline."""
+
+import os
+
+import cv2
+import numpy as np
+
+OUT_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "sample_videos")
+os.makedirs(OUT_DIR, exist_ok=True)
+
+
+def make_video(path, seed, seconds=3, fps=10, size=(160, 120)):
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(path, fourcc, fps, size)
+    rng = np.random.default_rng(seed)
+    base = rng.integers(0, 255, (size[1], size[0], 3), dtype=np.uint8)
+    for i in range(seconds * fps):
+        frame = base.copy()
+        cv2.circle(frame, (20 + (i * 4) % size[0], 60), 10, (0, 0, 255), -1)
+        writer.write(frame)
+    writer.release()
+
+
+if __name__ == "__main__":
+    make_video(os.path.join(OUT_DIR, "original.mp4"), seed=1)
+    make_video(os.path.join(OUT_DIR, "duplicate_reencoded.mp4"), seed=1)  # same content
+    make_video(os.path.join(OUT_DIR, "unrelated.mp4"), seed=99)  # different content
+    print("Wrote sample videos to", OUT_DIR)

storage.py

@@ -0,0 +1,139 @@
+"""Dataset storage: dataset/<id>/main.bin (metadata) + dataset/<id>/patch-N.dat (fingerprint chunks).
+
+Each video gets a folder named by its id (the "bin"). main.bin holds the
+metadata record. Every ingest call writes a new patch-N.dat file holding that
+call's frame hashes, so future re-ingests / additions just add more patch
+files instead of rewriting everything.
+"""
+
+import os
+import struct
+from datetime import datetime, timezone
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATASET_DIR = os.path.join(BASE_DIR, "dataset")
+
+MAIN_BIN_VERSION = 1
+PATCH_ENTRY = struct.Struct("<fQ")  # timestamp (float32), phash (uint64)
+
+
+def _write_str(f, s: str):
+    data = s.encode("utf-8")
+    f.write(struct.pack("<I", len(data)))
+    f.write(data)
+
+
+def _read_str(f) -> str:
+    (n,) = struct.unpack("<I", f.read(4))
+    return f.read(n).decode("utf-8")
+
+
+def video_dir(video_id: str) -> str:
+    d = os.path.join(DATASET_DIR, video_id)
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def _main_bin_path(video_id: str) -> str:
+    return os.path.join(video_dir(video_id), "main.bin")
+
+
+def write_main_bin(video_id, title, source_path, duration_seconds, created_at, num_patches, total_hashes):
+    with open(_main_bin_path(video_id), "wb") as f:
+        f.write(struct.pack("<B", MAIN_BIN_VERSION))
+        _write_str(f, video_id)
+        _write_str(f, title)
+        _write_str(f, source_path)
+        f.write(struct.pack("<d", duration_seconds))
+        _write_str(f, created_at)
+        f.write(struct.pack("<II", num_patches, total_hashes))
+
+
+def read_main_bin(video_id: str) -> dict:
+    with open(_main_bin_path(video_id), "rb") as f:
+        f.read(1)  # version, unused for now
+        vid = _read_str(f)
+        title = _read_str(f)
+        source_path = _read_str(f)
+        (duration,) = struct.unpack("<d", f.read(8))
+        created_at = _read_str(f)
+        num_patches, total_hashes = struct.unpack("<II", f.read(8))
+    return {
+        "id": vid,
+        "title": title,
+        "source_path": source_path,
+        "duration_seconds": duration,
+        "created_at": created_at,
+        "num_patches": num_patches,
+        "total_hashes": total_hashes,
+    }
+
+
+def list_patch_files(video_id: str) -> list:
+    d = video_dir(video_id)
+    files = [fn for fn in os.listdir(d) if fn.startswith("patch-") and fn.endswith(".dat")]
+    files.sort(key=lambda fn: int(fn[len("patch-"):-len(".dat")]))
+    return [os.path.join(d, fn) for fn in files]
+
+
+def write_patch(video_id: str, patch_index: int, fingerprint: list) -> str:
+    path = os.path.join(video_dir(video_id), f"patch-{patch_index}.dat")
+    with open(path, "wb") as f:
+        f.write(struct.pack("<I", len(fingerprint)))
+        for entry in fingerprint:
+            f.write(PATCH_ENTRY.pack(entry["t"], int(entry["hash"], 16)))
+    return path
+
+
+def read_patch(path: str) -> list:
+    entries = []
+    with open(path, "rb") as f:
+        (count,) = struct.unpack("<I", f.read(4))
+        for _ in range(count):
+            t, h = PATCH_ENTRY.unpack(f.read(PATCH_ENTRY.size))
+            entries.append({"t": t, "hash": format(h, "016x")})
+    return entries
+
+
+def load_all_hashes(video_id: str) -> list:
+    hashes = []
+    for p in list_patch_files(video_id):
+        hashes.extend(read_patch(p))
+    return hashes
+
+
+def add_video_patch(video_id, title, source_path, duration_seconds, fingerprint) -> dict:
+    """Write a new patch file for this id and refresh main.bin. Works for both
+    brand-new ids and appending more fingerprint data to an existing id."""
+    next_index = len(list_patch_files(video_id))
+    write_patch(video_id, next_index, fingerprint)
+
+    total_hashes = sum(len(read_patch(p)) for p in list_patch_files(video_id))
+    created_at = datetime.now(timezone.utc).isoformat()
+    write_main_bin(
+        video_id=video_id,
+        title=title,
+        source_path=source_path,
+        duration_seconds=duration_seconds,
+        created_at=created_at,
+        num_patches=next_index + 1,
+        total_hashes=total_hashes,
+    )
+    return read_main_bin(video_id)
+
+
+def list_videos() -> list:
+    if not os.path.isdir(DATASET_DIR):
+        return []
+    results = []
+    for vid in sorted(os.listdir(DATASET_DIR)):
+        if os.path.isfile(os.path.join(DATASET_DIR, vid, "main.bin")):
+            results.append(read_main_bin(vid))
+    return results
+
+
+def get_video(video_id: str):
+    try:
+        return read_main_bin(video_id)
+    except FileNotFoundError:
+        return None