dlboard 0.1.3__tar.gz

dlboard-0.1.3/.gitignore

@@ -0,0 +1,21 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+*.env
+.data/
+lightning-logs/
+_scratch_test.py
+.coverage
+
+# Output of the docs-screenshot check (see dlboard/tests/docs_screenshots_test.py)
+screenshot-diffs/
+
+# Claude Code's own local settings/session state -- developer-machine-local, not project config.
+.claude/

dlboard-0.1.3/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2025 David Langerman
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

dlboard-0.1.3/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.5
+Name: dlboard
+Version: 0.1.3
+Summary: A pytorch_lightning-compatible logger client for dlboard, a free, self-hosted experiment-tracking server.
+Project-URL: Changelog, https://github.com/dlangerm/dlboard/blob/main/CHANGELOG.md
+Project-URL: Documentation, https://github.com/dlangerm/dlboard#readme
+Project-URL: Homepage, https://github.com/dlangerm/dlboard
+Project-URL: Issues, https://github.com/dlangerm/dlboard/issues
+Project-URL: Repository, https://github.com/dlangerm/dlboard
+Author-email: David Langerman <dev.onyxzerosoftware@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: experiment-tracking,logging,machine-learning,mlops,pytorch-lightning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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 :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: coolname>=5.0.0
+Requires-Dist: dltype>=0.16.0
+Requires-Dist: numpy>=2.2.0
+Requires-Dist: pendulum>=3.2.0
+Requires-Dist: pillow>=12.3.0
+Requires-Dist: pydantic-settings>=2.14.2
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: requests>=2.32.0
+Requires-Dist: structlog>=26.1.0
+Requires-Dist: typing-extensions>=4.12.0
+Provides-Extra: lightning
+Requires-Dist: pytorch-lightning>=2.6.5; extra == 'lightning'
+Provides-Extra: server
+Requires-Dist: dlboard-server; extra == 'server'
+Description-Content-Type: text/markdown
+
+# dlboard
+
+A `pytorch_lightning`-compatible logger client for [dlboard](https://github.com/dlangerm/dlboard), a
+free, self-hosted ML experiment-tracking server. This package ships metrics, hyperparameters, and
+artifacts from a training script to a running dlboard server over a REST API.
+
+```python
+from dlboard.client.dlboard_logger import DLBoardLogger
+
+logger = DLBoardLogger.from_names("my-project", "my-experiment", "a description")
+trainer = pl.Trainer(logger=logger)
+```
+
+You'll also need a dlboard server to point it at — either `pip install dlboard[server]` for a
+single-machine setup, or a shared deployment your team already runs. See the
+[project README](https://github.com/dlangerm/dlboard#readme) for the full picture, and
+[docs/client.md](https://github.com/dlangerm/dlboard/blob/main/docs/client.md) for logger setup,
+authentication, and logging custom artifact types.

dlboard-0.1.3/README.md

@@ -0,0 +1,18 @@
+# dlboard
+
+A `pytorch_lightning`-compatible logger client for [dlboard](https://github.com/dlangerm/dlboard), a
+free, self-hosted ML experiment-tracking server. This package ships metrics, hyperparameters, and
+artifacts from a training script to a running dlboard server over a REST API.
+
+```python
+from dlboard.client.dlboard_logger import DLBoardLogger
+
+logger = DLBoardLogger.from_names("my-project", "my-experiment", "a description")
+trainer = pl.Trainer(logger=logger)
+```
+
+You'll also need a dlboard server to point it at — either `pip install dlboard[server]` for a
+single-machine setup, or a shared deployment your team already runs. See the
+[project README](https://github.com/dlangerm/dlboard#readme) for the full picture, and
+[docs/client.md](https://github.com/dlangerm/dlboard/blob/main/docs/client.md) for logger setup,
+authentication, and logging custom artifact types.

dlboard-0.1.3/dlboard/__init__.py

@@ -0,0 +1 @@
+"""DLBoard main entrypoint."""

dlboard-0.1.3/dlboard/_batching.py

@@ -0,0 +1,153 @@
+"""
+Drain a queue into batches and ship each one somewhere that can fail.
+
+Shared by the client's metric/artifact shipping processes (`dlboard_logger.py`) and every blob
+artifact store's ref-ingest thread (`plugins/data_stores/_blob_store.py`) -- both batch items off a
+queue towards a destination that can fail transiently (a server, a locked database), and both must
+never lose a batch to a failure that a retry would have survived.
+"""
+
+from __future__ import annotations
+
+import logging
+import random
+import time
+from queue import Empty
+from typing import TYPE_CHECKING, NamedTuple, Protocol, TypeVar
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from multiprocessing.synchronize import Event as MPEvent
+
+_log = logging.getLogger(__name__)
+
+T = TypeVar("T")
+"""Pre-3.12 `TypeVar` style (the client's floor is 3.10): the kind of item `ship_batches` moves."""
+
+_T_co = TypeVar("_T_co", covariant=True)
+"""`Receiver`'s own type parameter -- covariant, since it only ever appears in a return position."""
+
+_MAX_BACKOFF_FACTOR: int = 6
+"""Caps retry backoff at `wait_sec * 2**6` (64x) -- a dead server shouldn't make the next retry wait
+arbitrarily long, just long enough to stop hammering it."""
+
+_JITTER_FRACTION: float = 0.25
+"""+/- this fraction of the computed backoff, so many shipping processes retrying the same outage
+don't all land on the server in lockstep."""
+
+
+class BatchParams(NamedTuple):
+    """How `ship_batches` batches, plus the events it reports through."""
+
+    flush_size: int
+    wait_sec: float
+    ready: MPEvent
+    flushed: MPEvent
+
+
+class Receiver(Protocol[_T_co]):
+    """The one queue method `ship_batches` needs -- both `multiprocessing` and `queue` queues have it."""
+
+    def get(self, block: bool = True, timeout: float | None = None) -> _T_co: ...  # noqa: FBT001, FBT002
+
+
+def _split_oversized(
+    ship: Callable[[list[T]], None],
+    batch: list[T],
+    *,
+    is_permanent: Callable[[Exception], bool],
+    is_oversized: Callable[[Exception], bool],
+) -> list[T]:
+    """
+    Ship `batch` in two halves, recursing into a half that's still too large, down to one item each.
+
+    Returns whatever's left unshipped: a permanently-rejected chunk is dropped (and so absent from
+    the result), but one that fails for some other transient reason comes back in it, for
+    `ship_batches` to retry (at its own pace, with backoff) on a later pass -- never lost, and never
+    re-sent on top of a chunk that already landed. A chunk of exactly one item that's still too
+    large has nothing left to split into, so it's treated as permanent either way: resending the
+    same single oversized item can never succeed.
+    """
+    mid = len(batch) // 2
+    leftover: list[T] = []
+    for chunk in (batch[:mid], batch[mid:]):
+        try:
+            ship(chunk)
+        except Exception as exc:  # noqa: BLE001 -- nothing may kill the shipping loop
+            if is_oversized(exc) and len(chunk) > 1:
+                leftover.extend(
+                    _split_oversized(ship, chunk, is_permanent=is_permanent, is_oversized=is_oversized)
+                )
+            elif is_permanent(exc):
+                _log.exception("A sub-batch of %s was rejected, dropping it", len(chunk))
+            else:
+                leftover.extend(chunk)  # transient; retry (with backoff) on a later pass
+    return leftover
+
+
+def ship_batches(
+    q: Receiver[T | None],
+    ship: Callable[[list[T]], None],
+    params: BatchParams,
+    *,
+    is_permanent: Callable[[Exception], bool],
+    is_oversized: Callable[[Exception], bool] = lambda _exc: False,
+) -> None:
+    """
+    Forever drain `q` into batches, shipping one once it's full, `wait_sec` old, or a flush asks for it.
+
+    A batch whose failure `is_permanent` is dropped: resending it can never succeed, and keeping it
+    would wedge every later item behind it. A batch whose failure `is_oversized` is instead split in
+    half and each half attempted once right away (`_split_oversized`) -- resending the exact same
+    oversized batch could never succeed either, but a batch that only grew this large because the
+    server was briefly unreachable shouldn't be dropped just because it doesn't fit in one request
+    once it's reachable again. Any other failure is transient -- the batch is kept, keeps growing
+    with whatever arrives meanwhile, and is retried after an exponentially growing backoff (reset
+    the moment a batch ships successfully) rather than hammering a server that's still down. A
+    `None` queued in place of an item requests a flush, acknowledged (`params.flushed`) only once
+    everything queued before it is gone. Returns once `q` itself is closed (e.g. at interpreter
+    shutdown) -- nothing more can ever arrive through it.
+    """
+    params.ready.set()
+    batch: list[T] = []
+    flush_requested = False
+    last_attempt = time.perf_counter()
+    consecutive_failures = 0
+    while True:
+        try:
+            item = q.get(timeout=params.wait_sec / 10)
+            if item is None:
+                flush_requested = True
+            else:
+                batch.append(item)
+        except Empty:
+            pass
+        except (OSError, ValueError):  # a closed `multiprocessing` queue raises one or the other
+            return
+        due = flush_requested or len(batch) >= params.flush_size
+        if batch and (due or time.perf_counter() - last_attempt > params.wait_sec):
+            try:
+                ship(batch)
+                batch = []
+                consecutive_failures = 0
+            except Exception as exc:  # noqa: BLE001 -- nothing may kill the shipping loop
+                if is_oversized(exc) and len(batch) > 1:
+                    _log.warning("A batch of %s was too large for one request, splitting it", len(batch))
+                    batch = _split_oversized(
+                        ship, batch, is_permanent=is_permanent, is_oversized=is_oversized
+                    )
+                    consecutive_failures = 0
+                elif is_permanent(exc):
+                    _log.exception("A batch of %s was rejected, dropping it", len(batch))
+                    batch = []
+                    consecutive_failures = 0
+                else:
+                    _log.exception("Failed to ship a batch of %s, retrying", len(batch))
+                    backoff = params.wait_sec * 2 ** min(consecutive_failures, _MAX_BACKOFF_FACTOR)
+                    jitter = backoff * _JITTER_FRACTION
+                    time.sleep(backoff + random.uniform(-jitter, jitter))
+                    consecutive_failures += 1
+            last_attempt = time.perf_counter()
+        if flush_requested and not batch:
+            flush_requested = False
+            params.flushed.set()

dlboard-0.1.3/dlboard/_compat.py

@@ -0,0 +1,31 @@
+"""
+Backports for stdlib `typing`/`enum` members not available on the client's floor (Python 3.10).
+
+Nothing here is dlboard-specific; it exists only because the client supports 3.10+ while the
+syntax/stdlib members below landed later. Every model/client module that needs one of these
+imports it from here instead of `enum` directly, so there's exactly one place that cares which
+Python version is actually running.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # Pyright always sees the real `enum.StrEnum` -- this repo's own dev/CI env always has 3.12+.
+    # The try/except below is the runtime-only fallback, for an actual 3.10/3.11 interpreter.
+    from enum import StrEnum
+else:
+    try:
+        from enum import StrEnum
+    except ImportError:  # Python < 3.11 (PEP 663 landed in 3.11)
+        from enum import Enum
+
+        class StrEnum(str, Enum):
+            """A `str`-valued `Enum` whose `str()` is its value, not `ClassName.MEMBER`."""
+
+            def __str__(self) -> str:
+                return str(self.value)
+
+
+__all__ = ["StrEnum"]

dlboard-0.1.3/dlboard/_identity.py

@@ -0,0 +1,48 @@
+"""
+Best-effort resolution of "who is running this" for attribution purposes.
+
+This is an identity helper, not authentication -- nothing here is a security boundary, and nothing
+here proves a caller actually is who they claim. It exists so a local, single-user dlboard install
+can attribute projects/experiments/runs to *someone* with zero configuration, the same way `git`
+picks up `user.name` from the environment. Used by both the client (`dlboard.client`, to label
+what it logs) and the server (schema migrations, to pick a name for the one-time bootstrap admin).
+"""
+
+from __future__ import annotations
+
+import getpass
+
+from pydantic_settings import BaseSettings
+from structlog.stdlib import get_logger
+
+_log = get_logger(__name__)
+
+ANONYMOUS: str = "anonymous"
+
+
+class _IdentitySettings(BaseSettings):
+    """Reads the `DLBOARD_USER` env var `resolve_username` checks first."""
+
+    dlboard_user: str = ""
+
+
+def resolve_username() -> str:
+    """
+    Resolve a username via a best-effort chain: the `DLBOARD_USER` env var, then the OS login name, then `"anonymous"`.
+
+    Every step is wrapped so a failure (e.g. `getpass.getuser()` raising in a sandboxed container
+    with no passwd entry) falls through to the next step instead of raising.
+    """
+    env_value = _IdentitySettings().dlboard_user.strip()
+    if env_value:
+        return env_value
+
+    try:
+        os_username = getpass.getuser().strip()
+    except Exception:  # noqa: BLE001
+        _log.debug("Could not resolve an OS username, falling back to %s", ANONYMOUS)
+    else:
+        if os_username:
+            return os_username
+
+    return ANONYMOUS

dlboard-0.1.3/dlboard/_mp_context.py

@@ -0,0 +1,15 @@
+"""
+Shared multiprocessing context for dlboard's background worker processes.
+
+`DLBoardLogger` (client-side metric/artifact shipping) and `BlobArtifactStore` (server-side blob
+writes) each spawn a worker process off a `multiprocessing.Queue`; both need the same "spawn"
+context (never "fork", which can deadlock a process that already has threads running -- both of
+these do, e.g. Flask's/Dash's request-handling threads on the server side). Sharing one context
+instance keeps that choice in exactly one place instead of two independent literal `"spawn"` calls.
+"""
+
+from __future__ import annotations
+
+from multiprocessing import get_context
+
+SPAWN_CONTEXT = get_context("spawn")

dlboard-0.1.3/dlboard/_version.py

@@ -0,0 +1,17 @@
+"""
+The single source of dlboard's version.
+
+Both `client/pyproject.toml` and `server/pyproject.toml` read `__version__` from here via hatch's
+dynamic `[tool.hatch.version]` (see their own `path` setting), instead of each hardcoding its own
+`version` field -- which is how the two distributions drifted out of lockstep before this existed:
+nothing kept `dlboard`'s version and `dlboard-server`'s `dlboard==...` pin pointed at the same
+release. Bump this one file to cut a release; neither `pyproject.toml`'s `version` is ever edited
+directly.
+
+Also read at runtime -- `Identity.server_version` (see `dlboard._wire`) is what a client's `whoami`
+handshake actually sees.
+"""
+
+# No type annotation -- hatchling's default `regex` version source (`[tool.hatch.version]` in both
+# `pyproject.toml`s) matches `__version__ *= *"..."` literally and wouldn't see this past a `: str`.
+__version__ = "0.1.3"