PyPI - withcache - Versions diffs - 0.5.0__tar.gz → 0.5.2__tar.gz - Mend

@@ -982,7 +982,7 @@ class Handler(http.server.BaseHTTPRequestHandler):
 <body><main class="container">
   <nav>
     <ul><li>
-      <strong>withcache</strong> &nbsp;<small>cache-host</small>
+      <strong>withcache</strong>
       &nbsp;<small class="mono">v{html.escape(__version__)}</small>
     </li></ul>
     <ul>
@@ -996,7 +996,11 @@ class Handler(http.server.BaseHTTPRequestHandler):
         hx-indicator="#spin" hx-on::after-request="this.reset()">
     <fieldset role="group">
       <input type="url" name="url" placeholder="https://origin/path/artifact.tar.gz" required>
-      <button type="submit">Fetch &amp; store</button>
+      <!-- white-space: nowrap so the label "Fetch & store" stays on
+           one line; default flex-grow inside fieldset[role=group]
+           shrinks the button to content width, which on a narrow
+           viewport wrapped the ampersand to a second line. -->
+      <button type="submit" style="white-space: nowrap;">Fetch &amp; store</button>
     </fieldset>
   </form>
@@ -1011,6 +1015,42 @@ class Handler(http.server.BaseHTTPRequestHandler):
        hx-swap="innerHTML">
     {self.render_dash()}
   </div>
