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

{url_normalize-2.1.0 → url_normalize-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: url-normalize
-Version: 2.1.0
+Version: 2.2.0
 Summary: URL normalization for Python
 Author-email: Nikolay Panov <github@npanov.com>
 License: MIT
@@ -50,6 +50,7 @@ Inspired by Sam Ruby's [urlnorm.py](<http://intertwingly.net/blog/2004/08/04/Url
 
 * IDN (Internationalized Domain Name) support
 * Configurable default scheme (https by default)
+* Configurable default domain for absolute paths
 * Query parameter filtering with allowlists
 * Support for various URL formats including:
   * Empty string URLs
@@ -97,6 +98,14 @@ print(url_normalize(
     param_allowlist=["page", "id"]
 ))
 # Output: https://example.com?page=1&id=123
+
+# 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
 ```
 
 ### Command-line usage
@@ -119,6 +128,14 @@ $ url-normalize -f "www.google.com/search?q=test&utm_source=test"
 $ 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
+
 # Via uv tool/uvx
 $ uvx url-normalize www.foo.com:80/foo
 # Output: https://www.foo.com:80/foo

{url_normalize-2.1.0 → url_normalize-2.2.0}/README.md

@@ -24,6 +24,7 @@ Inspired by Sam Ruby's [urlnorm.py](<http://intertwingly.net/blog/2004/08/04/Url
 
 * IDN (Internationalized Domain Name) support
 * Configurable default scheme (https by default)
+* Configurable default domain for absolute paths
 * Query parameter filtering with allowlists
 * Support for various URL formats including:
   * Empty string URLs
@@ -71,6 +72,14 @@ print(url_normalize(
     param_allowlist=["page", "id"]
 ))
 # Output: https://example.com?page=1&id=123
+
+# 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
 ```
 
 ### Command-line usage
@@ -93,6 +102,14 @@ $ url-normalize -f "www.google.com/search?q=test&utm_source=test"
 $ 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
+
 # Via uv tool/uvx
 $ uvx url-normalize www.foo.com:80/foo
 # Output: https://www.foo.com:80/foo

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

@@ -1,6 +1,6 @@
 [project]
 name = "url-normalize"
-version = "2.1.0"
+version = "2.2.0"
 description = "URL normalization for Python"
 authors = [{ name = "Nikolay Panov", email = "github@npanov.com" }]
 license = { text = "MIT" }

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

@@ -231,3 +231,64 @@ def test_cli_charset() -> None:
     assert result_charset_short.returncode == 0
     assert result_charset_short.stdout.strip() == expected_idn
     assert not result_charset_short.stderr
+
+
+def test_cli_default_domain() -> None:
+    """Test adding default domain to absolute path via CLI."""
+    url = "/path/to/image.png"
+    expected = "https://example.com/path/to/image.png"
+
+    result = run_cli("--default-domain", "example.com", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
+def test_cli_default_domain_short_arg() -> None:
+    """Test adding default domain using short argument."""
+    url = "/path/to/image.png"
+    expected = "https://example.com/path/to/image.png"
+
+    result = run_cli("-d", "example.com", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
+def test_cli_default_domain_with_scheme() -> None:
+    """Test adding default domain with custom scheme."""
+    url = "/path/to/image.png"
+    expected = "http://example.com/path/to/image.png"
+
+    result = run_cli("-d", "example.com", "-s", "http", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
+def test_cli_default_domain_no_effect_on_absolute_urls() -> None:
+    """Test default domain has no effect on absolute URLs."""
+    url = "http://original-domain.com/path"
+    expected = "http://original-domain.com/path"
+
+    result = run_cli("-d", "example.com", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr
+
+
+def test_cli_default_domain_no_effect_on_relative_paths() -> None:
+    """Test default domain has no effect on relative paths."""
+    url = "path/to/file.html"
+    # This becomes a regular URL with the default scheme
+    expected = "https://path/to/file.html"
+
+    result = run_cli("-d", "example.com", url)
+
+    assert result.returncode == 0
+    assert result.stdout.strip() == expected
+    assert not result.stderr

{url_normalize-2.1.0 → url_normalize-2.2.0}/tests/test_normalize_path.py

@@ -29,10 +29,12 @@ EXPECTED_DATA = {
     "/foo/bar/../baz": "/foo/baz",
     "/foo/bar/.": "/foo/bar/",
     "/foo/bar/./": "/foo/bar/",
+    # Issue #25: we should preserve ? in the path
+    "/More+Tea+Vicar%3F/discussion": "/More+Tea+Vicar%3F/discussion",
 }
 
 
-def test_normalize_host_result_is_expected():
+def test_normalize_path_result_is_expected():
     """Assert we got expected results from the normalize_path function."""
     for url, expected in EXPECTED_DATA.items():
         result = normalize_path(url, "http")

{url_normalize-2.1.0 → url_normalize-2.2.0}/tests/test_normalize_query.py

@@ -14,6 +14,8 @@ from url_normalize.url_normalize import normalize_query
         ("Ç=Ç", "%C3%87=%C3%87"),
         ("%C3%87=%C3%87", "%C3%87=%C3%87"),
         ("q=C%CC%A7", "q=%C3%87"),
+        ("q=%23test", "q=%23test"),  # Preserve encoded # in value, #31
+        ("where=code%3D123", "where=code%3D123"),  # Preserve encoded = in value, #25
     ],
 )
 def test_normalize_query_result_is_expected(query, expected):

url_normalize-2.2.0/tests/test_provide_url_domain.py

@@ -0,0 +1,31 @@
+"""Tests for provide_url_domain function."""
+
+import pytest
+
+from url_normalize.provide_url_domain import provide_url_domain
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        ("", ""),
+        ("-", "-"),
+        ("http://example.com/", "http://example.com/"),
+        ("/file/path", "//example.com/file/path"),
+        ("site/page", "site/page"),  # No change for relative paths
+    ],
+)
+def test_provide_url_domain_result_is_expected(url: str, expected: str) -> None:
+    """Assert we get expected results from provide_url_domain function."""
+    result = provide_url_domain(url, default_domain="example.com")
+    assert result == expected
+
+
+def test_provide_url_domain_accept_different_domains():
+    """Assert we could provide different default_domain values."""
+    url = "/file/path"
+    expected = "//custom-domain.org/file/path"
+
+    actual = provide_url_domain(url, default_domain="custom-domain.org")
+
+    assert actual == expected

url_normalize-2.2.0/tests/test_url_normalize.py

@@ -0,0 +1,163 @@
+"""Integrations tests."""
+
+from __future__ import annotations
+
+import pytest
+
+from url_normalize import url_normalize
+
+
+@pytest.mark.parametrize(
+    "value",
+    [
+        "-",
+        "",
+        "/..foo",
+        "/.foo",
+        "/foo..",
+        "/foo.",
+        "ftp://user:pass@ftp.foo.net/foo/bar",
+        "http://127.0.0.1/",
+        "http://example.com:8080/",
+        "http://example.com/?a&b",
+        "http://example.com/?q=%5C",
+        "http://example.com/?q=%C3%87",
+        "http://example.com/?q=%E2%85%A0",
+        "http://example.com/",
+        "http://example.com/~jane",
+        "http://example.com/a/b",
+        "http://example.com/FOO",
+        "http://user:password@example.com/",
+        "http://www.foo.com:8000/foo",
+        # from rfc2396bis
+        "ftp://ftp.is.co.za/rfc/rfc1808.txt",
+        "http://www.ietf.org/rfc/rfc2396.txt",
+        "ldap://[2001:db8::7]/c=GB?objectClass?one",
+        "mailto:John.Doe@example.com",
+        "news:comp.infosystems.www.servers.unix",
+        "tel:+1-816-555-1212",
+        "telnet://192.0.2.16:80/",
+        "urn:oasis:names:specification:docbook:dtd:xml:4.1.2",
+        # Issue #36: Fragment with '=' should not be encoded
+        "https://docs.google.com/spreadsheets/d/abcd/edit#gid=1234",
+    ],
+)
+def test_url_normalize_no_changes_expected(value: str) -> None:
+    """Assert url_normalize do not change URI if not required.
+
+    http://www.intertwingly.net/wiki/pie/PaceCanonicalIds
+    """
+    assert url_normalize(value) == value
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        ("/../foo", "/foo"),
+        ("/./../foo", "/foo"),
+        ("/./foo", "/foo"),
+        ("/./foo/.", "/foo/"),
+        ("//www.foo.com/", "https://www.foo.com/"),
+        ("/foo/../bar", "/bar"),
+        ("/foo/./bar", "/foo/bar"),
+        ("/foo//", "/foo/"),
+        ("/foo///bar//", "/foo/bar/"),
+        ("/foo/bar/..", "/foo/"),
+        ("/foo/bar/../..", "/"),
+        ("/foo/bar/../../../../baz", "/baz"),
+        ("/foo/bar/../../../baz", "/baz"),
+        ("/foo/bar/../../", "/"),
+        ("/foo/bar/../../baz", "/baz"),
+        ("/foo/bar/../", "/foo/"),
+        ("/foo/bar/../baz", "/foo/baz"),
+        ("/foo/bar/.", "/foo/bar/"),
+        ("/foo/bar/./", "/foo/bar/"),
+        ("http://:@example.com/", "http://example.com/"),
+        ("http://@example.com/", "http://example.com/"),
+        ("http://127.0.0.1:80/", "http://127.0.0.1/"),
+        ("http://example.com:081/", "http://example.com:81/"),
+        ("http://example.com:80/", "http://example.com/"),
+        ("http://example.com", "http://example.com/"),
+        ("http://example.com/?b&a", "http://example.com/?b&a"),
+        ("http://example.com/?q=%5c", "http://example.com/?q=%5C"),
+        ("http://example.com/?q=%C7", "http://example.com/?q=%EF%BF%BD"),
+        ("http://example.com/?q=C%CC%A7", "http://example.com/?q=%C3%87"),
+        ("http://EXAMPLE.COM/", "http://example.com/"),
+        ("http://example.com/%7Ejane", "http://example.com/~jane"),
+        ("http://example.com/a/../a/b", "http://example.com/a/b"),
+        ("http://example.com/a/./b", "http://example.com/a/b"),
+        (
+            "http://example.com/#!5753509/hello-world",
+            "http://example.com/?_escaped_fragment_=5753509/hello-world",
+        ),
+        (
+            "http://USER:pass@www.Example.COM/foo/bar",
+            "http://USER:pass@www.example.com/foo/bar",
+        ),
+        ("http://www.example.com./", "http://www.example.com/"),
+        ("http://www.foo.com:80/foo", "http://www.foo.com/foo"),
+        ("http://www.foo.com.:81/foo", "http://www.foo.com:81/foo"),
+        ("http://www.foo.com./foo/bar.html", "http://www.foo.com/foo/bar.html"),
+        ("http://www.foo.com/%7Ebar", "http://www.foo.com/~bar"),
+        ("http://www.foo.com/%7ebar", "http://www.foo.com/~bar"),
+        (
+            "пример.испытание/Служебная:Search/Test",
+            "https://xn--e1afmkfd.xn--80akhbyknj4f/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F:Search/Test",
+        ),
+        # Issue #19: http:example.com
+        ("http:example.com", "http://example.com/"),
+        ("http:example.com/path", "http://example.com/path"),
+        ("ftp:test.com/files", "ftp://test.com/files"),
+        ("https:www.example.com", "https://www.example.com/"),
+    ],
+)
+def test_url_normalize_expected_changes(value: str, expected: str) -> None:
+    """Assert url_normalize return expected results."""
+    assert url_normalize(value) == expected
+
+
+def test_url_normalize_filtered() -> None:
+    """Assert url_normalize return expected results."""
+    url = "/?a&b"
+    expected = "/"
+
+    actual = url_normalize(url, filter_params=True)
+
+    assert actual == expected
+
+
+def test_url_normalize_with_http_scheme() -> None:
+    """Assert we could use http scheme as default."""
+    url = "//www.foo.com/"
+    expected = "http://www.foo.com/"
+
+    actual = url_normalize(url, default_scheme="http")
+
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    ("url", "expected"),
+    [
+        ("/foo.png", "https://example.com/foo.png"),
+        ("//google.com", "https://google.com/"),
+        ("//example.com:80/foo.png", "https://example.com:80/foo.png"),
+        ("//example.com/foo.png?foo=bar", "https://example.com/foo.png?foo=bar"),
+        ("http://google.com", "http://google.com/"),
+    ],
+)
+def test_url_normalize_with_default_domain(url: str, expected: str) -> None:
+    """Assert we could use default_domain parameter."""
+    actual = url_normalize(url, default_domain="example.com")
+
+    assert actual == expected
+
+
+def test_url_normalize_with_default_domain_and_scheme() -> None:
+    """Assert we can use both default_domain and default_scheme together."""
+    url = "/foo.png"
+    expected = "http://example.com/foo.png"
+
+    actual = url_normalize(url, default_scheme="http", default_domain="example.com")
+
+    assert actual == expected

