pep723-to-wheel 0.1.0__tar.gz

pep723_to_wheel-0.1.0/.github/workflows/cd.yml

@@ -0,0 +1,58 @@
+name: CD
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  publish:
+    if: github.actor != 'github-actions[bot]'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - uses: astral-sh/setup-uv@v6
+      - name: Install dependencies
+        run: uv sync --frozen
+      - name: Determine version
+        id: version
+        run: |
+          LATEST_TAG="$(git tag --list 'v*' --sort=-v:refname | head -n1)"
+          export LATEST_TAG
+          uv run python .github/workflows/cd_version.py
+      - name: Commit version bump
+        run: |
+          if git status --porcelain | grep -q "pyproject.toml"; then
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+            git add pyproject.toml
+            git commit -m "chore: bump version to v${{ steps.version.outputs.version }}"
+            git push
+          fi
+      - name: Tag release
+        run: |
+          VERSION="v${{ steps.version.outputs.version }}"
+          if git tag -l "$VERSION" | grep -q "$VERSION"; then
+            echo "Tag $VERSION already exists."
+          else
+            git tag "$VERSION"
+            git push origin "$VERSION"
+          fi
+      - name: Build
+        run: uv build
+      - name: Publish to PyPI (Trusted Publishing)
+        run: uv publish
+      - name: Create GitHub release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: dist/*.whl
+          tag_name: v${{ steps.version.outputs.version }}
+          name: v${{ steps.version.outputs.version }}

pep723_to_wheel-0.1.0/.github/workflows/cd_version.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import re
+import tomllib
+import tomli_w
+from dataclasses import dataclass
+
+
+# Strict semantic versioning pattern: MAJOR.MINOR.PATCH
+# - MAJOR is either 0 (pre-1.0 semantics) or a non-zero integer without leading zeros.
+# - MINOR and PATCH are non-negative integers.
+# - Pre-release identifiers (e.g. "-alpha") and build metadata (e.g. "+build.1") are
+#   intentionally not supported, because this script only needs to handle final release
+#   versions when resolving and bumping versions.
+VERSION_PATTERN = re.compile(r"^(?P<major>0|[1-9]\d*)\.(?P<minor>\d+)\.(?P<patch>\d+)$")
+
+
+@dataclass(frozen=True)
+class Version:
+    major: int
+    minor: int
+    patch: int
+
+    @classmethod
+    def parse(cls, value: str) -> "Version | None":
+        match = VERSION_PATTERN.match(value)
+        if not match:
+            return None
+        return cls(
+            major=int(match.group("major")),
+            minor=int(match.group("minor")),
+            patch=int(match.group("patch")),
+        )
+
+    def bump_patch(self) -> "Version":
+        return Version(self.major, self.minor, self.patch + 1)
+
+    def __str__(self) -> str:
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+
+def read_current_version(pyproject_path: pathlib.Path) -> Version:
+    data = tomllib.loads(pyproject_path.read_text())
+    current = data["project"]["version"]
+    parsed = Version.parse(current)
+    if not parsed:
+        raise ValueError(f"Invalid project.version in {pyproject_path}: {current}")
+    return parsed
+
+
+def write_version(pyproject_path: pathlib.Path, version: Version) -> None:
+    data = tomllib.loads(pyproject_path.read_text())
+    project = data.get("project")
+    if not isinstance(project, dict):
+        raise ValueError(f"Missing [project] table in {pyproject_path}")
+    if "version" not in project:
+        raise ValueError(f"Missing project.version in {pyproject_path}")
+    project["version"] = str(version)
+    pyproject_path.write_text(tomli_w.dumps(data))
+
+
+def resolve_version(current: Version, latest_tag: str | None) -> Version:
+    if not latest_tag:
+        return current
+    parsed = Version.parse(latest_tag.lstrip("v"))
+    if not parsed:
+        return current
+    if current.major == parsed.major and current.minor == parsed.minor:
+        new_patch = max(current.patch, parsed.patch) + 1
+        return Version(current.major, current.minor, new_patch)
+    return current
+
+
+def main() -> None:
+    pyproject_path = pathlib.Path("pyproject.toml")
+    current = read_current_version(pyproject_path)
+    new_version = resolve_version(current, os.environ.get("LATEST_TAG"))
+
+    if new_version != current:
+        write_version(pyproject_path, new_version)
+
+    output_path = os.environ.get("GITHUB_OUTPUT")
+    if output_path:
+        with pathlib.Path(output_path).open("a") as handle:
+            handle.write(f"version={new_version}\n")
+    else:
+        raise RuntimeError("GITHUB_OUTPUT is not set")
+    print(f"Resolved version: {new_version}")
+
+
+if __name__ == "__main__":
+    main()

pep723_to_wheel-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.12", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - uses: astral-sh/setup-uv@v5
+      - name: Install dependencies
+        run: uv sync --dev
+      - name: Run tests
+        run: make test
+      - name: Upload coverage reports to Codecov
+        uses: codecov/codecov-action@v5
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage.xml
+          fail_ci_if_error: true
+      - name: Upload coverage report
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-xml-${{ matrix.python-version }}
+          path: coverage.xml
+      - name: Run type checks
+        run: uv run ty check
+      - name: Run ruff
+        run: uv run ruff check .

pep723_to_wheel-0.1.0/.github/workflows/ruff-autofix.yml

@@ -0,0 +1,35 @@
+name: Ruff Autofix
+
+on:
+  push:
+    branches:
+      - "**"
+
+permissions:
+  contents: write
+
+jobs:
+  autofix:
+    if: github.actor != 'github-actions[bot]'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - uses: astral-sh/setup-uv@v5
+      - name: Install dependencies
+        run: uv sync --dev
+      - name: Run ruff autofix
+        run: uv run ruff check --fix .
+      - name: Commit and push changes
+        run: |
+          if [[ -n "$(git status --porcelain)" ]]; then
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+            git add -A
+            git commit -m "chore: ruff autofix"
+            git push
+          fi

pep723_to_wheel-0.1.0/.gitignore

@@ -0,0 +1,65 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+dist/
+*.egg-info/
+.eggs/
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# mypy
+.mypy_cache/
+.dmypy.json
+
+# Pyre
+.pyre/
+
+# Ruff
+.ruff_cache/
+
+# IDEs and editors
+.vscode/
+.idea/
+
+# Environments
+.env
+.venv/
+venv/
+ENV/
+
+# Pyenv
+.python-version
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Jupyter
+.ipynb_checkpoints/
+
+# marimo
+__marimo__/

pep723_to_wheel-0.1.0/AGENTS.md

@@ -0,0 +1,28 @@
+# Agent guide for pep723-to-wheel
+
+## Repository overview
+- `src/pep723_to_wheel/` contains the library and CLI implementation.
+- `tests/` holds pytest coverage for core behavior.
+- `pyproject.toml` defines dependencies, entry points, and tooling.
+
+## Development setup
+- Requires Python 3.12+ (see `pyproject.toml`).
+- Environment management is with uv.
+- Run Python and related CLI tools via `uv run` so they use the uv virtualenv.
+
+## Common commands
+- Run tests: `make test`
+- Run type checks: `make typecheck`
+- Run ruff checks: `make ruff`
+- Run all checks: `make all-tests`
+
+## Style and conventions
+- TDD for all code development - write test, then run to verify it fails, then develop, then verify the test passes.
+- All tasks should end by running `make all-tests` and verifying it passes.
+- Prefer updating or adding pytest tests in `tests/` for behavior changes.
+- For CLI changes, update both `src/pep723_to_wheel/cli.py` and any relevant tests.
+- Target modern Python 3.12+ syntax, no need to be backwards compatible.
+
+## Tips
+- Use `pep723_to_wheel.core` for the main build/import logic.
+- The CLI entry point is `pep723_to_wheel.cli:app`.

pep723_to_wheel-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johan Carlin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pep723_to_wheel-0.1.0/Makefile

@@ -0,0 +1,12 @@
+.PHONY: test typecheck ruff all-tests
+
+test:
+	uv run pytest --cov=pep723_to_wheel --cov-report=term-missing --cov-report=xml
+
+typecheck:
+	uv run ty check
+
+ruff:
+	uv run ruff check .
+
+all-tests: test typecheck ruff

pep723_to_wheel-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: pep723-to-wheel
+Version: 0.1.0
+Summary: PoC for pep-723 script to wheel and back
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.5
+Requires-Dist: tomli-w>=1.1.0
+Requires-Dist: typer>=0.21.1
+Description-Content-Type: text/markdown
+
+# pep723-to-wheel
+
+[![CI](https://github.com/jooh/pep723-to-wheel/actions/workflows/ci.yml/badge.svg)](https://github.com/jooh/pep723-to-wheel/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/jooh/pep723-to-wheel/branch/main/graph/badge.svg?token=PS0IS5TVBV)](https://codecov.io/gh/jooh/pep723-to-wheel)
+
+A small utility for converting [PEP 723](https://peps.python.org/pep-0723/) inline dependency scripts into wheels and reconstructing scripts from wheels. Especially useful for taking [reproducible Marimo notebooks](https://marimo.io/blog/sandboxed-notebooks) to production environments.
+
+## CLI
+
+Build a wheel from a script that has a PEP 723 inline block:
+
+```bash
+pep723-to-wheel build path/to/script.py --output-dir dist
+```
+
+Set an explicit wheel version (defaults to calendar versioning using the script mtime as the patch segment):
+
+```bash
+pep723-to-wheel build path/to/script.py --version 2024.12.25
+```
+
+Reconstruct a script from a wheel or package name:
+
+```bash
+pep723-to-wheel import path/to/package.whl --output reconstructed.py
+pep723-to-wheel import requests --output reconstructed.py
+```
+
+## Library
+
+```python
+from pathlib import Path
+from pep723_to_wheel import build_script_to_wheel, import_wheel_to_script
+
+result = build_script_to_wheel(Path("script.py"))
+print(result.wheel_path)
+
+import_result = import_wheel_to_script("requests", Path("reconstructed.py"))
+print(import_result.script_path)
+```
+
+## Development
+
+```bash
+make test
+make typecheck
+make ruff
+```
+
+## Release process
+
+Releases are automated on pushes to `main` by the CD workflow in `.github/workflows/cd.yml`.
+
+1. The workflow determines the latest `v*` Git tag and runs `.github/workflows/cd_version.py` to
+   resolve the next version. If the latest tag matches the current major/minor, it bumps the patch
+   to one higher than the max of the current patch and the tag patch.
+2. If `pyproject.toml` changes, the workflow commits the version bump back to `main`.
+3. It tags the release as `v<version>`, builds the wheel with `uv build --wheel`, publishes to
+   PyPI, and creates a GitHub release with the wheel attached.
+
+To trigger a release, merge or push changes to `main` and ensure `PYPI_API_TOKEN` is configured in
+the repository secrets.

pep723_to_wheel-0.1.0/README.md

@@ -0,0 +1,62 @@
+# pep723-to-wheel
+
+[![CI](https://github.com/jooh/pep723-to-wheel/actions/workflows/ci.yml/badge.svg)](https://github.com/jooh/pep723-to-wheel/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/jooh/pep723-to-wheel/branch/main/graph/badge.svg?token=PS0IS5TVBV)](https://codecov.io/gh/jooh/pep723-to-wheel)
+
+A small utility for converting [PEP 723](https://peps.python.org/pep-0723/) inline dependency scripts into wheels and reconstructing scripts from wheels. Especially useful for taking [reproducible Marimo notebooks](https://marimo.io/blog/sandboxed-notebooks) to production environments.
+
+## CLI
+
+Build a wheel from a script that has a PEP 723 inline block:
+
+```bash
+pep723-to-wheel build path/to/script.py --output-dir dist
+```
+
+Set an explicit wheel version (defaults to calendar versioning using the script mtime as the patch segment):
+
+```bash
+pep723-to-wheel build path/to/script.py --version 2024.12.25
+```
+
+Reconstruct a script from a wheel or package name:
+
+```bash
+pep723-to-wheel import path/to/package.whl --output reconstructed.py
+pep723-to-wheel import requests --output reconstructed.py
+```
+
+## Library
+
+```python
+from pathlib import Path
+from pep723_to_wheel import build_script_to_wheel, import_wheel_to_script
+
+result = build_script_to_wheel(Path("script.py"))
+print(result.wheel_path)
+
+import_result = import_wheel_to_script("requests", Path("reconstructed.py"))
+print(import_result.script_path)
+```
+
+## Development
+
+```bash
+make test
+make typecheck
+make ruff
+```
+
+## Release process
+
+Releases are automated on pushes to `main` by the CD workflow in `.github/workflows/cd.yml`.
+
+1. The workflow determines the latest `v*` Git tag and runs `.github/workflows/cd_version.py` to
+   resolve the next version. If the latest tag matches the current major/minor, it bumps the patch
+   to one higher than the max of the current patch and the tag patch.
+2. If `pyproject.toml` changes, the workflow commits the version bump back to `main`.
+3. It tags the release as `v<version>`, builds the wheel with `uv build --wheel`, publishes to
+   PyPI, and creates a GitHub release with the wheel attached.
+
+To trigger a release, merge or push changes to `main` and ensure `PYPI_API_TOKEN` is configured in
+the repository secrets.

pep723_to_wheel-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "pep723-to-wheel"
+version = "0.1.0"
+description = "PoC for pep-723 script to wheel and back"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pydantic>=2.5",
+    "tomli-w>=1.1.0",
+    "typer>=0.21.1",
+]
+
+[project.scripts]
+pep723-to-wheel = "pep723_to_wheel.cli:app"
+
+[build-system]
+requires = ["hatchling>=1.27.0"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pep723_to_wheel"]
+
+[dependency-groups]
+dev = [
+    "pytest>=9.0.2",
+    "pytest-cov>=6.0.0",
+    "ruff>=0.9.10",
+    "ty>=0.0.14",
+]
+
+[tool.ty.src]
+exclude = ["tests/examples/**"]
+
+[tool.coverage.run]
+branch = true
+source = ["pep723_to_wheel"]
+
+[tool.coverage.report]
+fail_under = 100
+show_missing = true
+skip_covered = true

pep723_to_wheel-0.1.0/src/pep723_to_wheel/__init__.py

@@ -0,0 +1,5 @@
+"""Library for converting PEP 723 scripts to wheels and back."""
+
+from pep723_to_wheel.core import build_script_to_wheel, import_wheel_to_script
+
+__all__ = ["build_script_to_wheel", "import_wheel_to_script"]

pep723_to_wheel-0.1.0/src/pep723_to_wheel/cli.py

@@ -0,0 +1,45 @@
+"""Typer-based CLI entry points."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from pep723_to_wheel.core import build_script_to_wheel, import_wheel_to_script
+
+app = typer.Typer(add_completion=False, no_args_is_help=True)
+
+
+@app.command("build")
+def build_command(
+    script_path: Path = typer.Argument(..., help="Path to the PEP 723 script."),
+    output_dir: Path | None = typer.Option(
+        None, "--output-dir", "-o", help="Directory for the built wheel."
+    ),
+    version: str | None = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Wheel version (defaults to calendar versioning).",
+    ),
+) -> None:
+    """Build a wheel from a PEP 723 script."""
+
+    result = build_script_to_wheel(script_path, output_dir, version)
+    typer.echo(str(result.wheel_path))
+
+
+@app.command("import")
+def import_command(
+    wheel_or_package: str = typer.Argument(
+        ..., help="Wheel path or package name to import."
+    ),
+    output_path: Path = typer.Option(
+        ..., "--output", "-o", help="Path to write the reconstructed script."
+    ),
+) -> None:
+    """Reconstruct a script from a wheel or package name."""
+
+    result = import_wheel_to_script(wheel_or_package, output_path)
+    typer.echo(str(result.script_path))