inito 0.0.1b0__tar.gz

inito-0.0.1b0/.github/workflows/ci.yml

@@ -0,0 +1,65 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  quality:
+    name: lint, format, typecheck, test (py${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v7
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.2.0
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install project (dev extras)
+        run: |
+          uv venv --python ${{ matrix.python-version }}
+          uv pip install -e ".[dev]"
+      - name: Ruff check
+        run: uv run ruff check .
+      - name: Ruff format check
+        run: uv run ruff format --check .
+      - name: Mypy
+        run: uv run mypy src
+      - name: Pytest with coverage
+        run: uv run pytest --cov-report=html
+      - name: Build docs (warnings-as-errors)
+        if: matrix.python-version == '3.13'
+        run: uv run sphinx-build -b html docs docs/_build -W
+      - name: Upload coverage artifact
+        if: matrix.python-version == '3.13'
+        uses: actions/upload-artifact@v7
+        with:
+          name: coverage-html
+          path: htmlcov
+
+  build:
+    name: build sdist and wheel
+    runs-on: ubuntu-latest
+    needs: quality
+    steps:
+      - uses: actions/checkout@v7
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.2.0
+        with:
+          python-version: "3.13"
+      - name: Build
+        run: uv build
+      - name: Check metadata with twine
+        run: uvx twine check dist/*
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist

inito-0.0.1b0/.github/workflows/release.yml

@@ -0,0 +1,46 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  build:
+    name: Build distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.2.0
+        with:
+          python-version: "3.13"
+      - name: Build
+        run: uv build
+      - name: Check metadata with twine
+        run: uvx twine check dist/*
+      - uses: actions/upload-artifact@v7
+        with:
+          name: release-dist
+          path: dist
+
+  publish:
+    name: Publish to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/inito/
+    permissions:
+      id-token: write # required for PyPI trusted publishing (OIDC) - no API token needed
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: release-dist
+          path: dist
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

inito-0.0.1b0/.gitignore

@@ -0,0 +1,25 @@
+local_dev/
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+.venv/
+.venv*/
+venv/
+
+# Build artifacts
+dist/
+build/
+
+# Tooling caches
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Docs
+site/
+docs/_build/

inito-0.0.1b0/.pre-commit-config.yaml

@@ -0,0 +1,14 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.6.9
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.11.2
+    hooks:
+      - id: mypy
+        additional_dependencies: []
+        args: [src]
+        pass_filenames: false

inito-0.0.1b0/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.0.1-beta] - 2026-07-01
+
+### Added
+- Core metadata/reflection/code-generation engine: decoration-time-only
+  field metadata extraction, an `exec()`-based method-generation utility,
+  a shared dual-mode (`@dec`/`@dec(...)`) decorator factory, and a
+  generator registry for capability-based reuse across decorators.
+- `@Data`: constructor, `__repr__`, `__eq__`, `__hash__`, and
+  `get_`/`set_` accessors for every declared field.
+- `@Getter`, `@Setter`: accessors only.
+- `@NoArgsConstructor`: no-argument constructor using field defaults.
+- `@AllArgsConstructor`, `@RequiredArgsConstructor`: constructor-only
+  decorators accepting every field or only required fields, respectively.
+- `@Builder`/`builder`: a fluent, chainable builder (`.builder()...build()`)
+  with `to_builder()` support (`to_builder=True`), `setter_prefix`, and
+  `build_method_name` options. Works standalone on plain classes and
+  composes with `@dataclass`.
+- `@ToString`: `__repr__` only.
+- `@EqualsAndHashCode`: `__eq__`/`__hash__` only.
+- Full test suite (176 tests, 100% line+branch coverage), a
+  pytest-benchmark/pyperf/tracemalloc/import-time benchmark suite, and
+  Sphinx + Furo documentation (installation, quickstart, API reference,
+  examples, migration guide, performance report, FAQ, troubleshooting).
+- GitHub Actions CI (lint/format/typecheck/test/build across Python
+  3.9-3.13) and a tag-triggered PyPI trusted-publishing release workflow.
+
+### Known limitations
+- Static type checkers (mypy/pyright) don't see generated members without
+  a dedicated plugin (tracked for a future release).
+- Stacking any constructor-generating decorator with
+  `@dataclass(frozen=True)` raises `FrozenInstanceError` (expected, not a
+  bug — see the README/troubleshooting docs).
+- Self-referential forward references (e.g. `next: Node`) aren't supported,
+  since annotations resolve eagerly at decoration time.

inito-0.0.1b0/CLAUDE.md

@@ -0,0 +1,105 @@
+# CLAUDE.md
+
+Guidance for working on `inito` in this repository.
+
+## Project summary
+
+`inito` is a Lombok-inspired, zero-runtime-dependency Python library. It
+eliminates boilerplate (constructors, `repr`, equality/hashing, accessors,
+builders) via decorators that generate real methods once, at class-decoration
+time, then attach them directly to the class.
+
+## Authoritative specs
+
+`local_dev/inito.md` (product/technical spec) and `local_dev/engineering.md`
+(coding standards) are the governing documents for this project. Both are
+gitignored and dev-machine-only — if they're missing on a fresh clone, ask
+the user for them before doing feature work. Read them before implementing
+anything not already covered here.
+
+## The non-negotiable performance rule
+
+All reflection/annotation inspection happens **exactly once, at decoration
+time**. Never inspect annotations or defaults at instance-construction or
+method-call time. Generated methods are real Python functions built from
+source text via `exec()` and attached directly to the class — never
+`__getattr__`/`__getattribute__` overrides, proxies, descriptors, or
+monkeypatching after class creation.
+
+Two sanctioned mutation points, and only two:
+- `src/inito/utils/codegen.py` (`build_function`) — the only `exec()` call site.
+- `src/inito/core/attach.py` (`attach_method` / `attach_capability`) — the
+  only place a class is mutated after code generation.
+
+## Naming convention
+
+- Canonical decorator names are PascalCase, matching Lombok and `inito.md`'s
+  Initial Features list: `Data`, `Getter`, `Setter`, `Builder`, `ToString`,
+  `EqualsAndHashCode`, `NoArgsConstructor`, `AllArgsConstructor`,
+  `RequiredArgsConstructor`.
+- Each is built by `make_decorator` (a factory function, not a class) so it
+  supports both `@Data` and `@Data(frozen=True)`.
+- Lowercase aliases are exported bound to the same object (`data = Data`,
+  `builder = Builder`, ...) to satisfy the `from inito import builder`
+  examples from the spec, while keeping one canonical name.
+- Internal generator classes always use the `*Generator` suffix
+  (`ConstructorGenerator`, `ReprGenerator`, ...) and are never exported at the
+  top level.
+
+## Architecture map
+
+- `decorators/` — public decorators (`@Data`, ...); each is a thin
+  ~10–35 line module wiring generators together via `make_decorator`.
+- `generators/` — one atomic capability per generator (`constructor`, `repr`,
+  `eq`+`hash`, `getter`+`setter`), registered under a capability name in
+  `generators/registry.py`.
+- `builders/` — the `@Builder` generator (not yet implemented — see Phase 8).
+- `reflection/` — low-level MRO/annotation-walking helpers used once by
+  `MetadataExtractor`.
+- `typing/` — reserved for Protocol/generic typing support (currently empty).
+- `metadata/` — `FieldMetadata`/`ClassMetadata` value types and
+  `MetadataExtractor`, which builds and caches metadata once per class.
+- `utils/` — `codegen.build_function` and
+  `decorator_factory.make_decorator`, the two cross-cutting utilities every
+  decorator/generator depends on.
+- `core/` — `attach.py`, the sole class-mutation choke point.
+- `exceptions/` — the `InitoError` hierarchy.
+
+**How to add a new decorator:** implement a generator (matching the
+`MethodGenerator` or `MultiMethodGenerator` protocol in `generators/base.py`),
+register it under a new capability name in `generators/__init__.py`, then
+write a small decorator module that resolves that capability via
+`core.attach.attach_capability` and wraps it with `make_decorator`. Never
+modify an existing generator to add a new decorator.
+
+## Commands
+
+```bash
+uv pip install -e ".[dev]"   # or: pip install -e ".[dev]"
+pytest                        # run tests + coverage
+pytest tests/decorators/test_data.py -v   # run a single test file
+pytest --cov-report=html       # generate an HTML coverage report
+ruff check .                   # lint
+ruff format .                  # format
+ruff format --check .           # format check (CI mode)
+mypy src                        # typecheck
+uv build                        # build sdist + wheel
+./scripts/check_all.sh          # run all of the above
+pytest benchmarks/ --benchmark-only   # run the pytest-benchmark suite
+python benchmarks/pyperf_suite.py     # process-isolated pyperf construction comparison
+python benchmarks/memory_profile.py   # per-instance memory footprint comparison
+python benchmarks/import_time.py      # cold-import overhead comparison
+sphinx-build -b html docs docs/_build -W   # build docs, warnings-as-errors
+```
+
+## Testing conventions
+
+`tests/` mirrors `src/inito/`'s package structure. Test files are named
+`test_<module>.py`. Prefer shared fixtures in `conftest.py` over redefining
+sample classes per test file (DRY).
+
+## Progress tracking
+
+`TASKS.md` is the single source of truth for what's implemented versus
+planned across sessions. Always update its checkboxes as work completes —
+a future session should be able to resume by finding the first unchecked box.

inito-0.0.1b0/CONTRIBUTING.md

@@ -0,0 +1,64 @@
+# Contributing
+
+## Setup
+
+```bash
+uv pip install -e ".[dev]"
+# or: pip install -e ".[dev]"
+pre-commit install
+```
+
+## Workflow
+
+```bash
+ruff check .            # lint
+ruff format .            # format
+mypy src                 # typecheck
+pytest                   # test + coverage
+./scripts/check_all.sh   # all of the above
+sphinx-build -b html docs docs/_build -W   # build docs, warnings-as-errors
+```
+
+## Standards
+
+Follow `local_dev/engineering.md`'s SOLID/DRY/cognitive-complexity/error-handling
+rules and `local_dev/inito.md`'s performance rules (reflection only at
+decoration time, generated methods attached once, zero runtime dependencies).
+See [CLAUDE.md](./CLAUDE.md) for the architecture map and naming conventions.
+
+## Progress tracking
+
+[TASKS.md](./TASKS.md) is the single source of truth for what's implemented
+versus planned. Update its checkboxes as work lands.
+
+## Versioning
+
+Semantic versioning. Version is single-sourced from `src/inito/__init__.py`'s
+`__version__` — hatchling reads it via a regex, so bumping it there is the
+only place that needs to change.
+
+## Release process
+
+1. Bump `__version__` in `src/inito/__init__.py`, following semver.
+2. Update `CHANGELOG.md`: move the `[Unreleased]` entries under a new
+   `[X.Y.Z] - YYYY-MM-DD` heading.
+3. Commit, then tag: `git tag vX.Y.Z && git push origin vX.Y.Z`.
+4. Pushing a `v*` tag triggers `.github/workflows/release.yml`, which builds
+   the sdist/wheel, runs `twine check`, and publishes to PyPI via trusted
+   publishing (OIDC) — no API token needed in CI.
+
+**One-time setup required before the first release** (not something CI or
+this repo's config can do on its own):
+
+- On [PyPI](https://pypi.org/manage/account/publishing/), register a
+  "trusted publisher" for the `inito` project pointing at this repo, the
+  `release.yml` workflow filename, and a `pypi` environment name (this can
+  be done *before* the first release — PyPI supports pending publishers for
+  projects that don't exist yet).
+- In the GitHub repo settings, create an environment named `pypi` (matches
+  `release.yml`'s `environment: name: pypi`) — optionally with protection
+  rules (e.g. required reviewers) before it can publish.
+
+Without that one-time PyPI-side setup, `release.yml`'s publish job will
+fail with an OIDC/trusted-publisher authentication error — that's expected
+until the trusted publisher is registered.

inito-0.0.1b0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Swetank Subham
+
+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.

inito-0.0.1b0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: inito
+Version: 0.0.1b0
+Summary: A Lombok-inspired boilerplate-elimination library for Python.
+Project-URL: Homepage, https://github.com/swtnk/inito
+Project-URL: Repository, https://github.com/swtnk/inito
+Project-URL: Documentation, https://github.com/swtnk/inito#readme
+Project-URL: Changelog, https://github.com/swtnk/inito/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/swtnk/inito/issues
+Author-email: Swetank Subham <swetanksubham.r@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: boilerplate,builder,codegen,dataclass,lombok
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+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: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: attrs>=23; extra == 'dev'
+Requires-Dist: furo>=2024.1; extra == 'dev'
+Requires-Dist: mypy<2,>=1.11; extra == 'dev'
+Requires-Dist: myst-parser>=3; extra == 'dev'
+Requires-Dist: pre-commit>=3.7; extra == 'dev'
+Requires-Dist: pyperf>=2.6; extra == 'dev'
+Requires-Dist: pytest-benchmark>=4; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Requires-Dist: sphinx>=7; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# inito
+
+A Lombok-inspired boilerplate-elimination library for Python. `inito`
+generates constructors, `repr`, equality/hashing, accessors, and fluent
+builders once at class-decoration time — never at instance construction or
+attribute-access time — so the generated classes perform like handwritten
+ones. Zero runtime dependencies.
+
+## Install
+
+```bash
+pip install inito
+```
+
+or
+
+```bash
+uv add inito
+```
+
+## Quick start
+
+```python
+from inito import Data
+
+
+@Data
+class User:
+    name: str
+    age: int = 0
+
+
+user = User("Ada", age=30)
+print(user)              # User(name='Ada', age=30)
+print(user.get_name())   # Ada
+user.set_age(31)
+```
+
+`@Data` also accepts options:
+
+```python
+from inito import Data
+
+
+@Data(frozen=True)
+class Point:
+    x: int
+    y: int
+```
+
+`@builder` generates a fluent, chainable builder, and composes with
+`@dataclass`:
+
+```python
+from dataclasses import dataclass
+from inito import builder
+
+
+@builder(to_builder=True)
+@dataclass
+class Request:
+    prompt: str
+    temperature: float = 0.7
+
+
+request = Request.builder().prompt("hello").build()
+revised = request.to_builder().temperature(0.9).build()
+```
+
+## Status
+
+Implemented today: `@Data` (constructor, `__repr__`, `__eq__`, `__hash__`,
+getters, setters), `@Getter` (getters only), `@Setter` (setters only),
+`@NoArgsConstructor` (no-argument constructor using field defaults),
+`@AllArgsConstructor` (constructor only, every field),
+`@RequiredArgsConstructor` (constructor only accepting required fields),
+`@Builder`/`builder` (fluent builder, `to_builder=True` support),
+`@ToString` (`__repr__` only — pairs well with `@Builder` for a readable
+repr without pulling in `@Data`'s constructor/eq/hash/accessors), and
+`@EqualsAndHashCode` (`__eq__`/`__hash__` only).
+
+All of `inito.md`'s Initial Features (v1) are now implemented. See
+[docs/performance.md](./docs/performance.md) for benchmarks against
+handwritten classes, `dataclasses`, and `attrs`. See [TASKS.md](./TASKS.md)
+for what's left: docs, CI hardening, and release.
+
+### Known limitation: static type checkers don't see generated members yet
+
+Every generated member (`get_x`, `set_x`, `.builder()`, `.to_builder()`, the
+generated constructor's parameters, ...) is attached to your class via
+`setattr` at decoration time — real attributes at runtime, but invisible to
+`mypy`/`pyright` today, since neither tool has a plugin for inito yet. Your
+code will run correctly; `mypy --strict`/`pyright` will flag those accesses
+as unknown attributes in the meantime. `attrs` and Pydantic hit the same
+problem and solved it with dedicated mypy plugins — that's tracked as a
+future initiative (see `TASKS.md` Phase 17), not required for this release.
+
+### Known limitations: frozen dataclasses and self-referential fields
+
+Stacking any inito constructor-generating decorator (`@Data`, `@Builder`,
+`@AllArgsConstructor`, ...) with `@dataclass(frozen=True)` — in either
+order — raises `dataclasses.FrozenInstanceError`. This is expected, not a
+bug: the generated `__init__`/`build()` assign fields with plain
+`self.x = value`, which correctly respects the frozen class's blocking
+`__setattr__` rather than silently bypassing the immutability you asked
+for. If you want inito's own frozen-style behavior, use `@Data(frozen=True)`
+(which just omits setters) instead of also stacking `@dataclass(frozen=True)`.
+
+Self-referential type hints (e.g. a linked-list `next: Node`) also aren't
+supported: inito resolves annotations eagerly, once, at decoration time —
+before the class's own name is bound in its module's globals — so a forward
+reference to the class currently being decorated can't resolve. Forward
+references to any other, already-defined class work normally.
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

inito-0.0.1b0/README.md

@@ -0,0 +1,121 @@
+# inito
+
+A Lombok-inspired boilerplate-elimination library for Python. `inito`
+generates constructors, `repr`, equality/hashing, accessors, and fluent
+builders once at class-decoration time — never at instance construction or
+attribute-access time — so the generated classes perform like handwritten
+ones. Zero runtime dependencies.
+
+## Install
+
+```bash
+pip install inito
+```
+
+or
+
+```bash
+uv add inito
+```
+
+## Quick start
+
+```python
+from inito import Data
+
+
+@Data
+class User:
+    name: str
+    age: int = 0
+
+
+user = User("Ada", age=30)
+print(user)              # User(name='Ada', age=30)
+print(user.get_name())   # Ada
+user.set_age(31)
+```
+
+`@Data` also accepts options:
+
+```python
+from inito import Data
+
+
+@Data(frozen=True)
+class Point:
+    x: int
+    y: int
+```
+
+`@builder` generates a fluent, chainable builder, and composes with
+`@dataclass`:
+
+```python
+from dataclasses import dataclass
+from inito import builder
+
+
+@builder(to_builder=True)
+@dataclass
+class Request:
+    prompt: str
+    temperature: float = 0.7
+
+
+request = Request.builder().prompt("hello").build()
+revised = request.to_builder().temperature(0.9).build()
+```
+
+## Status
+
+Implemented today: `@Data` (constructor, `__repr__`, `__eq__`, `__hash__`,
+getters, setters), `@Getter` (getters only), `@Setter` (setters only),
+`@NoArgsConstructor` (no-argument constructor using field defaults),
+`@AllArgsConstructor` (constructor only, every field),
+`@RequiredArgsConstructor` (constructor only accepting required fields),
+`@Builder`/`builder` (fluent builder, `to_builder=True` support),
+`@ToString` (`__repr__` only — pairs well with `@Builder` for a readable
+repr without pulling in `@Data`'s constructor/eq/hash/accessors), and
+`@EqualsAndHashCode` (`__eq__`/`__hash__` only).
+
+All of `inito.md`'s Initial Features (v1) are now implemented. See
+[docs/performance.md](./docs/performance.md) for benchmarks against
+handwritten classes, `dataclasses`, and `attrs`. See [TASKS.md](./TASKS.md)
+for what's left: docs, CI hardening, and release.
+
+### Known limitation: static type checkers don't see generated members yet
+
+Every generated member (`get_x`, `set_x`, `.builder()`, `.to_builder()`, the
+generated constructor's parameters, ...) is attached to your class via
+`setattr` at decoration time — real attributes at runtime, but invisible to
+`mypy`/`pyright` today, since neither tool has a plugin for inito yet. Your
+code will run correctly; `mypy --strict`/`pyright` will flag those accesses
+as unknown attributes in the meantime. `attrs` and Pydantic hit the same
+problem and solved it with dedicated mypy plugins — that's tracked as a
+future initiative (see `TASKS.md` Phase 17), not required for this release.
+
+### Known limitations: frozen dataclasses and self-referential fields
+
+Stacking any inito constructor-generating decorator (`@Data`, `@Builder`,
+`@AllArgsConstructor`, ...) with `@dataclass(frozen=True)` — in either
+order — raises `dataclasses.FrozenInstanceError`. This is expected, not a
+bug: the generated `__init__`/`build()` assign fields with plain
+`self.x = value`, which correctly respects the frozen class's blocking
+`__setattr__` rather than silently bypassing the immutability you asked
+for. If you want inito's own frozen-style behavior, use `@Data(frozen=True)`
+(which just omits setters) instead of also stacking `@dataclass(frozen=True)`.
+
+Self-referential type hints (e.g. a linked-list `next: Node`) also aren't
+supported: inito resolves annotations eagerly, once, at decoration time —
+before the class's own name is bound in its module's globals — so a forward
+reference to the class currently being decorated can't resolve. Forward
+references to any other, already-defined class work normally.
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## License
+
+MIT — see [LICENSE](./LICENSE).