{url_normalize-2.1.0 → url_normalize-2.2.0}/url_normalize/__init__.py

@@ -8,6 +8,6 @@ SPDX-License-Identifier: MIT
 from .url_normalize import url_normalize
 
 __license__ = "MIT"
-__version__ = "2.1.0"
+__version__ = "2.2.0"
 
 __all__ = ["url_normalize"]

{url_normalize-2.1.0 → url_normalize-2.2.0}/url_normalize/cli.py

@@ -36,6 +36,12 @@ def main() -> None:
         action="store_true",
         help="Filter common tracking parameters.",
     )
+    parser.add_argument(
+        "-d",
+        "--default-domain",
+        type=str,
+        help="Default domain to use for absolute paths (starting with '/').",
+    )
     parser.add_argument(
         "-p",
         "--param-allowlist",
@@ -52,6 +58,7 @@ def main() -> None:
             args.url,
             charset=args.charset,
             default_scheme=args.default_scheme,
+            default_domain=args.default_domain,
             filter_params=args.filter_params,
             param_allowlist=allowlist,
         )

{url_normalize-2.1.0 → url_normalize-2.2.0}/url_normalize/normalize_path.py

@@ -21,9 +21,9 @@ def normalize_path(path: str, scheme: str) -> str:
     # Only perform percent-encoding where it is essential.
     # Always use uppercase A-through-F characters when percent-encoding.
     # All portions of the URI must be utf-8 encoded NFC from Unicode strings
