uritools 6.1.2__tar.gz → 6.1.4__tar.gz

{uritools-6.1.2 → uritools-6.1.4}/CHANGELOG.rst

@@ -1,3 +1,27 @@
+v6.1.4 (2026-11-04)
+===================
+
+- Fix newline handling in ``uricompose()`` and ``urisplit()``.
+
+- Compare schemes case-insensitively in non-strict ``urijoin()``.
+
+- Recognize an uppercase ``IPvFuture`` version flag.
+
+- Various documentation improvements.
+
+- Minor unit test improvements.
+
+- Update build environment.
+
+
+v6.1.3 (2026-07-24)
+===================
+
+- Minor style improvements to keep ``ruff`` happy.
+
+- Update build environment.
+
+
 v6.1.2 (2026-05-22)
 ===================
 

{uritools-6.1.2/src/uritools.egg-info → uritools-6.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uritools
-Version: 6.1.2
+Version: 6.1.4
 Summary: URI parsing, classification and composition
 Author-email: Thomas Kemmer <tkemmer@computer.org>
 Maintainer-email: Thomas Kemmer <tkemmer@computer.org>
@@ -21,6 +21,7 @@ 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: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst

uritools-6.1.4/docs/conf.py

@@ -0,0 +1,18 @@
+import importlib.metadata
+
+project = "uritools"
+copyright = "2014-2026 Thomas Kemmer"
+release = importlib.metadata.version(project)
+version = ".".join(release.split(".")[:2])
+
+extensions = [
+    "sphinx.ext.autodoc",
+    "sphinx.ext.coverage",
+    "sphinx.ext.doctest",
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.todo",
+]
+exclude_patterns = ["_build"]
+root_doc = "index"
+html_theme = "classic"
+intersphinx_mapping = {"python": ("https://docs.python.org/3", None)}

{uritools-6.1.2 → uritools-6.1.4}/docs/index.rst

@@ -102,6 +102,9 @@ URI Composition
 
    All components may be specified as either Unicode strings, which
    will be encoded according to `encoding`, or :class:`bytes` objects.
+   A `host` given as a Unicode string is always encoded as UTF-8,
+   regardless of `encoding`, as :rfc:`3986#section-3.2.2` requires
+   for non-ASCII registered names.
 
    `authority` may also be passed a three-item sequence specifying
    userinfo, host and port subcomponents.  If both `authority` and any
@@ -118,10 +121,15 @@ URI Composition
 .. autofunction:: urijoin
 
    If `strict` is :const:`False`, a scheme in the reference is
-   ignored if it is identical to the base URI's scheme.
+   ignored if it matches the base URI's scheme, ignoring case.
 
 .. autofunction:: uriunsplit
 
+   The type of the returned URI reference is that of the `path`
+   element.  All other elements must be of the same type, or
+   :const:`None`; mixing :class:`str` and :class:`bytes` elements
+   raises :exc:`TypeError`.
+
 
 URI Decomposition
 =================
@@ -187,6 +195,11 @@ URI Encoding
    percent-encodings and decode `uristring` using the codec registered
    for `encoding`, returning a Unicode string.
 
+   `errors` specifies how decoding errors are handled, as for
+   :meth:`bytes.decode`.  A Unicode `uristring` is first encoded as
+   ASCII if `encoding` is :const:`None`, and using `encoding`
+   otherwise, with the same `errors` setting.
+
 .. autofunction:: uriencode
 
    If `uristring` is a :class:`bytes` object, replace any characters
@@ -195,6 +208,12 @@ URI Encoding
    Otherwise, encode `uristring` using the codec registered for
    `encoding` before replacing any percent encodings.
 
+   `safe` specifies additional characters that are left unencoded, as
+   a string of ASCII characters or a :class:`bytes` object, for
+   example ``"/"`` to keep path separators.  `encoding` and `errors`
+   are passed to :meth:`str.encode` when `uristring` is a Unicode
+   string; they are ignored for :class:`bytes` input.
+
 
 Structured Parse Results
 ========================
@@ -211,6 +230,11 @@ convenience methods.
 .. autoclass:: SplitResult
    :members:
 
+   :meth:`transform` expects `ref` to be of the same type as the
+   components of the result, i.e. a string or a :class:`bytes`
+   object; :func:`urijoin` converts mixed `base` and `ref` types
+   itself.
+
 
 Character Constants
 ===================

{uritools-6.1.2 → uritools-6.1.4}/pyproject.toml

@@ -27,6 +27,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 
@@ -49,5 +50,7 @@ version = {attr = "uritools.__version__"}
 
 [tool.pyright]
 typeCheckingMode = "standard"
-reportAttributeAccessIssue = "information"
-reportOptionalMemberAccess = "warning"
+reportUnnecessaryTypeIgnoreComment = "error"
+
+[tool.ruff.lint]
+ignore = ["DTZ005", "SIM102", "UP031"]

{uritools-6.1.2 → uritools-6.1.4}/src/uritools/__init__.py

@@ -33,7 +33,7 @@ __all__ = (
     "uriunsplit",
 )
 
-__version__ = "6.1.2"
+__version__ = "6.1.4"
 
 
 # RFC 3986 2.2.  Reserved Characters
@@ -74,7 +74,7 @@ def uriencode(uristring, safe="", encoding="utf-8", errors="strict"):
     """Encode a URI string or string component."""
     if not isinstance(uristring, bytes):
         uristring = uristring.encode(encoding, errors)
-    if not isinstance(safe, bytes):
+    if isinstance(safe, str):
         safe = safe.encode("ascii")
     # FIXME: though unlikely, _encoded may grow without bounds if arbitrary
     # safe values are passed by a caller - consider using @functools.lru_cache
@@ -84,7 +84,7 @@ def uriencode(uristring, safe="", encoding="utf-8", errors="strict"):
     except KeyError:
         encoded = _encoded[b""][:]
         for i in safe:
-            encoded[i] = bytes([i])  # type: ignore
+            encoded[i] = bytes([i])
         _encoded[safe] = encoded
     return b"".join(map(encoded.__getitem__, uristring))
 
@@ -141,6 +141,21 @@ class SplitResult(
 
     __slots__ = ()  # prevent creation of instance dictionary
 
+    # regex and delimiter constants, defined by SplitResultBytes and SplitResultString
+    _RE: re.Pattern
+    _COLON: str | bytes
+    _SLASH: str | bytes
+    _QUEST: str | bytes
+    _HASH: str | bytes
+    _LBRACKET: str | bytes
+    _RBRACKET: str | bytes
+    _AT: str | bytes
+    _DOT: str | bytes
+    _DOTDOT: str | bytes
+    _EMPTY: str | bytes
+    _EQ: str | bytes
+    _DIGITS: str | bytes
+
     @property
     def userinfo(self):
         authority = self.authority
@@ -260,6 +275,10 @@ class SplitResult(
             else:
                 return ipaddress.IPv4Address(host)
         except ValueError:
+            # RFC 3986 3.2.2. Host: Non-ASCII characters must first be
+            # encoded according to UTF-8 [STD63], and then each octet
+            # of the corresponding UTF-8 sequence must be
+            # percent-encoded to be represented as URI characters.
             return uridecode(host, "utf-8", errors).lower()
 
     def getport(self, default=None):
@@ -381,8 +400,11 @@ class SplitResult(
         """
         scheme, authority, path, query, fragment = self._match(ref).groups()
 
-        # RFC 3986 5.2.2. Transform References
-        if scheme is not None and (strict or scheme != self.scheme):
+        # RFC 3986 5.2.2. Transform References; scheme names are
+        # case-insensitive (RFC 3986 3.1)
+        if scheme is not None and (
+            strict or self.scheme is None or scheme.lower() != self.scheme.lower()
+        ):
             path = self.__remove_dot_segments(path)
         elif authority is not None:
             scheme = self.scheme
@@ -402,6 +424,10 @@ class SplitResult(
             path = self.__remove_dot_segments(self.__merge(path))
         return type(self)(scheme, authority, path, query, fragment)
 
+    @classmethod
+    def _match(cls, ref):
+        return cls._RE.match(ref)
+
     def __merge(self, path):
         # RFC 3986 5.2.3. Merge Paths
         if self.authority is not None and not self.path:
@@ -451,8 +477,8 @@ class SplitResult(
         # not supported".
         if isinstance(address, bytes):
             address = address.decode("ascii")
-        if address.startswith("v"):
-            raise ValueError("address mechanism not supported")
+        if address.startswith(("v", "V")):
+            raise ValueError("Address mechanism not supported")
         return ipaddress.IPv6Address(address)
 
 
@@ -469,13 +495,9 @@ class SplitResultBytes(SplitResult):
     (?:\?([^#]*))?                   # query
     (?:\#(.*))?                      # fragment
     """,
-        flags=re.VERBOSE,
+        flags=re.VERBOSE | re.DOTALL,
     )
 
-    @classmethod
-    def _match(cls, ref):
-        return cls._RE.match(ref)
-
     # RFC 3986 2.2 gen-delims
     _COLON, _SLASH, _QUEST, _HASH, _LBRACKET, _RBRACKET, _AT = (
         b":",
@@ -508,13 +530,9 @@ class SplitResultString(SplitResult):
     (?:\?([^#]*))?                   # query
     (?:\#(.*))?                      # fragment
     """,
-        flags=re.VERBOSE,
+        flags=re.VERBOSE | re.DOTALL,
     )
 
-    @classmethod
-    def _match(cls, ref):
-        return cls._RE.match(ref)
-
     # RFC 3986 2.2 gen-delims
     _COLON, _SLASH, _QUEST, _HASH, _LBRACKET, _RBRACKET, _AT = (
         ":",
@@ -614,11 +632,11 @@ def issamedoc(uristring):
 
 
 # RFC 3986 3.1: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
-_SCHEME_RE = re.compile(b"^[A-Za-z][A-Za-z0-9+.-]*$")
+_SCHEME_RE = re.compile(b"[A-Za-z][A-Za-z0-9+.-]*")
 
 # RFC 3986 3.2: authority = [ userinfo "@" ] host [ ":" port ]
-_AUTHORITY_RE_BYTES = re.compile(b"^(?:(.*)@)?(.*?)(?::([0-9]*))?$")
-_AUTHORITY_RE_STR = re.compile("^(?:(.*)@)?(.*?)(?::([0-9]*))?$")
+_AUTHORITY_RE_BYTES = re.compile(b"(?:(.*)@)?(.*?)(?::([0-9]*))?", re.DOTALL)
+_AUTHORITY_RE_STR = re.compile("(?:(.*)@)?(.*?)(?::([0-9]*))?", re.DOTALL)
 
 # safe component characters
 _SAFE_USERINFO = SUB_DELIMS + ":"
@@ -629,7 +647,7 @@ _SAFE_FRAGMENT = SUB_DELIMS + ":@/?"
 
 
 def _scheme(scheme):
-    if _SCHEME_RE.match(scheme):
+    if _SCHEME_RE.fullmatch(scheme):
         return scheme.lower()
     else:
         raise ValueError("Invalid scheme component")
@@ -664,7 +682,7 @@ def _authority(userinfo, host, port, encoding):
 
 
 def _ip_literal(address):
-    if address.startswith("v"):
+    if address.startswith(("v", "V")):
         raise ValueError("Address mechanism not supported")
     else:
         return b"[" + ipaddress.IPv6Address(address).compressed.encode() + b"]"
@@ -755,9 +773,9 @@ def uricompose(
     if authority is None:
         authority = (None, None, None)
     elif isinstance(authority, bytes):
-        authority = _AUTHORITY_RE_BYTES.match(authority).groups()
+        authority = _AUTHORITY_RE_BYTES.fullmatch(authority).groups()  # type: ignore
     elif isinstance(authority, str):
-        authority = _AUTHORITY_RE_STR.match(authority).groups()
+        authority = _AUTHORITY_RE_STR.fullmatch(authority).groups()  # type: ignore
     elif not isinstance(authority, collections.abc.Sequence):
         raise TypeError("Invalid authority type")
     elif len(authority) != 3:
@@ -817,4 +835,5 @@ def uricompose(
         fragment = uriencode(fragment, _SAFE_FRAGMENT, encoding)
 
     # return URI reference as `str`
-    return uriunsplit((scheme, authority, path, query, fragment)).decode()
+    parts = (scheme, authority, path, query, fragment)
+    return uriunsplit(parts).decode()  # type: ignore

{uritools-6.1.2 → uritools-6.1.4}/src/uritools/__init__.pyi

@@ -1,9 +1,8 @@
 import ipaddress
 from collections.abc import Iterable, Mapping, Sequence
-from typing import Any, AnyStr, Generic, NamedTuple, overload
-from typing_extensions import TypeAlias
+from typing import Any, AnyStr, Generic, NamedTuple, TypeAlias, overload
 
-__all__ = [
+__all__ = (
     "GEN_DELIMS",
     "RESERVED",
     "SUB_DELIMS",
@@ -21,7 +20,7 @@ __all__ = [
     "urijoin",
     "urisplit",
     "uriunsplit",
-]
+)
 __version__: str
 
 GEN_DELIMS: str

{uritools-6.1.2 → uritools-6.1.4/src/uritools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uritools
-Version: 6.1.2
+Version: 6.1.4
 Summary: URI parsing, classification and composition
 Author-email: Thomas Kemmer <tkemmer@computer.org>
 Maintainer-email: Thomas Kemmer <tkemmer@computer.org>
@@ -21,6 +21,7 @@ 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: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst

{uritools-6.1.2 → uritools-6.1.4}/tests/test_compose.py

@@ -37,7 +37,7 @@ class ComposeTest(unittest.TestCase):
         for uri, scheme in cases:
             self.check(uri, scheme=scheme)
         # invalid scheme
-        for scheme in ("", "foo:", "\xf6lk\xfcrbis"):
+        for scheme in ("", "foo:", "foo\n", b"foo\n", "\xf6lk\xfcrbis"):
             with self.assertRaises(ValueError, msg="scheme=%r" % scheme):
                 uricompose(scheme=scheme)
 
@@ -62,6 +62,12 @@ class ComposeTest(unittest.TestCase):
             ("//user@[::1]:42", b"user@[::1]:42"),
             ("//user:c2VjcmV0@example.com", "user:c2VjcmV0@example.com"),
             ("//user:c2VjcmV0@example.com", b"user:c2VjcmV0@example.com"),
+            ("//foo%0Abar", "foo\nbar"),
+            ("//foo%0Abar", b"foo\nbar"),
+            ("//a%0Ab@example.com", "a\nb@example.com"),
+            ("//a%0Ab@example.com", b"a\nb@example.com"),
+            ("//example.com%3A42%0A", "example.com:42\n"),
+            ("//example.com%3A42%0A", b"example.com:42\n"),
         ]
         for uri, authority in cases:
             self.check(uri, authority=authority)
@@ -120,11 +126,15 @@ class ComposeTest(unittest.TestCase):
             with self.assertRaises(TypeError, msg="host=%r" % host):
                 uricompose(host=host)  # type: ignore
         # invalid host ip-literal
-        for host in ("[foo]", "[v1.x]"):
+        for host in ("[foo]", "[v1.x]", "[V1.x]"):
             with self.assertRaises(ValueError, msg="host=%r" % host):
                 uricompose(authority=[None, host, None])
             with self.assertRaises(ValueError, msg="host=%r" % host):
                 uricompose(host=host)
+        # RFC 3986 3.2.2: the IPvFuture version flag is case-insensitive
+        for host in ("[v1.x]", "[V1.x]", b"[v1.x]", b"[V1.x]"):
+            with self.assertRaisesRegex(ValueError, "mechanism not supported"):
+                uricompose(host=host)
         # invalid port value
         for port in (-1, "foo", 3.14):
             with self.assertRaises(ValueError, msg="port=%r" % port):
@@ -138,6 +148,25 @@ class ComposeTest(unittest.TestCase):
             ("//user@example.com:42", "", "user", "example.com", 42),
             ("//user@example.com:42", "example.com", "user", None, 42),
             ("//user@example.com:42", "user@:42", None, "example.com", None),
+            ("//user@example.com:42", b"", b"user", b"example.com", b"42"),
+            ("//user@example.com:42", b"example.com", b"user", None, 42),
+            ("//user@example.com:42", b"user@:42", None, b"example.com", None),
+            ("//user@example.com:42", b"user@:42", None, "example.com", None),
+            ("//user@example.com:42", "user@:42", None, b"example.com", None),
+            (
+                "//user@example.com:42",
+                b"nobody@localhost:80",
+                "user",
+                b"example.com",
+                "42",
+            ),
+            (
+                "//user@example.com:42",
+                "nobody@localhost:80",
+                b"user",
+                "example.com",
+                b"42",
+            ),
         ]
         for uri, authority, userinfo, host, port in cases:
             self.check(
@@ -212,13 +241,13 @@ class ComposeTest(unittest.TestCase):
             ("?name=foo&type=bar", od([("name", "foo"), ("type", "bar")])),
             ("?name=foo&name=bar", [("name", "foo"), ("name", "bar")]),
             ("?name=foo&name=bar", {"name": ["foo", "bar"]}),
-            ("?name=a/b/c", dict(name="a/b/c")),
-            ("?name=a:b:c", dict(name="a:b:c")),
-            ("?name=a?b?c", dict(name="a?b?c")),
-            ("?name=a@b@c", dict(name="a@b@c")),
-            ("?name=a;b;c", dict(name="a;b;c")),
-            ("?name=a%23b%23c", dict(name="a#b#c")),
-            ("?name=a%26b%26c", dict(name="a&b&c")),
+            ("?name=a/b/c", {"name": "a/b/c"}),
+            ("?name=a:b:c", {"name": "a:b:c"}),
+            ("?name=a?b?c", {"name": "a?b?c"}),
+            ("?name=a@b@c", {"name": "a@b@c"}),
+            ("?name=a;b;c", {"name": "a;b;c"}),
+            ("?name=a%23b%23c", {"name": "a#b#c"}),
+            ("?name=a%26b%26c", {"name": "a&b&c"}),
         ]
         for uri, query in cases:
             self.check(uri, query=query)
@@ -236,3 +265,41 @@ class ComposeTest(unittest.TestCase):
         ]
         for sep, uri, query in cases:
             self.check(uri, query=query, querysep=sep)
+
+    def test_encoding(self):
+        cases = [
+            ("//%E4@example.com", {"userinfo": "\xe4", "host": "example.com"}),
+            ("/%E4", {"path": "/\xe4"}),
+            ("?name=%E4", {"query": "name=\xe4"}),
+            ("?name=%E4", {"query": {"name": "\xe4"}}),
+            ("?name=%E4", {"query": [("name", "\xe4")]}),
+            ("#%E4", {"fragment": "\xe4"}),
+        ]
+        for uri, kwargs in cases:
+            self.check(uri, encoding="latin-1", **kwargs)
+        # host is always encoded as UTF-8
+        self.check("//%C3%A4", host="\xe4", encoding="latin-1")
+        # bytes components are not affected by encoding
+        self.check("/%C3%A4", path=b"/\xc3\xa4", encoding="latin-1")
+        # characters not representable in encoding
+        with self.assertRaises(UnicodeEncodeError):
+            uricompose(path="/\u20ac", encoding="latin-1")
+
+    def test_fragment(self):
+        cases = [
+            ("", None),
+            ("#", ""),
+            ("#", b""),
+            ("#nose", "nose"),
+            ("#nose", b"nose"),
+            ("#foo%20bar", "foo bar"),
+            ("#foo%20bar", b"foo bar"),
+            ("#a/b?c:d@e", "a/b?c:d@e"),
+            ("#a/b?c:d@e", b"a/b?c:d@e"),
+            ("#a%23b", "a#b"),
+            ("#a%23b", b"a#b"),
+            ("#%C3%A4", "\xe4"),
+            ("#%C3%A4", b"\xc3\xa4"),
+        ]
+        for uri, fragment in cases:
+            self.check(uri, fragment=fragment)

{uritools-6.1.2 → uritools-6.1.4}/tests/test_defrag.py

@@ -23,7 +23,7 @@ class DefragTest(unittest.TestCase):
         def encode(s):
             return s.encode() if s is not None else None
 
-        cases += list(map(encode, case) for case in cases)
+        cases += [map(encode, case) for case in cases]
 
         for uri, base, fragment in cases:
             defrag = uridefrag(uri)
@@ -42,6 +42,18 @@ class DefragTest(unittest.TestCase):
         self.assertEqual(uridefrag("#foo%20bar").getfragment(), "foo bar")
         self.assertEqual(uridefrag(b"#foo%20bar").getfragment(), "foo bar")
 
+    def test_getfragment_default(self):
+        self.assertEqual(uridefrag("").getfragment("baz"), "baz")
+        self.assertEqual(uridefrag(b"").getfragment("baz"), "baz")
+        self.assertEqual(uridefrag("").getfragment(default="baz"), "baz")
+        self.assertEqual(uridefrag(b"").getfragment(default="baz"), "baz")
+        self.assertEqual(uridefrag("#").getfragment("baz"), "")
+        self.assertEqual(uridefrag(b"#").getfragment("baz"), "")
+        self.assertEqual(uridefrag("#foo").getfragment("baz"), "foo")
+        self.assertEqual(uridefrag(b"#foo").getfragment("baz"), "foo")
+        self.assertEqual(uridefrag("#foo%20bar").getfragment("baz"), "foo bar")
+        self.assertEqual(uridefrag(b"#foo%20bar").getfragment("baz"), "foo bar")
+
     def test_getfragment_encoding_none(self):
         self.assertEqual(uridefrag("").getfragment(encoding=None), None)
         self.assertEqual(uridefrag(b"").getfragment(encoding=None), None)

{uritools-6.1.2 → uritools-6.1.4}/tests/test_encoding.py

@@ -8,7 +8,7 @@ class EncodingTest(unittest.TestCase):
         self.assertEqual(uriencode(decoded, safe, encoding), encoded)
         self.assertEqual(uridecode(encoded, encoding), decoded)
         # swap bytes/string types
-        self.assertEqual(uriencode(decoded.encode(encoding), safe, encoding), encoded)  # noqa
+        self.assertEqual(uriencode(decoded.encode(encoding), safe, encoding), encoded)
         self.assertEqual(uridecode(encoded.decode("ascii"), encoding), decoded)
 
     def test_encoding(self):

{uritools-6.1.2 → uritools-6.1.4}/tests/test_join.py

@@ -66,6 +66,14 @@ class JoinTest(unittest.TestCase):
         self.check(self.RFC3986_BASE, "http:g", "http:g", True)
         self.check(self.RFC3986_BASE, "http:g", "http://a/b/c/g", False)
 
+    def test_scheme_case(self):
+        # RFC 3986 3.1: scheme names are case-insensitive
+        self.check(self.RFC3986_BASE, "HTTP:g", "http://a/b/c/g")
+        self.check(self.RFC3986_BASE, "HTTP:g", "HTTP:g", strict=True)
+        self.check("HTTP://a/b/c/d;p?q", "http:g", "HTTP://a/b/c/g")
+        self.check("HTTP://a/b/c/d;p?q", "http:g", "http:g", strict=True)
+        self.check("g:h", "G:h", "g:h")
+
     def test_rfc3986_merge(self):
         """urijoin test cases for RFC 3986 5.2.3. Merge Paths"""
         self.check("http://a", "b", "http://a/b")

{uritools-6.1.2 → uritools-6.1.4}/tests/test_split.py

@@ -48,6 +48,8 @@ class SplitTest(unittest.TestCase):
             ("//?", (None, "", "", "", None)),
             ("//#", (None, "", "", None, "")),
             ("//?#", (None, "", "", "", "")),
+            ("#foo\nbar", (None, None, "", None, "foo\nbar")),
+            ("?foo\nbar#baz\n", (None, None, "", "foo\nbar", "baz\n")),
             ("?", (None, None, "", "", None)),
             ("??", (None, None, "", "?", None)),
             ("?#", (None, None, "", "", "")),
@@ -77,6 +79,8 @@ class SplitTest(unittest.TestCase):
             (b"?:", (None, None, b"", b":", None)),
             (b"#:", (None, None, b"", None, b":")),
             (b"_:", (None, None, b"_:", None, None)),
+            (b"#foo\nbar", (None, None, b"", None, b"foo\nbar")),
+            (b"?foo\nbar#baz\n", (None, None, b"", b"foo\nbar", b"baz\n")),
         ]
         for uri, parts in cases:
             self.check(uri, parts)
@@ -281,9 +285,31 @@ class SplitTest(unittest.TestCase):
                 ("nobody", "localhost", 42),
                 ("userinfo", "test.python.org", 5432),
             ),
+            (
+                "urn:example:animal:ferret:nose",
+                (b"nobody", b"localhost", 42),
+                (b"nobody", b"localhost", 42),
+            ),
+            ("file:///", (b"nobody", b"localhost", 42), (b"nobody", b"localhost", 42)),
+            (
+                "http://Test.python.org/foo/",
+                (b"nobody", b"localhost", 42),
+                (b"nobody", "test.python.org", 42),
+            ),
+            (
+                "http://@Test.python.org:5432/foo/",
+                (b"nobody", b"localhost", 42),
+                ("", "test.python.org", 5432),
+            ),
+            (
+                "http://userinfo@Test.python.org:5432/foo/",
+                (b"nobody", b"localhost", 42),
+                ("userinfo", "test.python.org", 5432),
+            ),
         ]
         for uri, default, authority in cases:
             self.assertEqual(urisplit(uri).getauthority(default), authority)
+            self.assertEqual(urisplit(uri.encode()).getauthority(default), authority)
         for uri in ["http://[::1/", "http://::1]/"]:
             with self.assertRaises(ValueError, msg="%r" % uri):
                 urisplit(uri).getauthority()
@@ -314,7 +340,7 @@ class SplitTest(unittest.TestCase):
     def test_getport(self):
         for uri in ["foo://bar", "foo://bar:", "foo://bar/", "foo://bar:/"]:
             result = urisplit(uri)
-            if result.authority.endswith(":"):
+            if result.authority.endswith(":"):  # type: ignore
                 self.assertEqual(result.port, "")
             else:
                 self.assertEqual(result.port, None)
@@ -565,6 +591,12 @@ class SplitTest(unittest.TestCase):
                 urisplit(uri).gethost()
             with self.assertRaises(ValueError, msg="%r" % uri.encode("ascii")):
                 urisplit(uri.encode("ascii")).gethost()
+        # RFC 3986 3.2.2: the IPvFuture version flag is case-insensitive
+        for uri in ["http://[v7.future]/", "http://[V7.future]/"]:
+            with self.assertRaisesRegex(ValueError, "mechanism not supported"):
+                urisplit(uri).gethost()
+            with self.assertRaisesRegex(ValueError, "mechanism not supported"):
+                urisplit(uri.encode("ascii")).gethost()
 
     def test_encoding_none(self):
         uri = "foo://user@example.com:8042/over/there?name=ferret#nose"

{uritools-6.1.2 → uritools-6.1.4}/tests/test_unsplit.py

@@ -30,3 +30,17 @@ class UnsplitTest(unittest.TestCase):
         ]
         for parts, uri in cases:
             self.check(parts, uri)
+
+    def test_mixed_types(self):
+        # the type of `path` selects the result type; all other parts must match
+        cases = [
+            ("foo", None, b"/over/there", None, None),
+            (b"foo", None, "/over/there", None, None),
+            (None, "example.com", b"/over/there", None, None),
+            (None, b"example.com", "/over/there", None, None),
+            (None, None, "/over/there", None, b"nose"),
+            (None, None, "/over/there", b"name=ferret", None),
+        ]
+        for parts in cases:
+            with self.assertRaises(TypeError):
+                uriunsplit(parts)

{uritools-6.1.2 → uritools-6.1.4}/tox.ini

@@ -1,12 +1,12 @@
 [tox]
-envlist = py,docs,doctest,ruff,ruff-format,pyright
+envlist = py,docs,doctest,pyright,ruff,ruff-format
 
 [testenv]
 deps =
     pytest
     pytest-cov
 commands =
-    py.test --basetemp={envtmpdir} --cov=uritools --cov-report term-missing {posargs}
+    py.test --basetemp={envtmpdir} --cov=uritools --cov-branch --cov-report term-missing {posargs}
 
 [testenv:docs]
 deps =
@@ -20,23 +20,20 @@ deps =
 commands =
      sphinx-build -W -b doctest -d {envtmpdir}/doctrees docs {envtmpdir}/doctest
 
+[testenv:pyright]
+deps =
+    pyright
+commands =
+    pyright {posargs}
+
 [testenv:ruff]
 deps =
     ruff
 commands =
     ruff check {posargs}
-skip_install = true
 
 [testenv:ruff-format]
 deps =
     ruff
 commands =
     ruff format --diff -q {posargs}
-skip_install = true
-
-[testenv:pyright]
-deps =
-    pyright
-commands =
-    pyright {posargs}
-skip_install = true

uritools-6.1.2/docs/conf.py

@@ -1,36 +0,0 @@
-import pathlib
-import sys
-
-src_directory = (pathlib.Path(__file__).parent.parent / "src").resolve()
-sys.path.insert(0, str(src_directory))
-
-
-# Extract the current version from the source.
-def get_version():
-    """Get the version and release from the source code."""
-
-    text = (src_directory / "uritools/__init__.py").read_text()
-    for line in text.splitlines():
-        if not line.strip().startswith("__version__"):
-            continue
-        full_version = line.partition("=")[2].strip().strip("\"'")
-        partial_version = ".".join(full_version.split(".")[:2])
-        return full_version, partial_version
-    return (None, None)
-
-
-project = "uritools"
-copyright = "2014-2026 Thomas Kemmer"
-release, version = get_version()
-
-extensions = [
-    "sphinx.ext.autodoc",
-    "sphinx.ext.coverage",
-    "sphinx.ext.doctest",
-    "sphinx.ext.intersphinx",
-    "sphinx.ext.todo",
-]
-exclude_patterns = ["_build"]
-master_doc = "index"
-html_theme = "classic"
-intersphinx_mapping = {"python": ("https://docs.python.org/3", None)}