typedmultidict 0.2.0__tar.gz

typedmultidict-0.2.0/.gitattributes

@@ -0,0 +1 @@
+* text=auto eol=lf

typedmultidict-0.2.0/.gitignore

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

typedmultidict-0.2.0/CHANGELOG.md

@@ -0,0 +1,44 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.2.0] - 2026-10-13
+
+### Added
+
+- `getone(key, default)`, `popone(key[, default])`, `merge(other)`, `to_dict()` and
+  `copy()`.
+- `allitems()` and `allvalues()` return live, sized views of every pair or value.
+- `update` accepts keyword arguments for string keys, like `MutableMapping.update`.
+
+### Changed
+
+- Lookups, `in`, `len()` and adding no longer scan every pair: an index keeps them
+  constant time whatever the size.
+- `update` replaces the values of each incoming key in place instead of keeping only the
+  first value of a multi-dict source, and `popitem` removes only the last pair added.
+- `popall(key, default)` accepts a default of any type.
+- Bulk input is checked in full before anything changes: `md.extend(md)` no longer hangs,
+  and a malformed element raises `TypeError` or `ValueError` with its position.
+- Changing a multi-dict while iterating over it or its views raises `RuntimeError`.
+- Comparing with a plain mapping is equal only when every key has exactly one value, and
+  a plain and a case-insensitive multi-dict compare with case folded.
+- Pickles hold plain pairs and name the classes by their public path
+  (`typedmultidict.MultiDict`); pickles written by 0.1.0 still load. Copies and pickles
+  of subclasses keep their attributes and slots, and a multi-dict may contain itself.
+- `CIMultiDict` raises `TypeError` for a non-`str` key on write and treats it as absent on
+  read, instead of failing with `AttributeError`.
+
+## [0.1.0]
+
+- First release.
+- `MultiDict[K, V]`: typed, insertion-ordered multi-value mapping implementing
+  `MutableMapping`, with `add`, `getone`, `getall`, `popall`, `extend` and `allitems`.
+- `CIMultiDict[V]`: case-insensitive string-keyed variant that preserves the original
+  casing of each key.
+- Pure Python, zero runtime dependencies, `py.typed`, `mypy --strict` clean. Unlike the
+  C-extension `multidict`, it needs no build step.

typedmultidict-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,22 @@
+# Contributing
+
+Thanks for taking the time. This project keeps a small, predictable shape.
+
+## Setup
+
+```
+pip install -r requirements-dev.txt
+```
+
+## Before you open a pull request
+
+- Keep public API in `src/typedmultidict/__init__.py`; internals live in `_`-prefixed modules.
+- Add a test for the behaviour you change. Tests inject time, disk and network; they
+  never touch the real thing.
+- Run `scripts/check.ps1` (format, lint, types, tests) and make sure it passes.
+- Set `TYPEDMULTIDICT_E2E=1` to also build the wheel, install it in a fresh venv and
+  exercise it. `multidict` and `werkzeug` are dev dependencies used only as reference
+  implementations in the tests; the library never imports them.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

typedmultidict-0.2.0/LICENSE

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

typedmultidict-0.2.0/PKG-INFO