-    path = quote(unquote(path), "~:/?#[]@!$&'()*+,;=")
+    path = quote(unquote(path), "~:/#[]@!$&'()*+,;=")
     # Prevent dot-segments appearing in non-relative URI paths.
-    if scheme in ["", "http", "https", "ftp", "file"]:
+    if scheme in {"", "http", "https", "ftp", "file"}:
         output: list[str] = []
         for part in path.split("/"):
             if part == "":
@@ -38,11 +38,11 @@ def normalize_path(path: str, scheme: str) -> str:
                 output.append(part)
         # The part variable is used in the final check
         last_part = part
-        if last_part in ["", ".", ".."]:
+        if last_part in {"", ".", ".."}:
             output.append("")
         path = "/".join(output)
     # For schemes that define an empty path to be equivalent to a path of "/",
     # use "/".
-    if not path and scheme in ["http", "https", "ftp", "file"]:
+    if not path and scheme in {"http", "https", "ftp", "file"}:
         path = "/"
     return path

{url_normalize-2.1.0 → url_normalize-2.2.0}/url_normalize/normalize_query.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from .param_allowlist import get_allowed_params
 from .tools import quote, unquote
 
-QUERY_PARAM_RESERVED_CHARS = "~:/?#[]@!$'()*+,;="
+QUERY_PARAM_SAFE_CHARS = "~:/?[]@!$'()*+,;"
 
 
 def process_query_param(param: str) -> str:
