syncnet-python 0.1.0__py3-none-any.whl

syncnet_python/run_syncnet_pipeline_on_your_own_model_results.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Batch SyncNet evaluation for MoChaBench.
+"""
+
+import json
+import csv
+from pathlib import Path
+import time
+from collections import defaultdict
+
+import pandas as pd
+from syncnet_pipeline import SyncNetPipeline
+
+# ------------------------------------------------------------------ #
+# 1)  paths & config                                                 #
+# ------------------------------------------------------------------ #
+
+# folder that contains *this* script
+ROOT = Path(r"/full/path/to/MoChaBench") # <<< fill with your own repo path/MoChaBench
+
+# ---- adapt these if you move folders around ---------------------- #
+BASE_VIDEO = ROOT / "your model output videos"       # <<< fill with your own path e.g. …/MoChaBench/xxx-model-out
+BASE_BENCHMARK = ROOT / "benchmark"                  # parent folder that contains 'speeches/'
+CSV_FILE   = BASE_BENCHMARK / "benchmark.csv"
+# ------------------------------------------------------------------ #
+
+OUT_CSV  = ROOT / "eval-lipsync" / "your own model-eval-results" / "sync_scores.csv"  # <<< fill with your own path
+OUT_JSON = ROOT / "eval-lipsync"/  "your own model-eval-results" / "sync_scores.json"  # <<< fill with your own path
+
+pipe = SyncNetPipeline(
+    {
+        "s3fd_weights":  ROOT / "eval-lipsync" / "weights" / "sfd_face.pth",
+        "syncnet_weights": ROOT / "eval-lipsync" /"weights" / "syncnet_v2.model",
+    },
+    device="cuda",
+)
+
+# category buckets for your extra means
+ENGLISH_1P_CATEGORIES = {
+    "1p_closeup_facingcamera",
+    "1p_camera_movement",
+    "1p_emotion",
+    "1p_mediumshot_actioncontrol",
+    "2p_1clip_1talk",
+    "1p_protrait",
+}
+TURNTALK_CATEGORY = {"2p_2clip_2talk"}
+
+# ------------------------------------------------------------------ #
+# 2)  helper: run one sample                                         #
+# ------------------------------------------------------------------ #
+def run_sample(row):
+    idx = int(row["idx_in_category"])
+    cat = row["category"].strip()
+    base_name = row["context_id"].strip()  # e.g. 1_man_bag_of_gold
+    id = f"{cat}_{base_name}"
+
+    video_fp = BASE_VIDEO / cat / f"{base_name}.mp4"
+    audio_fp = BASE_BENCHMARK / "speeches" / cat / f"{base_name}_speech.wav"
+
+    if not video_fp.exists():
+        raise FileNotFoundError(f"Video not found: {video_fp}")
+    if not audio_fp.exists():
+        raise FileNotFoundError(f"Audio not found: {audio_fp}")
+
+    t0 = time.time()
+    off, confs, dists, best_conf, min_dist, _, has_face = pipe.inference(
+        video_path=str(video_fp),
+        audio_path=str(audio_fp),
+        cache_dir= ROOT / "eval-lipsync"/  "mocha-eval-results" / "cache" / id
+    )
+    return {
+        "idx": idx,
+        "category": cat,
+        "video": str(Path(cat) / f"{base_name}.mp4"),
+        "audio": str(Path(cat) / f"{base_name}_speech.wav"),
+        "offsets": [int(o) for o in off],
+        "best_conf": float(best_conf),
+        "min_dist": float(min_dist),
+        "has_face": has_face,
+        "runtime_s": round(time.time() - t0, 2),
+    }
+
+
+# ------------------------------------------------------------------ #
+# 3)  main loop                                                      #
+# ------------------------------------------------------------------ #
+def main():
+    df = pd.read_csv(CSV_FILE)
+    results = []
+    for _, row in df.iterrows():
+        try:
+            res = run_sample(row)
+            results.append(res)
+            print(
+                f"[{res['idx']}] {res['category']}  "
+                f"Δ={res['offsets']}  conf={res['best_conf']:.3f}  "
+                f"dist={res['min_dist']:.3f}"
+            )
+        except Exception as e:
+            print(f"[{row['idx']}] ERROR – {e}")
+
+    # ------------------------------------------------------------------ #
+    # 4)  save full table                                                #
+    # ------------------------------------------------------------------ #
+    pd.DataFrame(results).to_csv(OUT_CSV, index=False)
+    with open(OUT_JSON, "w") as f:
+        json.dump(results, f, indent=2)
+
+    # ------------------------------------------------------------------ #
+    # 5)  category aggregates                                            #
+    # ------------------------------------------------------------------ #
+    # Separate stats for each category (only when face is detected)
+    cat_dists = defaultdict(list)
+    cat_confs = defaultdict(list)
+
+    for r in results:
+        # !!!! sometimes SyncNetPipeline fails to detect faces, we should not inlcude those
+        if r["has_face"]:
+            cat_dists[r["category"]].append(r["min_dist"])
+            cat_confs[r["category"]].append(r["best_conf"])
+
+    def mean(vals):
+        return sum(vals) / len(vals) if vals else float("nan")
+
+    print("\n=== per-category averages (only if face detected) ===")
+    for cat in sorted(set(cat_dists.keys()) | set(cat_confs.keys())):
+        avg_dist = mean(cat_dists[cat])
+        avg_conf = mean(cat_confs[cat])
+        print(f"{cat:30s}:  dist={avg_dist:.3f}   conf={avg_conf:.3f}   (n={len(cat_dists[cat])})")
+
+
+    #  super-sets
+    english_dists = [
+        d for c, v in cat_dists.items() if c in ENGLISH_1P_CATEGORIES for d in v
+    ]
+    english_confs = [
+        c for cat, v in cat_confs.items() if cat in ENGLISH_1P_CATEGORIES for c in v
+    ]
+
+    dialog_dists = [
+        d for c, v in cat_dists.items() if c in TURNTALK_CATEGORY for d in v
+    ]
+    dialog_confs = [
+        c for cat, v in cat_confs.items() if cat in TURNTALK_CATEGORY for c in v
+    ]
+    print("\n--- aggregate groups (only face-detected entries) ---")
+    print(f"single-character English (1p*): dist={mean(english_dists):.3f}  conf={mean(english_confs):.3f}")
+    print(f"turn-based dialogue English (2p_2clip): dist={mean(dialog_dists):.3f}  conf={mean(dialog_confs):.3f}")
+
+    print(f"\nSaved detailed table → {OUT_CSV}")
+    print(f"Saved JSON dump      → {OUT_JSON}")
+
+
+if __name__ == "__main__":
+    main()

syncnet_python/syncnet_pipeline.py

@@ -0,0 +1,332 @@
+import json
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass
+from glob import glob
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import cv2
+import ffmpeg
+import numpy as np
+import torch
+from scipy import signal
+from scipy.interpolate import interp1d
+from scenedetect import ContentDetector, SceneManager, StatsManager
+from scenedetect.video_manager import VideoManager
+
+from detectors.s3fd import S3FD
+from detectors.s3fd.nets import S3FDNet
+from SyncNetInstance import SyncNetInstance
+from SyncNetModel import S
+
+# ---------------------------------------------------------------------- #
+# Configuration                                                          #
+# ---------------------------------------------------------------------- #
+@dataclass
+class PipelineConfig:
+    # Face-detection / tracking
+    facedet_scale: float = 0.25
+    crop_scale: float = 0.40
+    min_track: int = 50
+    frame_rate: int = 25
+    num_failed_det: int = 25
+    min_face_size: int = 100
+
+    # SyncNet
+    batch_size: int = 20
+    vshift: int = 15
+
+    # Local weight paths
+    s3fd_weights: str = "sfd_face.pth"
+    syncnet_weights: str = "syncnet_v2.model"
+
+    # Tools
+    ffmpeg_bin: str = "ffmpeg"  # assumes ffmpeg in $PATH
+    audio_sample_rate: int = 16000  # resample rate for speech
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]):
+        return cls(**{k: v for k, v in d.items() if k in cls.__annotations__})
+
+
+# ---------------------------------------------------------------------- #
+# Pipeline                                                               #
+# ---------------------------------------------------------------------- #
+class SyncNetPipeline:
+    def __init__(
+        self,
+        cfg: Union[PipelineConfig, Dict[str, Any], None] = None,
+        *,
+        device: str = "cuda",
+        **override,
+    ):
+        base = cfg if isinstance(cfg, PipelineConfig) else PipelineConfig.from_dict(cfg or {})
+        for k, v in override.items():
+            if hasattr(base, k):
+                setattr(base, k, v)
+        self.cfg = base
+        self.device = device
+
+        self.s3fd = self._load_s3fd(self.cfg.s3fd_weights)
+        self.syncnet = self._load_syncnet(self.cfg.syncnet_weights)
+
+    # ---------------------------- model loading ---------------------------- #
+    def _load_s3fd(self, path: str) -> S3FD:
+        logging.info(f"Loading S3FD from {path}")
+        net = S3FDNet(device=self.device)
+        net.load_state_dict(torch.load(path, map_location=self.device))
+        net.eval()
+        return S3FD(net=net, device=self.device)
+
+    def _load_syncnet(self, path: str) -> SyncNetInstance:
+        logging.info(f"Loading SyncNet from {path}")
+        model = S()
+        model.load_state_dict(torch.load(path, map_location=self.device))
+        model.eval()
+        return SyncNetInstance(net=model, device=self.device)
+
+    # ---------------------------- helpers ---------------------------------- #
+    @staticmethod
+    def _iou(a, b):
+        xA, yA = max(a[0], b[0]), max(a[1], b[1])
+        xB, yB = min(a[2], b[2]), min(a[3], b[3])
+        inter = max(0, xB - xA) * max(0, yB - yA)
+        areaA = (a[2] - a[0]) * (a[3] - a[1])
+        areaB = (b[2] - b[0]) * (b[3] - b[1])
+        return inter / (areaA + areaB - inter + 1e-8)
+
+    def _track(self, dets):
+        cfg = self.cfg
+        tracks = []
+        while True:
+            t = []
+            for faces in dets:
+                for f in faces:
+                    if not t:
+                        t.append(f)
+                        faces.remove(f)
+                    elif (
+                        f["frame"] - t[-1]["frame"] <= cfg.num_failed_det
+                        and self._iou(f["bbox"], t[-1]["bbox"]) > 0.5
+                    ):
+                        t.append(f)
+                        faces.remove(f)
+                        continue
+                    else:
+                        break
+            if not t:
+                break
+            if len(t) > cfg.min_track:
+                fr = np.array([d["frame"] for d in t])
+                bb = np.array([d["bbox"] for d in t])
+                full_f = np.arange(fr[0], fr[-1] + 1)
+                bb_i = np.stack([interp1d(fr, bb[:, i])(full_f) for i in range(4)], 1)
+                if max(
+                    np.mean(bb_i[:, 2] - bb_i[:, 0]),
+                    np.mean(bb_i[:, 3] - bb_i[:, 1]),
+                ) > cfg.min_face_size:
+                    tracks.append({"frame": full_f, "bbox": bb_i})
+        return tracks
+    
+    def _crop(self, track, frames, audio_wav, base):
+        cfg = self.cfg
+        base.parent.mkdir(parents=True, exist_ok=True)
+        tmp_avi = f"{base}t.avi"
+        vw = cv2.VideoWriter(tmp_avi, cv2.VideoWriter_fourcc(*"XVID"), cfg.frame_rate, (224, 224))
+
+        s, x, y = [], [], []
+        for b in track["bbox"]:
+            s.append(max(b[3] - b[1], b[2] - b[0]) / 2)
+            x.append((b[0] + b[2]) / 2)
+            y.append((b[1] + b[3]) / 2)
+        s, x, y = map(lambda v: signal.medfilt(v, 13), (s, x, y))
+
+        for i, fidx in enumerate(track["frame"]):
+            img = cv2.imread(frames[fidx])
+            if img is None:
+                continue
+            bs = s[i]
+            cs = cfg.crop_scale
+            pad = int(bs * (1 + 2 * cs))
+            img_p = cv2.copyMakeBorder(
+                img, pad, pad, pad, pad, cv2.BORDER_CONSTANT, value=(110, 110, 110)
+            )
+            my, mx = y[i] + pad, x[i] + pad
+            y1, y2 = int(my - bs), int(my + bs * (1 + 2 * cs))
+            x1, x2 = int(mx - bs * (1 + cs)), int(mx + bs * (1 + cs))
+            crop = cv2.resize(img_p[y1:y2, x1:x2], (224, 224))
+            vw.write(crop)
+        vw.release()
+
+        slice_wav = f"{base}.wav"
+        ss = track["frame"][0] / cfg.frame_rate
+        to = (track["frame"][-1] + 1) / cfg.frame_rate
+        subprocess.call(
+            f'{cfg.ffmpeg_bin} -y -i "{audio_wav}" -ss {ss:.3f} -to {to:.3f} "{slice_wav}"',
+            shell=True,
+        )
+
+        final_avi = f"{base}.avi"
+        subprocess.call(
+            f'{cfg.ffmpeg_bin} -y -i "{tmp_avi}" -i "{slice_wav}" -c:v copy -c:a copy "{final_avi}"',
+            shell=True,
+        )
+        os.remove(tmp_avi)
+        return final_avi
+
+    # ---------------------------- inference -------------------------------- #
+    def inference(
+        self,
+        video_path: str,  # We do not extract audio from video_path!
+        audio_path: str,
+        *,
+        cache_dir: Optional[str] = None,
+    ) -> Tuple[List[int], List[float], List[float], float, float, str, bool]:
+        cfg = self.cfg
+        work = Path(cache_dir) if cache_dir else Path(tempfile.mkdtemp())
+        if cache_dir:
+            work.mkdir(parents=True, exist_ok=True)
+
+        try:
+            # 1) Convert video to constant-fps AVI
+            avi = work / "video.avi"
+            (
+                ffmpeg.input(video_path)
+                .output(str(avi), **{"q:v": 2}, r=cfg.frame_rate, **{"async": 1})
+                .overwrite_output()
+                .run()
+            )
+
+            # 2) Extract frames
+            frames_dir = work / "frames"
+            frames_dir.mkdir(exist_ok=True)
+            (
+                ffmpeg.input(str(avi))
+                .output(str(frames_dir / "%06d.jpg"), **{"q:v": 2}, f="image2", threads=1)
+                .overwrite_output()
+                .run()
+            )
+            frames = sorted(glob(str(frames_dir / "*.jpg")))
+
+            # 3) Resample speech
+            audio_wav = work / "speech.wav"
+            (
+                ffmpeg.input(audio_path)
+                .output(str(audio_wav), ac=1, ar=cfg.audio_sample_rate, format="wav")
+                .overwrite_output()
+                .run()
+            )
+
+            # 4) Face detection
+            detections = []
+            for i, fp in enumerate(frames):
+                img = cv2.imread(fp)
+                boxes = (
+                    self.s3fd.detect_faces(
+                        cv2.cvtColor(img, cv2.COLOR_BGR2RGB),
+                        conf_th=0.9,
+                        scales=[cfg.facedet_scale],
+                    )
+                    if img is not None
+                    else []
+                )
+                detections.append(
+                    [
+                        {"frame": i, "bbox": b[:-1].tolist(), "conf": float(b[-1])}
+                        for b in boxes
+                    ]
+                )
+
+            flat = [f for fs in detections for f in fs]
+            s3fd_json = json.dumps(flat) if flat else ""
+            has_face = bool(flat)
+
+            # 5) Scene detection
+            vm = VideoManager([str(avi)])
+            sm = SceneManager(StatsManager())
+            sm.add_detector(ContentDetector())
+            vm.start()
+            sm.detect_scenes(frame_source=vm)
+            scenes = sm.get_scene_list(vm.get_base_timecode()) or [
+                (vm.get_base_timecode(), vm.get_current_timecode())
+            ]
+
+            # 6) Track faces
+            tracks = []
+            for sc in scenes:
+                s, e = sc[0].frame_num, sc[1].frame_num
+                if e - s >= cfg.min_track:
+                    tracks.extend(self._track([lst.copy() for lst in detections[s:e]]))
+
+            # 7) Crop tracks
+            crops = [
+                self._crop(t, frames, str(audio_wav), Path(work) / "cropped" / f"{i:05d}") for i, t in enumerate(tracks)
+            ]
+            # AV offset:      5
+            # Min dist:       5.370
+            # Confidence:     9.892
+
+            # crops = [work / ".." / ".."/ "data" / "example.avi"]
+            # AV offset:      3
+            # Min dist:       5.348
+            # Confidence:     10.081
+            
+            # crops = [work / "video.avi"]
+            # AV offset:      3
+            # Min dist:       6.668
+            # Confidence:     8.337
+
+            # 8) SyncNet evaluation
+            offsets, confs, dists = [], [], []
+            class Opt: ...
+            for i, cp in enumerate(crops):
+                crop_dir = work / "cropped" / f"crop_{i:05d}"
+                frames_dir = crop_dir
+                frames_dir.mkdir(parents=True, exist_ok=True)
+                audio_path = crop_dir / "audio.wav"
+
+                # Extract frames
+                (
+                    ffmpeg.input(cp)
+                    .output(str(frames_dir / "%06d.jpg"), f="image2", threads=1)
+                    .overwrite_output()
+                    .run()
+                )
+                
+                # Extract audio
+                (
+                    ffmpeg.input(cp)
+                    .output(
+                        str(audio_path),
+                        ac=1,
+                        vn=None,
+                        acodec="pcm_s16le",
+                        ar=16000,
+                        af="aresample=async=1",
+                    )
+                    .overwrite_output()
+                    .run()
+                )
+
+                opt = Opt()
+                opt.tmp_dir = str(crop_dir)
+                opt.batch_size = cfg.batch_size
+                opt.vshift = cfg.vshift
+
+                off, conf, dist = self.syncnet.evaluate(opt=opt)
+                offsets.append(off)
+                confs.append(conf)
+                dists.append(dist)
+
+            if not offsets:
+                return ([], [], [], 0.0, 0.0, "", False)
+
+            return offsets, confs, dists, max(confs), min(dists), s3fd_json, has_face
+
+        finally:
+            if not cache_dir:
+                shutil.rmtree(work, ignore_errors=True)

syncnet_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: syncnet-python
+Version: 0.1.0
+Summary: SyncNet: Audio-visual synchronization detection using deep learning
+Author: SyncNet Python Contributors
+Maintainer: SyncNet Python Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/nawta/SyncNet_py313
+Project-URL: Bug Reports, https://github.com/nawta/SyncNet_py313/issues
+Project-URL: Source, https://github.com/nawta/SyncNet_py313
+Keywords: audio-visual,synchronization,deep-learning,pytorch,lip-sync,video-processing,computer-vision
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Requires-Dist: torchvision>=0.15.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: scenedetect[opencv]>=0.6.0
+Requires-Dist: opencv-contrib-python>=4.8.0
+Requires-Dist: python-speech-features>=0.6
+Requires-Dist: ffmpeg-python>=0.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.7.0; extra == "dev"
+Requires-Dist: types-opencv-python; extra == "dev"
+Requires-Dist: types-scipy; extra == "dev"
+Dynamic: license-file
+
+# SyncNet Python
+
+Audio-visual synchronization detection using deep learning.
+
+## Overview
+
+SyncNet Python is a PyTorch implementation of the SyncNet model, which detects audio-visual synchronization in videos. It can identify lip-sync errors by analyzing the correspondence between mouth movements and spoken audio.
+
+## Features
+
+- 🎥 **Audio-Visual Sync Detection**: Accurately detect synchronization between audio and video
+- 🔍 **Face Detection**: Automatic face detection and tracking using S3FD
+- 🚀 **Batch Processing**: Process multiple videos efficiently
+- 🐍 **Python API**: Easy-to-use Python interface
+- 📊 **Confidence Scores**: Get confidence metrics for sync quality
+
+## Installation
+
+```bash
+pip install syncnet-python
+```
+
+### Additional Requirements
+
+1. **FFmpeg**: Required for video processing
+   ```bash
+   # Ubuntu/Debian
+   sudo apt-get install ffmpeg
+   
+   # macOS
+   brew install ffmpeg
+   ```
+
+2. **Model Weights**: Download pre-trained weights
+   - Download `sfd_face.pth` and `syncnet_v2.model`
+   - Place them in a `weights/` directory
+
+## Quick Start
+
+```python
+from syncnet_python import SyncNetPipeline
+
+# Initialize pipeline
+pipeline = SyncNetPipeline(
+    s3fd_weights="weights/sfd_face.pth",
+    syncnet_weights="weights/syncnet_v2.model",
+    device="cuda"  # or "cpu"
+)
+
+# Process video
+results = pipeline.inference(
+    video_path="video.mp4",
+    audio_path=None  # Extract from video
+)
+
+# Get results
+offset, confidence = results['offset'], results['confidence']
+print(f"AV Offset: {offset} frames")
+print(f"Confidence: {confidence:.3f}")
+```
+
+## Command Line Usage
+
+```bash
+# Process single video
+syncnet-python video.mp4
+
+# Process multiple videos
+syncnet-python video1.mp4 video2.mp4 --output results.json
+
+# Use CPU instead of GPU
+syncnet-python video.mp4 --device cpu
+```
+
+## Requirements
+
+- Python 3.9+
+- PyTorch 2.0+
+- CUDA (optional but recommended)
+- FFmpeg
+
+## Citation
+
+If you use this code in your research, please cite:
+
+```bibtex
+@inproceedings{chung2016out,
+  title={Out of time: automated lip sync in the wild},
+  author={Chung, Joon Son and Zisserman, Andrew},
+  booktitle={Asian Conference on Computer Vision},
+  year={2016}
+}
+```
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Links
+
+- GitHub: https://github.com/yourusername/syncnet-python
+- Documentation: https://syncnet-python.readthedocs.io
+- Issues: https://github.com/yourusername/syncnet-python/issues

syncnet_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+syncnet_python/SyncNetInstance.py,sha256=V-RtWL4nN2CW5n56DkE0d6hcnet4hAs_OVMaMS1ih20,6227
+syncnet_python/SyncNetModel.py,sha256=6qk27paoyV39MTsVyu6K2sbbM-1SLU_2N1zbqm1eeYs,3575
+syncnet_python/__init__.py,sha256=RUVJaCRWFMqFPDA8DOihkkCxJj_yoCBanVsHnOmgrS4,702
+syncnet_python/cli.py,sha256=YSQVVDChLkQ96gFRFqD7laQXqbrLC2b8SKaF-vc8FuA,3256
+syncnet_python/run_syncnet_pipeline_on_1example.py,sha256=7I8_jEgIFw-RUqCHU29LrIWIRP77lTUiH6MePOxsuWQ,1008
+syncnet_python/run_syncnet_pipeline_on_mocha_generation_on_mocha_bench.py,sha256=HJHGLgKpf21bG27_x1QD3MAhqtHey26Ujxb8s2aK-tA,5928
+syncnet_python/run_syncnet_pipeline_on_your_own_model_results.py,sha256=m-kz_DHhka_DywpBRWdxk-S0hrwqvCR16RiVQ7HUqDk,6003
+syncnet_python/syncnet_pipeline.py,sha256=9mSuNHnpgwxCNRUGmgat8peEtDNI6MFc_0VAykaSubM,11679
+syncnet_python/detectors/__init__.py,sha256=WLone-DTbvQUFleY93pmq7xomPDVjda9ATpZYcS6_sA,23
+syncnet_python/detectors/s3fd/__init__.py,sha256=MIJfIEsKFTGh8brmD3fBQg8JZAp57NtaTkY6_I5QZP0,2322
+syncnet_python/detectors/s3fd/box_utils.py,sha256=CWn46LMJKO1cdenI_IWxBbDriO2ueWTCl14Xp28fr-U,7235
+syncnet_python/detectors/s3fd/nets.py,sha256=BYPJq9UJ5bq5Q5RgP1j-NsFzO1gP3N0PYE1X19-4PZw,5891
+syncnet_python-0.1.0.dist-info/licenses/LICENSE,sha256=qwJOQjZqnGgzcgwg3VUkT2pGKwLyZr5nUOm0Gv7Zfog,1088
+syncnet_python-0.1.0.dist-info/METADATA,sha256=-ij02QUR1EUpy61vt7LoTnojQ06CYAeuYwIBUuspf3c,4445
+syncnet_python-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+syncnet_python-0.1.0.dist-info/entry_points.txt,sha256=zPJrIl_ekAa31dHZNCoTHiII2k_m5GyMD5BEkMR6Ytk,59
+syncnet_python-0.1.0.dist-info/top_level.txt,sha256=OkvKpxwq9NzQSjjdD571umGrI3meW9kVleOV2N5Ua04,15
+syncnet_python-0.1.0.dist-info/RECORD,,

syncnet_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

syncnet_python-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+syncnet-python = syncnet_python.cli:main

syncnet_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 SyncNet Python 3.13 Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

syncnet_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+syncnet_python