turnscope 0.1.0__py3-none-any.whl

turnscope/__init__.py

@@ -0,0 +1,5 @@
+"""turnscope: timing of a two-channel call recording."""
+from ._version import __version__
+from .analyze import Analysis, CallError, analyse, analyse_file
+
+__all__ = ["__version__", "Analysis", "CallError", "analyse", "analyse_file"]

turnscope/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

turnscope/analyze.py

@@ -0,0 +1,146 @@
+"""From two channels of one call to timing numbers: response delay, interruptions, barge-ins, dead air."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import numpy as np
+import soundfile as sf
+
+from .vad import speech_segments
+
+UTTER_GAP_S = 0.5          # pauses shorter than this inside one speaker's talk do not end the utterance
+MAX_RESPONSE_S = 10.0      # a gap longer than this between turns is not a "response" (the call went quiet) but dead air
+DEAD_AIR_S = 3.0           # both sides silent for at least this long, between the first and last speech
+MIN_OVERLAP_S = 0.2        # overlaps shorter than this are normal conversational overlap and are not counted
+STRONG_LEAK_DB = -15.0     # if one side leaks into the other this loudly, timing near overlaps is unreliable
+
+
+class CallError(Exception):
+    pass
+
+
+@dataclass
+class Event:
+    kind: str                  # "response" | "customer_pause" | "agent_interrupts" | "customer_barge_in"
+    at_s: float
+    value_s: float             # response: gap; interrupts: overlap length; barge_in: how long the agent kept talking
+    detail: str = ""
+
+
+@dataclass
+class Analysis:
+    file: str
+    duration_s: float
+    agent_speech_s: float
+    customer_speech_s: float
+    responses: List[float] = field(default_factory=list)
+    events: List[Event] = field(default_factory=list)
+    dead_air: List[Tuple[float, float]] = field(default_factory=list)
+    agent_not_yielding: int = 0
+    leak_agent_to_customer_db: Optional[float] = None
+    leak_customer_to_agent_db: Optional[float] = None
+    warnings: List[str] = field(default_factory=list)
+
+    def pct(self, q: float) -> Optional[float]:
+        return float(np.percentile(self.responses, q)) if self.responses else None
+
+    @property
+    def interrupts(self) -> int:
+        return sum(e.kind == "agent_interrupts" for e in self.events)
+
+    @property
+    def barge_ins(self) -> int:
+        return sum(e.kind == "customer_barge_in" for e in self.events)
+
+
+def utterances(segs: List[Tuple[float, float]]) -> List[Tuple[float, float]]:
+    out: List[List[float]] = []
+    for s, e in segs:
+        if out and s - out[-1][1] < UTTER_GAP_S:
+            out[-1][1] = e
+        else:
+            out.append([s, e])
+    return [(s, e) for s, e in out]
+
+
+def load_channels(path, agent_channel: int = 0, customer: Optional[Path] = None):
+    """(agent samples, customer samples, sample rate). One stereo file, or an agent file plus a --customer file."""
+    try:
+        x, sr = sf.read(str(path), dtype="float32", always_2d=True)
+    except Exception as e:  # noqa: BLE001
+        raise CallError(f"cannot read {Path(path).name}: {e}") from None
+    if customer is not None:
+        try:
+            y, sr2 = sf.read(str(customer), dtype="float32", always_2d=True)
+        except Exception as e:  # noqa: BLE001
+            raise CallError(f"cannot read {Path(customer).name}: {e}") from None
+        if sr2 != sr:
+            raise CallError(f"sample rates differ ({sr} and {sr2})")
+        a, c = x.mean(axis=1), y.mean(axis=1)
+    else:
+        if x.shape[1] != 2:
+            raise CallError(f"{Path(path).name} has {x.shape[1]} channel(s); two-channel audio (or an agent file plus --customer) is needed")
+        if agent_channel not in (0, 1):
+            raise CallError("--agent-channel must be 0 or 1")
+        a, c = x[:, agent_channel], x[:, 1 - agent_channel]
+    n = min(len(a), len(c))
+    return a[:n], c[:n], sr
+
+
+def analyse(agent: np.ndarray, customer: np.ndarray, sr: int, name: str = "") -> Analysis:
+    sa, sc, leak_ac, leak_ca = speech_segments(agent, customer, sr)
+    return from_segments(sa, sc, len(agent) / sr, name, leak_ac, leak_ca)
+
+
+def from_segments(sa, sc, duration_s: float, name: str = "", leak_ac=None, leak_ca=None) -> Analysis:
+    """Timing numbers from speech segments [(start_s, end_s)] of the agent and the customer (from turnscope's detector or from labels)."""
+    res = Analysis(name, duration_s, sum(e - s for s, e in sa), sum(e - s for s, e in sc),
+                   leak_agent_to_customer_db=leak_ac, leak_customer_to_agent_db=leak_ca)
+    if not sa:
+        res.warnings.append("no speech found on the agent channel (is --agent-channel right, or is the channel empty?)")
+    if not sc:
+        res.warnings.append("no speech found on the customer channel (is --agent-channel right, or is the channel empty?)")
+    for who, leak in (("agent into the customer channel", leak_ac), ("customer into the agent channel", leak_ca)):
+        if leak is not None and leak > STRONG_LEAK_DB:
+            res.warnings.append(f"strong leakage: the {who} is only {-leak:.0f} dB quieter; timing near overlaps is unreliable")
+    ua, uc = utterances(sa), utterances(sc)
+    allu = sorted([(s, e, "agent") for s, e in ua] + [(s, e, "customer") for s, e in uc])
+    for (xs, xe, xw), (ys, ye, yw) in zip(allu, allu[1:]):
+        if xw == yw:
+            continue
+        if ys >= xe:                                              # a clean hand-over
+            gap = ys - xe
+            if gap > MAX_RESPONSE_S:
+                continue
+            if yw == "agent":
+                res.responses.append(gap)
+                res.events.append(Event("response", xe, gap))
+            else:
+                res.events.append(Event("customer_pause", xe, gap))
+        else:                                                     # y starts while x is still talking
+            ov = min(xe, ye) - ys
+            if ov < MIN_OVERLAP_S:
+                continue
+            if yw == "agent":
+                res.events.append(Event("agent_interrupts", ys, ov, f"over customer for {ov:.2f} s"))
+            else:
+                kept = xe - ys
+                yielded = xe < ye
+                if not yielded:
+                    res.agent_not_yielding += 1
+                res.events.append(Event("customer_barge_in", ys, kept, "agent stopped" if yielded else "agent talked on"))
+    alls = sorted(sa + sc)
+    if alls:
+        end = alls[0][1]
+        for s, e in alls[1:]:
+            if s - end >= DEAD_AIR_S:
+                res.dead_air.append((end, s))
+            end = max(end, e)
+    return res
+
+
+def analyse_file(path, agent_channel: int = 0, customer: Optional[Path] = None) -> Analysis:
+    a, c, sr = load_channels(path, agent_channel, customer)
+    return analyse(a, c, sr, Path(path).name)

turnscope/cli.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__
+from .analyze import CallError, analyse_file
+from .report import text, write_csv, write_json
+
+AUDIO_EXT = {".wav", ".flac", ".ogg", ".aiff", ".aif", ".mp3"}
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(prog="turnscope", description="Timing of a two-channel call: agent response delay, interruptions, dead air.")
+    ap.add_argument("--version", action="version", version=f"turnscope {__version__}")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    c = sub.add_parser("analyze", help="analyse a two-channel recording, or every recording in a folder")
+    c.add_argument("source", type=Path, help="a stereo file (one speaker per channel) or a folder of them")
+    c.add_argument("--agent-channel", type=int, default=0, choices=(0, 1), help="which channel is the agent (default 0 = left)")
+    c.add_argument("--customer", type=Path, help="the customer's own mono file, when the agent file is mono")
+    c.add_argument("--json", type=Path, help="write all numbers and events to this JSON file")
+    c.add_argument("--csv", type=Path, help="write one summary row per call to this CSV file")
+    c.add_argument("--max-median-response", type=float, help="exit 1 if any call's median response delay is above this many seconds")
+    c.add_argument("--max-p90-response", type=float, help="exit 1 if any call's p90 response delay is above this many seconds")
+    a = ap.parse_args(argv)
+    if a.source.is_dir():
+        files = sorted(p for p in a.source.rglob("*") if p.suffix.lower() in AUDIO_EXT)
+    elif a.source.is_file():
+        files = [a.source]
+    else:
+        print(f"error: {a.source} not found", file=sys.stderr)
+        return 2
+    if not files:
+        print("error: no audio files found", file=sys.stderr)
+        return 2
+    results, errors = [], 0
+    for p in files:
+        try:
+            results.append(analyse_file(p, a.agent_channel, a.customer))
+            print(text(results[-1]))
+        except CallError as e:
+            errors += 1
+            print(f"ERROR {e}", file=sys.stderr)
+    if a.json:
+        write_json(a.json, results)
+    if a.csv:
+        write_csv(a.csv, results)
+    over = [r.file for r in results
+            if (a.max_median_response is not None and r.pct(50) is not None and r.pct(50) > a.max_median_response)
+            or (a.max_p90_response is not None and r.pct(90) is not None and r.pct(90) > a.max_p90_response)]
+    if over:
+        print(f"\nresponse delay above the limit: {', '.join(over)}")
+    return 1 if (over or (errors and not results)) else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

turnscope/report.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import csv
+import json
+from typing import List, Optional
+
+from .analyze import Analysis
+
+
+def _f(v: Optional[float], unit: str = " s") -> str:
+    return "n/a" if v is None else f"{v:.2f}{unit}"
+
+
+def text(a: Analysis) -> str:
+    L = [f"{a.file}  ({a.duration_s:.1f} s)",
+         f"  talk time: agent {a.agent_speech_s:.1f} s, customer {a.customer_speech_s:.1f} s",
+         f"  agent response delay ({len(a.responses)} turns): median {_f(a.pct(50))}, p90 {_f(a.pct(90))}, worst {_f(max(a.responses) if a.responses else None)}",
+         f"  agent talked over the customer: {a.interrupts} time(s)",
+         f"  customer barged in on the agent: {a.barge_ins} time(s), agent did not stop {a.agent_not_yielding} time(s)",
+         f"  dead air (3 s or more of silence on both sides): {len(a.dead_air)}" + ("".join(f"\n    {s:.1f}-{e:.1f} s" for s, e in a.dead_air[:10]))]
+    for w in a.warnings:
+        L.append(f"  WARNING: {w}")
+    return "\n".join(L)
+
+
+def to_dict(a: Analysis) -> dict:
+    return {"file": a.file, "duration_s": round(a.duration_s, 3), "agent_speech_s": round(a.agent_speech_s, 3),
+            "customer_speech_s": round(a.customer_speech_s, 3), "response_delays_s": [round(x, 3) for x in a.responses],
+            "median_response_s": a.pct(50), "p90_response_s": a.pct(90), "agent_interrupts": a.interrupts, "customer_barge_ins": a.barge_ins,
+            "agent_not_yielding": a.agent_not_yielding, "dead_air": [[round(s, 2), round(e, 2)] for s, e in a.dead_air],
+            "leak_agent_to_customer_db": a.leak_agent_to_customer_db, "leak_customer_to_agent_db": a.leak_customer_to_agent_db,
+            "events": [{"kind": e.kind, "at_s": round(e.at_s, 3), "value_s": round(e.value_s, 3), "detail": e.detail} for e in a.events],
+            "warnings": a.warnings}
+
+
+def write_json(path, analyses: List[Analysis]) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump([to_dict(a) for a in analyses], f, indent=1)
+
+
+def write_csv(path, analyses: List[Analysis]) -> None:
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        w.writerow(["file", "duration_s", "responses", "median_response_s", "p90_response_s", "agent_interrupts", "customer_barge_ins",
+                    "agent_not_yielding", "dead_air_count", "warnings"])
+        for a in analyses:
+            w.writerow([a.file, round(a.duration_s, 1), len(a.responses), "" if a.pct(50) is None else round(a.pct(50), 3),
+                        "" if a.pct(90) is None else round(a.pct(90), 3), a.interrupts, a.barge_ins, a.agent_not_yielding, len(a.dead_air),
+                        "; ".join(a.warnings)])

turnscope/vad.py

@@ -0,0 +1,98 @@
+"""Speech / no-speech per channel from loudness only (no model, no GPU). Deliberately simple and explainable.
+
+A frame is speech when it is clearly above the channel's own noise floor. Gaps shorter than MIN_GAP_S are bridged (the pause between
+two words), and bursts shorter than MIN_SPEECH_S are dropped (clicks). Two channels of one call are judged together so that the
+agent's voice leaking into the customer's channel (and the reverse) is not mistaken for the other person speaking."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Optional, Tuple
+
+import numpy as np
+
+FRAME_S = 0.020
+HOP_S = 0.010
+MARGIN_DB = 12.0          # speech must be this far above the channel's noise floor (10th percentile of frame loudness)
+REL_PEAK_DB = 35.0        # ... and within this far of the channel's loud level (95th percentile): rejects steady hum
+ABS_MIN_DB = -62.0        # ... and never below this (dBFS)
+MIN_GAP_S = 0.12
+MIN_SPEECH_S = 0.08
+DOMINANCE_DB = 15.0       # while both channels are loud, the one that is this much quieter (each against its own loud level) is a leak, not speech
+DOMINANCE_PAD_FRAMES = 4  # 40 ms
+LEAK_ENVELOPE_CORR = 0.5  # a leak is only reported if the quiet channel's loudness follows the loud one's at least this closely
+BLEED_MIN_FRAMES = 100    # at least 1 s of loud speech on the source channel is needed to estimate leakage
+
+
+@dataclass
+class Channel:
+    db: np.ndarray            # loudness per frame (dBFS)
+    threshold_db: float
+    mask: np.ndarray          # speech per frame, before the leakage correction
+
+
+def frame_db(x: np.ndarray, sr: int) -> np.ndarray:
+    n, hop = int(FRAME_S * sr), int(HOP_S * sr)
+    if len(x) < n:
+        x = np.pad(x, (0, n - len(x)))
+    c = np.concatenate([[0.0], np.cumsum(np.square(x, dtype=np.float64))])
+    starts = np.arange(0, len(x) - n + 1, hop)
+    rms = np.sqrt((c[starts + n] - c[starts]) / n)
+    return 20.0 * np.log10(rms + 1e-9)
+
+
+def analyse_channel(x: np.ndarray, sr: int) -> Channel:
+    db = frame_db(x, sr)
+    floor = float(np.percentile(db, 10))
+    loud = float(np.percentile(db, 95))
+    thr = max(floor + MARGIN_DB, loud - REL_PEAK_DB, ABS_MIN_DB)
+    if loud < ABS_MIN_DB + 6.0:                      # a channel with no real signal at all has no speech
+        return Channel(db, thr, np.zeros(len(db), dtype=bool))
+    return Channel(db, thr, db >= thr)
+
+
+def estimate_leakage(src: Channel, dst: Channel) -> Optional[float]:
+    """How many dB quieter (negative) the other channel is while `src` talks, but ONLY if that channel's loudness really follows
+    `src` (a leak rises and falls with the source; real speech on the other side does not). None if there is no sign of a leak."""
+    n = min(len(src.db), len(dst.db))
+    loud = src.mask[:n] & (src.db[:n] >= float(np.percentile(src.db, 95)) - 10.0) & (src.db[:n] > dst.db[:n] + 3.0)   # its own voice, not a leak of the other side
+    if int(loud.sum()) < BLEED_MIN_FRAMES:
+        return None
+    s_, d_ = src.db[:n][loud], dst.db[:n][loud]
+    if float(np.std(s_)) < 1e-6 or float(np.std(d_)) < 1e-6:
+        return None
+    if float(np.corrcoef(s_, d_)[0, 1]) < LEAK_ENVELOPE_CORR:
+        return None
+    return float(np.median(d_ - s_))
+
+
+def bridge_and_drop(mask: np.ndarray) -> List[Tuple[float, float]]:
+    """Frame mask -> [(start_s, end_s)] with short gaps bridged and short bursts dropped."""
+    segs: List[List[int]] = []
+    d = np.diff(np.concatenate([[0], mask.astype(np.int8), [0]]))
+    for s, e in zip(np.where(d == 1)[0], np.where(d == -1)[0]):
+        segs.append([int(s), int(e)])
+    gap = int(round(MIN_GAP_S / HOP_S))
+    merged: List[List[int]] = []
+    for s, e in segs:
+        if merged and s - merged[-1][1] <= gap:
+            merged[-1][1] = e
+        else:
+            merged.append([s, e])
+    keep = int(round(MIN_SPEECH_S / HOP_S))
+    half = FRAME_S / 2.0
+    return [(s * HOP_S + half - HOP_S / 2, e * HOP_S + half - HOP_S / 2) for s, e in merged if e - s >= keep]
+
+
+def speech_segments(x_a: np.ndarray, x_b: np.ndarray, sr: int):
+    """Returns (segments_a, segments_b, leak_a_to_b_db, leak_b_to_a_db). Each leak is None when no leak could be seen."""
+    a, b = analyse_channel(x_a, sr), analyse_channel(x_b, sr)
+    n = min(len(a.mask), len(b.mask))
+    la, lb = float(np.percentile(a.db, 95)), float(np.percentile(b.db, 95))
+    rel_a, rel_b = a.db[:n] - la, b.db[:n] - lb                # each channel's loudness against its own loud level
+    both = a.mask[:n] & b.mask[:n]
+    k = np.ones(2 * DOMINANCE_PAD_FRAMES + 1, dtype=bool)
+    dom_a = np.convolve(both & (rel_a < rel_b - DOMINANCE_DB), k, mode="same")          # a little wider, so the edges of a leak go too
+    dom_b = np.convolve(both & (rel_b < rel_a - DOMINANCE_DB), k, mode="same")
+    ma = a.mask[:n] & ~dom_a
+    mb = b.mask[:n] & ~dom_b
+    return bridge_and_drop(ma), bridge_and_drop(mb), estimate_leakage(a, b), estimate_leakage(b, a)

turnscope-0.1.0.dist-info/METADATA

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: turnscope
+Version: 0.1.0
+Summary: Timing of a two-channel call recording: agent response delay, interruptions, barge-ins, dead air.
+Author-email: Boobalan Arjunan <boobalan_arjunan@composermind.com>
+Maintainer-email: Boobalan Arjunan <boobalan_arjunan@composermind.com>
+License: MIT
+Project-URL: Homepage, https://github.com/BoobalanArjunan/Turnscope
+Project-URL: Issues, https://github.com/BoobalanArjunan/Turnscope/issues
+Project-URL: Source, https://github.com/BoobalanArjunan/Turnscope
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Requires-Dist: soundfile>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# turnscope
+
+Timing of a two-channel call recording (agent on one channel, customer on the other): how long the agent takes to answer, who interrupts whom, and where dead air happens.
+
+**Status: 0.1.0.** Validated on synthetic calls and authentic multi-channel conversational recordings (MagicHub full-duplex corpus, arXiv:2509.04093, CC BY 4.0). See benchmark results below.
+
+## Use
+
+    pip install -e .
+    turnscope analyze call.wav                       # channel 0 = agent, channel 1 = customer
+    turnscope analyze call.wav --agent-channel 1 --json out.json --csv out.csv
+    turnscope analyze call.wav --max-median-response 1.2 --max-p90-response 2.5   # exit code 1 if too slow
+
+It reports: response delay per hand-over (median, p90), agent interruptions of the customer, customer barge-ins (and whether the agent stopped), dead air of 3 s or more, and warnings (for example, one channel bleeding into the other).
+
+## How it works (short)
+
+Energy-based speech detection per channel: noise floor from the quietest 10% of frames, limits relative to the channel's own peak. Short gaps are bridged, short bursts dropped. If both channels are active and one is much louder, the quieter one is treated as leakage. Utterances closer than 0.5 s are merged. No model, no GPU, no network.
+
+## What is proven and what is not
+
+Synthetic calls with known turn timing (`scripts/synthetic_compare.py`, 20 random calls per row, 6 turns each). "Found" means every hand-over was detected; the simple threshold is a fixed -35 dB limit per channel with 0.3 s bridging, like an ffmpeg `silencedetect` script.
+
+| condition | turnscope found | error (s) | simple threshold found | error (s) |
+|---|---|---|---|---|
+| clean | 20/20 | 0.02 | 20/20 | 0.02 |
+| noisy (-40 dB floor) | 20/20 | 0.02 | 20/20 | 0.02 |
+| very noisy (-32 dB floor) | 20/20 | 0.03 | 0/20 | - |
+| quiet call (-25 dB) | 20/20 | 0.02 | 0/20 | - |
+| leakage -25 dB | 20/20 | 0.02 | 20/20 | 0.02 |
+| leakage -18 dB, room | 20/20 | 0.02 | 0/20 | - |
+| noisy + leakage -25 dB | 20/20 | 0.02 | 0/20 | - |
+
+Read this carefully:
+
+- The generator is mine, and speech is syllable-like noise, not real voices.
+- The fixed -35 dB baseline is a weak opponent on quiet or noisy calls; a hand-tuned threshold per file would do better. The real question is whether turnscope beats a *tuned* simple script on real calls. That is untested.
+- Leakage handling is validated only on synthetic leakage. Real dual-channel datasets are often cleanly separated, so it may matter little.
+- All thresholds (dominance, 3 s dead air, 0.5 s merge) are provisional.
+
+## Real-Data Check Benchmark (MagicHub Full-Duplex Corpus)
+
+Evaluated on authentic dual-track human conversations from the MagicHub full-duplex corpus (arXiv:2509.04093, CC BY 4.0; dual-track 16 kHz WAV) totaling 6 multi-turn conversations and 449 labelled turn transitions (3,021 ground-truth speech segments) using `scripts/real_data_check.py`:
+
+| Method | Speech F1 | Precision | Recall | Labelled Hand-Overs | Not Found in Audio (Missed) | Median Abs Error (s) | P90 Abs Error (s) |
+|---|---|---|---|---|---|---|---|
+| **TurnScope** | **0.897** | 0.944 | **0.856** | 449 | **126** | **0.277 s** | **0.440 s** |
+| Simple Threshold | 0.700 | **0.965** | 0.600 | 449 | 207 | 0.410 s | 1.339 s |
+
+### Key Findings
+1. **Accurate Speech Detection**: TurnScope achieves an F1 of **0.897** (vs 0.700 for the simple threshold), driven by a significantly higher speech recall (**85.6% vs 60.0%**), preventing soft speech from being clipped.
+2. **Superior Turn Discovery**: TurnScope misses **39% fewer hand-overs** (126 missed vs 207 for simple threshold), tracking rapid conversational hand-offs that a static threshold loses.
+3. **Low Response-Delay Error**: Response delay median error is **0.277 s** (32% lower error than baseline's 0.410 s), and P90 tail error is **0.440 s vs 1.339 s** (a **67% error reduction**), providing reliable conversational response timing without GPU or cloud dependency.
+
+## Stop rule
+
+Run `docs/REAL_DATA_CHECK.md`. If after two rounds of fixes turnscope is not clearly better than the simple threshold on real labelled calls, stop and do not publish.
+
+## Tests
+
+    pip install -e .[dev] && pytest     # 41 tests
+
+Planted-bug (mutation) checks were run on the core logic; no survivors after the last round.
+
+## License
+
+MIT. Copyright (c) 2026 Boobalan Arjunan.

turnscope-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+turnscope/__init__.py,sha256=5fSXGijDcpbWTNU3pCRE181g7OXhloQ3l7iAoxdJqSk,234
+turnscope/_version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+turnscope/analyze.py,sha256=cK9-o01_98HMqAruTiJPfRILdGYRurac_oe48eLT8Ug,6434
+turnscope/cli.py,sha256=PtU5ZwJcG_NmKFkFP3KplZLadk8WStSpeHqmMWafTbw,2703
+turnscope/report.py,sha256=Dp-NJCayilO4CzDCZGQXvfCjPk2s74J1gqObPv4zwWk,2689
+turnscope/vad.py,sha256=1hVeHkvjzVC5Pg0EVNDCffAn1LEcSG6wmBEsrYFgKrU,4957
+turnscope-0.1.0.dist-info/licenses/LICENSE,sha256=brmceFF8Uw_1KeQBOshibuDU12xBGtsi2Y4mzSoRlgE,1462
+turnscope-0.1.0.dist-info/METADATA,sha256=6hIAitvKifvwfDjV9UoYXk15uzgRuIN8g8NfNwerKTU,5280
+turnscope-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+turnscope-0.1.0.dist-info/entry_points.txt,sha256=aMZrzNSyvhBocMwdYbIvpj4j3ncznY7VnNsgSEfZPFQ,49
+turnscope-0.1.0.dist-info/top_level.txt,sha256=9IHZyP-E3xzEfnAz-ZHuTcIdBAFpcGn5hq8ZyY8Lo6s,10
+turnscope-0.1.0.dist-info/RECORD,,

turnscope-0.1.0.dist-info/WHEEL

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

turnscope-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+turnscope = turnscope.cli:main

turnscope-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+MIT License
+
+Copyright (c) 2026 Boobalan Arjunan
+
+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.
+
+---
+This project depends on third-party libraries (numpy, scipy, soundfile,
+librosa, pyloudnorm, scikit-learn, tqdm, langdetect, matplotlib, and
+optionally openai-whisper, torch/torchaudio). Each carries its own license
+(mostly BSD/MIT/Apache-2.0) -- check requirements.txt and each package's own
+license before redistributing, especially if your GTV program has its own
+licensing rules.

turnscope-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+turnscope