@@ -23,7 +23,7 @@ def process_query_param(param: str) -> str:
     """
     if not param:
         return ""
-    return quote(unquote(param), QUERY_PARAM_RESERVED_CHARS)
+    return quote(unquote(param), QUERY_PARAM_SAFE_CHARS)
 
 
 def normalize_query(

url_normalize-2.2.0/url_normalize/provide_url_domain.py

@@ -0,0 +1,28 @@
+"""URL domain validation and attachment."""
+
+from __future__ import annotations
+
+
+def provide_url_domain(url: str, default_domain: str | None = None) -> str:
+    """Add default domain to URL if needed.
+
+    For absolute paths (starting with '/'), adds the specified default domain.
+
+    Params:
+        url : str : the URL
+        default_domain : str | None : default domain to use, e.g. 'example.com'
+
+    Returns:
+        str : URL with domain added if applicable
+
+    """
+    # Skip processing if no default domain provided or URL is empty or stdout
+    if not default_domain or not url or url == "-":
+        return url
+
+    # Only apply to absolute paths (starting with '/')
+    # but not scheme-relative URLs ('//')
+    if url.startswith("/") and not url.startswith("//"):
+        return "//" + default_domain + url
+
+    return url

{url_normalize-2.1.0 → url_normalize-2.2.0}/url_normalize/provide_url_scheme.py

@@ -4,6 +4,9 @@ from __future__ import annotations
 
 from .normalize_scheme import DEFAULT_SCHEME
 
+# Schemes that require authority component reconstruction with //
+AUTHORITY_SCHEMES = frozenset(["http", "https", "ftp", "ftps"])
+
 
 def provide_url_scheme(url: str, default_scheme: str = DEFAULT_SCHEME) -> str:
     """Make sure we have valid url scheme.
