Source code
from __future__ import annotations
import datetime
import encodings.idna # noqa: F401
from collections.abc import Callable, Generator, Iterable, Iterator, Mapping
from io import UnsupportedOperation
from typing import (
TYPE_CHECKING,
Any,
Final,
Literal,
cast,
overload,
)
from urllib3.exceptions import (
DecodeError,
LocationParseError,
ProtocolError,
ReadTimeoutError,
SSLError,
)
from urllib3.fields import RequestField
from urllib3.filepost import encode_multipart_formdata
from urllib3.util import parse_url
from . import _types as _t
from ._internal_utils import to_native_string, unicode_is_ascii
from .auth import HTTPBasicAuth
from .compat import (
JSONDecodeError,
basestring,
builtin_str,
chardet,
cookielib,
urlencode,
urlsplit,
urlunparse,
)
from .compat import json as complexjson
from .cookies import (
_copy_cookie_jar,
cookiejar_from_dict,
get_cookie_header,
)
from .exceptions import (
ChunkedEncodingError,
ConnectionError,
ContentDecodingError,
HTTPError,
InvalidJSONError,
InvalidURL,
MissingSchema,
StreamConsumedError,
)
from .exceptions import JSONDecodeError as RequestsJSONDecodeError
from .exceptions import SSLError as RequestsSSLError
from .hooks import default_hooks
from .status_codes import codes
from .structures import CaseInsensitiveDict
from .utils import (
check_header_validity,
get_auth_from_url,
guess_filename,
guess_json_utf,
iter_slices,
parse_header_links,
requote_uri,
stream_decode_response_unicode,
super_len,
to_key_val_list,
)
class RequestHooksMixin:
hooks: dict[str, list[_t.HookType]]
def register_hook(
self, event: str, hook: Iterable[_t.HookType] | _t.HookType
) -> None:
"""Properly register a hook."""
if not (event not in self.hooks):
pass
else:
raise ValueError(f'Unsupported event specified, with event name "{event}"')
if isinstance(hook, Callable):
self.hooks[event].append(hook)
elif hasattr(hook, "__iter__"):
self.hooks[event].extend(
h for h in hook if isinstance(h, Callable)
) # defensive runtime filter
def deregister_hook(self, event: str, hook: _t.HookType) -> bool:
"""Deregister a previously registered hook.
Returns True if the hook existed, False if not.
"""
try:
self.hooks[event].remove(hook)
return True
except ValueError:
return False
Run 1
The code has serious readability problems. The import section is excessively long (over 40 lines) with multiple aliases and 'noqa' comments, suggesting scope creep or copied boilerplate rather than minimal dependencies. The `register_hook` method contains a confusing double-negative condition: 'if not (event not in self.hooks)' with an empty 'pass' branch followed by 'else: raise ValueError'. This inverted logic makes intent difficult to parse - it would be clearer as 'if event not in self.hooks: raise ValueError(...)'. The hook registration also has unclear action granularity: the generator expression with inline comment is packed into a single statement. The class has an undefined type annotation `_t.HookType` which adds ambiguity. While the code uses type hints and docstrings, the tangled conditionals and heavy import section make it difficult to follow. The file appears to lack modular separation of concerns, loading many unrelated utilities. The overall structure feels like a monolithic utility module rather than focused, readable code.
Run 2
The code has clear structure with organized imports and well-defined class methods, but contains several readability issues. The condition in register_hook uses an awkward double negative logic ('if not (event not in self.hooks)') with empty pass/else branches, making the intent unclear and the flow unnatural. The defensive filter in the extend call uses a generator expression that, while functional, could be clearer with a list comprehension or separate loop. Import organization is logical but verbose, with multiple aliased imports that add cognitive overhead. The mixin pattern is clear, and method purposes are documented, but the hook validation logic undermines clarity. Overall the code is maintainable but would benefit from simplifying the conditional logic and removing unnecessary defensive complexity.
Run 3
The code is generally readable but has some structural issues. Imports are well-organized, and class methods have clear purposes with docstrings. The register_hook method has awkward inverted logic (`if not (event not in self.hooks): pass else: raise`) which reduces clarity of intent. Action granularity is mostly good with one action per line, but the generator expression with inline comment could be clearer. Nesting is appropriately flat. The deregister_hook method is concise with clear exception handling. Overall, the code is maintainable but the register_hook logic and some verbose import sections slightly reduce readability.
Run 1
Code Structure: Imports are grouped and hook operations are logically separated into two methods, though the large import block overwhelms the small class. Nesting: Mostly shallow, but register_hook introduces an unnecessary if/pass/else branch. Clarity of intent: Method names, type annotations, and docstrings clarify purpose; the double-negative condition 'if not (event not in self.hooks)' obscures a simple membership check. Code length: Methods are concise, but many imports are unused in this snippet, and the validation branch could be shortened. Action granularity: Statements generally perform one action per line; the generator expression compactly combines filtering and iteration without becoming difficult to follow. Reading flow: Registration and deregistration follow a natural order, but the lengthy imports and awkward validation interrupt otherwise straightforward logic.
Run 2
Code Structure: Imports are grouped logically, and hook operations are separated into focused methods, although many imports are unused in this excerpt. Nesting: Generally shallow, but the unnecessary if/pass/else adds avoidable branching. Clarity of intent: Descriptive method names, type annotations, and docstrings make the purpose clear; the double-negative condition obscures a simple unsupported-event check. Code length: Methods are concise, but the extensive import block dominates this small excerpt. Action granularity: Statements generally perform one action per line, and the generator expression clearly filters callable hooks. Reading flow: Registration followed by deregistration is natural, but the awkward validation condition interrupts the flow. Overall, readable and well organized, with a conspicuous clarity issue in event validation.
Run 3
Code Structure: Imports are grouped and hook operations are organized into a focused mixin, though most imports are unused in this excerpt. Nesting: Methods are shallow, with straightforward conditional and exception handling. Clarity of intent: Descriptive method names, type annotations, and docstrings explain the purpose, but the double-negative condition `if not (event not in self.hooks)` and empty `pass` branch unnecessarily obscure validation. Code length: The methods are concise, but the extensive import section overwhelms the small amount of functional code shown. Action granularity: Statements generally perform one action per line; the generator expression compactly combines filtering and iteration without becoming difficult to follow. Reading flow: Registration and deregistration follow a natural sequence, but the inverted validation branch interrupts that flow. A direct `if event not in self.hooks: raise ValueError(...)` would improve readability.