python-leak-hunter 0.1.1__tar.gz

python_leak_hunter-0.1.1/.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv sync --python 3.13
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+      - run: uv run mypy
+
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv sync --python ${{ matrix.python }}
+      - run: uv run pytest
+      # Once with real grpcio, so the gRPC reproduction runs instead of being skipped.
+      - if: runner.os == 'Linux' && matrix.python == '3.12'
+        run: uv run --with grpcio pytest tests/test_grpc_cycle.py

python_leak_hunter-0.1.1/.github/workflows/release.yml

@@ -0,0 +1,33 @@
+name: Release
+
+# Publishes to PyPI with trusted publishing: PyPI trusts this workflow directly,
+# so no API token is stored anywhere.
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: Existing tag to publish, e.g. v0.1.0
+        required: true
+
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/python-leak-hunter/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.release.tag_name || inputs.tag }}
+      - uses: astral-sh/setup-uv@v6
+      - name: Check the tag matches the package version
+        run: |
+          tag="${{ github.event.release.tag_name || inputs.tag }}"
+          version="$(uv version --short)"
+          test "$tag" = "v$version" || { echo "tag $tag does not match version $version"; exit 1; }
+      - run: uv build
+      - uses: pypa/gh-action-pypi-publish@release/v1

python_leak_hunter-0.1.1/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.py[cod]
+.venv/
+.mypy_cache/
+.ruff_cache/
+.pytest_cache/
+dist/
+build/
+*.egg-info/

python_leak_hunter-0.1.1/LICENSE

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

python_leak_hunter-0.1.1/PKG-INFO