@@ -0,0 +1,213 @@
+Metadata-Version: 2.5
+Name: typedmultidict
+Version: 0.2.0
+Summary: Pure-Python typed ordered multi-value dictionary with a case-insensitive variant
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/typedmultidict
+Project-URL: Issues, https://github.com/JaviLianes8/typedmultidict/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/typedmultidict/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: dictionary,headers,mapping,multi-value,multidict,typed
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: hypothesis; extra == 'dev'
+Requires-Dist: multidict; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Requires-Dist: werkzeug; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# typedmultidict
+
+Pure-Python typed ordered multi-value dictionary with a case-insensitive variant.
+
+## Install
+
+```
+pip install typedmultidict
+```
+
+## Usage
+
+A `MultiDict[K, V]` is a normal mapping over the first value of each key, plus methods
+that see every value. Pairs keep their insertion order across keys.
+
+```python
+from typedmultidict import MultiDict
+
+params: MultiDict[str, str] = MultiDict([("tag", "python"), ("page", "2")])
+params.add("tag", "typing")
+
+print(params["tag"])  # python
+print(params.getall("tag"))  # ['python', 'typing']
+print(len(params), len(params.allitems()))  # 2 3
+print(list(params.allitems()))  # [('tag', 'python'), ('page', '2'), ('tag', 'typing')]
+print(dict(params))  # {'tag': 'python', 'page': '2'}
+print(params.to_dict())  # {'tag': ['python', 'typing'], 'page': ['2']}
+```
+
+Assigning replaces every value of a key in the position of its first one; removing can
+take the first value, every value, or the last pair added:
+
+```python
+from typedmultidict import MultiDict
+
+md = MultiDict([("a", 1), ("b", 2), ("a", 3), ("a", 4)])
+md["a"] = 9
+print(md)  # MultiDict([('a', 9), ('b', 2)])
+
+md.extend([("a", 5), ("c", 6)])
+print(md.popone("a"), md.getall("a"))  # 9 [5]
+print(md.popall("a"), "a" in md)  # [5] False
+print(md.popitem(), md)  # ('c', 6) MultiDict([('b', 2)])
+print(md.getone("missing", "default"))  # default
+```
+
+`extend` appends, `merge` only adds keys that are not present yet, and `update` replaces
+the values of each incoming key in place (extra new values go to the end, extra old
+values are dropped):
+
+```python
+from typedmultidict import MultiDict
+
+md = MultiDict([("a", 1), ("b", 2), ("a", 3)])
+md.merge([("a", 0), ("c", 4)])
+print(md)  # MultiDict([('a', 1), ('b', 2), ('a', 3), ('c', 4)])
+md.update([("a", 7), ("a", 8), ("a", 9)], b=0)
+print(md)  # MultiDict([('a', 7), ('b', 0), ('a', 8), ('c', 4), ('a', 9)])
+```
+
+`CIMultiDict[V]` has `str` keys compared case-insensitively. Every pair keeps the spelling
+it was added with, and keys are listed in the spelling of their first pair:
+
+```python
+from typedmultidict import CIMultiDict
+
+headers: CIMultiDict[str] = CIMultiDict()
+headers.add("Set-Cookie", "a=1")
+headers.add("set-cookie", "b=2")
+headers.add("Content-Type", "text/html")
+
+print(headers["SET-COOKIE"])  # a=1
+print(headers.getall("set-cookie"))  # ['a=1', 'b=2']
+print(list(headers))  # ['Set-Cookie', 'Content-Type']
+print(5 in headers)  # False
+```
+
+Views from `allitems()` and `allvalues()` follow the mapping. Changing the mapping while
+iterating over it, or over any of its views, raises `RuntimeError`. As in `multidict`,
+every write counts, even replacing a value in place (which `dict` allows):
+
+```python
+from typedmultidict import MultiDict
+
+md = MultiDict([("a", 1)])
+pairs = md.allitems()
+md.add("a", 2)
+print(len(pairs), ("a", 2) in pairs)  # 2 True
+try:
+    for key in md:
+        md.add("b", 3)
+except RuntimeError as error:
+    print(error)  # multi-dict changed during iteration
+```
+
+Equality, copies and pickles:
+
+```python
+import pickle
+
+from typedmultidict import CIMultiDict, MultiDict
+
+print(MultiDict([("a", 1), ("b", 2)]) == MultiDict([("b", 2), ("a", 1)]))  # False
+print(MultiDict([("a", 1), ("b", 2)]) == {"b": 2, "a": 1})  # True
+print(MultiDict([("a", 1), ("a", 2)]) == {"a": 1})  # False
+print(CIMultiDict([("A", 1)]) == MultiDict([("a", 1)]))  # True
+
+headers = CIMultiDict([("X-Id", "1")])
+print(pickle.loads(pickle.dumps(headers)))  # CIMultiDict([('X-Id', '1')])
+print(headers.copy() == headers, headers.copy() is headers)  # True False
+```
+
+## API
+
+| Name | What it does |
+| --- | --- |
+| `MultiDict[K, V](initial=None)` | Ordered multi-value mapping. `initial` is a mapping, a multi-dict (every pair is copied) or an iterable of pairs. `K` must be hashable. |
+| `CIMultiDict[V](initial=None)` | `MultiDict[str, V]` whose keys compare with `str.lower`. A non-`str` key raises `TypeError` when added and is absent when looked up. |
+| `md[key]`, `get`, `in`, `keys`, `items`, `values`, `len()`, iteration | The `Mapping` view: first value of each key, keys once each. |
+| `md[key] = value` | Replaces every value of `key` with one, in the place of the first. |
+| `del md[key]`, `pop(key[, default])` | Remove every value of `key` (`pop` returns the first). |
+| `setdefault(key[, default])` | First value of `key`, or adds `default`. |
+| `add(key, value)` | Appends one more pair. |
+| `extend(other)` | Appends every pair of `other`. |
+| `merge(other)` | Appends the pairs whose key is not present yet. |
+| `update(other=(), /, **kwargs)` | Replaces the values of each incoming key in place. |
+| `getone(key[, default])` | First value, else `default`, else `KeyError`. |
+| `getall(key)` | New list of every value of `key`, empty if absent. |
+| `popone(key[, default])` | Removes and returns the first value only. |
+| `popall(key[, default])` | Removes and returns every value as a list. |
+| `popitem()` | Removes and returns the last pair added (`KeyError` when empty). |
+| `allitems()`, `allvalues()` | Live views of every pair or value; `len()` counts pairs. |
+| `to_dict()` | New `dict` from each key to a new list of its values. |
+| `copy()`, `clear()` | Shallow copy of the same class; remove everything. |
+
+Bulk input (`initial`, `extend`, `merge`, `update`) is read and checked in full first: an
+element that is not a pair raises `TypeError`, one of the wrong length raises
+`ValueError`, both with its position, and the mapping is left unchanged. Lookups cost the
+same whatever the size; removals are linear in the number of pairs.
+
+### Compared with `multidict` and Werkzeug
+
+The method names and their behaviour follow the `multidict` package, with two
+differences that keep the type a consistent `Mapping`: `len()` counts keys (use
+`len(md.allitems())` for pairs), and `keys`, `items` and `values` show the first value of
+each key, as Werkzeug's `MultiDict` does. `getall` returns an empty list for a missing
+key instead of raising, and `pop` removes every value of the key.
+
+Like `dict`, a multi-dict is not safe to change from several threads at once without a
+lock. Equality between a plain and a case-insensitive multi-dict folds case, so it is not
+transitive across the two kinds. Any other mapping, a `multidict.MultiDict` included, is
+compared as a plain mapping.
+
+## Why
+
+HTTP headers and query strings routinely carry repeated keys, so a mapping that keeps every
+value is a common need. The existing options each fall short for a plain, typed project:
+
+- `multidict` (the aiohttp one) is a C extension; its pure-Python fallback runs many times
+  slower and still needs a build step for the fast path.
+- `orderedmultidict` depends on `six` and ships no type hints.
+- The `MultiDict` types in `werkzeug` and `starlette` come bundled with a whole framework.
+
+`typedmultidict` is a single, standalone, fully typed implementation with `py.typed`, zero
+runtime dependencies and no compilation. Reach for it when you want multi-value semantics
+and `mypy --strict` support without pulling in a framework or a native wheel.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

