| """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") |
|
|
|
|
| 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) |
| 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 |
|
|