@@ -0,0 +1,188 @@
+Metadata-Version: 2.5
+Name: python-leak-hunter
+Version: 0.1.1
+Summary: Find memory leaks in long-running Python services: what accumulates, what keeps it alive, and a test that keeps it fixed. Ships with an agent skill for Claude Code and Codex.
+Project-URL: Homepage, https://github.com/tariqamarneh/python-leak-hunter
+Project-URL: The leak behind it, https://www.tariqamarneh.com/writing/grpc-contextvars-memory-leak
+Author-email: Tariq Amarneh <tariqs.naser@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent skill,contextvars,debugging,gc,langgraph,memory leak,profiling,pytest
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: psutil
+Requires-Dist: psutil>=5.9; extra == 'psutil'
+Description-Content-Type: text/markdown
+
+# python-leak-hunter
+
+[![CI](https://github.com/tariqamarneh/python-leak-hunter/actions/workflows/ci.yml/badge.svg)](https://github.com/tariqamarneh/python-leak-hunter/actions/workflows/ci.yml)
+
+Find memory leaks in long-running Python services: **what accumulates**, **what keeps it
+alive** (down to "held by a C extension"), and **a test that keeps it fixed**. It ships with an
+[agent skill](https://github.com/tariqamarneh/python-leak-hunter/blob/main/skills/python-leak-hunter/SKILL.md) that teaches Claude Code, Codex and other
+coding agents the whole investigation, not just the tools.
+
+```text
+$ leak-hunter why harness:many_requests app.RunTrace
+
+43 live app.RunTrace; traced 5:
+5 of 5 held by:
+  outside Python: nothing the garbage collector can see refers to this grpc._plugin_wrapping._Plugin, yet it is alive (typically a C extension holding it)
+    -> grpc._plugin_wrapping._Plugin._stored_ctx
+    -> _contextvars.Context
+    -> hamt
+    -> hamt_bitmap_node
+    -> app.RunTrace  <- the object being explained
+```
+
+That output is from [a real grpcio reproduction](https://github.com/tariqamarneh/python-leak-hunter/blob/main/examples/grpc_cycle.py): a gRPC channel built
+inside a request captures the request's `contextvars` context. When that context can reach
+the channel back, the cycle runs through C code and is never freed. In production this pinned
+whole AI-agent graphs in memory, about 2 GB every 6 hours per worker.
+[The full story](https://www.tariqamarneh.com/writing/grpc-contextvars-memory-leak).
+
+## Use it as an agent skill
+
+The skill walks an agent through the method: confirm the growth is real, reproduce one unit
+of work, find what accumulates, trace what holds it, fix it by pattern, then prove it and add a
+regression test. It installs the package below as needed.
+
+```bash
+git clone https://github.com/tariqamarneh/python-leak-hunter
+
+# Claude Code: for you, or for one project
+cp -r python-leak-hunter/skills/python-leak-hunter ~/.claude/skills/
+cp -r python-leak-hunter/skills/python-leak-hunter your-project/.claude/skills/
+
+# Codex: per repository
+cp -r python-leak-hunter/skills/python-leak-hunter your-project/.agents/skills/
+```
+
+Then ask: *"Memory in our worker keeps growing. Find the leak."*
+
+## Use it directly
+
+```bash
+pip install python-leak-hunter
+```
+
+No dependencies. Python 3.10+.
+
+### 1. What accumulates?
+
+Write a function that runs one unit of work (a request, a message, an agent turn), then:
+
+```bash
+leak-hunter check harness:one_request --include myapp. --iterations 30
+```
+
+```text
+Objects accumulating across calls (2 windows x 30 calls):
+  myapp.RunTrace  +1 per call  (window 1: +30, window 2: +30)
+Next: why_alive('myapp.RunTrace') shows what keeps them alive.
+```
+
+The work runs in two windows after a warm-up, and only types that grow in **both** are
+reported, so a cache filling up once is not a leak. Async functions work too. Add `--trace` to
+also list allocation sites, which catches `bytes` and `str` that the object count cannot see.
+
+### 2. What keeps it alive?
+
+```bash
+leak-hunter why harness:many_requests myapp.RunTrace
+```
+
+It walks referrers back to a root and groups instances that share a chain:
+
+- `module X, global 'name'`: a module-level cache or registry.
+- `variable v in f() at file:line`: a long-running function's local.
+- `outside Python: ...`: nothing in Python refers to that object, yet it is alive, so native
+  code holds it.
+
+### 3. Keep it fixed
+
+The `leak_check` pytest fixture is registered when the package is installed:
+
+```python
+def test_request_does_not_leak(leak_check):
+    leak_check(handle_one_request, include=["myapp."], iterations=30)
+```
+
+```python
+from leak_hunter import assert_no_leak, assert_no_leak_async, measure_growth, why_alive
+
+report = measure_growth(handle_one_request, include=["myapp."])
+print(report.format())
+print(why_alive("myapp.RunTrace").format())
+```
+
+### Is it even a leak?
+
+Sample memory in the running service and let `diagnose` separate real retention from
+fragmentation and native allocations:
+
+```python
+import logging
+from leak_hunter import MemorySampler, diagnose
+
+sampler = MemorySampler(interval=60, on_sample=lambda s: logging.info("memory %s", s.to_json()))
+sampler.start()
+...
+print(diagnose(sampler.samples))
+```
+
+```text
+RSS grows +312.4 MB/h.
+malloc heap in use grows +305.1 MB/h: memory is being retained, not fragmented. Find what accumulates (measure_growth), then what holds it (why_alive).
+```
+
+On glibc it reads `mallinfo2()` to split malloc's heap into bytes in use and bytes free. If
+free space grows while in-use stays flat, the problem is fragmentation, and hunting objects
+would be a waste of time.
+
+## Try the demo
+
+```bash
+git clone https://github.com/tariqamarneh/python-leak-hunter && cd python-leak-hunter
+uv run python examples/contextvars_leak/demo.py          # no gRPC needed
+uv run --with grpcio python examples/grpc_cycle.py       # the real thing
+```
+
+## How it works
+
+- **Growth:** counts live objects tracked by the garbage collector, by type, after a full
+  collection, around two equal windows of calls.
+- **Retention:** breadth-first search over `gc.get_referrers` from an instance to the nearest
+  module global or running frame, skipping the tool's own references. Since Python 3.11,
+  executing frames are not reported as referrers, so their locals are checked separately; an
+  object held by a running function is not mistaken for native memory. A chain that ends at
+  an object with no visible referrers is reported as held outside Python.
+- **Memory:** RSS from `psutil` when installed, otherwise `/proc` or `ps`; heap stats from
+  glibc's `mallinfo2()`; open file descriptors.
+
+## Limits
+
+- Finding instances by type only works for objects the garbage collector tracks: class
+  instances and containers, not plain `str`, `bytes` or `int`. Use `--trace` for those.
+- `why_alive` scans the heap at each step. Use it in a test or a staging process, not on a
+  hot path in production.
+- The heap split needs glibc 2.33+ (most Linux images). Elsewhere, `diagnose` falls back to the
+  object count.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check . && uv run mypy
+```
+
+MIT licensed. Built by [Tariq Amarneh](https://www.tariqamarneh.com).

python_leak_hunter-0.1.1/README.md

@@ -0,0 +1,165 @@
+# python-leak-hunter
+
+[![CI](https://github.com/tariqamarneh/python-leak-hunter/actions/workflows/ci.yml/badge.svg)](https://github.com/tariqamarneh/python-leak-hunter/actions/workflows/ci.yml)
+
+Find memory leaks in long-running Python services: **what accumulates**, **what keeps it
+alive** (down to "held by a C extension"), and **a test that keeps it fixed**. It ships with an
+[agent skill](https://github.com/tariqamarneh/python-leak-hunter/blob/main/skills/python-leak-hunter/SKILL.md) that teaches Claude Code, Codex and other
+coding agents the whole investigation, not just the tools.
+
+```text
+$ leak-hunter why harness:many_requests app.RunTrace
+
+43 live app.RunTrace; traced 5:
+5 of 5 held by:
+  outside Python: nothing the garbage collector can see refers to this grpc._plugin_wrapping._Plugin, yet it is alive (typically a C extension holding it)
+    -> grpc._plugin_wrapping._Plugin._stored_ctx
+    -> _contextvars.Context
+    -> hamt
+    -> hamt_bitmap_node
+    -> app.RunTrace  <- the object being explained
+```
+
+That output is from [a real grpcio reproduction](https://github.com/tariqamarneh/python-leak-hunter/blob/main/examples/grpc_cycle.py): a gRPC channel built
+inside a request captures the request's `contextvars` context. When that context can reach
+the channel back, the cycle runs through C code and is never freed. In production this pinned
+whole AI-agent graphs in memory, about 2 GB every 6 hours per worker.
+[The full story](https://www.tariqamarneh.com/writing/grpc-contextvars-memory-leak).
+
+## Use it as an agent skill
+
+The skill walks an agent through the method: confirm the growth is real, reproduce one unit
+of work, find what accumulates, trace what holds it, fix it by pattern, then prove it and add a
+regression test. It installs the package below as needed.
+
+```bash
+git clone https://github.com/tariqamarneh/python-leak-hunter
+
+# Claude Code: for you, or for one project
+cp -r python-leak-hunter/skills/python-leak-hunter ~/.claude/skills/
+cp -r python-leak-hunter/skills/python-leak-hunter your-project/.claude/skills/
+
+# Codex: per repository
+cp -r python-leak-hunter/skills/python-leak-hunter your-project/.agents/skills/
+```
+
+Then ask: *"Memory in our worker keeps growing. Find the leak."*
+
+## Use it directly
+
+```bash
+pip install python-leak-hunter
+```
+
+No dependencies. Python 3.10+.
+
+### 1. What accumulates?
+
+Write a function that runs one unit of work (a request, a message, an agent turn), then:
+
+```bash
+leak-hunter check harness:one_request --include myapp. --iterations 30
+```
+
+```text
+Objects accumulating across calls (2 windows x 30 calls):
+  myapp.RunTrace  +1 per call  (window 1: +30, window 2: +30)
+Next: why_alive('myapp.RunTrace') shows what keeps them alive.
+```
+
+The work runs in two windows after a warm-up, and only types that grow in **both** are
+reported, so a cache filling up once is not a leak. Async functions work too. Add `--trace` to
+also list allocation sites, which catches `bytes` and `str` that the object count cannot see.
+
+### 2. What keeps it alive?
+
+```bash
+leak-hunter why harness:many_requests myapp.RunTrace
+```
+
+It walks referrers back to a root and groups instances that share a chain:
+
+- `module X, global 'name'`: a module-level cache or registry.
+- `variable v in f() at file:line`: a long-running function's local.
+- `outside Python: ...`: nothing in Python refers to that object, yet it is alive, so native
+  code holds it.
+
+### 3. Keep it fixed
+
+The `leak_check` pytest fixture is registered when the package is installed:
+
+```python
+def test_request_does_not_leak(leak_check):
+    leak_check(handle_one_request, include=["myapp."], iterations=30)
+```
+
+```python
+from leak_hunter import assert_no_leak, assert_no_leak_async, measure_growth, why_alive
+
+report = measure_growth(handle_one_request, include=["myapp."])
+print(report.format())
+print(why_alive("myapp.RunTrace").format())
+```
+
+### Is it even a leak?
+
+Sample memory in the running service and let `diagnose` separate real retention from
+fragmentation and native allocations:
+
+```python
+import logging
+from leak_hunter import MemorySampler, diagnose
+
+sampler = MemorySampler(interval=60, on_sample=lambda s: logging.info("memory %s", s.to_json()))
+sampler.start()
+...
+print(diagnose(sampler.samples))
+```
+
+```text
+RSS grows +312.4 MB/h.
+malloc heap in use grows +305.1 MB/h: memory is being retained, not fragmented. Find what accumulates (measure_growth), then what holds it (why_alive).
+```
+
+On glibc it reads `mallinfo2()` to split malloc's heap into bytes in use and bytes free. If
+free space grows while in-use stays flat, the problem is fragmentation, and hunting objects
+would be a waste of time.
+
+## Try the demo
+
+```bash
+git clone https://github.com/tariqamarneh/python-leak-hunter && cd python-leak-hunter
+uv run python examples/contextvars_leak/demo.py          # no gRPC needed
+uv run --with grpcio python examples/grpc_cycle.py       # the real thing
+```
+
+## How it works
+
+- **Growth:** counts live objects tracked by the garbage collector, by type, after a full
+  collection, around two equal windows of calls.
+- **Retention:** breadth-first search over `gc.get_referrers` from an instance to the nearest
+  module global or running frame, skipping the tool's own references. Since Python 3.11,
+  executing frames are not reported as referrers, so their locals are checked separately; an
+  object held by a running function is not mistaken for native memory. A chain that ends at
+  an object with no visible referrers is reported as held outside Python.
+- **Memory:** RSS from `psutil` when installed, otherwise `/proc` or `ps`; heap stats from
+  glibc's `mallinfo2()`; open file descriptors.
+
+## Limits
+
+- Finding instances by type only works for objects the garbage collector tracks: class
+  instances and containers, not plain `str`, `bytes` or `int`. Use `--trace` for those.
+- `why_alive` scans the heap at each step. Use it in a test or a staging process, not on a
+  hot path in production.
+- The heap split needs glibc 2.33+ (most Linux images). Elsewhere, `diagnose` falls back to the
+  object count.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check . && uv run mypy
+```
+
+MIT licensed. Built by [Tariq Amarneh](https://www.tariqamarneh.com).

python_leak_hunter-0.1.1/examples/contextvars_leak/app.py

@@ -0,0 +1,79 @@
+"""A request handler that leaks the way a gRPC client built per request does.
+
+gRPC's Python auth plugin stores `contextvars.copy_context()` when call credentials are
+created, and the native channel keeps that plugin. Build a client inside a request and the
+request's context, with everything in its context variables (tracing run trees, callbacks,
+the agent graph), is now reachable from C code. If anything in that context reaches the
+channel back, the cycle passes through C, the garbage collector cannot see it, and none of
+it is ever freed. examples/grpc_cycle.py shows the same leak with real grpcio.
+
+`_hold_in_native_code` stands in for the C extension so this demo needs no gRPC install.
+"""
+
+from __future__ import annotations
+
+import contextvars
+import ctypes
+import threading
+from typing import Any
+
+current_run: contextvars.ContextVar[RunTrace] = contextvars.ContextVar("current_run")
+
+
+class RunTrace:
+    """Per-request tracing state, like a LangSmith run tree. Big on purpose."""
+
+    def __init__(self) -> None:
+        self.payload = bytearray(200_000)
+        self.children: list[Any] = []
+
+
+def _hold_in_native_code(obj: object) -> None:
+    """Take a reference the way a C extension does, invisible to the garbage collector."""
+    ctypes.pythonapi.Py_IncRef(ctypes.py_object(obj))
+
+
+class SearchClient:
+    """A client whose constructor captures the caller's context, like grpc credentials."""
+
+    def __init__(self) -> None:
+        _hold_in_native_code(contextvars.copy_context())
+
+    def search(self, query: str) -> list[str]:
+        return [query.upper()]
+
+
+def handle_request_leaky(query: str = "shoes") -> list[str]:
+    token = current_run.set(RunTrace())
+    try:
+        client = SearchClient()  # built inside the request: its context is captured
+        return client.search(query)
+    finally:
+        current_run.reset(token)
+
+
+_client: SearchClient | None = None
+_client_lock = threading.Lock()
+
+
+def get_client() -> SearchClient:
+    """One client per process, constructed in an empty context so it captures nothing."""
+    global _client
+    if _client is None:
+        with _client_lock:
+            if _client is None:
+                _client = contextvars.Context().run(SearchClient)
+    return _client
+
+
+def handle_request_fixed(query: str = "shoes") -> list[str]:
+    token = current_run.set(RunTrace())
+    try:
+        return get_client().search(query)
+    finally:
+        current_run.reset(token)
+
+
+def handle_many_leaky() -> None:
+    for _ in range(50):
+        handle_request_leaky()

python_leak_hunter-0.1.1/examples/contextvars_leak/demo.py

@@ -0,0 +1,25 @@
+"""Find, explain and confirm the fix for the per-request client leak in app.py.
+
+python examples/contextvars_leak/demo.py
+"""
+
+from __future__ import annotations
+
+import app
+
+from leak_hunter import measure_growth, why_alive
+
+
+def main() -> None:
+    print("1. What accumulates per request?\n")
+    print(measure_growth(app.handle_request_leaky, include=["app."]).format())
+
+    print("\n2. What keeps it alive?\n")
+    print(why_alive("app.RunTrace").format())
+
+    print("\n3. After the fix (one client per process, built in an empty context):\n")
+    print(measure_growth(app.handle_request_fixed, include=["app."]).format())
+
+
+if __name__ == "__main__":
+    main()

python_leak_hunter-0.1.1/examples/grpc_cycle.py

@@ -0,0 +1,60 @@
+"""The real thing: a gRPC channel built per request, with the request's context reaching it.
+
+pip install grpcio python-leak-hunter
+python examples/grpc_cycle.py
+"""
+
+from __future__ import annotations
+
+import contextvars
+from typing import Any
+
+import grpc  # type: ignore[import-untyped, unused-ignore]
+
+from leak_hunter import measure_growth, why_alive
+
+current_run: contextvars.ContextVar[RunTrace] = contextvars.ContextVar("current_run")
+
+
+class RunTrace:
+    """Per-request state. Like a run tree whose inputs include the client, it reaches the channel."""
+
+    channel: Any = None
+
+
+def _auth(context: Any, callback: Any) -> None:
+    callback((("authorization", "Bearer token"),), None)
+
+
+def _channel() -> Any:
+    credentials = grpc.composite_channel_credentials(
+        grpc.ssl_channel_credentials(), grpc.metadata_call_credentials(_auth)
+    )
+    return grpc.secure_channel("localhost:50051", credentials)
+
+
+def handle_request_leaky() -> None:
+    run = RunTrace()
+    token = current_run.set(run)
+    try:
+        run.channel = _channel()  # credentials capture this request's context
+    finally:
+        current_run.reset(token)
+
+
+_shared = contextvars.Context().run(_channel)  # once per process, in an empty context
+
+
+def handle_request_fixed() -> None:
+    run = RunTrace()
+    token = current_run.set(run)
+    try:
+        run.channel = _shared
+    finally:
+        current_run.reset(token)
+
+
+if __name__ == "__main__":
+    print(measure_growth(handle_request_leaky, include=[f"{__name__}."]).format(), end="\n\n")
+    print(why_alive(f"{__name__}.RunTrace").format(), end="\n\n")
+    print(measure_growth(handle_request_fixed, include=[f"{__name__}."]).format())

python_leak_hunter-0.1.1/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "python-leak-hunter"
+version = "0.1.1"
+description = "Find memory leaks in long-running Python services: what accumulates, what keeps it alive, and a test that keeps it fixed. Ships with an agent skill for Claude Code and Codex."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Tariq Amarneh", email = "tariqs.naser@gmail.com" }]
+keywords = ["memory leak", "profiling", "debugging", "pytest", "gc", "contextvars", "langgraph", "agent skill"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Debuggers",
+    "Topic :: Software Development :: Testing",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+psutil = ["psutil>=5.9"]
+
+[project.urls]
+Homepage = "https://github.com/tariqamarneh/python-leak-hunter"
+"The leak behind it" = "https://www.tariqamarneh.com/writing/grpc-contextvars-memory-leak"
+
+[project.scripts]
+leak-hunter = "leak_hunter.cli:main"
+
+[project.entry-points.pytest11]
+leak_hunter = "leak_hunter.pytest_plugin"
+
+[dependency-groups]
+dev = ["pytest>=8", "mypy>=1.11", "ruff>=0.6"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/leak_hunter"]
+
+[tool.ruff]
+line-length = 110
+target-version = "py310"
+extend-exclude = ["*.md"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+strict = true
+python_version = "3.10"
+files = ["src", "tests", "examples"]
+mypy_path = "examples/contextvars_leak"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+pythonpath = ["examples/contextvars_leak"]