lint and formatting

Author: mvaught

setup.py

@@ -9,7 +9,6 @@
 
 from setuptools import find_packages, setup
 
-
 __author__ = "Mahmoud Hashemi and Glyph Lefkowitz"
 __version__ = "21.0.1dev"
 __contact__ = "mahmoud@hatnote.com"

src/hyperlink/_url.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 # -*- coding: utf-8 -*-
 """Hyperlink provides Pythonic URL parsing, construction, and rendering.
 
@@ -31,6 +32,7 @@
     cast,
     TYPE_CHECKING,
 )
+
 if TYPE_CHECKING:
     from typing import (
         Type,
@@ -43,8 +45,11 @@
         TypeVar,
         Union,
     )
+
     NoneType: Type[None] = type(None)
-    QueryPairs = Tuple[Tuple[str, Optional[str]], ...]  # internal representation
+    QueryPairs = Tuple[
+        Tuple[str, Optional[str]], ...
+    ]  # internal representation
     QueryParameters = Union[
         Mapping[str, Optional[str]],
         QueryPairs,
@@ -177,7 +182,9 @@ def __bool__(self) -> bool:
 _QUERY_KEY_DELIMS = _ALL_DELIMS - _QUERY_KEY_SAFE
 
 
-def _make_decode_map(delims: Iterable[str], allow_percent: bool = False) -> Mapping[bytes, bytes]:
+def _make_decode_map(
+    delims: Iterable[str], allow_percent: bool = False
+) -> Mapping[bytes, bytes]:
     ret = dict(_HEX_CHAR_MAP)
     if not allow_percent:
         delims = set(delims) | set(["%"])
@@ -262,9 +269,11 @@ def _encode_schemeless_path_part(text: str, maximal: bool = True) -> str:
         return "".join([_SCHEMELESS_PATH_PART_QUOTE_MAP[b] for b in bytestr])
     return "".join(
         [
-            _SCHEMELESS_PATH_PART_QUOTE_MAP[t]
-            if t in _SCHEMELESS_PATH_DELIMS
-            else t
+            (
+                _SCHEMELESS_PATH_PART_QUOTE_MAP[t]
+                if t in _SCHEMELESS_PATH_DELIMS
+                else t
+            )
             for t in text
         ]
     )
@@ -449,7 +458,10 @@ def _encode_userinfo_part(text: str, maximal: bool = True) -> str:
 
 
 def register_scheme(
-    text: str, uses_netloc: bool = True, default_port: Optional[int] = None, query_plus_is_space: bool = True
+    text: str,
+    uses_netloc: bool = True,
+    default_port: Optional[int] = None,
+    query_plus_is_space: bool = True,
 ) -> None:
     """Registers new scheme information, resulting in correct port and
     slash behavior from the URL object. There are dozens of standard