typedmultidict-0.2.0/README.md

@@ -0,0 +1,176 @@
+# typedmultidict
+
+Pure-Python typed ordered multi-value dictionary with a case-insensitive variant.
+
+## Install
+
+```
+pip install typedmultidict
+```
+
+## Usage
+
+A `MultiDict[K, V]` is a normal mapping over the first value of each key, plus methods
+that see every value. Pairs keep their insertion order across keys.
+
+```python
+from typedmultidict import MultiDict
+
+params: MultiDict[str, str] = MultiDict([("tag", "python"), ("page", "2")])
+params.add("tag", "typing")
+
+print(params["tag"])  # python
+print(params.getall("tag"))  # ['python', 'typing']
+print(len(params), len(params.allitems()))  # 2 3
+print(list(params.allitems()))  # [('tag', 'python'), ('page', '2'), ('tag', 'typing')]
+print(dict(params))  # {'tag': 'python', 'page': '2'}
+print(params.to_dict())  # {'tag': ['python', 'typing'], 'page': ['2']}
+```
+
+Assigning replaces every value of a key in the position of its first one; removing can
+take the first value, every value, or the last pair added:
+
+```python
+from typedmultidict import MultiDict
+
+md = MultiDict([("a", 1), ("b", 2), ("a", 3), ("a", 4)])
+md["a"] = 9
+print(md)  # MultiDict([('a', 9), ('b', 2)])
+
+md.extend([("a", 5), ("c", 6)])
+print(md.popone("a"), md.getall("a"))  # 9 [5]
+print(md.popall("a"), "a" in md)  # [5] False
+print(md.popitem(), md)  # ('c', 6) MultiDict([('b', 2)])
+print(md.getone("missing", "default"))  # default
+```
+
+`extend` appends, `merge` only adds keys that are not present yet, and `update` replaces
+the values of each incoming key in place (extra new values go to the end, extra old
+values are dropped):
+
+```python
+from typedmultidict import MultiDict
+
+md = MultiDict([("a", 1), ("b", 2), ("a", 3)])
+md.merge([("a", 0), ("c", 4)])
+print(md)  # MultiDict([('a', 1), ('b', 2), ('a', 3), ('c', 4)])
+md.update([("a", 7), ("a", 8), ("a", 9)], b=0)
+print(md)  # MultiDict([('a', 7), ('b', 0), ('a', 8), ('c', 4), ('a', 9)])
+```
+
+`CIMultiDict[V]` has `str` keys compared case-insensitively. Every pair keeps the spelling
+it was added with, and keys are listed in the spelling of their first pair:
+
+```python
+from typedmultidict import CIMultiDict
+
+headers: CIMultiDict[str] = CIMultiDict()
+headers.add("Set-Cookie", "a=1")
+headers.add("set-cookie", "b=2")
+headers.add("Content-Type", "text/html")
+
+print(headers["SET-COOKIE"])  # a=1
+print(headers.getall("set-cookie"))  # ['a=1', 'b=2']
+print(list(headers))  # ['Set-Cookie', 'Content-Type']
+print(5 in headers)  # False
+```
+
+Views from `allitems()` and `allvalues()` follow the mapping. Changing the mapping while
+iterating over it, or over any of its views, raises `RuntimeError`. As in `multidict`,
+every write counts, even replacing a value in place (which `dict` allows):
+
+```python
+from typedmultidict import MultiDict
+
+md = MultiDict([("a", 1)])
+pairs = md.allitems()
+md.add("a", 2)
+print(len(pairs), ("a", 2) in pairs)  # 2 True
+try:
+    for key in md:
+        md.add("b", 3)
+except RuntimeError as error:
+    print(error)  # multi-dict changed during iteration
+```
+
+Equality, copies and pickles:
+
+```python
+import pickle
+
+from typedmultidict import CIMultiDict, MultiDict
+
+print(MultiDict([("a", 1), ("b", 2)]) == MultiDict([("b", 2), ("a", 1)]))  # False
+print(MultiDict([("a", 1), ("b", 2)]) == {"b": 2, "a": 1})  # True
+print(MultiDict([("a", 1), ("a", 2)]) == {"a": 1})  # False
+print(CIMultiDict([("A", 1)]) == MultiDict([("a", 1)]))  # True
+
+headers = CIMultiDict([("X-Id", "1")])
+print(pickle.loads(pickle.dumps(headers)))  # CIMultiDict([('X-Id', '1')])
+print(headers.copy() == headers, headers.copy() is headers)  # True False
+```
+
+## API
+
+| Name | What it does |
+| --- | --- |
+| `MultiDict[K, V](initial=None)` | Ordered multi-value mapping. `initial` is a mapping, a multi-dict (every pair is copied) or an iterable of pairs. `K` must be hashable. |
+| `CIMultiDict[V](initial=None)` | `MultiDict[str, V]` whose keys compare with `str.lower`. A non-`str` key raises `TypeError` when added and is absent when looked up. |
+| `md[key]`, `get`, `in`, `keys`, `items`, `values`, `len()`, iteration | The `Mapping` view: first value of each key, keys once each. |
+| `md[key] = value` | Replaces every value of `key` with one, in the place of the first. |
+| `del md[key]`, `pop(key[, default])` | Remove every value of `key` (`pop` returns the first). |
+| `setdefault(key[, default])` | First value of `key`, or adds `default`. |
+| `add(key, value)` | Appends one more pair. |
+| `extend(other)` | Appends every pair of `other`. |
+| `merge(other)` | Appends the pairs whose key is not present yet. |
+| `update(other=(), /, **kwargs)` | Replaces the values of each incoming key in place. |
+| `getone(key[, default])` | First value, else `default`, else `KeyError`. |
+| `getall(key)` | New list of every value of `key`, empty if absent. |
+| `popone(key[, default])` | Removes and returns the first value only. |
+| `popall(key[, default])` | Removes and returns every value as a list. |
+| `popitem()` | Removes and returns the last pair added (`KeyError` when empty). |
+| `allitems()`, `allvalues()` | Live views of every pair or value; `len()` counts pairs. |
+| `to_dict()` | New `dict` from each key to a new list of its values. |
+| `copy()`, `clear()` | Shallow copy of the same class; remove everything. |
+
+Bulk input (`initial`, `extend`, `merge`, `update`) is read and checked in full first: an
+element that is not a pair raises `TypeError`, one of the wrong length raises
+`ValueError`, both with its position, and the mapping is left unchanged. Lookups cost the
+same whatever the size; removals are linear in the number of pairs.
+
+### Compared with `multidict` and Werkzeug
+
+The method names and their behaviour follow the `multidict` package, with two
+differences that keep the type a consistent `Mapping`: `len()` counts keys (use
+`len(md.allitems())` for pairs), and `keys`, `items` and `values` show the first value of
+each key, as Werkzeug's `MultiDict` does. `getall` returns an empty list for a missing
+key instead of raising, and `pop` removes every value of the key.
+
+Like `dict`, a multi-dict is not safe to change from several threads at once without a
+lock. Equality between a plain and a case-insensitive multi-dict folds case, so it is not
+transitive across the two kinds. Any other mapping, a `multidict.MultiDict` included, is
+compared as a plain mapping.
+
+## Why
+
+HTTP headers and query strings routinely carry repeated keys, so a mapping that keeps every
+value is a common need. The existing options each fall short for a plain, typed project:
+
+- `multidict` (the aiohttp one) is a C extension; its pure-Python fallback runs many times
+  slower and still needs a build step for the fast path.
+- `orderedmultidict` depends on `six` and ships no type hints.
+- The `MultiDict` types in `werkzeug` and `starlette` come bundled with a whole framework.
+
+`typedmultidict` is a single, standalone, fully typed implementation with `py.typed`, zero
+runtime dependencies and no compilation. Reach for it when you want multi-value semantics
+and `mypy --strict` support without pulling in a framework or a native wheel.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

