calkit-python 0.41.4__py3-none-any.whl → 0.41.5__py3-none-any.whl

calkit/cli/cloud.py

@@ -2,9 +2,6 @@
 
 from __future__ import annotations
 
-import socket
-import time
-import webbrowser
 from typing import Annotated
 
 import typer
@@ -48,79 +45,20 @@ def login(
     """
     from requests.exceptions import HTTPError
 
-    try:
-        calkit.cloud.get("/user")
-        calkit.echo("Authenticated successfully ✅")
-        if not force:
-            return
-    except (ValueError, HTTPError) as e:
-        if isinstance(e, HTTPError) and "401" not in str(e):
-            raise_error(str(e))
-    # Now perform the OAuth device flow
-    try:
-        hostname = socket.gethostname()
-    except Exception:
-        hostname = None
-    try:
-        calkit.echo("Initiating device login flow")
-        resp = calkit.cloud.post(
-            "/login/device",
-            json={"hostname": hostname},
-            auth=False,
-        )
-        device_code = resp["device_code"]
-        verification_uri = resp["verification_uri"]
-        expires_in = int(resp["expires_in"])
-        interval = int(resp["interval"])
-    except Exception as e:
-        raise_error(f"Failed to initiate device login flow: {e}")
-    calkit.echo("Authorize this device by opening this URL:")
-    calkit.echo(verification_uri)
-    calkit.echo("Waiting for authorization")
-    try:
-        webbrowser.open(verification_uri)
-    except Exception:
-        # If auto-open fails, user can still copy-paste the URL.
-        pass
-    deadline = time.monotonic() + expires_in
-    while time.monotonic() < deadline:
+    if not force:
         try:
-            token_resp = calkit.cloud.post(
-                "/login/device/token",
-                json={"device_code": device_code},
-                auth=False,
-            )
-        except Exception as e:
-            txt = str(e)
-            if "Device code has expired" in txt:
-                raise_error(
-                    "Device code has expired; Run 'calkit cloud login' again"
-                )
-            if "Device code not found" in txt:
-                raise_error(
-                    "Device code not found; Run 'calkit cloud login' again"
-                )
-            raise_error(f"Error while polling for device authorization: {e}")
-        access_token = token_resp.get("access_token")
-        if access_token:
-            refresh_token = token_resp.get("refresh_token")
-            try:
-                cfg = calkit.config.read()
-                cfg.access_token = access_token
-                if refresh_token:
-                    cfg.refresh_token = refresh_token
-                cfg.write()
-                calkit.cloud._tokens[calkit.cloud.get_base_url()] = (
-                    access_token
-                )
-            except Exception as e:
-                raise_error(f"Failed to save token in config: {e}")
-            calkit.echo("Logged in successfully ✅")
+            calkit.cloud.get("/user")
+            calkit.echo("Authenticated successfully ✅")
             return
-        sleep_seconds = min(interval, max(0.0, deadline - time.monotonic()))
-        if sleep_seconds > 0:
-            time.sleep(sleep_seconds)
-    raise_error(
-        "Timed out waiting for device authorization; "
-        "Run 'calkit cloud login' again"
-    )
+        except (ValueError, HTTPError) as e:
+            # Any auth failure (no token, 401, 403) falls through to the
+            # device flow so the user can re-authenticate. Other HTTP errors
+            # (e.g. 5xx) are surfaced.
+            if isinstance(e, HTTPError) and not any(
+                code in str(e) for code in ("401", "403")
+            ):
+                raise_error(str(e))
+    try:
+        calkit.cloud.run_device_flow()
+    except calkit.cloud.DeviceLoginError as e:
+        raise_error(str(e))

calkit/cloud.py

@@ -6,8 +6,11 @@ import base64
 import json
 import logging
 import os
+import socket
+import sys
 import threading
 import time
+import webbrowser
 from functools import partial
 from typing import Literal
 
@@ -28,6 +31,123 @@ _refresh_lock = threading.Lock()
 # Seconds before JWT expiry at which we proactively refresh.
 _REFRESH_BUFFER_SECONDS = 60
 
+# Serializes interactive device-login attempts so that, when several
+# concurrent requests all hit an auth failure, only one of them actually
+# prompts the user; the rest wait on the lock and then reuse the freshly
+# minted token. The device-flow's own polling calls use ``auth=False`` so
+# they don't recurse into the auth-retry paths in ``_request``.
+_device_login_lock = threading.Lock()
+
+
+class DeviceLoginError(RuntimeError):
+    """Raised when the OAuth device login flow cannot complete."""
+
+
+def run_device_flow() -> str:
+    """Run the OAuth device login flow and return the new access token.
+
+    On success the token is written to the config file and the in-memory
+    token cache. Raises :class:`DeviceLoginError` on any failure (server
+    error, expired/missing device code, timeout, etc.).
+    """
+    # Serialize concurrent attempts (e.g. multiple fsspec threads all hitting
+    # 403 at the same time): the first thread runs the flow, the rest wait
+    # and then reuse the freshly minted token.
+    base_url = get_base_url()
+    token_before = _tokens.get(base_url)
+    with _device_login_lock:
+        token_after = _tokens.get(base_url)
+        # If the cached token changed while we were waiting on the lock,
+        # another thread just completed a device flow — reuse its result.
+        if token_after is not None and token_after != token_before:
+            return token_after
+        try:
+            hostname = socket.gethostname()
+        except Exception:
+            hostname = None
+        print("Initiating device login flow", flush=True)
+        try:
+            resp = post(
+                "/login/device",
+                json={"hostname": hostname},
+                auth=False,
+            )
+            device_code = resp["device_code"]
+            verification_uri = resp["verification_uri"]
+            expires_in = int(resp["expires_in"])
+            interval = int(resp["interval"])
+        except Exception as e:
+            raise DeviceLoginError(
+                f"Failed to initiate device login flow: {e}"
+            ) from e
+        print("Authorize this device by opening this URL:", flush=True)
+        print(verification_uri, flush=True)
+        print("Waiting for authorization", flush=True)
+        try:
+            webbrowser.open(verification_uri)
+        except Exception:
+            pass
+        deadline = time.monotonic() + expires_in
+        while time.monotonic() < deadline:
+            try:
+                token_resp = post(
+                    "/login/device/token",
+                    json={"device_code": device_code},
+                    auth=False,
+                )
+            except Exception as e:
+                txt = str(e)
+                if "Device code has expired" in txt:
+                    raise DeviceLoginError(
+                        "Device code has expired; "
+                        "Run 'calkit cloud login' again"
+                    ) from e
+                if "Device code not found" in txt:
+                    raise DeviceLoginError(
+                        "Device code not found; "
+                        "Run 'calkit cloud login' again"
+                    ) from e
+                raise DeviceLoginError(
+                    f"Error while polling for device authorization: {e}"
+                ) from e
+            access_token = token_resp.get("access_token")
+            if access_token:
+                refresh_token = token_resp.get("refresh_token")
+                try:
+                    cfg = config.read()
+                    cfg.access_token = access_token
+                    if refresh_token:
+                        cfg.refresh_token = refresh_token
+                    # A stored PAT (``token``) takes priority over
+                    # ``access_token`` in get_token(), so a stale PAT would
+                    # keep being used by future processes and re-trigger
+                    # the device flow every time. The user just
+                    # re-authenticated, so device-flow credentials win.
+                    if getattr(cfg, "token", None) is not None:
+                        cfg.token = None
+                    # A stored DVC token may have been revoked alongside
+                    # the access token that just failed; clear it so the
+                    # next remote-auth check mints a fresh one.
+                    if getattr(cfg, "dvc_token", None) is not None:
+                        cfg.dvc_token = None
+                    cfg.write()
+                    _tokens[base_url] = access_token
+                except Exception as e:
+                    raise DeviceLoginError(
+                        f"Failed to save token in config: {e}"
+                    ) from e
+                print("Logged in successfully ✅", flush=True)
+                return access_token
+            sleep_seconds = min(
+                interval, max(0.0, deadline - time.monotonic())
+            )
+            if sleep_seconds > 0:
+                time.sleep(sleep_seconds)
+        raise DeviceLoginError(
+            "Timed out waiting for device authorization; "
+            "Run 'calkit cloud login' again"
+        )
+
 
 def get_base_url() -> str:
     """Get the API base URL."""
@@ -188,28 +308,92 @@ def _request(
     if base_url is None:
         base_url = get_base_url()
     refresh_attempted = False
+    device_login_attempted = False
+    # We may prompt the user via the device login flow only when stdin and
+    # stdout are TTYs (i.e. not in CI, daemons, or piped subprocesses) and
+    # the user hasn't opted out via the env var.
+    can_prompt = auth and not os.environ.get("CALKIT_NO_INTERACTIVE_LOGIN")
+    if can_prompt:
+        try:
+            can_prompt = sys.stdin.isatty() and sys.stdout.isatty()
+        except Exception:
+            can_prompt = False
     for retry_num in range(max_retries + 1):
+        try:
+            req_headers = get_headers(headers, auth=auth)
+        except ValueError:
+            # No token in config at all. If we can prompt the user, run
+            # the device flow and try again; otherwise re-raise so callers
+            # see the original "no token" error. ``run_device_flow``
+            # serializes concurrent callers via ``_device_login_lock`` and
+            # reuses the freshly minted token, so threads that arrive
+            # mid-flow simply wait their turn rather than re-prompting.
+            if can_prompt and not device_login_attempted:
+                device_login_attempted = True
+                run_device_flow()
+                continue
+            raise
         resp = func(
             base_url + path,
             params=params,
             json=json,
             data=data,
-            headers=get_headers(headers, auth=auth),
+            headers=req_headers,
             **kwargs,
         )
         if resp.status_code == 502 and retry_num < max_retries:
             wait = min(base_delay_seconds * (2**retry_num), max_delay_seconds)
             time.sleep(wait)
             continue
-        # On 401, attempt a token refresh once (only for access_token sessions,
-        # not PATs — _try_refresh returns None when no refresh_token is stored).
-        # get_headers() re-calls get_token() on the next iteration, so it will
-        # automatically pick up the new token stored in _tokens by _try_refresh.
-        if resp.status_code == 401 and auth and not refresh_attempted:
+        # Decide whether this response is a credential rejection (vs. a
+        # permission/authorization failure that happens to also be 403).
+        # 401 is always a credential rejection. For 403, only treat it as
+        # one if the API's ``detail`` identifies it as such — otherwise
+        # we'd hijack legitimate "you can't do that" errors and pop a
+        # browser-based login flow at the user.
+        looks_like_auth_failure = auth and resp.status_code == 401
+        if auth and resp.status_code == 403:
+            try:
+                detail = resp.json().get("detail")
+            except Exception:
+                detail = None
+            looks_like_auth_failure = isinstance(detail, str) and any(
+                s in detail
+                for s in (
+                    "Could not validate credentials",
+                    "Not authenticated",
+                    "Invalid token",
+                    "Token has expired",
+                )
+            )
+        # On credential rejection, attempt a token refresh once.
+        # ``_try_refresh`` returns ``None`` when no refresh token is stored
+        # (e.g. PAT-only sessions). ``get_headers()`` re-calls
+        # ``get_token()`` on the next iteration, so it will automatically
+        # pick up the new token stored in ``_tokens`` by ``_try_refresh``.
+        if looks_like_auth_failure and not refresh_attempted:
             refresh_attempted = True
             new_token = _try_refresh()
             if new_token is not None:
                 continue
+        # If refresh didn't help, fall back to the interactive device login
+        # flow once. This covers both HTTP remotes (where /user/tokens
+        # 401/403s) and ck:// remotes (which go through this same
+        # ``_request`` path). ``run_device_flow`` serializes via
+        # ``_device_login_lock`` and reuses the new token, so concurrent
+        # callers wait rather than each starting their own flow.
+        if (
+            looks_like_auth_failure
+            and can_prompt
+            and not device_login_attempted
+        ):
+            device_login_attempted = True
+            try:
+                run_device_flow()
+            except DeviceLoginError as e:
+                logger.warning("Device login failed: %s", e)
+            else:
+                continue
         try:
             resp.raise_for_status()
         except HTTPError as e:

calkit/tests/cli/test_cloud.py

@@ -62,8 +62,12 @@ def test_cloud_login_device_flow_success(monkeypatch, capsys):
     monkeypatch.setattr(cloud_cli.calkit.cloud, "get", _get)
     monkeypatch.setattr(cloud_cli.calkit.cloud, "post", _post)
     monkeypatch.setattr(cloud_cli.calkit.config, "read", lambda: cfg)
-    monkeypatch.setattr(cloud_cli.webbrowser, "open", lambda _url: True)
-    monkeypatch.setattr(cloud_cli.time, "sleep", lambda _seconds: None)
+    monkeypatch.setattr(
+        cloud_cli.calkit.cloud.webbrowser, "open", lambda _url: True
+    )
+    monkeypatch.setattr(
+        cloud_cli.calkit.cloud.time, "sleep", lambda _seconds: None
+    )
     cloud_cli.login()
     out = capsys.readouterr().out
     assert "Authorize this device by opening this URL:" in out
@@ -114,8 +118,10 @@ def test_cloud_login_force_re_authenticates(monkeypatch, capsys):
     monkeypatch.setattr(cloud_cli.calkit.cloud, "get", _get)
     monkeypatch.setattr(cloud_cli.calkit.cloud, "post", _post)
     monkeypatch.setattr(cloud_cli.calkit.config, "read", lambda: cfg)
-    monkeypatch.setattr(cloud_cli.webbrowser, "open", lambda _url: True)
-    monkeypatch.setattr(cloud_cli.time, "sleep", lambda _s: None)
+    monkeypatch.setattr(
+        cloud_cli.calkit.cloud.webbrowser, "open", lambda _url: True
+    )
+    monkeypatch.setattr(cloud_cli.calkit.cloud.time, "sleep", lambda _s: None)
     cloud_cli.login(force=True)
     out = capsys.readouterr().out
     assert "Logged in successfully" in out
@@ -140,8 +146,10 @@ def test_cloud_login_device_code_expired(monkeypatch):
 
     monkeypatch.setattr(cloud_cli.calkit.cloud, "get", _get)
     monkeypatch.setattr(cloud_cli.calkit.cloud, "post", _post)
-    monkeypatch.setattr(cloud_cli.webbrowser, "open", lambda _url: True)
-    monkeypatch.setattr(cloud_cli.time, "sleep", lambda _s: None)
+    monkeypatch.setattr(
+        cloud_cli.calkit.cloud.webbrowser, "open", lambda _url: True
+    )
+    monkeypatch.setattr(cloud_cli.calkit.cloud.time, "sleep", lambda _s: None)
     with pytest.raises(typer.Exit):
         cloud_cli.login()
 
@@ -164,7 +172,9 @@ def test_cloud_login_device_code_not_found(monkeypatch):
 
     monkeypatch.setattr(cloud_cli.calkit.cloud, "get", _get)
     monkeypatch.setattr(cloud_cli.calkit.cloud, "post", _post)
-    monkeypatch.setattr(cloud_cli.webbrowser, "open", lambda _url: True)
-    monkeypatch.setattr(cloud_cli.time, "sleep", lambda _s: None)
+    monkeypatch.setattr(
+        cloud_cli.calkit.cloud.webbrowser, "open", lambda _url: True
+    )
+    monkeypatch.setattr(cloud_cli.calkit.cloud.time, "sleep", lambda _s: None)
     with pytest.raises(typer.Exit):
         cloud_cli.login()

calkit/tests/test_cloud.py

@@ -238,6 +238,82 @@ def test_request_retries_on_401_with_refresh(monkeypatch):
     assert call_count["n"] == 2
 
 
+def test_request_invalid_credentials_403_triggers_refresh(monkeypatch):
+    """A 403 whose detail says credentials are invalid should be treated
+    like a 401 — refresh attempted, request retried."""
+    base_url = cloud.get_base_url()
+    fresh = _make_jwt(time.time() + 3600)
+    call_count = {"n": 0}
+
+    class Resp403:
+        status_code = 403
+
+        def raise_for_status(self):
+            from requests.exceptions import HTTPError
+
+            raise HTTPError("403")
+
+        def json(self):
+            return {"detail": "Could not validate credentials"}
+
+    class Resp200:
+        status_code = 200
+
+        def raise_for_status(self):
+            pass
+
+        def json(self):
+            return {"ok": True}
+
+    def _fake_get(url, **kwargs):
+        call_count["n"] += 1
+        return Resp403() if call_count["n"] == 1 else Resp200()
+
+    monkeypatch.setattr(cloud.requests, "get", _fake_get)
+    monkeypatch.setitem(cloud._tokens, base_url, fresh)
+    monkeypatch.setattr(cloud, "_try_refresh", lambda: fresh)
+    result = cloud._request("get", "/test", base_url=base_url)
+    assert result == {"ok": True}
+    assert call_count["n"] == 2
+
+
+def test_request_permission_403_does_not_trigger_refresh(monkeypatch):
+    """A 403 that's a real permission denial (e.g. user not allowed to
+    create a project under an org) must surface as an HTTPError, not
+    silently trigger refresh/device login."""
+    base_url = cloud.get_base_url()
+    fresh = _make_jwt(time.time() + 3600)
+    call_count = {"n": 0}
+    refresh_calls = {"n": 0}
+
+    class Resp403Perm:
+        status_code = 403
+
+        def raise_for_status(self):
+            from requests.exceptions import HTTPError
+
+            raise HTTPError("403")
+
+        def json(self):
+            return {"detail": "You are not allowed to create projects here"}
+
+    def _fake_post(url, **kwargs):
+        call_count["n"] += 1
+        return Resp403Perm()
+
+    def _fake_refresh():
+        refresh_calls["n"] += 1
+        return fresh
+
+    monkeypatch.setattr(cloud.requests, "post", _fake_post)
+    monkeypatch.setitem(cloud._tokens, base_url, fresh)
+    monkeypatch.setattr(cloud, "_try_refresh", _fake_refresh)
+    with pytest.raises(Exception):
+        cloud._request("post", "/projects", base_url=base_url)
+    assert call_count["n"] == 1
+    assert refresh_calls["n"] == 0
+
+
 def test_concurrent_refresh_fires_only_once(monkeypatch):
     """Many threads calling get_token() on an expiring JWT should trigger
     exactly one refresh request, not one per thread."""

{calkit_python-0.41.4.dist-info → calkit_python-0.41.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: calkit-python
-Version: 0.41.4
+Version: 0.41.5
 Summary: Reproducibility simplified.
 Project-URL: Homepage, https://calkit.org
 Project-URL: Issues, https://github.com/calkit/calkit/issues

{calkit_python-0.41.4.dist-info → calkit_python-0.41.5.dist-info}/RECORD

@@ -2,7 +2,7 @@ calkit/__init__.py,sha256=mJqFPNUPG6v4rrOXfZzNfjpjAdjOurlEQ9iLsBPzsBA,2602
 calkit/__main__.py,sha256=whqS7I7q_c9004emvKptZ9B9OVn-jgr5kaLaCFKmwa0,112
 calkit/calc.py,sha256=ucTWBssZhDDc585q2R6l5Zb-924vxwGID4KX7K-eUPA,7563
 calkit/check.py,sha256=VVJErHeCzX-bcdRtu0dgMpLLMU7M38SZI_wqyMgdzwg,9080
-calkit/cloud.py,sha256=mudtHkCuCbciQ5xwTjNeqRl0jGBSR-BzxbWq3zd-aSg,7638
+calkit/cloud.py,sha256=65380HbUVEINxXue9YZnbOX5PsnszdgR9ZCli0DR2Wg,15772
 calkit/conda.py,sha256=Jb1Fz3jwkk4SZ0NgoWXd4lf50gEC8d8U87ElrYjdiwk,30752
 calkit/config.py,sha256=tkrdAQU1m3__B9efpYgK6IhtLtS3WWFcVpY2zEQpBio,7573
 calkit/core.py,sha256=6yfW89FJ8N0NkYSUW17C3NEsobtT-yOKWh7ukXNaMQs,27441
@@ -31,7 +31,7 @@ calkit/releases.py,sha256=BNS1K8yYf7YPZpeLQV7qP4twb-4hF0Jk7Zhm2qX8IsM,9838
 calkit/server.py,sha256=GQm1bI5Q1NLFNwQL-iP6j4iWKUpKpP3cLEyfj5IMwe4,22009
 calkit/cli/__init__.py,sha256=pP_1wFuewdUUvEWTtaEcdKblPaSYuTvthQb2Ef08UMo,1921
 calkit/cli/check.py,sha256=RgFCY1xrqY5Hl2iSH7aA2ybyDpYfk7e65HntNjngN3M,49979
-calkit/cli/cloud.py,sha256=3FVvJUqG16I2PWIpcbvnVryK9tpqSK06BwPQBN_kvQs,4040
+calkit/cli/cloud.py,sha256=mMFRRFvo8MrzxQ-B_WTCSI8-erAWnFzgN2Hd0kVvB24,1815
 calkit/cli/config.py,sha256=cTNEM0AmwTPmxWcnXdWp4VdO_073ye74bLcuXSttNsQ,10340
 calkit/cli/core.py,sha256=oICn4rLv9316X5bThD1Wrcc_qdmBHqye8NE4dIwojmk,3031
 calkit/cli/describe.py,sha256=bCq-YPiWSM4nDyi6KJXBPqiGjD2eW3xh9xY2oaAK3LQ,347
@@ -71,7 +71,7 @@ calkit/templates/latex/jfm/upmath.sty,sha256=9nzNixqQd18zVrv0vLBjGjfnc8L19tP_m0b
 calkit/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/test_calc.py,sha256=h-wOUIRqfyi06LTzhY_rS-a1xChZTkmwdEfBybMUM7E,2033
 calkit/tests/test_check.py,sha256=ngRZq1_dSRQoa0oSjcx_QpR94omG9Bpas_h0wqjwrK0,1475
-calkit/tests/test_cloud.py,sha256=WKDaLmmsnSyjgBEQFTaP1VpJhrS44pYY7KLzl_GwvE4,7877
+calkit/tests/test_cloud.py,sha256=583oy2zH0fLexBBB_cmrxCgu7qsouBe7tKY-kkbzhXE,10227
 calkit/tests/test_conda.py,sha256=t-Oy1mL3Vb5njj_t3LQ8HwMhsmLN64HAzSlebnN1A9s,14204
 calkit/tests/test_core.py,sha256=MDSQCsUI4RkZ6VZGWhDELdebZujLuLn8o6BLBSaBb5w,4607
 calkit/tests/test_dependencies.py,sha256=HskXLzbvvRJz2TXnKPpPAo9lPhoZGYQFy4BmEF31nvk,11139
@@ -92,7 +92,7 @@ calkit/tests/test_releases.py,sha256=-eig7SpntQKjHLBRbHv0J-pX4ecr3HO5dukuvfZQPIo
 calkit/tests/test_templates.py,sha256=RN4RIgmuFlmFYQFgfJUYS-KaLmie8fnWzmfg5Ay1egk,430
 calkit/tests/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 calkit/tests/cli/test_check.py,sha256=TPdG1R-h7Byinsln9n3WegRuBWN0bHltuRcOROCZhwQ,6767
-calkit/tests/cli/test_cloud.py,sha256=cN9BSl9JuYWxp4MQQh9scKrndTh9OGhJPQLV5IL-Nq0,5826
+calkit/tests/cli/test_cloud.py,sha256=ZWTExR1R5V_CL6EO2QPVk-_iZrPLtYTbUkQwyH8ZHKc,6000
 calkit/tests/cli/test_config.py,sha256=Tl4LWfi81eQo6fUgJsoZRNPj_LfkKH-s42HRg5Mxh4c,2571
 calkit/tests/cli/test_import.py,sha256=e2BToVPebf4NalFQuIgyTNJHwbc9VMc6AYO-FAhYbQ0,663
 calkit/tests/cli/test_latex.py,sha256=SqDbenoFtnsgkfqFjR2Jhw6TJsYQBtLqIGjM3PJmddc,3604
@@ -117,23 +117,23 @@ calkit/tests/models/test_pipeline.py,sha256=AJsMAX4928U3_Omt0_8K96U5LU_KoNErgpHe
 calkit/agent_skills/add-pipeline-stage/SKILL.md,sha256=kpYYb-rJsS4B9p1Ub3gL21irCG5ZZ4DvWZpdJeEwPZk,3772
 calkit/agent_skills/conventions/SKILL.md,sha256=nAM2FjSMk6ED56Dr5zh2bL_dhfzDra-h2ZgzHU7ruS4,9524
 calkit/agent_skills/create-pipeline/SKILL.md,sha256=2FGw1iDQVRk5FUq79GP3lPdgvgof2Wi1O9O-abGGtgs,5422
-calkit_python-0.41.4.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/package.json,sha256=INxx8QhvSl7KP6yL7A7-m2-FIsnB__mYEWG_Eq5RP-c,6651
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=6w0b5y8LztEv2tErajJ5d39yBryld02crX0CG3zZFNs,6509
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.65469af996e7a96aa983.js,sha256=ZUaa-ZbnqWqpgxIpcQcRX7auvhOBkPH2YHNID5udGQs,8737
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
-calkit_python-0.41.4.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
-calkit_python-0.41.4.dist-info/METADATA,sha256=W5T03nVqGhjZo7IaJb097fUXquL7WQJKBDOOJ9aBJKU,12070
-calkit_python-0.41.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-calkit_python-0.41.4.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
-calkit_python-0.41.4.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
-calkit_python-0.41.4.dist-info/RECORD,,
+calkit_python-0.41.5.data/data/etc/jupyter/jupyter_server_config.d/calkit.json,sha256=CWrZP--JDGz8fsvbAlKr_duTL1vDriGT48SL1YCtkY0,81
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/package.json,sha256=INxx8QhvSl7KP6yL7A7-m2-FIsnB__mYEWG_Eq5RP-c,6651
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/schemas/calkit/package.json.orig,sha256=6w0b5y8LztEv2tErajJ5d39yBryld02crX0CG3zZFNs,6509
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/schemas/calkit/plugin.json,sha256=YSpIrwpwB-lQBk9Mwv-npedWTOOZreO6nlWZhqlWyGI,840
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/502.9a2c5772a15466e923ef.js,sha256=mixXcqFUZukj7_jQVxHTavsYl7cdZv83sEe4phJgkh0,59893
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/695.2c41003a452d43d2b358.js,sha256=LEEAOkUtQ9KzWEHn-QFv5yGi70B-sBOnrvztzHr0Shw,223
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/867.a42a046aa5108f54f8fb.js,sha256=pCoEaqUQj1T4-zAc9SUd__9ZGm7uL2wHQve2xwL89NI,8156
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/909.e3f9cc3408834a7fdcc3.js,sha256=4_nMNAiDSn_cw7UjIHEwone4fizrvqrqSgbwUWvjmoU,114571
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js,sha256=n_a0yu_gE7l6fauyoXXv9BZ7ZEYt2387mTfs7CbLcs4,51939
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/946.050af2abf7845cfbdbd2.js.LICENSE.txt,sha256=eNJ8gc9n9IF8nW1d9sI9niuHstYzjNz5vqXx9UgWSPc,249
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/b2f1c3efe70cb539d121.png,sha256=svHD7-cMtTnRITFwugwsVaB9nZ-h8A61ose8z32HiRE,24850
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/remoteEntry.65469af996e7a96aa983.js,sha256=ZUaa-ZbnqWqpgxIpcQcRX7auvhOBkPH2YHNID5udGQs,8737
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/style.js,sha256=r89Jlk5v1drcwhCpv9FnC3Jig_JH4k24kZNIvxh6Htk,149
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/static/third-party-licenses.json,sha256=2BGdItLJwO3fAopLl4eJvp26TEwuscYC0-yFaF-LaLU,13683
+calkit_python-0.41.5.data/data/share/jupyter/labextensions/calkit/install.json,sha256=DK9d8G-q-rMVlcT3rAeGIyo3REWKw6FySBZceLU9yaw,187
+calkit_python-0.41.5.dist-info/METADATA,sha256=nlqF81x6hGAVq-2v7BjeUGAcOdkFZUyUpV73jXYywp8,12070
+calkit_python-0.41.5.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+calkit_python-0.41.5.dist-info/entry_points.txt,sha256=2iQBBzjTAOdk66CwS-f3ecXXW5DjUqkG1KBRj8mHI1I,133
+calkit_python-0.41.5.dist-info/licenses/LICENSE,sha256=9ZamCaSUTZk9rcrnf-sWFKLOHr3ws-S_dgKMegW4nw8,1056
+calkit_python-0.41.5.dist-info/RECORD,,