teluri 0.2.0__tar.gz

teluri-0.2.0/.gitignore

@@ -0,0 +1,16 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Third-party reference files, fetched locally by scripts/fetch_upstream.py; only the manifest is tracked.
+tests/upstream/*
+!tests/upstream/MANIFEST.json

teluri-0.2.0/CHANGELOG.md

@@ -0,0 +1,42 @@
+# 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]
+
+### Added
+
+- `TelURIError.reason` from the closed set `Reason`; errors survive pickling.
+- Full RFC 3966 grammar: ASCII digits only, domain names per the ABNF, `pvalue` and
+  percent-encoding checks, `isub` per erratum 203, `ext` and `isub` mutually exclusive.
+- `parse(..., strict=True)` enforces the section 3 parameter order.
+- `equivalent(a, b)`, and `==` and `hash` on `TelURI`, follow the section 4 rules.
+- `TelURI.isub`, `is_e164`, `unknown_mandatory` and `href`.
+- `parse_link` reads real-world `tel:` links (spaces, encoded numbers, missing context).
+- `build` accepts `isub`, strips spaces from printed numbers and encodes values.
+- `teluri` command line with `--json`, `--strict`, `--link` and `--context`.
+
+### Changed
+
+- `str(TelURI)` writes the canonical form: section 3 order, lower-case parameter names.
+- `TelURI(number, ext, isub, phone_context, params)`: `is_global` is now derived from the
+  number, every field is validated on construction (wrong types raise `TypeError`), and
+  `params` is read-only and hashable.
+- `params` values are percent-decoded; `isub` has its own field.
+- `build` percent-encodes `params` values, so callers that passed encoded values must now
+  pass plain text.
+- `TelURIError(reason, message)` replaces the single message argument.
+
+## [0.1.0]
+
+- First release: parse and build tel: URIs per RFC 3966.
+- `parse` reads global numbers (leading `+`) and local numbers with a
+  `phone-context`, strips visual separators, and keeps other parameters verbatim.
+- `build` composes a tel: URI from a number, optional `ext`, optional
+  `phone-context` and extra parameters, normalizing visual separators.
+- `TelURI` is a frozen, typed result whose `str()` round-trips through `build`.
+- `TelURIError` signals malformed input.

teluri-0.2.0/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# 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/teluri/__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.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

teluri-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.

teluri-0.2.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.5
+Name: teluri
+Version: 0.2.0
+Summary: Strict, typed, zero-dependency parser, builder and comparator for tel: URIs (RFC 3966), with a reader for real-world tel: links
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/teluri
+Project-URL: Issues, https://github.com/JaviLianes8/teluri/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/teluri/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: e164,href,link,parser,phone,phone-number,rfc3966,sip,tel,telephone,uri
+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: Topic :: Communications :: Telephony
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# teluri
+
+Strict, typed, zero-dependency parser, builder and comparator for `tel:` URIs
+(RFC 3966), with a reader for the `tel:` links found in real web pages and apps.
+
+## Install
+
+```
+pip install teluri
+```
+
+## Usage
+
+### Parse
+
+```python
+from teluri import parse
+
+uri = parse("tel:+1-201-555-0123;ext=1234")
+print(uri.number)  # +12015550123
+print(uri.is_global)  # True
+print(uri.ext)  # 1234
+print(uri.is_e164)  # True
+print(uri)  # tel:+12015550123;ext=1234
+
+local = parse("tel:863-1234;phone-context=+1-914-555")
+print(local.number)  # 8631234
+print(local.phone_context)  # +1914555
+print(local.is_global)  # False
+```
+
+`parse` validates the whole RFC 3966 grammar and returns a frozen `TelURI`. Visual
+separators (`-`, `.`, `(`, `)`) are removed from the number, the extension and a numeric
+`phone-context`. Other parameters land in `params`, keyed by lower-case name, with
+percent-decoded values and `None` for a parameter without a value. `str()` gives a
+normalised form: separators removed, names in lower case, values re-encoded, and `ext` or
+`isub` first, then `phone-context`, then the rest sorted by name, as section 3 asks. The
+letter case of numbers, contexts and values is kept, so two equivalent URIs may still
+print differently. Wrong types (`parse(None)`, `TelURI(123)`) raise `TypeError`.
+
+### Errors
+
+```python
+from teluri import TelURIError, parse
+
+reasons = []
+for bad in ["tel:863-1234", "tel:+1;ext=1;isub=2", "tel:+1;b;a"]:
+    try:
+        parse(bad, strict=True)
+    except TelURIError as error:
+        reasons.append(error.reason)
+print(reasons)  # ['missing-context', 'ext-and-isub', 'param-order']
+```
+
+The ABNF accepts parameters in any order, so `parse` does too; `strict=True` also
+enforces the order rule of section 3, comparing names in lower case.
+
+### Compare
+
+```python
+from teluri import equivalent, parse
+
+print(equivalent("tel:+1-201-555-0123;EXT=1;a=X", "tel:+12015550123;a=x;ext=1"))  # True
+domain = "tel:7042;phone-context=Example.COM."
+print(equivalent(domain, "tel:7042;phone-context=example.com"))  # True
+print(equivalent("tel:+1234", "tel:1234;phone-context=+1"))  # False
+print(len({parse("tel:+1;b;a"), parse("tel:+1;A;B")}))  # 1
+```
+
+`==`, `hash` and `equivalent` follow section 4: global and local numbers never match,
+separators are ignored, a numeric context is compared digit by digit and a domain context
+as a host name (a final root dot is ignored), parameters are compared by name in any
+order, and the comparison is case-insensitive. Values, including `isub`, are compared as
+their percent-decoded octets with ASCII letters folded, so `%2F` equals `/` and `%41`
+equals `a`, while `%C3%A9` and `%C3%89` stay different.
+
+### Build
+
+```python
+from teluri import build
+
+print(build("+1 (201) 555-0123", ext="1234"))  # tel:+12015550123;ext=1234
+print(build("7042", phone_context="example.com"))  # tel:7042;phone-context=example.com
+print(build("+1 201 555 0123", params={"note": "a;b c"}))  # tel:+12015550123;note=a%3Bb%20c
+```
+
+`build` takes human input: it removes spaces and separators from the numbers, encodes
+parameter values, refuses `ext`, `isub` and `phone-context` inside `params`, and always
+writes the canonical order. The result always parses back with `strict=True`.
+
+### Links in the wild
+
+```python
+from teluri import parse_link
+
+print(parse_link("tel:+1 201 555 0123"))  # tel:+12015550123
+print(parse_link("tel:1-408-555-5555", context="+1"))  # tel:14085555555;phone-context=+1
+print(parse_link("tel:*31%23", context="example.com").href)  # tel:*31%23;phone-context=example.com
+```
+
+Web pages and apps often write `tel:` links that RFC 3966 does not allow: spaces as in
+printed numbers, percent-encoded numbers, and local numbers without a `phone-context`
+(Apple's Phone Links reference shows `tel:1-408-555-5555`). `parse_link` decodes and
+cleans the number, adds `context` (checked as a single phone-context descriptor) to a
+local number that has none, then validates the result as RFC 3966. In the other direction, `TelURI.href` writes `#` as `%23`: an HTML
+URL parser would otherwise read it as the start of a fragment. Apple also documents that
+its Phone app does not dial a link containing `*` or `#`.
+
+### Command line
+
+```
+$ teluri "tel:+1-201-555-0123;Ext=9" "tel:863-1234"
+tel:+12015550123;ext=9
+invalid (missing-context): tel:863-1234
+```
+
+One URI per argument, or one per line on standard input. `--json` prints every field,
+`--strict` enforces the parameter order, `--link` reads links as above (not with
+`--strict`) and `--context` gives local links their context. Output is ASCII, so any
+console can print it. The exit status is 1 when any input is invalid, 2 for bad usage.
+
+## API
+
+| Name | What it does |
+| --- | --- |
+| `parse(uri, *, strict=False)` | Parse and validate a `tel:` URI, return a `TelURI` |
+| `parse_link(href, *, context=None)` | Read a real-world `tel:` link, return a `TelURI` |
+| `build(number, *, ext, isub, phone_context, params)` | Canonical `tel:` URI from human input |
+| `equivalent(a, b)` | Section 4 comparison of two URIs (strings or `TelURI`) |
+| `TelURI` | Frozen, hashable result: `number`, `ext`, `isub`, `phone_context`, `params`, `is_global`, `is_e164`, `unknown_mandatory`, `href` |
+| `TelURIError` | `ValueError` with a `reason` from `Reason` |
+| `Reason` | The closed set of reasons, listed below |
+
+`is_e164` checks the E.164 limits only: a global number of at most 15 digits whose
+country code does not start with 0. `unknown_mandatory` lists `m-` parameters; section
+5.4 says not to use a URI whose mandatory parameters you do not understand. `isub` is
+kept in its encoded form because a subaddress may carry any octet.
+
+### Reasons
+
+- `scheme`: not a `tel:` URI
+- `number`: the number is empty or has a character the grammar does not allow
+- `ext`: the extension has no digit, or a character other than digits and separators
+- `isub`: the subaddress is empty or not `1*paramchar` (erratum 203)
+- `ext-and-isub`: both are present, which section 5.3 forbids
+- `phone-context`: the context is neither a global number prefix nor a domain name
+- `missing-context`: a local number without `phone-context`
+- `global-context`: a global number with `phone-context`
+- `param-name`: a parameter name is empty, malformed, or reserved for a field
+- `param-value`: a value is empty, malformed, badly percent-encoded or not UTF-8
+- `duplicate-param`: a parameter appears twice (names compare case-insensitively)
+- `param-order`: with `strict=True`, parameters are not in the section 3 order
+
+## Why
+
+RFC 3966 `tel:` URIs are their own grammar: global numbers with a leading `+`, local
+numbers that must carry a `phone-context`, visual separators, `ext` and `isub`, and a
+comparison rule that ignores separators, case and parameter order. The standard library
+does not model any of it, general URI libraries stop at RFC 3986, and `phonenumbers` is a
+number-validation database rather than a URI codec. teluri is a small, strict, typed one,
+with the browser and phone dialect handled explicitly instead of by accident.
+
+## Sources
+
+RFC 3966 and its errata, the IANA tel URI parameter registry, RFC 4694, 4715, 4759 and
+4904 for the registered parameters. Their examples are checked by the test suite; run
+`python scripts/fetch_upstream.py` to fetch the texts and enable the tests that compare
+against them.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

teluri-0.2.0/README.md

@@ -0,0 +1,178 @@
+# teluri
+
+Strict, typed, zero-dependency parser, builder and comparator for `tel:` URIs
+(RFC 3966), with a reader for the `tel:` links found in real web pages and apps.
+
+## Install
+
+```
+pip install teluri
+```
+
+## Usage
+
+### Parse
+
+```python
+from teluri import parse
+
+uri = parse("tel:+1-201-555-0123;ext=1234")
+print(uri.number)  # +12015550123
+print(uri.is_global)  # True
+print(uri.ext)  # 1234
+print(uri.is_e164)  # True
+print(uri)  # tel:+12015550123;ext=1234
+
+local = parse("tel:863-1234;phone-context=+1-914-555")
+print(local.number)  # 8631234
+print(local.phone_context)  # +1914555
+print(local.is_global)  # False
+```
+
+`parse` validates the whole RFC 3966 grammar and returns a frozen `TelURI`. Visual
+separators (`-`, `.`, `(`, `)`) are removed from the number, the extension and a numeric
+`phone-context`. Other parameters land in `params`, keyed by lower-case name, with
+percent-decoded values and `None` for a parameter without a value. `str()` gives a
+normalised form: separators removed, names in lower case, values re-encoded, and `ext` or
+`isub` first, then `phone-context`, then the rest sorted by name, as section 3 asks. The
+letter case of numbers, contexts and values is kept, so two equivalent URIs may still
+print differently. Wrong types (`parse(None)`, `TelURI(123)`) raise `TypeError`.
+
+### Errors
+
+```python
+from teluri import TelURIError, parse
+
+reasons = []
+for bad in ["tel:863-1234", "tel:+1;ext=1;isub=2", "tel:+1;b;a"]:
+    try:
+        parse(bad, strict=True)
+    except TelURIError as error:
+        reasons.append(error.reason)
+print(reasons)  # ['missing-context', 'ext-and-isub', 'param-order']
+```
+
+The ABNF accepts parameters in any order, so `parse` does too; `strict=True` also
+enforces the order rule of section 3, comparing names in lower case.
+
+### Compare
+
+```python
+from teluri import equivalent, parse
+
+print(equivalent("tel:+1-201-555-0123;EXT=1;a=X", "tel:+12015550123;a=x;ext=1"))  # True
+domain = "tel:7042;phone-context=Example.COM."
+print(equivalent(domain, "tel:7042;phone-context=example.com"))  # True
+print(equivalent("tel:+1234", "tel:1234;phone-context=+1"))  # False
+print(len({parse("tel:+1;b;a"), parse("tel:+1;A;B")}))  # 1
+```
+
+`==`, `hash` and `equivalent` follow section 4: global and local numbers never match,
+separators are ignored, a numeric context is compared digit by digit and a domain context
+as a host name (a final root dot is ignored), parameters are compared by name in any
+order, and the comparison is case-insensitive. Values, including `isub`, are compared as
+their percent-decoded octets with ASCII letters folded, so `%2F` equals `/` and `%41`
+equals `a`, while `%C3%A9` and `%C3%89` stay different.
+
+### Build
+
+```python
+from teluri import build
+
+print(build("+1 (201) 555-0123", ext="1234"))  # tel:+12015550123;ext=1234
+print(build("7042", phone_context="example.com"))  # tel:7042;phone-context=example.com
+print(build("+1 201 555 0123", params={"note": "a;b c"}))  # tel:+12015550123;note=a%3Bb%20c
+```
+
+`build` takes human input: it removes spaces and separators from the numbers, encodes
+parameter values, refuses `ext`, `isub` and `phone-context` inside `params`, and always
+writes the canonical order. The result always parses back with `strict=True`.
+
+### Links in the wild
+
+```python
+from teluri import parse_link
+
+print(parse_link("tel:+1 201 555 0123"))  # tel:+12015550123
+print(parse_link("tel:1-408-555-5555", context="+1"))  # tel:14085555555;phone-context=+1
+print(parse_link("tel:*31%23", context="example.com").href)  # tel:*31%23;phone-context=example.com
+```
+
+Web pages and apps often write `tel:` links that RFC 3966 does not allow: spaces as in
+printed numbers, percent-encoded numbers, and local numbers without a `phone-context`
+(Apple's Phone Links reference shows `tel:1-408-555-5555`). `parse_link` decodes and
+cleans the number, adds `context` (checked as a single phone-context descriptor) to a
+local number that has none, then validates the result as RFC 3966. In the other direction, `TelURI.href` writes `#` as `%23`: an HTML
+URL parser would otherwise read it as the start of a fragment. Apple also documents that
+its Phone app does not dial a link containing `*` or `#`.
+
+### Command line
+
+```
+$ teluri "tel:+1-201-555-0123;Ext=9" "tel:863-1234"
+tel:+12015550123;ext=9
+invalid (missing-context): tel:863-1234
+```
+
+One URI per argument, or one per line on standard input. `--json` prints every field,
+`--strict` enforces the parameter order, `--link` reads links as above (not with
+`--strict`) and `--context` gives local links their context. Output is ASCII, so any
+console can print it. The exit status is 1 when any input is invalid, 2 for bad usage.
+
+## API
+
+| Name | What it does |
+| --- | --- |
+| `parse(uri, *, strict=False)` | Parse and validate a `tel:` URI, return a `TelURI` |
+| `parse_link(href, *, context=None)` | Read a real-world `tel:` link, return a `TelURI` |
+| `build(number, *, ext, isub, phone_context, params)` | Canonical `tel:` URI from human input |
+| `equivalent(a, b)` | Section 4 comparison of two URIs (strings or `TelURI`) |
+| `TelURI` | Frozen, hashable result: `number`, `ext`, `isub`, `phone_context`, `params`, `is_global`, `is_e164`, `unknown_mandatory`, `href` |
+| `TelURIError` | `ValueError` with a `reason` from `Reason` |
+| `Reason` | The closed set of reasons, listed below |
+
+`is_e164` checks the E.164 limits only: a global number of at most 15 digits whose
+country code does not start with 0. `unknown_mandatory` lists `m-` parameters; section
+5.4 says not to use a URI whose mandatory parameters you do not understand. `isub` is
+kept in its encoded form because a subaddress may carry any octet.
+
+### Reasons
+
+- `scheme`: not a `tel:` URI
+- `number`: the number is empty or has a character the grammar does not allow
+- `ext`: the extension has no digit, or a character other than digits and separators
+- `isub`: the subaddress is empty or not `1*paramchar` (erratum 203)
+- `ext-and-isub`: both are present, which section 5.3 forbids
+- `phone-context`: the context is neither a global number prefix nor a domain name
+- `missing-context`: a local number without `phone-context`
+- `global-context`: a global number with `phone-context`
+- `param-name`: a parameter name is empty, malformed, or reserved for a field
+- `param-value`: a value is empty, malformed, badly percent-encoded or not UTF-8
+- `duplicate-param`: a parameter appears twice (names compare case-insensitively)
+- `param-order`: with `strict=True`, parameters are not in the section 3 order
+
+## Why
+
+RFC 3966 `tel:` URIs are their own grammar: global numbers with a leading `+`, local
+numbers that must carry a `phone-context`, visual separators, `ext` and `isub`, and a
+comparison rule that ignores separators, case and parameter order. The standard library
+does not model any of it, general URI libraries stop at RFC 3986, and `phonenumbers` is a
+number-validation database rather than a URI codec. teluri is a small, strict, typed one,
+with the browser and phone dialect handled explicitly instead of by accident.
+
+## Sources
+
+RFC 3966 and its errata, the IANA tel URI parameter registry, RFC 4694, 4715, 4759 and
+4904 for the registered parameters. Their examples are checked by the test suite; run
+`python scripts/fetch_upstream.py` to fetch the texts and enable the tests that compare
+against them.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

teluri-0.2.0/pyproject.toml

@@ -0,0 +1,78 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "teluri"
+version = "0.2.0"
+description = "Strict, typed, zero-dependency parser, builder and comparator for tel: URIs (RFC 3966), with a reader for real-world tel: links"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Javier Lianes", email = "javier@lianes8studio.com" }]
+keywords = ["tel", "uri", "rfc3966", "telephone", "phone", "phone-number", "e164", "href", "link", "sip", "parser"]
+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",
+    "Topic :: Communications :: Telephony",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["ruff", "mypy", "pytest", "build", "twine"]
+
+[project.urls]
+Homepage = "https://lianes8studio.com"
+Repository = "https://github.com/JaviLianes8/teluri"
+Issues = "https://github.com/JaviLianes8/teluri/issues"
+Changelog = "https://github.com/JaviLianes8/teluri/blob/main/CHANGELOG.md"
+LinkedIn = "https://www.linkedin.com/in/jlianes/"
+Funding = "https://buymeacoffee.com/jlianesglrs"
+
+[project.scripts]
+teluri = "teluri._cli:main"
+
+[tool.hatch.build.targets.sdist]
+# Third-party reference files are fetched locally and never shipped; only their manifest is.
+include = [
+    "src/teluri",
+    "tests/*.py",
+    "tests/data/examples.json",
+    "tests/upstream/MANIFEST.json",
+    "scripts/fetch_upstream.py",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "README.md",
+    "LICENSE",
+    "pyproject.toml",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/teluri"]
+
+[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"

teluri-0.2.0/scripts/fetch_upstream.py

@@ -0,0 +1,37 @@
+"""Fetch the third-party test files listed in tests/upstream/MANIFEST.json.
+
+The files are not part of the repository. Their tests skip until this script has fetched
+them; each download is checked against the size and sha256 in the manifest.
+
+    python scripts/fetch_upstream.py
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import sys
+import urllib.request
+from pathlib import Path
+
+FOLDER = Path(__file__).resolve().parents[1] / "tests" / "upstream"
+
+
+def main() -> int:
+    manifest = json.loads((FOLDER / "MANIFEST.json").read_text(encoding="utf-8"))
+    failed = 0
+    for name, entry in manifest.items():
+        with urllib.request.urlopen(entry["url"], timeout=60) as response:
+            body = response.read()
+        digest = hashlib.sha256(body).hexdigest()
+        if len(body) != entry["size"] or digest != entry["sha256"]:
+            print(f"{name}: got {len(body)} bytes, sha256 {digest}; manifest differs")
+            failed += 1
+            continue
+        (FOLDER / name).write_bytes(body)
+        print(f"{name}: ok")
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

teluri-0.2.0/src/teluri/__init__.py

@@ -0,0 +1,13 @@
+"""Parse, build and compare tel: URIs per RFC 3966, zero dependencies and fully typed."""
+
+from __future__ import annotations
+
+from ._build import build
+from ._errors import Reason, TelURIError
+from ._link import parse_link
+from ._model import TelURI
+from ._parse import equivalent, parse
+
+__version__ = "0.2.0"
+
+__all__ = ["Reason", "TelURI", "TelURIError", "build", "equivalent", "parse", "parse_link"]

teluri-0.2.0/src/teluri/__main__.py

@@ -0,0 +1,9 @@
+"""Run the command line with ``python -m teluri``."""
+
+from __future__ import annotations
+
+import sys
+
+from ._cli import main
+
+sys.exit(main())

teluri-0.2.0/src/teluri/_build.py

@@ -0,0 +1,39 @@
+"""Build a canonical tel: URI from human-written parts."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from ._model import TelURI
+
+
+def build(
+    number: str,
+    *,
+    ext: str | None = None,
+    isub: str | None = None,
+    phone_context: str | None = None,
+    params: Mapping[str, str | None] | None = None,
+) -> str:
+    """Build a canonical tel: URI, raising :class:`TelURIError` for invalid parts.
+
+    Spaces and visual separators are removed from the number, the extension and a numeric
+    phone-context, so printed forms such as ``+1 (201) 555-0123`` are accepted. A number
+    with a leading ``+`` is global; any other needs ``phone_context``. ``isub`` is taken
+    in its encoded form. ``params`` values are plain text and are percent-encoded.
+    """
+    context = phone_context
+    if context is not None and _unspaced(context).startswith("+"):
+        context = _unspaced(context)
+    uri = TelURI(
+        _unspaced(number),
+        ext=None if ext is None else _unspaced(ext),
+        isub=isub,
+        phone_context=context,
+        params=params or {},
+    )
+    return str(uri)
+
+
+def _unspaced(text: str) -> str:
+    return "".join(char for char in text if not char.isspace())