@@ -19,8 +22,12 @@ def provide_url_scheme(url: str, default_scheme: str = DEFAULT_SCHEME) -> str:
     has_scheme = ":" in url[:7]
     is_universal_scheme = url.startswith("//")
     is_file_path = url == "-" or (url.startswith("/") and not is_universal_scheme)
-    if not url or has_scheme or is_file_path:
+    if not url or is_file_path:
+        return url
+    if not has_scheme:
+        return f"{default_scheme}://{url.lstrip('/')}"
+    scheme_part, rest = url.split(":", 1)
+    if scheme_part.lower() not in AUTHORITY_SCHEMES:
+        # handle cases like tel:, mailto:, etc.
         return url
-    if is_universal_scheme:
-        return default_scheme + ":" + url
-    return default_scheme + "://" + url
+    return f"{scheme_part}://{rest.lstrip('/')}"

{url_normalize-2.1.0 → url_normalize-2.2.0}/url_normalize/url_normalize.py

@@ -16,15 +16,17 @@ from .normalize_port import normalize_port
 from .normalize_query import normalize_query
 from .normalize_scheme import DEFAULT_SCHEME, normalize_scheme
 from .normalize_userinfo import normalize_userinfo
+from .provide_url_domain import provide_url_domain
 from .provide_url_scheme import provide_url_scheme
 from .tools import deconstruct_url, reconstruct_url
 
 