typedmultidict-0.2.0/pyproject.toml

@@ -0,0 +1,71 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "typedmultidict"
+version = "0.2.0"
+description = "Pure-Python typed ordered multi-value dictionary with a case-insensitive variant"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Javier Lianes", email = "javier@lianes8studio.com" }]
+keywords = ["multidict", "multi-value", "dictionary", "mapping", "headers", "typed"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "ruff",
+    "mypy",
+    "pytest",
+    "hypothesis",
+    "build",
+    "twine",
+    # Test-only reference implementations; the library never imports them.
+    "multidict",
+    "werkzeug",
+]
+
+[project.urls]
+Homepage = "https://lianes8studio.com"
+Repository = "https://github.com/JaviLianes8/typedmultidict"
+Issues = "https://github.com/JaviLianes8/typedmultidict/issues"
+Changelog = "https://github.com/JaviLianes8/typedmultidict/blob/main/CHANGELOG.md"
+LinkedIn = "https://www.linkedin.com/in/jlianes/"
+Funding = "https://buymeacoffee.com/jlianesglrs"
+
+[tool.hatch.build.targets.sdist]
+exclude = [".github", "IMPROVEMENTS-round*.md"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/typedmultidict"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-q"

typedmultidict-0.2.0/requirements-dev.txt

@@ -0,0 +1,3 @@
+# Development dependencies: the package in editable mode plus its dev extras
+# (ruff, mypy, pytest, build, twine). Install with:  pip install -r requirements-dev.txt
+-e .[dev]

typedmultidict-0.2.0/scripts/check.ps1

@@ -0,0 +1,16 @@
+# Local quality gate. Run before every commit. No CI runs in the cloud.
+# $ErrorActionPreference does NOT stop on a native command's non-zero exit, so each tool's
+# exit code is checked explicitly: a red gate must fail, never pass silently.
+$ErrorActionPreference = "Stop"
+
+function Invoke-Step($label, [scriptblock]$cmd) {
+    Write-Host "== $label =="
+    & $cmd
+    if ($LASTEXITCODE -ne 0) { Write-Host "FAILED: $label (exit $LASTEXITCODE)"; exit $LASTEXITCODE }
+}
+
+Invoke-Step "ruff format" { ruff format --check . }
+Invoke-Step "ruff lint"   { ruff check . }
+Invoke-Step "mypy"        { mypy --strict src tests }
+Invoke-Step "pytest"      { pytest }
+Write-Host "gate green"

typedmultidict-0.2.0/scripts/release.ps1

@@ -0,0 +1,28 @@
+# Build and upload to PyPI. Run scripts/check.ps1 first.
+# The name must not already exist on PyPI; the token is read from a secret store, never git.
+$ErrorActionPreference = "Stop"
+
+# Works on both Windows PowerShell 5.1 and pwsh 7 (generic catch, no PS7-only types).
+$taken = $true
+try {
+    Invoke-WebRequest -UseBasicParsing "https://pypi.org/pypi/typedmultidict/json" | Out-Null
+} catch {
+    if ($_.Exception.Response.StatusCode.value__ -eq 404) { $taken = $false } else { throw }
+}
+if ($taken) { throw "The name 'typedmultidict' already exists on PyPI. Choose another before publishing." }
+
+$token = $env:PYPI_TOKEN
+if (-not $token -and (Test-Path "C:\secrets\pypi-token.txt")) {
+    $token = (Get-Content "C:\secrets\pypi-token.txt" -Raw).Trim()
+}
+if (-not $token) {
+    throw "No PyPI token. Set `$env:PYPI_TOKEN or save it to C:\secrets\pypi-token.txt (never commit it)."
+}
+
+Remove-Item -Recurse -Force dist -ErrorAction SilentlyContinue
+python -m build
+python -m twine check dist/*
+
+$env:TWINE_USERNAME = "__token__"
+$env:TWINE_PASSWORD = $token
+try { python -m twine upload dist/* } finally { Remove-Item Env:\TWINE_PASSWORD -ErrorAction SilentlyContinue }

typedmultidict-0.2.0/src/typedmultidict/__init__.py

@@ -0,0 +1,14 @@
+"""Pure-Python typed ordered multi-value dictionary with a case-insensitive variant."""
+
+from __future__ import annotations
+
+from ._cimultidict import CIMultiDict
+from ._multidict import MultiDict
+
+__version__ = "0.2.0"
+
+# Pickles name a class by its module: point them at the public one, which never moves.
+CIMultiDict.__module__ = __name__
+MultiDict.__module__ = __name__
+
+__all__ = ["CIMultiDict", "MultiDict"]

typedmultidict-0.2.0/src/typedmultidict/_cimultidict.py

@@ -0,0 +1,31 @@
+"""Case-insensitive multi-value mapping for HTTP-style string keys."""
+
+from __future__ import annotations
+
+from collections.abc import Hashable
+from typing import ClassVar, TypeVar
+
+from ._multidict import MultiDict
+
+V = TypeVar("V")
+
+# Never equal to a stored token, so a key of the wrong type is simply absent on lookup.
+_NO_MATCH = object()
+
+
+class CIMultiDict(MultiDict[str, V]):
+    """Keys compare case-insensitively (``str.lower``); each pair keeps its own spelling.
+
+    Keys must be ``str`` (or a subclass): adding any other key raises ``TypeError``, while
+    looking one up simply finds nothing.
+    """
+
+    _folds_case: ClassVar[bool] = True
+
+    def _token(self, key: str) -> Hashable:
+        if not isinstance(key, str):
+            raise TypeError(f"{type(self).__name__} keys must be str, not {type(key).__name__}")
+        return str.lower(key)
+
+    def _probe(self, key: object) -> Hashable:
+        return str.lower(key) if isinstance(key, str) else _NO_MATCH