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 event not in self.hooks:
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 is highly readable. The structure is logical: imports are grouped by source and then classes/functions follow, with related methods cohesive within a mixin. Nesting is minimal, restricted to a single level in conditionals and a generator expression. Intent is clearly conveyed through descriptive names (register_hook, deregister_hook), type hints, and concise docstrings explaining behavior. Length is appropriate, importing only necessary utilities even if the import block is long—it is standard for library code. Each line performs one action. Reading flow is natural: imports, then class definition, with the deregister_hook's try/except clearly mapping to success/failure. Minor notes: the inline comment in the generator is helpful, and the isinstance check against Callable—though correct for runtime—can be slightly unusual since callable() exists, but not a readability flaw in this codebase.
Run 2
The code demonstrates strong readability through clear class structure, logical import organization, and well-named methods. The RequestHooksMixin class has focused responsibilities with intuitive method names like register_hook and deregister_hook. Nesting is minimal with early validation handling edge cases. Type hints improve clarity and intent. Action granularity is appropriate - each line performs a distinct operation. The import block is verbose but organized by logical groups (stdlib, third-party, internal). However, some imports appear unused or redundant (encodings.idna, multiple SSLError imports with aliases), which slightly reduces clarity. The isinstance check with Callable is slightly unusual and could benefit from explanation. The defensive filter comment helps but the logic could be clearer. Overall flow is natural and readable.
Run 3
The code demonstrates good readability overall. The structure is logical with clear import organization and well-separated class definition. The RequestHooksMixin class has a clear, focused purpose with methods that are concise and follow the single responsibility principle. Nesting is minimal - the deepest nesting is a simple if/elif in register_hook and a try/except in deregister_hook. Intent is clear from naming and docstrings. Code length is appropriate - no unnecessary verbosity. Action granularity is well-maintained with one action per line. The reading flow is natural, moving from type hints to logic to return statements. Minor improvements could include adding type hints to deregister_hook's return annotation and slightly more detailed docstrings, but overall this is highly readable code.
Run 1
Code Structure: Imports are grouped by source, and hook operations are cleanly encapsulated in a mixin with separate methods. Nesting: Control flow is shallow, using straightforward conditionals and a small try/except. Clarity of intent: Descriptive method names, type annotations, docstrings, and an explanatory comment make registration and deregistration easy to understand, though silently filtering non-callables is slightly less obvious. Code length: Methods are concise, but the extensive import section adds substantial overhead to this short excerpt, with many imports unused here. Action granularity: Statements generally perform one action per line; the generator expression remains compact and readable. Reading flow: Validation precedes registration naturally, and deregistration follows a clear success/failure pattern. Minor spacing inconsistencies and the long import preamble slightly interrupt an otherwise clean flow.
Run 2
Code Structure: Imports are grouped clearly, and hook management is organized into a focused mixin, though many imports are unused in the shown excerpt. Nesting: Both methods use shallow conditionals or a simple try/except, making control flow easy to follow. Clarity of intent: Descriptive method names, type annotations, docstrings, and explicit error messages explain the purpose well; the runtime filtering behavior is less obvious from the brief register_hook docstring. Code length: The methods are concise, but the extensive import section outweighs the implementation shown. Action granularity: Statements generally perform one action each; the generator expression combines filtering and iteration compactly without becoming difficult to read. Reading flow: Registration and deregistration appear in a natural sequence, with validation before mutation and straightforward success/failure handling. Minor formatting issues, such as limited separation before the class and the split generator expression with a trailing comment, slightly reduce polish.
Run 3
Code Structure: Imports are grouped and hook operations are logically encapsulated in a mixin, though the extensive import block dominates this small excerpt. Nesting: Shallow conditionals and a straightforward try/except keep complexity low. Clarity of intent: Descriptive method names, type annotations, docstrings, and explicit errors make registration and deregistration easy to understand. Code length: Methods are concise, but many imports are unused in the shown excerpt and add visual overhead. Action granularity: Each statement performs one clear operation; the generator expression combines filtering and iteration compactly without becoming confusing. Reading flow: Validation precedes registration naturally, and deregistration follows a simple success/failure path. Minor distractions include the broad import list, the terse generator variable, and inconsistent spacing between the imports and class definition.