overc-clips 0.2.2__tar.gz → 0.2.4__tar.gz

{overc_clips-0.2.2 → overc_clips-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overc-clips
-Version: 0.2.2
+Version: 0.2.4
 Summary: Cut volleyball analysis clips from video, locally or hosted. Web UI, no command line required.
 Author-email: Bruce Ashfield <bruce.ashfield@gmail.com>
 License-Expression: AGPL-3.0-only

{overc_clips-0.2.2 → overc_clips-0.2.4}/overc_clips/config.py

@@ -28,13 +28,18 @@ DEFAULTS = {
     "clip_limit": 120,      # live — seconds; 0 means the platform has no limit
     "recent_limit": 12,     # live — how many videos "recent" keeps
     "autosave_points": False,  # live — keep a running record of clip points
+    "player_size": "normal",   # live — half | normal | double
+    "max_height": 720,         # live — advanced: fetch at most this tall
+    "exact_cut": False,        # live — advanced: decode to the exact frame
+    "quality": "balanced",     # live — advanced: smaller | balanced | better
     "port": 8080,           # restart
     "host": "0.0.0.0",      # restart
     "token": "",            # restart
     "outdir": "",           # restart; empty means "decide at launch"
 }
 LIVE_KEYS = ("keep_days", "encoder", "clip_limit", "recent_limit",
-             "autosave_points")
+             "autosave_points", "player_size",
+             "max_height", "exact_cut", "quality")
 RESTART_KEYS = ("port", "host", "token", "outdir")
 
 
@@ -93,6 +98,20 @@ class Config:
                         raise ValueError("a limit under 10s would split everything to nothing")
                 elif k == "autosave_points":
                     v = bool(v)
+                elif k == "max_height":
+                    v = int(v)
+                    if v not in (0, 480, 720, 1080, 1440, 2160):
+                        raise ValueError("must be 480, 720, 1080, 1440, 2160, or 0 for best")
+                elif k == "exact_cut":
+                    v = bool(v)
+                elif k == "quality":
+                    v = str(v)
+                    if v not in ("smaller", "balanced", "better"):
+                        raise ValueError("must be smaller, balanced or better")
+                elif k == "player_size":
+                    v = str(v)
+                    if v not in ("half", "normal", "double"):
+                        raise ValueError("must be half, normal or double")
                 elif k == "recent_limit":
                     v = int(v)
                     if not 1 <= v <= 200:

{overc_clips-0.2.2 → overc_clips-0.2.4}/overc_clips/engine.py

@@ -147,6 +147,29 @@ def plan_clip(name: str, start: str, end: str, ceiling: int = CEILING) -> list[C
     ]
 
 