@@ -499,7 +511,9 @@ def register_scheme(
     return
 
 
-def scheme_uses_netloc(scheme: str, default: Optional[bool] = None) -> Optional[bool]:
+def scheme_uses_netloc(
+    scheme: str, default: Optional[bool] = None
+) -> Optional[bool]:
     """Whether or not a URL uses :code:`:` or :code:`://` to separate the
     scheme from the rest of the URL depends on the scheme's own
     standard definition. There is no way to infer this behavior
@@ -560,7 +574,12 @@ def _typecheck(name: str, value: T, *types: Type[Any]) -> T:
     return value
 
 
-def _textcheck(name: str, value: T, delims: Iterable[str] = frozenset(), nullable: bool = False) -> T:
+def _textcheck(
+    name: str,
+    value: T,
+    delims: Iterable[str] = frozenset(),
+    nullable: bool = False,
+) -> T:
     if not isinstance(value, str):
         if nullable and value is None:
             # used by query string values
@@ -590,7 +609,9 @@ def iter_pairs(iterable: Iterable[Any]) -> Iterator[Any]:
     return iter(iterable)
 
 
-def _decode_unreserved(text: str, normalize_case: bool = False, encode_stray_percents: bool = False) -> str:
+def _decode_unreserved(
+    text: str, normalize_case: bool = False, encode_stray_percents: bool = False
+) -> str:
     return _percent_decode(
         text,
         normalize_case=normalize_case,
@@ -610,7 +631,9 @@ def _decode_userinfo_part(
     )
 
 
-def _decode_path_part(text: str, normalize_case: bool = False, encode_stray_percents: bool = False) -> str:
+def _decode_path_part(
+    text: str, normalize_case: bool = False, encode_stray_percents: bool = False
+) -> str:
     """
     >>> _decode_path_part(u'%61%77%2f%7a')
     u'aw%2fz'
@@ -625,7 +648,9 @@ def _decode_path_part(text: str, normalize_case: bool = False, encode_stray_perc
     )
 
 
-def _decode_query_key(text: str, normalize_case: bool = False, encode_stray_percents: bool = False) -> str:
+def _decode_query_key(
+    text: str, normalize_case: bool = False, encode_stray_percents: bool = False
+) -> str:
     return _percent_decode(
         text,
         normalize_case=normalize_case,
@@ -1154,7 +1179,9 @@ def authority(self, with_password: bool = False, **kw: Any) -> str:
         # first, a bit of twisted compat
         with_password = kw.pop("includeSecrets", with_password)
         if kw:
-            raise TypeError("got unexpected keyword arguments: %r" % list(kw.keys()))
+            raise TypeError(
+                "got unexpected keyword arguments: %r" % list(kw.keys())
+            )
         host = self.host
         if ":" in host:
             hostport = ["[" + host + "]"]
@@ -1612,9 +1639,11 @@ def to_uri(self) -> URL:
                 [
                     (
                         _encode_query_key(k, maximal=True),
-                        _encode_query_value(v, maximal=True)
-                        if v is not None
-                        else None,
+                        (
+                            _encode_query_value(v, maximal=True)
+                            if v is not None
+                            else None
+                        ),
                     )
                     for k, v in self.query
                 ]
@@ -1954,19 +1983,29 @@ class DecodedURL(object):
     .. versionadded:: 18.0.0
     """
 
-    def __init__(self, url: URL = _EMPTY_URL, lazy: bool = False, query_plus_is_space: Optional[bool] = None) -> None:
+    def __init__(
+        self,
+        url: URL = _EMPTY_URL,
+        lazy: bool = False,
+        query_plus_is_space: Optional[bool] = None,
+    ) -> None:
         self._url = url
         if query_plus_is_space is None:
             query_plus_is_space = url.scheme not in NO_QUERY_PLUS_SCHEMES
         self._query_plus_is_space = query_plus_is_space
         if not lazy:
             # cache the following, while triggering any decoding
             # issues with decodable fields
-            self.host, self.userinfo, self.path, self.query, self.fragment
+            _ = (self.host, self.userinfo, self.path, self.query, self.fragment)
         return
 
     @classmethod
-    def from_text(cls, text: str, lazy: bool = False, query_plus_is_space: Optional[bool] = None) -> DecodedURL:
+    def from_text(
+        cls,
+        text: str,
+        lazy: bool = False,
+        query_plus_is_space: Optional[bool] = None,
+    ) -> DecodedURL:
         """\
         Make a `DecodedURL` instance from any text string containing a URL.
 
@@ -2096,11 +2135,13 @@ def query(self) -> QueryPairs:
                 "QueryPairs",
                 tuple(
                     tuple(
-                        _percent_decode(
-                            predecode(x), raise_subencoding_exc=True
+                        (
+                            _percent_decode(
+                                predecode(x), raise_subencoding_exc=True
+                            )
+                            if x is not None
+                            else None
                         )
-                        if x is not None
-                        else None
                         for x in (k, v)
                     )
                     for k, v in self._url.query
@@ -2302,20 +2343,27 @@ def __dir__(self) -> Sequence[str]:
 
 # Add some overloads so that parse gives a better return value.
 if TYPE_CHECKING:
+
     @overload
     def parse(url: str, decoded: Literal[False], lazy: bool = False) -> URL:
         """Passing decoded=False returns URL."""
 
     @overload
-    def parse(url: str, decoded: Literal[True] = True, lazy: bool = False) -> DecodedURL:
+    def parse(
+        url: str, decoded: Literal[True] = True, lazy: bool = False
+    ) -> DecodedURL:
         """Passing decoded=True (or the default value) returns DecodedURL."""
 
     @overload
-    def parse(url: str, decoded: bool = True, lazy: bool = False) -> Union[URL, DecodedURL]:
+    def parse(
+        url: str, decoded: bool = True, lazy: bool = False
+    ) -> Union[URL, DecodedURL]:
         """If decoded is not a literal we don't know the return type."""
 
 
-def parse(url: str, decoded: bool = True, lazy: bool = False) -> Union[URL, DecodedURL]:
+def parse(
+    url: str, decoded: bool = True, lazy: bool = False
+) -> Union[URL, DecodedURL]:
     """
     Automatically turn text into a structured URL object.
 

src/hyperlink/hypothesis.py

@@ -111,7 +111,9 @@ def idna_characters() -> str:
     _idnaCharacters: str = ""
 
     @composite
-    def idna_text(draw: DrawCallable, min_size: int = 1, max_size: Optional[int] = None) -> str:
+    def idna_text(
+        draw: DrawCallable, min_size: int = 1, max_size: Optional[int] = None
+    ) -> str:
         """
         A strategy which generates IDNA-encodable text.
 
@@ -202,7 +204,11 @@ def hostname_labels(draw: DrawCallable, allow_idn: bool = True) -> str:
         return label
 
     @composite
-    def hostnames(draw: DrawCallable, allow_leading_digit: bool = True, allow_idn: bool = True) -> str:
+    def hostnames(
+        draw: DrawCallable,
+        allow_leading_digit: bool = True,
+        allow_idn: bool = True,
+    ) -> str:
         """
         A strategy which generates host names.
 
@@ -218,8 +224,10 @@ def hostnames(draw: DrawCallable, allow_leading_digit: bool = True, allow_idn: b
                 str,
                 draw(
                     hostname_labels(allow_idn=allow_idn).filter(
-                        lambda l: (
-                            True if allow_leading_digit else l[0] not in digits
+                        lambda label: (
+                            True
+                            if allow_leading_digit
+                            else label[0] not in digits
                         )
                     )
                 ),
@@ -239,7 +247,24 @@ def hostnames(draw: DrawCallable, allow_leading_digit: bool = True, allow_idn: b
 
         # Trim off labels until the total host name length fits in 252
         # characters.  This avoids having to filter the data.
-        while sum(len(label) for label in labels) + len(labels) - 1 > 252:
+        # For IDNs, the length must also be checked after Punycode encoding,
+        # because the encoded form may be much longer due to the 'xn--' prefix
+        # and Unicode-to-ASCII expansion. This ensures compliance with RFC 1035
+        # and IDNA's 255-byte limit.
+
+        def get_len(lbls: list[str]) -> int:
+            d = ".".join(lbls)
+            if allow_idn:
+                try:
+                    return len(idna_encode(d))
+                except IDNAError:
+                    # Encoding failed due to length or invalidity.
+                    # Return large number to force trimming.
+                    return 9999
+            return len(d)
+
+        # Trim off labels until total hostname length fits IDNA/DNS limits
+        while get_len(labels) > 253 and len(labels) > 1:
             labels = labels[:-1]
 
         return ".".join(labels)

src/hyperlink/test/__init__.py

@@ -3,11 +3,12 @@
 Tests for hyperlink
 """
 
+from __future__ import annotations
+
 __all = ()
 
 
-def _init_hypothesis():
-    # type: () -> None
+def _init_hypothesis() -> None:
     from os import environ
 
     if "CI" in environ:

src/hyperlink/test/test_common.py

@@ -34,8 +34,7 @@ def test_assertRaisesWithCallable(self):
         """
         called_with = []
 
-        def raisesExpected(*args, **kwargs):
-            # type: (Any, Any) -> None
+        def raisesExpected(*args: Any, **kwargs: Any) -> None:
             called_with.append((args, kwargs))
             raise _ExpectedException
 
@@ -44,15 +43,13 @@ def raisesExpected(*args, **kwargs):
         )
         self.assertEqual(called_with, [((1,), {"keyword": True})])
 
-    def test_assertRaisesWithCallableUnexpectedException(self):
-        # type: () -> None
+    def test_assertRaisesWithCallableUnexpectedException(self) -> None:
         """When given a callable that raises an unexpected exception,
         HyperlinkTestCase.assertRaises raises that exception.
 
         """
 
-        def doesNotRaiseExpected(*args, **kwargs):
-            # type: (Any, Any) -> None
+        def doesNotRaiseExpected(*args: Any, **kwargs: Any) -> None:
             raise _UnexpectedException
 
         try:
@@ -62,24 +59,21 @@ def doesNotRaiseExpected(*args, **kwargs):
         except _UnexpectedException:
             pass
 
-    def test_assertRaisesWithCallableDoesNotRaise(self):
-        # type: () -> None
+    def test_assertRaisesWithCallableDoesNotRaise(self) -> None:
         """HyperlinkTestCase.assertRaises raises an AssertionError when given
         a callable that, when called, does not raise any exception.
 
         """
 
-        def doesNotRaise(*args, **kwargs):
-            # type: (Any, Any) -> None
+        def doesNotRaise(*args: Any, **kwargs: Any) -> None:
             pass
 
         try:
             self.hyperlink_test.assertRaises(_ExpectedException, doesNotRaise)
         except AssertionError:
             pass
 
-    def test_assertRaisesContextManager(self):
-        # type: () -> None
+    def test_assertRaisesContextManager(self) -> None:
         """HyperlinkTestCase.assertRaises does not raise an AssertionError
         when used as a context manager with a suite that raises the
         expected exception.  The context manager stores the exception
@@ -93,8 +87,7 @@ def test_assertRaisesContextManager(self):
             isinstance(cm.exception, _ExpectedException)
         )
 
-    def test_assertRaisesContextManagerUnexpectedException(self):
-        # type: () -> None
+    def test_assertRaisesContextManagerUnexpectedException(self) -> None:
         """When used as a context manager with a block that raises an
         unexpected exception, HyperlinkTestCase.assertRaises raises
         that unexpected exception.
@@ -106,8 +99,7 @@ def test_assertRaisesContextManagerUnexpectedException(self):
         except _UnexpectedException:
             pass
 
-    def test_assertRaisesContextManagerDoesNotRaise(self):
-        # type: () -> None
+    def test_assertRaisesContextManagerDoesNotRaise(self) -> None:
         """HyperlinkTestcase.assertRaises raises an AssertionError when used
         as a context manager with a block that does not raise any
         exception.