picolet 0.0.1__tar.gz

picolet-0.0.1/.gitignore

@@ -0,0 +1,34 @@
+# Build output
+target/
+build/
+build-*/
+*.exe
+*.pyc
+__pycache__/
+
+# Frontend build outputs (Vite dist/) inside examples/
+examples/*/dist/
+
+# Cached runtime artifacts downloaded by `picolet build`
+.picolet-cache/
+
+# Dependencies / caches
+node_modules/
+.venv/
+.uv-cache/
+
+# Editor
+.vscode/
+.idea/
+*.swp
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Build-hook materialised resources (hatch_build.py copies these in
+# from sibling workspace packages; checked-in copies would drift).
+packages/picolet/picolet/_bridge/picolet-bridge.js
+packages/picolet/picolet/_runtime_data/sbom/runtime.toml
+packages/picolet/picolet/_runtime_data/mbm.toml
+packages/picolet/picolet/_runtime_data/RUNTIME_TAG

picolet-0.0.1/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.4
+Name: picolet
+Version: 0.0.1
+Summary: Compile Python programs to small self-contained native binaries via MicroPython
+Project-URL: Homepage, https://github.com/andrewleech/picolet
+Project-URL: Source, https://github.com/andrewleech/picolet
+Project-URL: Issues, https://github.com/andrewleech/picolet/issues
+Author-email: Andrew Leech <andrew@alelec.net>
+License: MIT
+Keywords: binary,bundler,freeze,lvgl,micropython,webview
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Requires-Dist: mpremote
+Provides-Extra: testing
+Requires-Dist: pillow>=10.0; extra == 'testing'
+Requires-Dist: playwright>=1.40; extra == 'testing'
+Requires-Dist: websockets>=12.0; extra == 'testing'
+Description-Content-Type: text/markdown
+
+# Picolet
+
+Compile a Python program into a small self-contained native executable. Like PyInstaller, but the binary is hundreds of kilobytes rather than tens of megabytes, starts in milliseconds, and has no runtime Python dependency on the host.
+
+## The shape of it
+
+A Picolet binary is one file. Inside:
+
+- A trimmed MicroPython interpreter (~410–650 KB depending on renderer).
+- Your application's `.py` code, compiled to bytecode and frozen into the binary.
+- Optional bundled assets (HTML, fonts, images, schemas) as a read-only ROM filesystem appended to the executable.
+- Optionally: a GUI renderer (system webview or native LVGL) for HTML/JS or native UIs.
+
+The result runs on any matching-OS/arch machine without installing Python.
+
+## Three ways to use it
+
+### 1. Bundle a single CLI script
+
+The simplest case:
+
+```bash
+picolet build hello.py
+./hello                # Linux  ≈ 647 KB
+./hello.exe            # Windows ≈ 409 KB
+```
+
+`hello.py` becomes a self-contained executable. Sub-second startup. No `python` interpreter needed on the host machine. Roughly 20–50× smaller than the equivalent PyInstaller bundle, with no first-launch unpacking delay.
+
+### 2. Manifest-driven build
+
+For multi-module apps, drive the build from a MicroPython `manifest.py`:
+
+```python
+# manifest.py
+require("argparse")                   # frozen micropython-lib module
+require("typing")
+freeze("./src", "main.py")            # your entry
+freeze("./src/lib", "utils.py")       # additional modules
+freeze("./src/lib", "data_model.py")
+```
+
+```bash
+picolet build --manifest manifest.py
+```
+
+The manifest is the canonical MicroPython mechanism for declaring what's frozen into a build. Picolet uses it directly — everything declared is included.
+
+Medium-term: romfs contents (HTML, fonts, etc.) declared in the same manifest, per upstream evolution.
+
+### 3. GUI application
+
+Add a `picolet.toml` to pick a renderer and bundle UI assets:
+
+```toml
+[app]
+name = "my-app"
+entry = "src/main.py"
+
+[ui]
+renderer = "webview"            # or "lvgl" for native
+root = "ui"
+
+[window]
+title = "My App"
+size = [900, 600]
+
+[romfs]
+include = ["ui", "assets"]
+```
+
+```bash
+picolet build
+```
+
+For Vue or other JS framework frontends:
+
+```toml
+[ui.frontend]
+framework = "vue"               # builds Vite output into romfs automatically
+```
+
+The IPC bridge is set up automatically:
+
+```javascript
+// JS side
+await window.picolet.invoke('list_items', { filter: 'active' });
+window.picolet.on('progress', e => bar.update(e.pct));
+```
+
+```python
+# Python side
+@picolet.command
+async def list_items(args):
+    return [...]
+```
+
+Four worked examples under `examples/` (`pydfu`, `notes`, `config-editor`, `dashboard`) demonstrate the patterns end-to-end, each with a distinct visual aesthetic.
+
+## Caveats
+
+Read these before adopting.
+
+- **MicroPython, not CPython.** The standard library subset is smaller. Pure-Python code using `os`, `sys`, `json`, `re`, `time`, `asyncio`, `struct`, `io` etc. typically works. Code that depends on C extensions (numpy, pandas, Pillow, lxml, etc.) does not. Picolet cannot make a CPython library "just work" — it would have to be ported or replaced with a MicroPython equivalent.
+
+- **`micropython-lib` fills most stdlib gaps.** Modules like `argparse`, `pathlib`, `dataclasses`, `typing`, `unittest` are available via [micropython-lib](https://github.com/micropython/micropython-lib) and are declared with `require("name")` in the manifest.
+
+- **Custom C modules are straightforward.** A Picolet binary is a MicroPython build under the hood, so any C module written against the standard MicroPython API works. Drop a directory under `user_c_modules/` and reference it in the manifest. Once [upstream PR #18229](https://github.com/micropython/micropython/pull/18229) lands in the fork, `c_module("./path/to/mymodule")` can declare it directly in the manifest.
+
+- **Python C-API extensions (CPython `.so`/`.pyd`) do NOT work.** MicroPython's runtime is binary-incompatible with CPython. Write a MicroPython C module instead.
+
+- **Async semantics differ slightly.** MicroPython's `asyncio` is a subset of CPython's. Coroutines, tasks, queues, locks, `gather`, `wait_for` work; `asyncio.run` with policies, debug mode, the `loop.add_signal_handler` interface, and some niche APIs don't. Most app code is unaffected.
+
+- **First-class platform support is Linux x64 and Windows x64.** macOS (Intel + Apple Silicon) is source-complete but requires GitHub Actions CI for native builds — local cross-compile from Linux is not supported. ARM Linux and mobile platforms are on the backlog.
+
+See [docs/caveats.md](docs/caveats.md) for a full catalogue.
+
+## Toolchain expectations
+
+- The `picolet` CLI runs on Linux, macOS, or Windows (host).
+- Building Windows binaries from Linux uses [`dockcross`](https://github.com/dockcross/dockcross); Docker is required for that path.
+- Building macOS binaries uses GitHub Actions runners (`macos-13` Intel, `macos-14` Apple Silicon).
+- Node.js + npm are required only when building Vue/React frontends.
+
+## Getting started
+
+Install the CLI. `uv tool install` is the recommended path (no separate
+package manager needed if you already use `uv`); `pipx` is the fallback
+for environments without `uv`. Plain `pip install` is deliberately not
+listed — most modern distros (PEP 668) block it system-wide.
+
+```bash
+uv tool install picolet-cli                       # recommended
+# or:
+pipx install picolet-cli                          # fallback
+
+picolet init my-app --template hello-cli          # see --list-templates for the full set
+cd my-app
+picolet dev                                        # live rebuild on file changes
+picolet build                                      # produce target/<os-arch>/my-app[.exe]
+```
+
+Templates: `hello-cli`, `hello-webview`, `hello-lvgl`, `hello-vue`, `pydfu`, `notes`, `config-editor`, `dashboard`.
+
+## Examples gallery
+
+<table>
+  <tr>
+    <td align="center">
+      <a href="examples/pydfu/">
+        <img src="examples/pydfu/screenshots/device-list-populated.png" alt="pydfu screenshot" />
+      </a>
+      <br>
+      <strong>pydfu</strong><br>
+      DFU firmware flasher (industrial control-panel aesthetic)
+    </td>
+    <td align="center">
+      <a href="examples/notes/">
+        <img src="examples/notes/screenshots/list-populated.png" alt="notes screenshot" />
+      </a>
+      <br>
+      <strong>notes</strong><br>
+      Markdown notes (editorial / refined)
+    </td>
+  </tr>
+  <tr>
+    <td align="center">
+      <a href="examples/config-editor/">
+        <img src="examples/config-editor/screenshots/edit-toml.png" alt="config-editor screenshot" />
+      </a>
+      <br>
+      <strong>config-editor</strong><br>
+      Schema-driven TOML/YAML/JSON editor (brutalist terminal)
+    </td>
+    <td align="center">
+      <a href="examples/dashboard/">
+        <img src="examples/dashboard/screenshots/full-dashboard.png" alt="dashboard screenshot" />
+      </a>
+      <br>
+      <strong>dashboard</strong><br>
+      Live system metrics (data-dense)
+    </td>
+  </tr>
+</table>
+
+See [docs/examples.md](docs/examples.md) for a longer tour of each.
+
+## Renderers
+
+| Renderer | Backed by | Use case | Binary size (typical) |
+|---|---|---|---|
+| (none) | — | CLI tool, no UI | ~647 KB Linux / ~409 KB Windows |
+| `webview` | WebKitGTK 4.1 (Linux), WebView2 (Windows), WKWebView (macOS) | HTML/CSS/JS frontend | ~710 KB Linux / ~525 KB Windows |
+| `lvgl` | [`lv_binding_micropython`](https://github.com/lvgl/lv_binding_micropython) + SDL2 | Native widgets, zero system UI deps | ~1.84 MB Linux / ~2.05 MB Windows |
+
+## Repository layout
+
+```
+picolet/
+├── packages/
+│   ├── picolet-cli/         # picolet init|dev|build|run|test
+│   ├── picolet-runtime/     # the MicroPython runtime + variants + user_c_modules
+│   ├── picolet-bridge-js/   # JS shim: window.picolet.invoke(...)
+│   ├── picolet-templates/   # `picolet init --template <name>` starter packs
+│   └── picolet-testing/     # AppHarness for autonomous test/screenshot
+├── examples/              # four worked example apps
+├── tests/                 # per-phase test suites
+└── docs/                  # architecture, caveats, examples, CLI reference
+```
+
+## More
+
+- [Getting started](docs/getting-started.md) — step-by-step tutorial
+- [`manifest.py` guide](docs/manifest.md) — declaring frozen modules + `require()` from `micropython-lib` and community packages
+- [Architecture](docs/architecture.md) — design decisions
+- [Caveats](docs/caveats.md) — MicroPython compatibility reference
+- [Examples tour](docs/examples.md) — what each example app demonstrates
+- [CLI reference](docs/cli-reference.md) — every `picolet` subcommand
+- [SBOM](docs/sbom.md) — supply-chain documentation
+- [History](docs/history/) — phase artefacts and version-specific specs/plans/audits
+
+## License
+
+MIT throughout. See [LICENSE](LICENSE).

picolet-0.0.1/README.md

@@ -0,0 +1,224 @@
+# Picolet
+
+Compile a Python program into a small self-contained native executable. Like PyInstaller, but the binary is hundreds of kilobytes rather than tens of megabytes, starts in milliseconds, and has no runtime Python dependency on the host.
+
+## The shape of it
+
+A Picolet binary is one file. Inside:
+
+- A trimmed MicroPython interpreter (~410–650 KB depending on renderer).
+- Your application's `.py` code, compiled to bytecode and frozen into the binary.
+- Optional bundled assets (HTML, fonts, images, schemas) as a read-only ROM filesystem appended to the executable.
+- Optionally: a GUI renderer (system webview or native LVGL) for HTML/JS or native UIs.
+
+The result runs on any matching-OS/arch machine without installing Python.
+
+## Three ways to use it
+
+### 1. Bundle a single CLI script
+
+The simplest case:
+
+```bash
+picolet build hello.py
+./hello                # Linux  ≈ 647 KB
+./hello.exe            # Windows ≈ 409 KB
+```
+
+`hello.py` becomes a self-contained executable. Sub-second startup. No `python` interpreter needed on the host machine. Roughly 20–50× smaller than the equivalent PyInstaller bundle, with no first-launch unpacking delay.
+
+### 2. Manifest-driven build
+
+For multi-module apps, drive the build from a MicroPython `manifest.py`:
+
+```python
+# manifest.py
+require("argparse")                   # frozen micropython-lib module
+require("typing")
+freeze("./src", "main.py")            # your entry
+freeze("./src/lib", "utils.py")       # additional modules
+freeze("./src/lib", "data_model.py")
+```
+
+```bash
+picolet build --manifest manifest.py
+```
+
+The manifest is the canonical MicroPython mechanism for declaring what's frozen into a build. Picolet uses it directly — everything declared is included.
+
+Medium-term: romfs contents (HTML, fonts, etc.) declared in the same manifest, per upstream evolution.
+
+### 3. GUI application
+
+Add a `picolet.toml` to pick a renderer and bundle UI assets:
+
+```toml
+[app]
+name = "my-app"
+entry = "src/main.py"
+
+[ui]
+renderer = "webview"            # or "lvgl" for native
+root = "ui"
+
+[window]
+title = "My App"
+size = [900, 600]
+
+[romfs]
+include = ["ui", "assets"]
+```
+
+```bash
+picolet build
+```
+
+For Vue or other JS framework frontends:
+
+```toml
+[ui.frontend]
+framework = "vue"               # builds Vite output into romfs automatically
+```
+
+The IPC bridge is set up automatically:
+
+```javascript
+// JS side
+await window.picolet.invoke('list_items', { filter: 'active' });
+window.picolet.on('progress', e => bar.update(e.pct));
+```
+
+```python
+# Python side
+@picolet.command
+async def list_items(args):
+    return [...]
+```
+
+Four worked examples under `examples/` (`pydfu`, `notes`, `config-editor`, `dashboard`) demonstrate the patterns end-to-end, each with a distinct visual aesthetic.
+
+## Caveats
+
+Read these before adopting.
+
+- **MicroPython, not CPython.** The standard library subset is smaller. Pure-Python code using `os`, `sys`, `json`, `re`, `time`, `asyncio`, `struct`, `io` etc. typically works. Code that depends on C extensions (numpy, pandas, Pillow, lxml, etc.) does not. Picolet cannot make a CPython library "just work" — it would have to be ported or replaced with a MicroPython equivalent.
+
+- **`micropython-lib` fills most stdlib gaps.** Modules like `argparse`, `pathlib`, `dataclasses`, `typing`, `unittest` are available via [micropython-lib](https://github.com/micropython/micropython-lib) and are declared with `require("name")` in the manifest.
+
+- **Custom C modules are straightforward.** A Picolet binary is a MicroPython build under the hood, so any C module written against the standard MicroPython API works. Drop a directory under `user_c_modules/` and reference it in the manifest. Once [upstream PR #18229](https://github.com/micropython/micropython/pull/18229) lands in the fork, `c_module("./path/to/mymodule")` can declare it directly in the manifest.
+
+- **Python C-API extensions (CPython `.so`/`.pyd`) do NOT work.** MicroPython's runtime is binary-incompatible with CPython. Write a MicroPython C module instead.
+
+- **Async semantics differ slightly.** MicroPython's `asyncio` is a subset of CPython's. Coroutines, tasks, queues, locks, `gather`, `wait_for` work; `asyncio.run` with policies, debug mode, the `loop.add_signal_handler` interface, and some niche APIs don't. Most app code is unaffected.
+
+- **First-class platform support is Linux x64 and Windows x64.** macOS (Intel + Apple Silicon) is source-complete but requires GitHub Actions CI for native builds — local cross-compile from Linux is not supported. ARM Linux and mobile platforms are on the backlog.
+
+See [docs/caveats.md](docs/caveats.md) for a full catalogue.
+
+## Toolchain expectations
+
+- The `picolet` CLI runs on Linux, macOS, or Windows (host).
+- Building Windows binaries from Linux uses [`dockcross`](https://github.com/dockcross/dockcross); Docker is required for that path.
+- Building macOS binaries uses GitHub Actions runners (`macos-13` Intel, `macos-14` Apple Silicon).
+- Node.js + npm are required only when building Vue/React frontends.
+
+## Getting started
+
+Install the CLI. `uv tool install` is the recommended path (no separate
+package manager needed if you already use `uv`); `pipx` is the fallback
+for environments without `uv`. Plain `pip install` is deliberately not
+listed — most modern distros (PEP 668) block it system-wide.
+
+```bash
+uv tool install picolet-cli                       # recommended
+# or:
+pipx install picolet-cli                          # fallback
+
+picolet init my-app --template hello-cli          # see --list-templates for the full set
+cd my-app
+picolet dev                                        # live rebuild on file changes
+picolet build                                      # produce target/<os-arch>/my-app[.exe]
+```
+
+Templates: `hello-cli`, `hello-webview`, `hello-lvgl`, `hello-vue`, `pydfu`, `notes`, `config-editor`, `dashboard`.
+
+## Examples gallery
+
+<table>
+  <tr>
+    <td align="center">
+      <a href="examples/pydfu/">
+        <img src="examples/pydfu/screenshots/device-list-populated.png" alt="pydfu screenshot" />
+      </a>
+      <br>
+      <strong>pydfu</strong><br>
+      DFU firmware flasher (industrial control-panel aesthetic)
+    </td>
+    <td align="center">
+      <a href="examples/notes/">
+        <img src="examples/notes/screenshots/list-populated.png" alt="notes screenshot" />
+      </a>
+      <br>
+      <strong>notes</strong><br>
+      Markdown notes (editorial / refined)
+    </td>
+  </tr>
+  <tr>
+    <td align="center">
+      <a href="examples/config-editor/">
+        <img src="examples/config-editor/screenshots/edit-toml.png" alt="config-editor screenshot" />
+      </a>
+      <br>
+      <strong>config-editor</strong><br>
+      Schema-driven TOML/YAML/JSON editor (brutalist terminal)
+    </td>
+    <td align="center">
+      <a href="examples/dashboard/">
+        <img src="examples/dashboard/screenshots/full-dashboard.png" alt="dashboard screenshot" />
+      </a>
+      <br>
+      <strong>dashboard</strong><br>
+      Live system metrics (data-dense)
+    </td>
+  </tr>
+</table>
+
+See [docs/examples.md](docs/examples.md) for a longer tour of each.
+
+## Renderers
+
+| Renderer | Backed by | Use case | Binary size (typical) |
+|---|---|---|---|
+| (none) | — | CLI tool, no UI | ~647 KB Linux / ~409 KB Windows |
+| `webview` | WebKitGTK 4.1 (Linux), WebView2 (Windows), WKWebView (macOS) | HTML/CSS/JS frontend | ~710 KB Linux / ~525 KB Windows |
+| `lvgl` | [`lv_binding_micropython`](https://github.com/lvgl/lv_binding_micropython) + SDL2 | Native widgets, zero system UI deps | ~1.84 MB Linux / ~2.05 MB Windows |
+
+## Repository layout
+
+```
+picolet/
+├── packages/
+│   ├── picolet-cli/         # picolet init|dev|build|run|test
+│   ├── picolet-runtime/     # the MicroPython runtime + variants + user_c_modules
+│   ├── picolet-bridge-js/   # JS shim: window.picolet.invoke(...)
+│   ├── picolet-templates/   # `picolet init --template <name>` starter packs
+│   └── picolet-testing/     # AppHarness for autonomous test/screenshot
+├── examples/              # four worked example apps
+├── tests/                 # per-phase test suites
+└── docs/                  # architecture, caveats, examples, CLI reference
+```
+
+## More
+
+- [Getting started](docs/getting-started.md) — step-by-step tutorial
+- [`manifest.py` guide](docs/manifest.md) — declaring frozen modules + `require()` from `micropython-lib` and community packages
+- [Architecture](docs/architecture.md) — design decisions
+- [Caveats](docs/caveats.md) — MicroPython compatibility reference
+- [Examples tour](docs/examples.md) — what each example app demonstrates
+- [CLI reference](docs/cli-reference.md) — every `picolet` subcommand
+- [SBOM](docs/sbom.md) — supply-chain documentation
+- [History](docs/history/) — phase artefacts and version-specific specs/plans/audits
+
+## License
+
+MIT throughout. See [LICENSE](LICENSE).

picolet-0.0.1/hatch_build.py

@@ -0,0 +1,77 @@
+"""Hatch build hook: materialize sibling-package resources into picolet/.
+
+The picolet wheel ships three pieces of data that live in sibling workspace
+packages outside packages/picolet/:
+
+  packages/picolet-bridge-js/dist/picolet-bridge.js
+  packages/picolet-runtime/sbom/runtime.toml
+  packages/picolet-runtime/mbm.toml
+  packages/picolet-runtime/RUNTIME_TAG
+
+A ``[tool.hatch.build.targets.wheel.force-include]`` rule with ``../`` paths
+*almost* works — it does when hatch is building directly from the source
+workspace.  It fails when uv (or pip) builds the wheel from an extracted
+sdist, because the extracted sdist root has no siblings.
+
+This hook runs in ``initialize`` (before file enumeration) and copies the
+sibling files into the picolet/ package tree at:
+
+  picolet/_bridge/picolet-bridge.js
+  picolet/_runtime_data/sbom/runtime.toml
+  picolet/_runtime_data/mbm.toml
+  picolet/_runtime_data/RUNTIME_TAG
+
+Once present in the tree they get enumerated as ordinary package files for
+both sdist and wheel.  The sdist therefore contains them, so a downstream
+``pip wheel`` from the sdist works without needing the workspace.
+
+The destination files are git-ignored in the repo so they don't drift
+between dev builds and CI rebuilds.
+
+When the hook can't find the source files (the workspace root has no
+siblings — e.g. an extracted sdist), it skips silently; the assumption is
+that the files are already in the package tree because the sdist build hook
+already put them there.
+"""
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from hatchling.builders.hooks.plugin.interface import BuildHookInterface
+
+
+# (workspace-relative source, package-relative destination)
+_FILE_MAP = (
+    ("packages/picolet-bridge-js/dist/picolet-bridge.js",
+     "picolet/_bridge/picolet-bridge.js"),
+    ("packages/picolet-runtime/sbom/runtime.toml",
+     "picolet/_runtime_data/sbom/runtime.toml"),
+    ("packages/picolet-runtime/mbm.toml",
+     "picolet/_runtime_data/mbm.toml"),
+    ("packages/picolet-runtime/RUNTIME_TAG",
+     "picolet/_runtime_data/RUNTIME_TAG"),
+)
+
+
+class CustomBuildHook(BuildHookInterface):
+    PLUGIN_NAME = "picolet-resources"
+
+    def initialize(self, version, build_data):
+        pkg_root = Path(self.root)              # packages/picolet/
+        # workspace root: parent.parent from packages/picolet/ → repo root
+        repo_root = pkg_root.parent.parent
+
+        for src_rel, dst_rel in _FILE_MAP:
+            src = repo_root / src_rel
+            dst = pkg_root / dst_rel
+
+            if not src.is_file():
+                # Likely building from an extracted sdist where siblings
+                # don't exist.  The sdist build hook should have already
+                # placed the file at dst; if it's missing too the build
+                # will fail later with a clearer error.
+                continue
+
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src, dst)

picolet-0.0.1/picolet/__init__.py

@@ -0,0 +1,26 @@
+"""Picolet — compile Python programs to small self-contained native binaries.
+
+Public surface from the host-installed CLI:
+
+  picolet.cli         — command implementations (build, dev, init, run, test, ...)
+  picolet.testing     — AppHarness + webview/CDP drivers for autonomous testing
+                        (requires the [testing] extra: ``pip install picolet[testing]``)
+  picolet.templates   — starter-app templates discoverable via importlib.resources
+
+The ``picolet`` CLI command is exposed via the entry point declared in
+pyproject.toml; ``python -m picolet`` invokes the same main().
+
+Note: the in-binary ``import picolet`` inside a compiled MicroPython runtime
+refers to a separate set of frozen modules (the dispatcher, IPC transport,
+system event facade, etc.) that live under packages/picolet-runtime/python/
+and never ship in this wheel.
+"""
+
+try:
+    from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+    __version__ = _pkg_version("picolet")
+except Exception:
+    __version__ = "0.0.0-dev"
+
+__all__ = ("__version__",)