+def probe_vcodec(path: Path, tools) -> str:
+    """The video codec in a file, or "" if it cannot be determined.
+
+    Uses ffprobe when there is one and parses `ffmpeg -i` when there is not --
+    the bundled ffmpeg ships without ffprobe, which is exactly the machine this
+    check matters on.
+    """
+    if getattr(tools, "ffprobe", None):
+        r = subprocess.run(
+            [str(tools.ffprobe), "-v", "error", "-select_streams", "v:0",
+             "-show_entries", "stream=codec_name", "-of", "csv=p=0", str(path)],
+            capture_output=True, text=True)
+        if r.returncode == 0 and r.stdout.strip():
+            return r.stdout.strip().splitlines()[0].strip().lower()
+    if getattr(tools, "ffmpeg", None):
+        r = subprocess.run([str(tools.ffmpeg), "-i", str(path)],
+                           capture_output=True, text=True)
+        m = re.search(r"Stream #\d+:\d+.*?: Video: (\w+)", r.stderr or "")
+        if m:
+            return m.group(1).lower()
+    return ""
+
+
 def probe_duration(path: Path, tools) -> float | None:
     """Seconds, or None if it cannot be determined.
 
@@ -198,6 +221,7 @@ def clip_metadata(title: str, source: str, start: str, end: str,
 
 
 def encode(src: Path, clip: Clip, outdir: Path, tools, *, on_proc=None,
+           quality: str = "balanced",
            encoder: str = "sw", accurate: bool = False, copy: bool = False,
            limit: int | None = HARD_LIMIT, meta: dict | None = None) -> Path:
     """Produce one clip file and verify it against the hard limit."""
@@ -206,12 +230,13 @@ def encode(src: Path, clip: Clip, outdir: Path, tools, *, on_proc=None,
     outdir.mkdir(parents=True, exist_ok=True)
     dest = outdir / f"{clip.name}.mp4"
 
+    q = QUALITY.get(quality, QUALITY["balanced"])
     if copy:
         vcodec = ["-c:v", "copy"]
     elif encoder == "hw":
-        vcodec = ["-c:v", "h264_videotoolbox", "-b:v", "4M", "-allow_sw", "1"]
+        vcodec = ["-c:v", "h264_videotoolbox", "-b:v", q["bitrate"], "-allow_sw", "1"]
     elif encoder == "sw":
-        vcodec = ["-c:v", "libx264", "-preset", "veryfast", "-crf", "20"]
+        vcodec = ["-c:v", "libx264", "-preset", "veryfast", "-crf", q["crf"]]
     else:
         raise ClipError(f"encoder must be 'sw' or 'hw', got {encoder!r}")
 
@@ -243,8 +268,32 @@ def encode(src: Path, clip: Clip, outdir: Path, tools, *, on_proc=None,
 # the DASH streams download fine -- verified both ways against the same video.
 # Falling back to `b[...]` would quietly reintroduce progressive, so it is last
 # and only reached when nothing else exists.
-FORMAT_SELECTOR = ("bv*[height<=720][ext=mp4]+ba[ext=m4a]/"
-                   "bv*[height<=720]+ba/b[height<=720]")
+# avc1 first, explicitly. Asking only for ext=mp4 is not the same thing: yt-dlp
+# will happily merge VP9 or AV1 into an mp4 container, and QuickTime and Safari
+# decode neither -- which plays as a black picture with working sound. The
+# later branches stay as a last resort, and anything they produce is re-encoded
+# rather than trusted.
+def format_selector(max_height: int = 720) -> str:
+    """What to ask YouTube for. 0 means "best available"."""
+    h = f"[height<={max_height}]" if max_height else ""
+    return (f"bv*{h}[vcodec^=avc1]+ba[acodec^=mp4a]/"
+            f"bv*{h}[ext=mp4]+ba[ext=m4a]/"
+            f"bv*{h}+ba/b{h}")
+
+
+FORMAT_SELECTOR = format_selector()          # the default, for callers with no opinion
+
+# Quality is three named points rather than a CRF box: the number means nothing
+# without knowing the scale runs backwards, and these are the only three
+# answers anyone actually wants.
+QUALITY = {
+    "smaller":  {"crf": "26", "bitrate": "2M"},
+    "balanced": {"crf": "20", "bitrate": "4M"},
+    "better":   {"crf": "17", "bitrate": "8M"},
+}
+
+# What a mac, an iPhone and every browser can play without thinking about it.
+PLAYABLE_VCODECS = {"h264", "avc1"}
 
 VIDEO_ID_RE = re.compile(
     r"(?:youtube\.com/(?:watch\?(?:.*&)?v=|live/|shorts/)|youtu\.be/)([A-Za-z0-9_-]{11})")
@@ -280,7 +329,7 @@ def _ffmpeg_loc(tools) -> list[str]:
 
 
 def fetch_full(url: str, cache_dir: Path, tools, *, log=lambda _m: None,
-               on_proc=None) -> Path:
+               on_proc=None, max_height: int = 720) -> Path:
     """Download the whole video once, natively, and keep it.
 
     The ranged path below hands the CDN URL to ffmpeg, and YouTube answers