-def url_normalize(
+def url_normalize(  # noqa: PLR0913
     url: str | None,
+    *,  # Force keyword-only arguments
     charset: str = DEFAULT_CHARSET,
     default_scheme: str = DEFAULT_SCHEME,
-    *,  # Force keyword-only arguments
+    default_domain: str | None = None,
     filter_params: bool = False,
     param_allowlist: dict | list | None = None,
 ) -> str | None:
@@ -43,6 +45,8 @@ def url_normalize(
         charset : str : optional
             The target charset for the URL if the url was given as unicode string
         default_scheme : str : default scheme to use if none present
+        default_domain : str | None : optional
+            Default domain to use for absolute paths (starting with '/')
         filter_params : bool : optional
             Whether to filter non-allowlisted parameters (False by default)
         param_allowlist : dict | list | None : optional
@@ -54,6 +58,7 @@ def url_normalize(
     """
     if not url:
         return url
+    url = provide_url_domain(url, default_domain)
     url = provide_url_scheme(url, default_scheme)
     url = generic_url_cleanup(url)
     url_elements = deconstruct_url(url)

{url_normalize-2.1.0 → url_normalize-2.2.0}/url_normalize.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: url-normalize
-Version: 2.1.0
+Version: 2.2.0
 Summary: URL normalization for Python
 Author-email: Nikolay Panov <github@npanov.com>
 License: MIT
@@ -50,6 +50,7 @@ Inspired by Sam Ruby's [urlnorm.py](<http://intertwingly.net/blog/2004/08/04/Url
 
 * IDN (Internationalized Domain Name) support
 * Configurable default scheme (https by default)
+* Configurable default domain for absolute paths
 * Query parameter filtering with allowlists
 * Support for various URL formats including:
   * Empty string URLs
@@ -97,6 +98,14 @@ print(url_normalize(
     param_allowlist=["page", "id"]
 ))
 # Output: https://example.com?page=1&id=123
+
+# 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
 ```
 
 ### Command-line usage
@@ -119,6 +128,14 @@ $ url-normalize -f "www.google.com/search?q=test&utm_source=test"
 $ 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
+
 # Via uv tool/uvx
 $ uvx url-normalize www.foo.com:80/foo
 # Output: https://www.foo.com:80/foo

{url_normalize-2.1.0 → url_normalize-2.2.0}/url_normalize.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ tests/test_normalize_query.py
 tests/test_normalize_query_filters.py
 tests/test_normalize_scheme.py
 tests/test_normalize_userinfo.py
+tests/test_provide_url_domain.py
 tests/test_provide_url_scheme.py
 tests/test_reconstruct_url.py
 tests/test_tools.py
@@ -27,6 +28,7 @@ url_normalize/normalize_query.py
 url_normalize/normalize_scheme.py
 url_normalize/normalize_userinfo.py
 url_normalize/param_allowlist.py
+url_normalize/provide_url_domain.py
 url_normalize/provide_url_scheme.py
 url_normalize/tools.py
 url_normalize/url_normalize.py

url_normalize-2.1.0/tests/test_url_normalize.py

@@ -1,127 +0,0 @@
-"""Integrations tests."""
-
-from __future__ import annotations
-
-from typing import Final
-
-from url_normalize import url_normalize
-
-EXPECTED_RESULTS: Final[dict[str, str]] = {
-    "/../foo": "/foo",
-    "/./../foo": "/foo",
-    "/./foo": "/foo",
-    "/./foo/.": "/foo/",
-    "//www.foo.com/": "https://www.foo.com/",
-    "/foo/../bar": "/bar",
-    "/foo/./bar": "/foo/bar",
-    "/foo//": "/foo/",
-    "/foo///bar//": "/foo/bar/",
-    "/foo/bar/..": "/foo/",
-    "/foo/bar/../..": "/",
-    "/foo/bar/../../../../baz": "/baz",
-    "/foo/bar/../../../baz": "/baz",
-    "/foo/bar/../../": "/",
-    "/foo/bar/../../baz": "/baz",
-    "/foo/bar/../": "/foo/",
-    "/foo/bar/../baz": "/foo/baz",
-    "/foo/bar/.": "/foo/bar/",
-    "/foo/bar/./": "/foo/bar/",
-    "http://:@example.com/": "http://example.com/",
-    "http://@example.com/": "http://example.com/",
-    "http://127.0.0.1:80/": "http://127.0.0.1/",
-    "http://example.com:081/": "http://example.com:81/",
-    "http://example.com:80/": "http://example.com/",
-    "http://example.com": "http://example.com/",
-    "http://example.com/?b&a": "http://example.com/?b&a",
-    "http://example.com/?q=%5c": "http://example.com/?q=%5C",
-    "http://example.com/?q=%C7": "http://example.com/?q=%EF%BF%BD",
-    "http://example.com/?q=C%CC%A7": "http://example.com/?q=%C3%87",
-    "http://EXAMPLE.COM/": "http://example.com/",
-    "http://example.com/%7Ejane": "http://example.com/~jane",
-    "http://example.com/a/../a/b": "http://example.com/a/b",
-    "http://example.com/a/./b": "http://example.com/a/b",
-    "http://example.com/#!5753509/hello-world": (
-        "http://example.com/?_escaped_fragment_=5753509/hello-world"
-    ),
-    "http://USER:pass@www.Example.COM/foo/bar": (
-        "http://USER:pass@www.example.com/foo/bar"
-    ),
-    "http://www.example.com./": "http://www.example.com/",
-    "http://www.foo.com:80/foo": "http://www.foo.com/foo",
-    "http://www.foo.com.:81/foo": "http://www.foo.com:81/foo",
-    "http://www.foo.com./foo/bar.html": "http://www.foo.com/foo/bar.html",
-    "http://www.foo.com/%7Ebar": "http://www.foo.com/~bar",
-    "http://www.foo.com/%7ebar": "http://www.foo.com/~bar",
-    "пример.испытание/Служебная:Search/Test": (
-        "https://xn--e1afmkfd.xn--80akhbyknj4f"
-        "/%D0%A1%D0%BB%D1%83%D0%B6%D0%B5%D0%B1%D0%BD%D0%B0%D1%8F:Search/Test"
-    ),
-}
-
-NO_CHANGES_EXPECTED: Final[tuple[str, ...]] = (
-    "-",
-    "",
-    "/..foo",
-    "/.foo",
-    "/foo..",
-    "/foo.",
-    "ftp://user:pass@ftp.foo.net/foo/bar",
-    "http://127.0.0.1/",
-    "http://example.com:8080/",
-    "http://example.com/?a&b",
-    "http://example.com/?q=%5C",
-    "http://example.com/?q=%C3%87",
-    "http://example.com/?q=%E2%85%A0",
-    "http://example.com/",
-    "http://example.com/~jane",
-    "http://example.com/a/b",
-    "http://example.com/FOO",
-    "http://user:password@example.com/",
-    "http://www.foo.com:8000/foo",
-    # from rfc2396bis
-    "ftp://ftp.is.co.za/rfc/rfc1808.txt",
-    "http://www.ietf.org/rfc/rfc2396.txt",
-    "ldap://[2001:db8::7]/c=GB?objectClass?one",
-    "mailto:John.Doe@example.com",
-    "news:comp.infosystems.www.servers.unix",
-    "tel:+1-816-555-1212",
-    "telnet://192.0.2.16:80/",
-    "urn:oasis:names:specification:docbook:dtd:xml:4.1.2",
-    # Issue #36: Fragment with '=' should not be encoded
-    "https://docs.google.com/spreadsheets/d/abcd/edit#gid=1234",
-)
-
-
-def test_url_normalize_changes() -> None:
-    """Assert url_normalize do not change URI if not required.
-
-    http://www.intertwingly.net/wiki/pie/PaceCanonicalIds
-    """
-    for value in NO_CHANGES_EXPECTED:
-        assert url_normalize(value) == value
-
-
-def test_url_normalize_results() -> None:
-    """Assert url_normalize return expected results."""
-    for value, expected in EXPECTED_RESULTS.items():
-        assert expected == url_normalize(value), value
-
-
-def test_url_normalize_filtered() -> None:
-    """Assert url_normalize return expected results."""
-    url = "/?a&b"
-    expected = "/"
-
-    actual = url_normalize(url, filter_params=True)
-
-    assert actual == expected
-
-
-def test_url_normalize_with_http_scheme() -> None:
-    """Assert we could use http scheme as default."""
-    url = "//www.foo.com/"
-    expected = "http://www.foo.com/"
-
-    actual = url_normalize(url, default_scheme="http")
-
-    assert actual == expected