url-normalize 2.2.0__tar.gz → 3.0.1__tar.gz

url_normalize-3.0.1/PKG-INFO

@@ -0,0 +1,215 @@
+Metadata-Version: 2.4
+Name: url-normalize
+Version: 3.0.1
+Summary: URL normalization for Python
+Author-email: Nikolay Panov <github@npanov.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/niksite/url-normalize
+Project-URL: Repository, https://github.com/niksite/url-normalize
+Project-URL: Issues, https://github.com/niksite/url-normalize/issues
+Project-URL: Changelog, https://github.com/niksite/url-normalize/blob/master/CHANGELOG.md
+Keywords: url,normalization,normalize,normalizer
+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
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: idna>=3.3
+Provides-Extra: dev
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-socket; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# url-normalize
+
+[![tests](https://github.com/niksite/url-normalize/actions/workflows/ci.yml/badge.svg)](https://github.com/niksite/url-normalize/actions/workflows/ci.yml)
+[![Coveralls](https://img.shields.io/coveralls/github/niksite/url-normalize/master.svg)](https://coveralls.io/r/niksite/url-normalize)
+[![PyPI](https://img.shields.io/pypi/v/url-normalize.svg)](https://pypi.org/project/url-normalize/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/url-normalize.svg)](https://pypi.org/project/url-normalize/)
+[![License](https://img.shields.io/pypi/l/url-normalize.svg)](https://github.com/niksite/url-normalize/blob/master/LICENSE)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+A Python library for standardizing and normalizing URLs. Ideal for database deduplication, caching, web crawling, and anywhere you need to ensure that equivalent URLs resolve to the exact same string.
+
+```python
+from url_normalize import url_normalize
+
+# Fixes IDN, lowercases host/scheme, removes default ports, resolves path segments
+url_normalize("HTTP://User:Pass@www.FOO.com:80///foo/../bar/./baz?q=1#frag")
+# -> 'http://User:Pass@www.foo.com/bar/baz?q=1#frag'
+```
+
+## Features
+
+url-normalize provides a robust URI normalization function that handles IDN domains, scheme/host lowercasing, and RFC-compliant path normalization.
+
+- **IDN Support**: Full internationalized domain name handling (using IDNA2008 with UTS46).
+- **Humanization**: Convert normalized URLs to a readable display format while preserving round-trip normalization.
+- **RFC Compliance**:
+  - Proper percent-encoding (minimal, uppercase hex).
+  - Dot-segment removal in paths.
+  - Default port and authority handling.
+  - UTF-8 NFC normalization.
+- **Configurable Defaults**:
+  - Customizable default scheme (https by default).
+  - Configurable default domain for absolute paths.
+- **Query Parameter Control**:
+  - Parameter filtering with allowlists.
+  - Support for domain-specific parameter rules.
+- **Versatile URL Handling**: Handles empty strings, double-slash URLs (//domain.tld), and shebang (#!) URLs.
+- **Developer Friendly**:
+  - Python 3.10+ compatibility.
+  - 100% statement coverage, enforced by the test suite.
+  - Modern type hints and string handling.
+
+Inspired by Sam Ruby's [urlnorm.py](http://intertwingly.net/blog/2004/08/04/Urlnorm).
+
+## Installation
+
+Install as a library:
+
+```sh
+pip install url-normalize
+```
+
+Or install as a standalone CLI tool using [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv tool install url-normalize
+```
+
+## Usage
+
+### Python API
+
+#### Basic Normalization
+
+```python
+from url_normalize import url_normalize
+
+# Basic normalization (uses https by default)
+print(url_normalize("www.foo.com:80/foo"))
+# Output: https://www.foo.com:80/foo
+
+# With custom default scheme
+print(url_normalize("www.foo.com/foo", default_scheme="http"))
+# Output: http://www.foo.com/foo
+```
+
+The `charset` argument remains for compatibility. Unicode characters use UTF-8 percent encoding, regardless of this argument.
+
+#### Query Parameter Filtering
+
+With `filter_params=True`, normalization retains only allowlisted query parameters. The built-in rules cover selected domains.
+
+Other domains have an empty default allowlist. Without a custom allowlist, filtering removes all query parameters from those domains.
+
+```python
+# With the built-in Google allowlist
+print(url_normalize("www.google.com/search?q=test&utm_source=test", filter_params=True))
+# Output: https://www.google.com/search?q=test
+
+# With custom parameter allowlist as a list
+print(url_normalize(
+    "example.com?page=1&id=123&ref=test",
+    filter_params=True,
+    param_allowlist=["page", "id"]
+))
+# Output: https://example.com/?page=1&id=123
+
+# With domain-specific parameter allowlists
+print(url_normalize(
+    "example.com?page=1&id=123&ref=test",
+    filter_params=True,
+    param_allowlist={"example.com": ["page", "id"]}
+))
+# Output: https://example.com/?page=1&id=123
+```
+
+#### Default Domain & Scheme
+
+Useful for resolving relative URLs found on a specific page.
+
+```python
+# With default domain for absolute paths
+print(url_normalize("/images/logo.png", default_domain="example.com"))
+# Output: https://example.com/images/logo.png
+
+# With default domain and custom scheme
+print(url_normalize("/images/logo.png", default_scheme="http", default_domain="example.com"))
+# Output: http://example.com/images/logo.png
+```
+
+#### Humanizing URLs
+
+Convert normalized URLs back into a user-friendly format for display, particularly useful for IDN domains and percent-encoded paths.
+
+```python
+from url_normalize import url_humanize
+
+# Human-readable display form that still normalizes back to the same URL
+print(url_humanize("https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"))
+# Output: https://пример.испытание/Служебная
+
+# Humanization accepts the same normalization options
+print(url_humanize("/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F", default_domain="xn--e1afmkfd.xn--80akhbyknj4f"))
+# Output: https://пример.испытание/Служебная
+```
+
+### Command-line Usage
+
+You can also use `url-normalize` directly from the terminal to process URLs.
+
+```bash
+$ url-normalize "www.foo.com:80/foo"
+# Output: https://www.foo.com:80/foo
+
+# With custom default scheme
+$ url-normalize -s http "www.foo.com/foo"
+# Output: http://www.foo.com/foo
+
+# With query parameter filtering
+$ url-normalize -f "www.google.com/search?q=test&utm_source=test"
+# Output: https://www.google.com/search?q=test
+
+# With custom allowlist
+$ url-normalize -f -p page,id "example.com?page=1&id=123&ref=test"
+# Output: https://example.com/?page=1&id=123
+
+# With default domain for absolute paths
+$ url-normalize -d example.com "/images/logo.png"
+# Output: https://example.com/images/logo.png
+
+# With default domain and custom scheme
+$ url-normalize -d example.com -s http "/images/logo.png"
+# Output: http://example.com/images/logo.png
+
+# Human-readable display form
+$ url-normalize -H "https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+# Output: https://пример.испытание/Служебная
+
+# Via uv tool/uvx
+$ uvx url-normalize www.foo.com:80/foo
+# Output: https://www.foo.com:80/foo
+```
+
+## Documentation
+
+For a complete history of changes, see [CHANGELOG.md](CHANGELOG.md).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License

url_normalize-3.0.1/README.md

@@ -0,0 +1,184 @@
+# url-normalize
+
+[![tests](https://github.com/niksite/url-normalize/actions/workflows/ci.yml/badge.svg)](https://github.com/niksite/url-normalize/actions/workflows/ci.yml)
+[![Coveralls](https://img.shields.io/coveralls/github/niksite/url-normalize/master.svg)](https://coveralls.io/r/niksite/url-normalize)
+[![PyPI](https://img.shields.io/pypi/v/url-normalize.svg)](https://pypi.org/project/url-normalize/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/url-normalize.svg)](https://pypi.org/project/url-normalize/)
+[![License](https://img.shields.io/pypi/l/url-normalize.svg)](https://github.com/niksite/url-normalize/blob/master/LICENSE)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+
+A Python library for standardizing and normalizing URLs. Ideal for database deduplication, caching, web crawling, and anywhere you need to ensure that equivalent URLs resolve to the exact same string.
+
+```python
+from url_normalize import url_normalize
+
+# Fixes IDN, lowercases host/scheme, removes default ports, resolves path segments
+url_normalize("HTTP://User:Pass@www.FOO.com:80///foo/../bar/./baz?q=1#frag")
+# -> 'http://User:Pass@www.foo.com/bar/baz?q=1#frag'
+```
+
+## Features
+
+url-normalize provides a robust URI normalization function that handles IDN domains, scheme/host lowercasing, and RFC-compliant path normalization.
+
+- **IDN Support**: Full internationalized domain name handling (using IDNA2008 with UTS46).
+- **Humanization**: Convert normalized URLs to a readable display format while preserving round-trip normalization.
+- **RFC Compliance**:
+  - Proper percent-encoding (minimal, uppercase hex).
+  - Dot-segment removal in paths.
+  - Default port and authority handling.
+  - UTF-8 NFC normalization.
+- **Configurable Defaults**:
+  - Customizable default scheme (https by default).
+  - Configurable default domain for absolute paths.
+- **Query Parameter Control**:
+  - Parameter filtering with allowlists.
+  - Support for domain-specific parameter rules.
+- **Versatile URL Handling**: Handles empty strings, double-slash URLs (//domain.tld), and shebang (#!) URLs.
+- **Developer Friendly**:
+  - Python 3.10+ compatibility.
+  - 100% statement coverage, enforced by the test suite.
+  - Modern type hints and string handling.
+
+Inspired by Sam Ruby's [urlnorm.py](http://intertwingly.net/blog/2004/08/04/Urlnorm).
+
+## Installation
+
+Install as a library:
+
+```sh
+pip install url-normalize
+```
+
+Or install as a standalone CLI tool using [uv](https://docs.astral.sh/uv/):
+
+```sh
+uv tool install url-normalize
+```
+
+## Usage
+
+### Python API
+
+#### Basic Normalization
+
+```python
+from url_normalize import url_normalize
+
+# Basic normalization (uses https by default)
+print(url_normalize("www.foo.com:80/foo"))
+# Output: https://www.foo.com:80/foo
+
+# With custom default scheme
+print(url_normalize("www.foo.com/foo", default_scheme="http"))
+# Output: http://www.foo.com/foo
+```
+
+The `charset` argument remains for compatibility. Unicode characters use UTF-8 percent encoding, regardless of this argument.
+
+#### Query Parameter Filtering
+
+With `filter_params=True`, normalization retains only allowlisted query parameters. The built-in rules cover selected domains.
+
+Other domains have an empty default allowlist. Without a custom allowlist, filtering removes all query parameters from those domains.
+
+```python
+# With the built-in Google allowlist
+print(url_normalize("www.google.com/search?q=test&utm_source=test", filter_params=True))
+# Output: https://www.google.com/search?q=test
+
+# With custom parameter allowlist as a list
+print(url_normalize(
+    "example.com?page=1&id=123&ref=test",
+    filter_params=True,
+    param_allowlist=["page", "id"]
+))
+# Output: https://example.com/?page=1&id=123
+
+# With domain-specific parameter allowlists
+print(url_normalize(
+    "example.com?page=1&id=123&ref=test",
+    filter_params=True,
+    param_allowlist={"example.com": ["page", "id"]}
+))
+# Output: https://example.com/?page=1&id=123
+```
+
+#### Default Domain & Scheme
+
+Useful for resolving relative URLs found on a specific page.
+
+```python
+# With default domain for absolute paths
+print(url_normalize("/images/logo.png", default_domain="example.com"))
+# Output: https://example.com/images/logo.png
+
+# With default domain and custom scheme
+print(url_normalize("/images/logo.png", default_scheme="http", default_domain="example.com"))
+# Output: http://example.com/images/logo.png
+```
+
+#### Humanizing URLs
+
+Convert normalized URLs back into a user-friendly format for display, particularly useful for IDN domains and percent-encoded paths.
+
+```python
+from url_normalize import url_humanize
+
+# Human-readable display form that still normalizes back to the same URL
+print(url_humanize("https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"))
+# Output: https://пример.испытание/Служебная
+
+# Humanization accepts the same normalization options
+print(url_humanize("/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F", default_domain="xn--e1afmkfd.xn--80akhbyknj4f"))
+# Output: https://пример.испытание/Служебная
+```
+
+### Command-line Usage
+
+You can also use `url-normalize` directly from the terminal to process URLs.
+
+```bash
+$ url-normalize "www.foo.com:80/foo"
+# Output: https://www.foo.com:80/foo
+
+# With custom default scheme
+$ url-normalize -s http "www.foo.com/foo"
+# Output: http://www.foo.com/foo
+
+# With query parameter filtering
+$ url-normalize -f "www.google.com/search?q=test&utm_source=test"
+# Output: https://www.google.com/search?q=test
+
+# With custom allowlist
+$ url-normalize -f -p page,id "example.com?page=1&id=123&ref=test"
+# Output: https://example.com/?page=1&id=123
+
+# With default domain for absolute paths
+$ url-normalize -d example.com "/images/logo.png"
+# Output: https://example.com/images/logo.png
+
+# With default domain and custom scheme
+$ url-normalize -d example.com -s http "/images/logo.png"
+# Output: http://example.com/images/logo.png
+
+# Human-readable display form
+$ url-normalize -H "https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+# Output: https://пример.испытание/Служебная
+
+# Via uv tool/uvx
+$ uvx url-normalize www.foo.com:80/foo
+# Output: https://www.foo.com:80/foo
+```
+
+## Documentation
+
+For a complete history of changes, see [CHANGELOG.md](CHANGELOG.md).
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License

{url_normalize-2.2.0 → url_normalize-3.0.1}/pyproject.toml

@@ -1,12 +1,21 @@
 [project]
 name = "url-normalize"
-version = "2.2.0"
+version = "3.0.1"
 description = "URL normalization for Python"
 authors = [{ name = "Nikolay Panov", email = "github@npanov.com" }]
-license = { text = "MIT" }
+license = "MIT"
 readme = "README.md"
-requires-python = ">=3.8"
-keywords = ["url", "normalization", "normalize"]
+requires-python = ">=3.10"
+keywords = ["url", "normalization", "normalize", "normalizer"]
+classifiers = [
+  "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",
+]
 dependencies = ["idna>=3.3"]
 
 [project.urls]
@@ -19,19 +28,10 @@ Changelog = "https://github.com/niksite/url-normalize/blob/master/CHANGELOG.md"
 url-normalize = "url_normalize.cli:main"
 
 [project.optional-dependencies]
-dev = [
-  "mypy",
-  "pre-commit",
-  "pytest-cov",
-  "pytest-ruff",
-  "pytest-socket",
-  "pytest",
-  "ruff",
-  "tox",
-]
+dev = ["mypy", "pre-commit", "pytest-cov", "pytest-socket", "pytest", "ruff"]
 
 [tool.ruff]
-target-version = "py38"
+target-version = "py310"
 line-length = 88
 unsafe-fixes = true
 
@@ -62,20 +62,19 @@ indent-style = "space"
 [tool.mypy]
 ignore_missing_imports = true
 exclude = ["tests"]
-python_version = "3.8"
+python_version = "3.10"
 show_error_codes = true
 
 [build-system]
-requires = ["setuptools>=42", "wheel"]
+requires = ["setuptools>=77", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [tool.pytest.ini_options]
 addopts = [
-  "--cov-fail-under=100",
   "--cov-report=term-missing:skip-covered",
   "--cov=url_normalize",
+  "--cov-fail-under=100",
   "--disable-socket",
-  "--ruff",
   "-v",
 ]
 python_files = ["tests.py", "test_*.py", "*_tests.py"]

{url_normalize-2.2.0 → url_normalize-3.0.1}/tests/test_cli.py

@@ -22,10 +22,42 @@ def run_cli(*args: str) -> subprocess.CompletedProcess:
     """
     command = [sys.executable, "-m", "url_normalize.cli", *list(args)]
     return subprocess.run(  # noqa: S603
-        command, capture_output=True, text=True, check=False
+        command, capture_output=True, text=True, encoding="utf-8", check=False
     )
 
 
+def test_cli_help_describes_allowlist_filtering() -> None:
+    """Describe filtering as an allowlist, not a tracking-parameter blocklist."""
+    result = run_cli("--help")
+    assert result.returncode == 0
+    help_text = " ".join(result.stdout.split())
+    assert "Keep only allowlisted query parameters." in help_text
+    assert "Unknown domains have an empty default allowlist." in help_text
+
+
+def test_cli_help_describes_fixed_utf8_encoding() -> None:
+    """Describe charset as a compatibility option for Unicode URL input."""
+    result = run_cli("--help")
+    assert result.returncode == 0
+    help_text = " ".join(result.stdout.split())
+    assert "Retained for compatibility." in help_text
+    assert "Unicode characters use UTF-8 percent encoding." in help_text
+    normalized = run_cli("--charset", "iso-8859-1", "https://example.com/é")
+    assert normalized.returncode == 0
+    assert normalized.stdout.strip() == "https://example.com/%C3%A9"
+
+
+def test_cli_successful_main(capsys, monkeypatch):
+    """Exercise successful CLI output in the measured process."""
+    monkeypatch.setattr(
+        sys, "argv", ["url-normalize", "http://EXAMPLE.com/./path/../other/"]
+    )
+    main()
+    captured = capsys.readouterr()
+    assert captured.out == "http://example.com/other/\n"
+    assert not captured.err
+
+
 def test_cli_error_handling(capsys, monkeypatch):
     """Test CLI error handling when URL normalization fails."""
     with patch("url_normalize.cli.url_normalize") as mock_normalize:
@@ -66,6 +98,56 @@ def test_cli_basic_normalization_short_args() -> None:
     assert not result.stderr
 
 
+def test_cli_humanize() -> None:
+    """Test human-readable URL output via CLI."""
+    url = (
+        "https://xn--e1afmkfd.xn--80akhbyknj4f/"
+        "%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+    )
+    expected = "https://пример.испытание/Служебная"
+
+    result = run_cli("--humanize", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
+def test_cli_humanize_short_arg() -> None:
+    """Test human-readable URL output via CLI using short argument."""
+    url = (
+        "https://xn--e1afmkfd.xn--80akhbyknj4f/"
+        "%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+    )
+    expected = "https://пример.испытание/Служебная"
+
+    result = run_cli("-H", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
+def test_cli_humanize_respects_normalization_options() -> None:
+    """Test humanized output keeps the existing CLI normalization options."""
+    url = "/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F"
+    expected = "https://пример.испытание/Служебная?keep=Ç"
+
+    result = run_cli(
+        "--humanize",
+        "--default-domain",
+        "xn--e1afmkfd.xn--80akhbyknj4f",
+        "--filter-params",
+        "--param-allowlist",
+        "keep",
+        f"{url}?utm_source=ignored&keep=%C3%87",
+    )
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
 def test_cli_default_scheme() -> None:
     """Test default scheme addition via CLI."""
     url = "//example.com"

url_normalize-3.0.1/tests/test_deconstruct_url.py

@@ -0,0 +1,87 @@
+"""Deconstruct url tests."""
+
+import pytest
+
+from url_normalize import url_normalize
+from url_normalize.tools import URL, deconstruct_url
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        (
+            "http://site.com",
+            URL(
+                fragment="",
+                host="site.com",
+                path="",
+                port="",
+                query="",
+                scheme="http",
+                userinfo="",
+            ),
+        ),
+        (
+            "http://user@www.example.com:8080/path/index.html?param=val#fragment",
+            URL(
+                fragment="fragment",
+                host="www.example.com",
+                path="/path/index.html",
+                port="8080",
+                query="param=val",
+                scheme="http",
+                userinfo="user@",
+            ),
+        ),
+    ],
+)
+def test_deconstruct_url_result_is_expected(url: str, expected: URL) -> None:
+    """Assert we got expected results from the deconstruct_url function."""
+    result = deconstruct_url(url)
+    assert result == expected, url
+
+
+@pytest.mark.parametrize(
+    ("authority", "userinfo", "host", "port", "normalized_authority"),
+    [
+        ("[2001:DB8::1]:080", "", "[2001:DB8::1]", "080", "[2001:db8::1]"),
+        ("[2001:DB8::1]:0081", "", "[2001:DB8::1]", "0081", "[2001:db8::1]:81"),
+        ("[::1]", "", "[::1]", "", "[::1]"),
+        ("[::1]:", "", "[::1]", "", "[::1]"),
+        ("user:pass@[::1]:080", "user:pass@", "[::1]", "080", "user:pass@[::1]"),
+        ("EXAMPLE.com:080", "", "EXAMPLE.com", "080", "example.com"),
+        ("127.0.0.1:0081", "", "127.0.0.1", "0081", "127.0.0.1:81"),
+    ],
+)
+def test_deconstruct_url_separates_bracketed_host_and_port(
+    authority, userinfo, host, port, normalized_authority
+):
+    """Parse the entire bracketed host before considering a port separator."""
+    url = f"http://{authority}/path?q=1#fragment"
+    assert deconstruct_url(url) == URL(
+        "http", userinfo, host, port, "/path", "q=1", "fragment"
+    )
+    assert url_normalize(url) == f"http://{normalized_authority}/path?q=1#fragment"
+
+
+@pytest.mark.parametrize("whitespace", [" ", "\u00a0", " \t\r\n"])
+@pytest.mark.parametrize("suffix", ["", "/path ", "?q=x ", "#part "])
+@pytest.mark.parametrize(
+    ("authority", "normalized"),
+    [
+        ("EXAMPLE.com", "example.com"),
+        ("example.com:443", "example.com"),
+        ("user:pass@example.com:443", "user:pass@example.com"),
+        ("[FE80::1%25ethA]:443", "[fe80::1%25ethA]"),
+    ],
+)
+def test_deconstruct_url_trims_authority_whitespace_only(
+    authority, normalized, whitespace, suffix
+):
+    """Trim the authority without deleting whitespace from other components."""
+    value = f"https://{authority}{whitespace}{suffix}"
+    assert deconstruct_url(value) == deconstruct_url(f"https://{authority}{suffix}")
+    path_suffix = suffix if suffix.startswith("/") else "/" + suffix
+    assert (
+        url_normalize(value) == f"https://{normalized}{path_suffix.replace(' ', '%20')}"
+    )