@@ -295,6 +344,7 @@ def fetch_full(url: str, cache_dir: Path, tools, *, log=lambda _m: None,
     from . import preflight
     vid = video_id(url) or sanitise(url)[:32]
     cache_dir.mkdir(parents=True, exist_ok=True)
+    fmt = format_selector(max_height)
     dest = cache_dir / f"{vid}.mp4"
     if dest.exists() and dest.stat().st_size > 0:
         log(f"using cached download for {vid}")
@@ -302,7 +352,7 @@ def fetch_full(url: str, cache_dir: Path, tools, *, log=lambda _m: None,
 
     log(f"downloading the full video once ({vid}) — this is the slow part")
     cmd = [*preflight.ytdlp_cmd(tools),
-           "-f", FORMAT_SELECTOR, "--merge-output-format", "mp4",
+           "-f", fmt, "--merge-output-format", "mp4",
            *_ffmpeg_loc(tools),
            "-o", str(cache_dir / f"{vid}.%(ext)s"), url]
     r = _spawn(cmd, on_proc)
@@ -366,7 +416,8 @@ def provenance_from_tags(tags: dict) -> dict:
 
 def fetch_span(url: str, start: str, end: str, dest_stem: Path, tools,
                *, attempts: int = 2, cache_dir: Path | None = None,
-               log=lambda _m: None, on_proc=None, stop=None) -> Path:
+               log=lambda _m: None, on_proc=None, stop=None,
+               max_height: int = 720) -> Path:
     """Get just this span as dest_stem.mp4.
 
     Fast path: ask yt-dlp for the range, which it fulfils via ffmpeg. That is a
@@ -378,6 +429,7 @@ def fetch_span(url: str, start: str, end: str, dest_stem: Path, tools,
     if not tools.ytdlp:
         raise ClipError("yt-dlp not available — run `overc-clips doctor`")
     dest_stem.parent.mkdir(parents=True, exist_ok=True)
+    fmt = format_selector(max_height)
     # --ffmpeg-location is what makes the ranged fetch work on a machine with
     # no system ffmpeg. yt-dlp fulfils --download-sections through ffmpeg and
     # finds it on PATH; the bundled copy is inside site-packages under a
@@ -388,7 +440,7 @@ def fetch_span(url: str, start: str, end: str, dest_stem: Path, tools,
            *_ffmpeg_loc(tools),
            "--download-sections", f"*{start}-{end}",
            "--force-keyframes-at-cuts",
-           "-f", FORMAT_SELECTOR,
+           "-f", fmt,
            "--merge-output-format", "mp4",
            "-o", f"{dest_stem}.%(ext)s", url]
     last = ""
@@ -415,7 +467,8 @@ def fetch_span(url: str, start: str, end: str, dest_stem: Path, tools,
     if stop and stop():
         raise Cancelled("stopped")
     log("ranged fetch unavailable for this video; falling back to full download")
-    full = fetch_full(url, cache_dir, tools, log=log, on_proc=on_proc)
+    full = fetch_full(url, cache_dir, tools, log=log, on_proc=on_proc,
+                      max_height=max_height)
     span = Clip(dest_stem.name, parse_hms(start), parse_hms(end) - parse_hms(start))
     out = encode(full, span, dest_stem.parent, tools, accurate=True)
     return out.rename(Path(f"{dest_stem}.mp4")) if out.name != f"{dest_stem.name}.mp4" else out

{overc_clips-0.2.2 → overc_clips-0.2.4}/overc_clips/jobs.py

@@ -81,8 +81,12 @@ def _hold(job: Job):
 class Runner:
     def __init__(self, outdir: Path, workers: int = 1, keep: int = 200,
                  cache_dir: Path | None = None, clip_limit: int = 120,
-                 library=None):
+                 library=None, config=None):
         self.outdir = Path(outdir)
+        # Read through to config on each use rather than snapshotting: these
+        # are live settings, and a change should apply to the next job without
+        # a restart.
+        self.config = config
         # Full downloads land here when the ranged fetch is refused. Shared
         # across jobs so several clips from one match cost one download.
         self.cache_dir = Path(cache_dir or self.outdir / ".cache")
@@ -194,6 +198,9 @@ class Runner:
         if self.library.delete(job.replaces):
             job.say(f"replaced {job.replaces}")
 
+    def _opt(self, key, default):
+        return (self.config.data.get(key, default) if self.config else default)
+
     def _meta(self, job: Job, clip) -> dict:
         return engine.clip_metadata(
             job.title, job.url or job.path, clip.start_hms,
@@ -226,7 +233,9 @@ class Runner:
             for c in plan:
                 p = engine.encode(src, c, out, self.tools, on_proc=_hold(job),
                                   encoder=job.encoder,
-                                  accurate=job.accurate, copy=job.copy,
+                                  accurate=job.accurate or self._opt("exact_cut", False),
+                                  quality=self._opt("quality", "balanced"),
+                                  copy=job.copy,
                                   limit=self.clip_limit, meta=self._meta(job, c))
                 job.clips.append(p.name)
                 self._note(job, p.name, c)
@@ -241,11 +250,30 @@ class Runner:
             span = engine.fetch_span(job.url, job.start, job.end, tmp / "span",
                                      self.tools, cache_dir=self.cache_dir,
                                      log=job.say, on_proc=_hold(job),
+                                     max_height=self._opt("max_height", 720),
                                      stop=lambda: job.status == "cancelled")
             job.say("fetched; producing clips")
             if len(plan) == 1:
                 dest = out / f"{plan[0].name}.mp4"
-                shutil.move(str(span), dest)
+                # Moving the fetched span is the fast path, and only safe when
+                # what came down is actually playable. yt-dlp can merge VP9 or
+                # AV1 into an mp4 container when no avc1 stream is offered, and
+                # that plays as a black picture with sound -- a clip that looks
+                # produced and is not usable. Re-encode rather than hand that
+                # over.
+                vcodec = engine.probe_vcodec(span, self.tools)
+                if vcodec and vcodec not in engine.PLAYABLE_VCODECS:
+                    job.say(f"source is {vcodec}; re-encoding so it plays anywhere")
+                    whole = engine.Clip(plan[0].name, 0.0,
+                                        engine.probe_duration(span, self.tools) or plan[0].seconds)
+                    produced = engine.encode(span, whole, out, self.tools,
+                                             on_proc=_hold(job), encoder=job.encoder,
+                                             quality=self._opt("quality", "balanced"),
+                                             limit=self.clip_limit,
+                                             meta=self._meta(job, plan[0]))
+                    dest = produced
+                else:
+                    shutil.move(str(span), dest)
                 job.clips.append(dest.name)
                 self._note(job, dest.name, plan[0])
                 job.say(f"-> {dest.name}")
@@ -258,7 +286,9 @@ class Runner:
                 for c in engine.plan_clip(plan[0].source_name, "00:00:00", dur,
                                           ceiling=ceiling):
                     p = engine.encode(span, c, out, self.tools,
-                                      encoder=job.encoder, accurate=job.accurate,
+                                      encoder=job.encoder,
+                                      accurate=job.accurate or self._opt("exact_cut", False),
+                                      quality=self._opt("quality", "balanced"),
                                       copy=job.copy, limit=self.clip_limit,
                                       meta=self._meta(job, c))
                     job.clips.append(p.name)

{overc_clips-0.2.2 → overc_clips-0.2.4}/overc_clips/server.py

@@ -574,7 +574,7 @@ def serve(outdir: Path, host: str = "0.0.0.0", port: int = 8080,
     library = Library(Path(outdir), keep_days=keep_days)
     runner = Runner(outdir, workers=workers,
                     clip_limit=config.data.get("clip_limit", 120),
-                    library=library)
+                    library=library, config=config)
     history = History(Path(outdir) / ".sources.json",
                       limit=config.data.get("recent_limit", 12))
     q = f"?token={token}" if token else ""

{overc_clips-0.2.2 → overc_clips-0.2.4}/overc_clips/web/index.html

@@ -71,8 +71,19 @@
      inside it; #player itself is disposable, because the IFrame API REPLACES
      the element it is handed with an iframe -- which is why toggling
      visibility on that node kept losing the player. */
+  /* The player is the biggest thing on the page and on a small laptop it
+     crowds out the controls under it. Sized by the width it is allowed, so the
+     16/9 box follows and nothing else has to move. */
   #stage{position:relative;aspect-ratio:16/9;width:100%;background:#000;
-         border-radius:8px;overflow:hidden;margin:12px 0}
+         border-radius:8px;overflow:hidden;margin:12px 0;
+         max-width:var(--stage-max, 100%)}
+  body[data-player="half"]   #stage{--stage-max:52%}
+  body[data-player="normal"] #stage{--stage-max:100%}
+  body[data-player="double"] #stage{--stage-max:100%}
+  /* "Double" cannot be twice the column, so it widens the column itself --
+     the only way to make the player bigger once it already fills the width. */
+  body[data-player="double"] .wrap{max-width:1180px}
+  @media (max-width:700px){ body[data-player="half"] #stage{--stage-max:100%} }
   #stage>#playerBox,#stage>#localPlayer{position:absolute;inset:0;width:100%;
                                         height:100%;background:#000}
   #playerBox iframe,#playerBox>div{width:100%;height:100%;border:0;display:block}
@@ -167,6 +178,20 @@
   /* Deliberately smaller and quieter than .rec-x. They sit an inch apart and
      the outer one discards the whole video and every point under it, so equal
      visual weight would misstate what each does. */
+  /* The version, where it is actually wanted: beside the button that changes
+     it, and in the menu header. It was only at the foot of the settings panel
+     next to the licence, which is where you look for a licence. */
+  .adv{border-top:1px solid var(--line);padding-top:10px;margin-top:6px}
+  .adv summary{cursor:pointer;font-size:13px;color:var(--dim);padding:2px 0;
+               user-select:none}
+  .adv summary:hover{color:var(--accent)}
+  .adv[open] summary{margin-bottom:4px}
+  .sizes{display:inline-flex;gap:2px;margin-left:2px}
+  .sizes .sz{min-width:30px;padding:0 6px;line-height:1}
+  .sizes .sz.on{color:var(--accent);border-color:var(--accent);background:var(--bg)}
+  .verpill{flex:0 0 auto;font-size:11px;color:var(--dim);background:var(--bg);
+           border:1px solid var(--line);border-radius:999px;padding:2px 8px;
+           letter-spacing:.01em;white-space:nowrap}
   .ptshead{display:flex;align-items:center;gap:6px;cursor:pointer;padding:3px 2px 5px;
            user-select:none}
   .ptshead:hover .rec-m{color:var(--accent)}
@@ -403,6 +428,11 @@
         <option value="1" selected>1×</option><option value="1.5">1.5×</option>
         <option value="2">2×</option>
       </select>
+      <span class="sizes" role="group" aria-label="Video size">
+        <button class="t sz" data-size="half"   title="Small video">▫</button>
+        <button class="t sz" data-size="normal" title="Normal video">▪</button>
+        <button class="t sz" data-size="double" title="Wide video">⬛</button>
+      </span>
     </div>
     <div class="setrow">
       <button class="mark" id="markIn" title="Use the player's current position">Set start</button>
@@ -483,6 +513,7 @@
   <div class="dhead">
     <button class="dback" id="drawerBack" hidden title="Back to the menu">‹</button>
     <strong id="drawerTitle">Menu</strong>
+    <span class="verpill mono" id="verTop">—</span>
     <button class="dclose" id="drawerClose" title="Close">✕</button>
   </div>
   <div class="dbody">
@@ -560,7 +591,10 @@
       <div id="updBox" class="set" hidden
            style="align-items:flex-start;flex-direction:column;gap:6px;
                   border-bottom:1px solid var(--line);padding-bottom:14px;margin-bottom:4px">
-        <span>Updates</span>
+        <span class="row" style="width:100%;align-items:baseline">
+          <span class="grow">Updates</span>
+          <span class="verpill mono" id="verNow">—</span>
+        </span>
         <p class="muted" style="font-size:12px;margin:0">
           An out-of-date downloader is the usual reason a video that worked
           yesterday fails today. Safe while clips are being made.</p>
@@ -605,12 +639,14 @@
         </select>
       </label>
       <label class="set">
-        <span>Default quality</span>
-        <select id="setEncoder">
-          <option value="sw">Better (slower)</option>
-          <option value="hw">Faster (hardware)</option>
+        <span>Video size</span>
+        <select id="setPlayer">
+          <option value="half">Half width</option>
+          <option value="normal">Normal</option>
+          <option value="double">Wide</option>
         </select>
       </label>
+
       <label class="set" style="align-items:flex-start;flex-direction:column;gap:5px">
         <span>Save clips to <em id="outdirNote" class="warn-note" hidden>— restart to apply</em></span>
         <span class="row" style="width:100%">
@@ -621,6 +657,44 @@
       </label>
       <p class="muted" id="aboutLine" style="font-size:12px;margin:8px 0 0;
          border-top:1px solid var(--line);padding-top:10px"></p>
+      <details class="adv">
+        <summary>Advanced video options</summary>
+        <p class="muted" style="font-size:12px;margin:2px 0 10px">
+          The defaults suit most people. These change how clips are fetched and
+          encoded, and apply to the next clip you make.</p>
+        <label class="set">
+          <span>Fetch at most</span>
+          <select id="setHeight">
+            <option value="480">480p — smallest, fastest</option>
+            <option value="720">720p — default</option>
+            <option value="1080">1080p — more detail</option>
+            <option value="0">Best available</option>
+          </select>
+        </label>
+        <label class="set">
+          <span>Cutting</span>
+          <select id="setExact">
+            <option value="0">Fast — may start a second early</option>
+            <option value="1">Exact — slower, starts where you asked</option>
+          </select>
+        </label>
+        <label class="set">
+          <span>Encoding quality</span>
+          <select id="setQuality">
+            <option value="smaller">Smaller files</option>
+            <option value="balanced">Balanced</option>
+            <option value="better">Better picture</option>
+          </select>
+        </label>
+        <label class="set">
+          <span>Encoder</span>
+          <select id="setEncoder">
+            <option value="sw">Better (slower)</option>
+            <option value="hw">Faster (hardware)</option>
+          </select>
+        </label>
+      </details>
+
       <p class="muted" style="font-size:12px;margin:2px 0 0">
         Changes apply straight away, except the folder, which needs a restart.
         Stored in <code id="cfgPath" class="mono"></code>.</p>
@@ -1430,6 +1504,11 @@ async function loadSettings(){
   $('#outdirNote').hidden = !(d.values.outdir && liveOutdir &&
                               d.values.outdir !== liveOutdir);
   $('#setEncoder').value = d.values.encoder;
+  $('#setHeight').value = String(d.values.max_height ?? 720);
+  $('#setExact').value = d.values.exact_cut ? '1' : '0';
+  $('#setQuality').value = d.values.quality || 'balanced';
+  applyPlayerSize(d.values.player_size || 'normal');
+  $('#setPlayer').value = d.values.player_size || 'normal';
   $('#encoder').value = d.values.encoder;     // the main-flow picker follows it
   $('#cfgPath').textContent = d.path;
 }
@@ -1892,6 +1971,10 @@ fetch('/api/info').then(r=>r.json()).then(i=>{
   $('#outdir').textContent = i.outdir;
   // AGPL section 13: offer the source to whoever is using it, including
   // someone on a phone who never touched this machine.
+  const v = i.version ? `v${i.version}` : '';
+  $('#verNow').textContent = v || '—';
+  $('#verTop').textContent = v || '—';
+  $('#verTop').hidden = !v;
   $('#aboutLine').innerHTML =
     `overc-clips ${esc(i.version || '')} · ${esc(i.license || '')} · ` +
     `<a href="${esc(i.source_url || '')}" target="_blank" rel="noopener">source</a>`;
@@ -1929,6 +2012,27 @@ fetch('/api/info').then(r=>r.json()).then(i=>{
   });
 }).catch(()=>{});
 
+function applyPlayerSize(v){
+  document.body.dataset.player = v;
+  document.querySelectorAll('.sz').forEach(b => b.classList.toggle('on', b.dataset.size === v));
+  const sel = $('#setPlayer');
+  if(sel) sel.value = v;
+}
+// Beside the speed control on purpose: both are about watching, and both get
+// changed while hunting for a boundary. Going to Settings to make the video
+// smaller means leaving the thing you were looking at.
+document.querySelectorAll('.sz').forEach(b => b.onclick = () => {
+  applyPlayerSize(b.dataset.size);
+  saveSetting('player_size', b.dataset.size);
+});
+$('#setHeight').onchange  = e => saveSetting('max_height', +e.target.value);
+$('#setExact').onchange   = e => saveSetting('exact_cut', e.target.value === '1');
+$('#setQuality').onchange = e => saveSetting('quality', e.target.value);
+$('#setPlayer').onchange = e => {
+  applyPlayerSize(e.target.value);
+  saveSetting('player_size', e.target.value);
+};
+
 $('#doUpdate').onclick = async () => {
   const b = $('#doUpdate'), m = $('#updMsg');
   b.disabled = true; m.textContent = 'Updating — this can take a minute…';
@@ -1942,6 +2046,8 @@ $('#doUpdate').onclick = async () => {
         ? moved.map(p => `${p.name} ${p.before} → ${p.after}`).join(', ')
         : 'Everything is already up to date.';
       $('#updRestart').hidden = !r.restart_needed;
+      const me = (r.packages||[]).find(p => p.name === 'overc-clips');
+      if(me && me.after) $('#verNow').textContent = `v${me.after}`;
     }
   } catch { m.textContent = 'could not reach the server'; }
   b.disabled = false;

{overc_clips-0.2.2 → overc_clips-0.2.4}/overc_clips.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: overc-clips
-Version: 0.2.2
+Version: 0.2.4
 Summary: Cut volleyball analysis clips from video, locally or hosted. Web UI, no command line required.
 Author-email: Bruce Ashfield <bruce.ashfield@gmail.com>
 License-Expression: AGPL-3.0-only

{overc_clips-0.2.2 → overc_clips-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "overc-clips"
-version = "0.2.2"
+version = "0.2.4"
 description = "Cut volleyball analysis clips from video, locally or hosted. Web UI, no command line required."
 requires-python = ">=3.10"
 readme = "README.md"