+  <!-- Tab activation. Applies an ``active-tab`` class to the
+       ``section.tab`` whose id matches the URL hash (defaulting to
+       the first section when no hash is set) and to the
+       corresponding ``nav.tabs a``. Runs on initial load, on every
+       click into a tab link (so the operator gets immediate
+       feedback before the next htmx tick), and on every
+       ``htmx:afterSettle`` so the class survives the 1 Hz
+       innerHTML replacement of ``#dash``. Without this the
+       previous ``:target``-based CSS would snap the operator back
+       to the first tab within a second of any click. -->
+  <script>
+    (function () {{
+      function applyActiveTab() {{
+        var hash = (window.location.hash || '').replace(/^#/, '');
+        var sections = document.querySelectorAll('#dash section.tab');
+        if (!sections.length) return;
+        var ids = Array.prototype.map.call(sections, function (s) {{ return s.id; }});
+        if (ids.indexOf(hash) === -1) hash = ids[0];
+        sections.forEach(function (s) {{
+          s.classList.toggle('active-tab', s.id === hash);
+        }});
+        document.querySelectorAll('#dash nav.tabs a').forEach(function (a) {{
+          var target = (a.getAttribute('href') || '').replace(/^#/, '');
+          a.classList.toggle('active-tab', target === hash);
+        }});
+      }}
+      window.addEventListener('hashchange', applyActiveTab);
+      document.body.addEventListener('htmx:afterSettle', applyActiveTab);
+      document.addEventListener('click', function (ev) {{
+        var a = ev.target.closest && ev.target.closest('#dash nav.tabs a');
+        if (a) setTimeout(applyActiveTab, 0);
+      }});
+      applyActiveTab();
+    }})();
+  </script>
 </main></body></html>"""
     def render_dash(self) -> str:
@@ -1024,13 +1064,20 @@ class Handler(http.server.BaseHTTPRequestHandler):
             used += f" / {human_size(self.store.max_bytes)}"
         full = "" if self.store.has_capacity() else " &middot; <strong>cache full</strong>"
-        # Tabs are pure-CSS via :target. The URL hash names the active
-        # section; htmx innerHTML-replacement of #dash leaves the hash
-        # alone, so the operator's tab choice survives every refresh.
-        # ``body:not(:has(section:target))`` selects the default tab
-        # when no hash is present; :has() lands cleanly on Chrome 105+,
-        # Firefox 121+, Safari 15.4+, which is the whole modern web by
-        # the time this ships in 2026.
+        # Tabs are driven by an ``active-tab`` class applied to one
+        # ``section.tab`` (and matching ``nav.tabs a``). A tiny script
+        # at the bottom of the dash watches the URL hash, the htmx
+        # post-swap event, and click events on the tab links so the
+        # class survives every 1 Hz innerHTML replacement.
+        #
+        # An earlier pure-CSS attempt used ``:target`` + ``:has()``.
+        # That works on a static page, but when htmx swaps the
+        # ``#dash`` innerHTML each second the freshly-inserted
+        # ``section.tab`` elements do not always get re-matched by
+        # ``:target`` (the browser keeps the URL hash but the
+        # newly-inserted node is not the one ``:target`` resolved to
+        # at hash-change time). The visible symptom was the tab
+        # snapping back to Streams within a second of every click.
         tab_style = """
 <style>
   nav.tabs { margin: 1rem 0 .25rem; border-bottom: 1px solid var(--pico-muted-border-color); }
@@ -1042,22 +1089,13 @@ class Handler(http.server.BaseHTTPRequestHandler):
     margin-bottom: -1px; font-size: .9rem;
   }
   nav.tabs a:hover { color: var(--pico-color); }
-  section.tab { display: none; padding-top: .75rem; }
-  section.tab:target { display: block; }
-  body:not(:has(section.tab:target)) section.tab#tab-streams { display: block; }
-  body:has(#tab-streams:target)  nav.tabs a[href="#tab-streams"],
-  body:has(#tab-downloads:target) nav.tabs a[href="#tab-downloads"],
-  body:has(#tab-misses:target)    nav.tabs a[href="#tab-misses"],
-  body:has(#tab-cached:target)    nav.tabs a[href="#tab-cached"] {
-    color: var(--pico-color);
-    border-bottom-color: var(--pico-primary, #0172ad);
-    font-weight: 600;
-  }
-  body:not(:has(section.tab:target)) nav.tabs a[href="#tab-streams"] {
+  nav.tabs a.active-tab {
     color: var(--pico-color);
     border-bottom-color: var(--pico-primary, #0172ad);
     font-weight: 600;
   }
+  section.tab { display: none; padding-top: .75rem; }
+  section.tab.active-tab { display: block; }
 </style>
 """
@@ -1102,10 +1140,26 @@ class Handler(http.server.BaseHTTPRequestHandler):
             or '<tr><td colspan="4"><em>No misses recorded.</em></td></tr>'
         )
+        # Build the per-row /b/ serve URL once; the cell wraps the
+        # origin string in a link that GETs the cached bytes when
+        # the operator clicks. Same path-encoded form the shim
+        # generates so curl / wget / a browser save all end up
+        # writing the correct output filename.
+        def _serve_url_for(row: sqlite3.Row) -> str:
+            origin = row["url"]
+            token = base64.urlsafe_b64encode(origin.encode("utf-8")).decode("ascii").rstrip("=")
+            # last path segment of the origin, fallback "download" so a
+            # URL ending in / still serves with a usable filename.
+            name = urllib.parse.urlsplit(origin).path.rsplit("/", 1)[-1] or "download"
+            return f"/b/{token}/{urllib.parse.quote(name)}"
         blob_rows = (
             "".join(
                 f"""<tr>
-                <td class="url">{html.escape(b["url"])}</td>
+                <td class="url">
+                  <a href="{_serve_url_for(b)}"
+                     title="Download the cached object">{html.escape(b["url"])}</a>
+                </td>
                 <td>{human_size(b["size"])}</td>
                 <td class="num">{b["hits"]}</td>
                 <td class="num">{b["misses"]}</td>
@@ -1133,12 +1187,22 @@ class Handler(http.server.BaseHTTPRequestHandler):
   <p><small>{nblobs} cached ({used}){full} &middot; {nmisses} pending miss(es)</small></p>
 {tab_style}
   <nav class="tabs"><ul>
+    <li><a href="#tab-cached">Cached ({nblobs})</a></li>
     <li><a href="#tab-streams">Streams ({nstreams})</a></li>
     <li><a href="#tab-downloads">Downloads ({njobs})</a></li>
     <li><a href="#tab-misses">Misses ({nmisses})</a></li>
-    <li><a href="#tab-cached">Cached ({nblobs})</a></li>
   </ul></nav>
+  <section id="tab-cached" class="tab">
+    <figure><table class="striped">
+      <thead><tr>
+        <th>URL</th><th>Size</th><th class="num">Hits</th><th class="num">Misses</th>
+        <th>SHA-256</th><th>Fetched</th><th>Action</th>
+      </tr></thead>
+      <tbody>{blob_rows}</tbody>
+    </table></figure>
+  </section>
   <section id="tab-streams" class="tab">
     <figure><table class="striped">
       <thead><tr>
@@ -1169,16 +1233,6 @@ class Handler(http.server.BaseHTTPRequestHandler):
       </tr></thead>
       <tbody>{miss_rows}</tbody>
     </table></figure>
-  </section>
-  <section id="tab-cached" class="tab">
-    <figure><table class="striped">
-      <thead><tr>
-        <th>URL</th><th>Size</th><th class="num">Hits</th><th class="num">Misses</th>
-        <th>SHA-256</th><th>Fetched</th><th>Action</th>
-      </tr></thead>
-      <tbody>{blob_rows}</tbody>
-    </table></figure>
   </section>"""
     def _stream_progress_cell(self, s: Stream) -> str:

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: withcache
-Version: 0.5.0
+Version: 0.5.2
 Summary: Operator-curated, URL-keyed artifact cache for a small lab (CUDA/ROCm/DOCA/firmware)
 Project-URL: Homepage, https://github.com/safl/withcache
 Author-email: "Simon A. F. Lund" <safl@safl.dk>

@@ -2,7 +2,7 @@
     .name = .withcache_shim,
     // Zig requires a literal here; keep it in lockstep with the project's
     // single source (src/withcache/__init__.py) via `make bump` / `make version-check`.
-    .version = "0.5.0",
+    .version = "0.5.2",
     .fingerprint = 0xd7d96c5ed212ccaa,
     .minimum_zig_version = "0.16.0",
     .paths = .{

@@ -12,6 +12,6 @@ All modules are stdlib-only and self-contained.
 from .client import blob_url, cache_base, is_cached, serve_url
-__version__ = "0.5.0"
+__version__ = "0.5.2"
 __all__ = ["__version__", "blob_url", "cache_base", "is_cached", "serve_url"]

withcache 0.5.0__tar.gz → 0.5.2__tar.gz

withcache 0.5.0tar.gz → 0.5.2tar.gz