typewirepy 0.1.0__tar.gz

typewirepy-0.1.0/.claude/skills/release/SKILL.md

@@ -0,0 +1,95 @@
+---
+name: release
+description: Analyze commits and determine next version for PyPI release
+user_invocable: true
+---
+
+# /release — Release Analysis Skill
+
+Analyzes conventional commits since the last GitHub release and determines the next version to publish. Does NOT modify any files or create any commits.
+
+Supports two modes:
+- `/release` — standard release
+- `/release dev` — dev pre-release
+
+## Steps
+
+### 1. Find the last GitHub release
+
+Run:
+```bash
+gh release list --limit 1 --json tagName -q '.[0].tagName'
+```
+
+- If the command fails (non-zero exit), stop and tell the user to run `gh auth login`.
+- If the output is empty (no releases exist), this is the **first release**:
+  - Read `pyproject.toml` and extract the `version` value (e.g., `0.1.0`)
+  - Skip commit analysis — use that version as-is
+  - Jump to **Display summary** with bump type "initial"
+
+### 2. List commits since last release
+
+Run (replacing `<tag>` with the tag from step 1):
+```bash
+git log <tag>..HEAD --format='%s%n%b---'
+```
+
+- If no output (no commits since last release), stop and tell the user: "No commits since the last release. Nothing to release."
+
+### 3. Parse conventional commits
+
+For each commit, determine its bump level:
+
+1. If the commit body contains `BREAKING CHANGE:` (literal text) OR the subject matches `<type>[(scope)]!:` (note the `!`) → **major**
+2. If the subject starts with `feat:` or `feat(` → **minor**
+3. All other commits → **patch** (including `fix`, `refactor`, `docs`, `chore`, `ci`, `test`, `perf`, `style`, `build`, and non-conventional formats)
+
+The **highest bump wins** across all commits: major > minor > patch.
+
+### 4. Calculate new version
+
+Extract the base version from the last release tag (strip leading `v`). Apply the bump:
+- **major**: increment major, reset minor and patch to 0
+- **minor**: increment minor, reset patch to 0
+- **patch**: increment patch
+
+### 5. Display summary
+
+Show the user:
+
+```
+## Release Summary
+
+### Commits included
+- <commit subject> → <bump level>
+- ...
+
+### Version
+Bump type: <major|minor|patch|initial>
+Version: <old> → <new>
+
+### Publish command
+gh workflow run publish.yml -f version=<new-version> -f dry-run=true
+
+Change dry-run=false when ready to actually publish.
+```
+
+## Dev release flow (`/release dev`)
+
+Same as above through step 4, then:
+
+1. Determine the next version from conventional commits (same logic as standard flow)
+2. Query PyPI for existing dev versions. Run:
+   ```bash
+   curl -s -o /tmp/pypi.json -w '%{http_code}' https://pypi.org/pypi/typewirepy/json
+   ```
+   - If HTTP status is `404` (project doesn't exist on PyPI yet), start at `.dev1`
+   - If `200`, parse `/tmp/pypi.json`: extract all release keys matching `<next-version>.dev*`, parse the dev number as an **integer**, find the max, and increment by 1
+   - Use **numeric comparison** (not lexicographic) for dev numbers
+3. Version becomes `<next-version>.dev<N>` (e.g., `0.2.0.dev1`)
+4. Display summary with the dev version and provide the dispatch command
+
+## First release (no prior GitHub releases)
+
+- Use the version from `pyproject.toml` directly (no bump)
+- Provide the dispatch command for that version

typewirepy-0.1.0/.envrc

@@ -0,0 +1,14 @@
+watch_file flake.nix
+watch_file flake.lock
+
+if ! has nix_direnv_version || ! nix_direnv_version 3.1.0; then
+  source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/3.1.0/direnvrc" "sha256-buKPWv3gHXcQVIjkNxwBcaVQt+zIBqGB6WIZt3GJR/0="
+fi
+
+DEVENV_IN_DIRENV_SHELL=1
+export DEVENV_IN_DIRENV_SHELL
+
+if ! use flake . --no-pure-eval
+then
+  echo "devenv could not be built. The devenv environment was not loaded. Make the necessary changes to flake.nix and hit enter to try again." >&2
+fi

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

@@ -0,0 +1,116 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_call:
+
+jobs:
+  test:
+    name: Test / Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --python ${{ matrix.python-version }}
+
+      - name: Run tests
+        run: uv run pytest --tb=short -q
+
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Ruff check
+        run: uv run ruff check src/ tests/
+
+      - name: Ruff format check
+        run: uv run ruff format --check src/ tests/
+
+  type-check:
+    name: Types / ${{ matrix.checker }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        checker: [mypy, pyright, ty, pyrefly]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run mypy
+        if: matrix.checker == 'mypy'
+        run: uv run mypy src/typewirepy/
+
+      - name: Run pyright
+        if: matrix.checker == 'pyright'
+        run: uv run pyright src/typewirepy/
+
+      - name: Run ty
+        if: matrix.checker == 'ty'
+        run: uv run ty check src/typewirepy/
+
+      - name: Run pyrefly
+        if: matrix.checker == 'pyrefly'
+        run: uv run pyrefly check src/typewirepy/
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Build package
+        run: uv build
+
+  ci-ok:
+    name: CI OK
+    needs: [test, lint, type-check, build]
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - run: |
+          test "${{ needs.test.result }}" = "success" \
+            && test "${{ needs.lint.result }}" = "success" \
+            && test "${{ needs.type-check.result }}" = "success" \
+            && test "${{ needs.build.result }}" = "success"

typewirepy-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,108 @@
+name: Publish to PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        type: string
+        required: true
+        description: "Version to publish (e.g. 0.2.0, 0.2.0.dev1)"
+      dry-run:
+        type: boolean
+        default: true
+        description: "Dry run (build only, skip publish)"
+
+concurrency:
+  group: publish-${{ github.event.inputs.version }}
+  cancel-in-progress: false
+
+jobs:
+  ci:
+    name: CI
+    uses: ./.github/workflows/ci.yml
+
+  publish:
+    name: Publish
+    needs: [ci]
+    runs-on: ubuntu-latest
+    environment: ${{ inputs['dry-run'] == false && 'pypi' || 'dry-run' }}
+    permissions:
+      id-token: write
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          fetch-tags: true
+
+      - name: Validate version format
+        run: |
+          VERSION="${{ inputs.version }}"
+          if ! echo "$VERSION" | grep -qE '^[0-9]+\.[0-9]+\.[0-9]+(\.dev[0-9]+)?$'; then
+            echo "::error::Invalid version format: $VERSION (expected X.Y.Z or X.Y.Z.devN)"
+            exit 1
+          fi
+
+      - name: Check tag doesn't already exist
+        run: |
+          if git rev-parse "v${{ inputs.version }}" >/dev/null 2>&1; then
+            echo "::error::Tag v${{ inputs.version }} already exists"
+            exit 1
+          fi
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Patch version
+        run: |
+          python3 -c "
+          import re, pathlib
+          p = pathlib.Path('pyproject.toml')
+          text = p.read_text()
+          text = re.sub(r'^version\s*=\s*\"[^\"]*\"', 'version = \"${{ inputs.version }}\"', text, count=1, flags=re.MULTILINE)
+          p.write_text(text)
+          "
+
+      - name: Build package
+        run: uv build
+
+      - name: Verify package version
+        run: |
+          PKG_VERSION=$(python3 -c "
+          import zipfile, glob, re
+          whl = glob.glob('dist/*.whl')[0]
+          with zipfile.ZipFile(whl) as z:
+              meta = [n for n in z.namelist() if n.endswith('METADATA')][0]
+              text = z.read(meta).decode()
+              print(re.search(r'^Version: (.+)$', text, re.MULTILINE).group(1))
+          ")
+          if [ "$PKG_VERSION" != "${{ inputs.version }}" ]; then
+            echo "::error::Built package version ($PKG_VERSION) doesn't match input (${{ inputs.version }})"
+            exit 1
+          fi
+
+      - name: Publish to PyPI
+        if: inputs['dry-run'] == false
+        run: uv publish
+
+      - name: Create tag
+        if: inputs['dry-run'] == false
+        run: |
+          git tag "v${{ inputs.version }}"
+          git push origin "v${{ inputs.version }}"
+
+      - name: Create GitHub Release
+        if: inputs['dry-run'] == false
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: "v${{ inputs.version }}"
+          generate_release_notes: true
+
+      - name: Dry run summary
+        if: inputs['dry-run'] == true
+        run: |
+          echo "::notice::Dry run complete — built v${{ inputs.version }} successfully"
+          echo "::notice::To publish for real, re-run with dry-run=false"

typewirepy-0.1.0/.gitignore

@@ -0,0 +1,50 @@
+# ── Python ──
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+*.egg
+dist/
+build/
+*.whl
+
+# ── Virtual environments ──
+.venv/
+venv/
+ENV/
+
+# ── UV ──
+# uv.lock is committed (reproducibility)
+# .python-version is committed
+
+# ── IDE ──
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+.DS_Store
+
+# ── Testing ──
+.pytest_cache/
+htmlcov/
+.coverage
+.coverage.*
+coverage.xml
+
+# ── Type checkers ──
+.mypy_cache/
+.pyright/
+.ty/
+
+# ── Nix / devenv / direnv ──
+result
+result-*
+.devenv/
+.devenv.flake.nix
+.direnv/
+# flake.lock is committed (reproducibility)
+
+# ── Distribution ──
+dist/
+*.tar.gz

typewirepy-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

typewirepy-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,40 @@
+# Contributing to TypeWirePy
+
+## Prerequisites
+
+- Python 3.10+
+- [uv](https://docs.astral.sh/uv/) (package manager)
+
+## Development setup
+
+```bash
+git clone https://github.com/typewirepy/typewirepy.git
+cd typewirepy
+uv sync
+```
+
+## Running tests
+
+```bash
+uv run pytest
+```
+
+## Linting & formatting
+
+```bash
+uv run ruff check src/ tests/
+uv run ruff format src/ tests/
+```
+
+## Type checking
+
+```bash
+uv run mypy src/typewirepy/
+uv run pyright src/typewirepy/
+```
+
+## Pull request guidelines
+
+1. Branch from `main`
+2. Ensure all CI checks pass (tests, lint, format, type-check)
+3. Keep changes focused — one feature or fix per PR

typewirepy-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 TypeWirePy Contributors
+
+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.

typewirepy-0.1.0/PKG-INFO

@@ -0,0 +1,166 @@
+Metadata-Version: 2.4
+Name: typewirepy
+Version: 0.1.0
+Summary: Lightweight, container-agnostic dependency injection for Python — typed, explicit, composable.
+Project-URL: Homepage, https://github.com/typewirepy/typewirepy
+Project-URL: Repository, https://github.com/typewirepy/typewirepy
+Project-URL: Issues, https://github.com/typewirepy/typewirepy/issues
+Author: TypeWireTS Contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: container,dependency-injection,di,ioc,typed,typesafe
+Classifier: Development Status :: 3 - Alpha
+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 :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100.0; extra == 'fastapi'
+Description-Content-Type: text/markdown
+
+# typewirepy
+
+[![CI](https://github.com/typewirepy/typewirepy/actions/workflows/ci.yml/badge.svg)](https://github.com/typewirepy/typewirepy/actions/workflows/ci.yml)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+Lightweight, container-agnostic dependency injection for Python — typed, explicit, composable.
+
+## Features
+
+- **Zero runtime dependencies** — only stdlib
+- **Fully typed** — strict mypy + pyright out of the box
+- **Async-first** — native `async`/`await`; sync wrappers included
+- **Immutable wires** — safe to share across threads and modules
+- **Scopes** — singleton (default) and transient
+- **Generator lifecycle** — `yield`-based creators with automatic cleanup
+- **FastAPI integration** — `WireDepends()` bridges wires to FastAPI's `Depends()`
+
+## Installation
+
+```bash
+pip install typewirepy
+```
+
+With FastAPI support:
+
+```bash
+pip install typewirepy[fastapi]
+```
+
+## Quick Start
+
+### Async (primary)
+
+```python
+from typewirepy import Scope, TypeWireContainer, type_wire_group_of, type_wire_of
+
+config_wire = type_wire_of(token="Config", creator=lambda: {"db_url": "sqlite://"})
+
+db_wire = type_wire_of(
+    token="Database",
+    imports={"config": config_wire},
+    create_with=lambda deps: f"db({deps['config']['db_url']})",
+)
+
+app_wires = type_wire_group_of([config_wire, db_wire])
+
+async def main():
+    async with TypeWireContainer() as container:
+        await app_wires.apply(container)
+        db = await db_wire.get_instance(container)
+        print(db)  # "db(sqlite://)"
+```
+
+### Sync
+
+```python
+from typewirepy import TypeWireContainer, type_wire_of
+
+wire = type_wire_of(token="Greeting", creator=lambda: "hello")
+
+with TypeWireContainer.sync() as container:
+    wire.apply_sync(container)
+    print(wire.get_instance_sync(container))  # "hello"
+```
+
+## Key Concepts
+
+### Wires
+
+A **wire** is an immutable description of a dependency — its token (name), how to create it, and what it depends on. Create wires with `type_wire_of()`:
+
+- **Leaf wire** — uses `creator` (zero-arg callable)
+- **Composed wire** — uses `create_with` + `imports` to receive resolved dependencies
+
+### Imports
+
+Imports declare which other wires a composed wire depends on. They're passed as a `dict[str, TypeWire]` and delivered to `create_with` as a dict (Convention A) or as keyword arguments (Convention B):
+
+```python
+# Convention A: dict parameter
+type_wire_of(token="Svc", imports={"db": db_wire}, create_with=lambda deps: deps["db"])
+
+# Convention B: keyword-only parameters
+def create_svc(*, db: Database) -> Service: ...
+type_wire_of(token="Svc", imports={"db": db_wire}, create_with=create_svc)
+```
+
+### Scopes
+
+- `Scope.SINGLETON` (default) — resolved once, cached for the container's lifetime
+- `Scope.TRANSIENT` — resolved fresh on every call
+
+### Groups
+
+A `TypeWireGroup` bundles wires together for batch application:
+
+```python
+group = type_wire_group_of([config_wire, db_wire, service_wire])
+await group.apply(container)
+```
+
+Override wires for testing with `with_extra_wires()`:
+
+```python
+test_group = group.with_extra_wires([service_wire.with_creator(lambda _: mock_svc)])
+```
+
+## FastAPI Integration
+
+```python
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from typewirepy import TypeWireContainer, type_wire_group_of, type_wire_of
+from typewirepy.integrations.fastapi import WireDepends
+
+db_wire = type_wire_of(token="DB", creator=lambda: "db_connection")
+app_wires = type_wire_group_of([db_wire])
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    async with TypeWireContainer() as container:
+        await app_wires.apply(container)
+        app.state.typewire_container = container
+        yield
+
+app = FastAPI(lifespan=lifespan)
+
+@app.get("/")
+async def root(db: str = WireDepends(db_wire)):
+    return {"db": db}
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT