SYMBOL INDEX (1151 symbols across 54 files)

FILE: httpx/__init__.py
  function main (line 18) | def main() -> None:  # type: ignore

FILE: httpx/_api.py
  function request (line 39) | def request(
  function stream (line 124) | def stream(
  function get (line 174) | def get(
  function options (line 210) | def options(
  function head (line 246) | def head(
  function post (line 282) | def post(
  function put (line 323) | def put(
  function patch (line 364) | def patch(
  function delete (line 405) | def delete(

FILE: httpx/_auth.py
  class Auth (line 22) | class Auth:
    method auth_flow (line 38) | def auth_flow(self, request: Request) -> typing.Generator[Request, Res...
    method sync_auth_flow (line 62) | def sync_auth_flow(
    method async_auth_flow (line 87) | async def async_auth_flow(
  class FunctionAuth (line 113) | class FunctionAuth(Auth):
    method __init__ (line 119) | def __init__(self, func: typing.Callable[[Request], Request]) -> None:
    method auth_flow (line 122) | def auth_flow(self, request: Request) -> typing.Generator[Request, Res...
  class BasicAuth (line 126) | class BasicAuth(Auth):
    method __init__ (line 132) | def __init__(self, username: str | bytes, password: str | bytes) -> None:
    method auth_flow (line 135) | def auth_flow(self, request: Request) -> typing.Generator[Request, Res...
    method _build_auth_header (line 139) | def _build_auth_header(self, username: str | bytes, password: str | by...
  class NetRCAuth (line 145) | class NetRCAuth(Auth):
    method __init__ (line 150) | def __init__(self, file: str | None = None) -> None:
    method auth_flow (line 157) | def auth_flow(self, request: Request) -> typing.Generator[Request, Res...
    method _build_auth_header (line 169) | def _build_auth_header(self, username: str | bytes, password: str | by...
  class DigestAuth (line 175) | class DigestAuth(Auth):
    method __init__ (line 187) | def __init__(self, username: str | bytes, password: str | bytes) -> None:
    method auth_flow (line 193) | def auth_flow(self, request: Request) -> typing.Generator[Request, Res...
    method _parse_challenge (line 224) | def _parse_challenge(
    method _build_auth_header (line 255) | def _build_auth_header(
    method _get_client_nonce (line 303) | def _get_client_nonce(self, nonce_count: int, nonce: bytes) -> bytes:
    method _get_header_value (line 311) | def _get_header_value(self, header_fields: dict[str, bytes]) -> str:
    method _resolve_qop (line 329) | def _resolve_qop(self, qop: bytes | None, request: Request) -> bytes |...
  class _DigestAuthChallenge (line 343) | class _DigestAuthChallenge(typing.NamedTuple):

FILE: httpx/_client.py
  function _is_https_redirect (line 62) | def _is_https_redirect(url: URL, location: URL) -> bool:
  function _port_or_default (line 77) | def _port_or_default(url: URL) -> int | None:
  function _same_origin (line 83) | def _same_origin(url: URL, other: URL) -> bool:
  class UseClientDefault (line 94) | class UseClientDefault:
  class ClientState (line 125) | class ClientState(enum.Enum):
  class BoundSyncStream (line 139) | class BoundSyncStream(SyncByteStream):
    method __init__ (line 145) | def __init__(
    method __iter__ (line 152) | def __iter__(self) -> typing.Iterator[bytes]:
    method close (line 156) | def close(self) -> None:
  class BoundAsyncStream (line 162) | class BoundAsyncStream(AsyncByteStream):
    method __init__ (line 168) | def __init__(
    method __aiter__ (line 175) | async def __aiter__(self) -> typing.AsyncIterator[bytes]:
    method aclose (line 179) | async def aclose(self) -> None:
  class BaseClient (line 188) | class BaseClient:
    method __init__ (line 189) | def __init__(
    method is_closed (line 224) | def is_closed(self) -> bool:
    method trust_env (line 231) | def trust_env(self) -> bool:
    method _enforce_trailing_slash (line 234) | def _enforce_trailing_slash(self, url: URL) -> URL:
    method _get_proxy_map (line 239) | def _get_proxy_map(
    method timeout (line 254) | def timeout(self) -> Timeout:
    method timeout (line 258) | def timeout(self, timeout: TimeoutTypes) -> None:
    method event_hooks (line 262) | def event_hooks(self) -> dict[str, list[EventHook]]:
    method event_hooks (line 266) | def event_hooks(self, event_hooks: dict[str, list[EventHook]]) -> None:
    method auth (line 273) | def auth(self) -> Auth | None:
    method auth (line 284) | def auth(self, auth: AuthTypes) -> None:
    method base_url (line 288) | def base_url(self) -> URL:
    method base_url (line 295) | def base_url(self, url: URL | str) -> None:
    method headers (line 299) | def headers(self) -> Headers:
    method headers (line 306) | def headers(self, headers: HeaderTypes) -> None:
    method cookies (line 319) | def cookies(self) -> Cookies:
    method cookies (line 326) | def cookies(self, cookies: CookieTypes) -> None:
    method params (line 330) | def params(self) -> QueryParams:
    method params (line 337) | def params(self, params: QueryParamTypes) -> None:
    method build_request (line 340) | def build_request(
    method _merge_url (line 391) | def _merge_url(self, url: URL | str) -> URL:
    method _merge_cookies (line 413) | def _merge_cookies(self, cookies: CookieTypes | None = None) -> Cookie...
    method _merge_headers (line 424) | def _merge_headers(self, headers: HeaderTypes | None = None) -> Header...
    method _merge_queryparams (line 433) | def _merge_queryparams(
    method _build_auth (line 445) | def _build_auth(self, auth: AuthTypes | None) -> Auth | None:
    method _build_request_auth (line 457) | def _build_request_auth(
    method _build_redirect_request (line 475) | def _build_redirect_request(self, request: Request, response: Response...
    method _redirect_method (line 494) | def _redirect_method(self, request: Request, response: Response) -> str:
    method _redirect_url (line 517) | def _redirect_url(self, request: Request, response: Response) -> URL:
    method _redirect_headers (line 546) | def _redirect_headers(self, request: Request, url: URL, method: str) -...
    method _redirect_stream (line 573) | def _redirect_stream(
    method _set_timeout (line 584) | def _set_timeout(self, request: Request) -> None:
  class Client (line 594) | class Client(BaseClient):
    method __init__ (line 639) | def __init__(
    method _init_transport (line 718) | def _init_transport(
    method _init_proxy_transport (line 740) | def _init_proxy_transport(
    method _transport_for_url (line 760) | def _transport_for_url(self, url: URL) -> BaseTransport:
    method request (line 771) | def request(
    method stream (line 828) | def stream(
    method send (line 879) | def send(
    method _send_handling_auth (line 930) | def _send_handling_auth(
    method _send_handling_redirects (line 964) | def _send_handling_redirects(
    method _send_single_request (line 1001) | def _send_single_request(self, request: Request) -> Response:
    method get (line 1036) | def get(
    method options (line 1065) | def options(
    method head (line 1094) | def head(
    method post (line 1123) | def post(
    method put (line 1160) | def put(
    method patch (line 1197) | def patch(
    method delete (line 1234) | def delete(
    method close (line 1263) | def close(self) -> None:
    method __enter__ (line 1275) | def __enter__(self: T) -> T:
    method __exit__ (line 1293) | def __exit__(
  class AsyncClient (line 1307) | class AsyncClient(BaseClient):
    method __init__ (line 1353) | def __init__(
    method _init_transport (line 1432) | def _init_transport(
    method _init_proxy_transport (line 1454) | def _init_proxy_transport(
    method _transport_for_url (line 1474) | def _transport_for_url(self, url: URL) -> AsyncBaseTransport:
    method request (line 1485) | async def request(
    method stream (line 1543) | async def stream(
    method send (line 1594) | async def send(
    method _send_handling_auth (line 1645) | async def _send_handling_auth(
    method _send_handling_redirects (line 1679) | async def _send_handling_redirects(
    method _send_single_request (line 1717) | async def _send_single_request(self, request: Request) -> Response:
    method get (line 1751) | async def get(
    method options (line 1780) | async def options(
    method head (line 1809) | async def head(
    method post (line 1838) | async def post(
    method put (line 1875) | async def put(
    method patch (line 1912) | async def patch(
    method delete (line 1949) | async def delete(
    method aclose (line 1978) | async def aclose(self) -> None:
    method __aenter__ (line 1990) | async def __aenter__(self: U) -> U:
    method __aexit__ (line 2008) | async def __aexit__(

FILE: httpx/_config.py
  class UnsetType (line 16) | class UnsetType:
  function create_ssl_context (line 23) | def create_ssl_context(
  class Timeout (line 72) | class Timeout:
    method __init__ (line 86) | def __init__(
    method as_dict (line 132) | def as_dict(self) -> dict[str, float | None]:
    method __eq__ (line 140) | def __eq__(self, other: typing.Any) -> bool:
    method __repr__ (line 149) | def __repr__(self) -> str:
  class Limits (line 159) | class Limits:
    method __init__ (line 173) | def __init__(
    method __eq__ (line 184) | def __eq__(self, other: typing.Any) -> bool:
    method __repr__ (line 192) | def __repr__(self) -> str:
  class Proxy (line 201) | class Proxy:
    method __init__ (line 202) | def __init__(
    method raw_auth (line 227) | def raw_auth(self) -> tuple[bytes, bytes] | None:
    method __repr__ (line 235) | def __repr__(self) -> str:

FILE: httpx/_content.py
  class ByteStream (line 31) | class ByteStream(AsyncByteStream, SyncByteStream):
    method __init__ (line 32) | def __init__(self, stream: bytes) -> None:
    method __iter__ (line 35) | def __iter__(self) -> Iterator[bytes]:
    method __aiter__ (line 38) | async def __aiter__(self) -> AsyncIterator[bytes]:
  class IteratorByteStream (line 42) | class IteratorByteStream(SyncByteStream):
    method __init__ (line 45) | def __init__(self, stream: Iterable[bytes]) -> None:
    method __iter__ (line 50) | def __iter__(self) -> Iterator[bytes]:
  class AsyncIteratorByteStream (line 67) | class AsyncIteratorByteStream(AsyncByteStream):
    method __init__ (line 70) | def __init__(self, stream: AsyncIterable[bytes]) -> None:
    method __aiter__ (line 75) | async def __aiter__(self) -> AsyncIterator[bytes]:
  class UnattachedStream (line 92) | class UnattachedStream(AsyncByteStream, SyncByteStream):
    method __iter__ (line 99) | def __iter__(self) -> Iterator[bytes]:
    method __aiter__ (line 102) | async def __aiter__(self) -> AsyncIterator[bytes]:
  function encode_content (line 107) | def encode_content(
  function encode_urlencoded_data (line 136) | def encode_urlencoded_data(
  function encode_multipart_data (line 152) | def encode_multipart_data(
  function encode_text (line 160) | def encode_text(text: str) -> tuple[dict[str, str], ByteStream]:
  function encode_html (line 168) | def encode_html(html: str) -> tuple[dict[str, str], ByteStream]:
  function encode_json (line 176) | def encode_json(json: Any) -> tuple[dict[str, str], ByteStream]:
  function encode_request (line 186) | def encode_request(
  function encode_response (line 221) | def encode_response(

FILE: httpx/_decoders.py
  class ContentDecoder (line 36) | class ContentDecoder:
    method decode (line 37) | def decode(self, data: bytes) -> bytes:
    method flush (line 40) | def flush(self) -> bytes:
  class IdentityDecoder (line 44) | class IdentityDecoder(ContentDecoder):
    method decode (line 49) | def decode(self, data: bytes) -> bytes:
    method flush (line 52) | def flush(self) -> bytes:
  class DeflateDecoder (line 56) | class DeflateDecoder(ContentDecoder):
    method __init__ (line 63) | def __init__(self) -> None:
    method decode (line 67) | def decode(self, data: bytes) -> bytes:
    method flush (line 78) | def flush(self) -> bytes:
  class GZipDecoder (line 85) | class GZipDecoder(ContentDecoder):
    method __init__ (line 92) | def __init__(self) -> None:
    method decode (line 95) | def decode(self, data: bytes) -> bytes:
    method flush (line 101) | def flush(self) -> bytes:
  class BrotliDecoder (line 108) | class BrotliDecoder(ContentDecoder):
    method __init__ (line 118) | def __init__(self) -> None:
    method decode (line 136) | def decode(self, data: bytes) -> bytes:
    method flush (line 145) | def flush(self) -> bytes:
  class ZStandardDecoder (line 161) | class ZStandardDecoder(ContentDecoder):
    method __init__ (line 170) | def __init__(self) -> None:
    method decode (line 180) | def decode(self, data: bytes) -> bytes:
    method flush (line 194) | def flush(self) -> bytes:
  class MultiDecoder (line 203) | class MultiDecoder(ContentDecoder):
    method __init__ (line 208) | def __init__(self, children: typing.Sequence[ContentDecoder]) -> None:
    method decode (line 216) | def decode(self, data: bytes) -> bytes:
    method flush (line 221) | def flush(self) -> bytes:
  class ByteChunker (line 228) | class ByteChunker:
    method __init__ (line 233) | def __init__(self, chunk_size: int | None = None) -> None:
    method decode (line 237) | def decode(self, content: bytes) -> list[bytes]:
    method flush (line 260) | def flush(self) -> list[bytes]:
  class TextChunker (line 267) | class TextChunker:
    method __init__ (line 272) | def __init__(self, chunk_size: int | None = None) -> None:
    method decode (line 276) | def decode(self, content: str) -> list[str]:
    method flush (line 299) | def flush(self) -> list[str]:
  class TextDecoder (line 306) | class TextDecoder:
    method __init__ (line 311) | def __init__(self, encoding: str = "utf-8") -> None:
    method decode (line 314) | def decode(self, data: bytes) -> str:
    method flush (line 317) | def flush(self) -> str:
  class LineDecoder (line 321) | class LineDecoder:
    method __init__ (line 329) | def __init__(self) -> None:
    method decode (line 333) | def decode(self, text: str) -> list[str]:
    method flush (line 371) | def flush(self) -> list[str]:

FILE: httpx/_exceptions.py
  class HTTPError (line 74) | class HTTPError(Exception):
    method __init__ (line 92) | def __init__(self, message: str) -> None:
    method request (line 97) | def request(self) -> Request:
    method request (line 103) | def request(self, request: Request) -> None:
  class RequestError (line 107) | class RequestError(HTTPError):
    method __init__ (line 112) | def __init__(self, message: str, *, request: Request | None = None) ->...
  class TransportError (line 123) | class TransportError(RequestError):
  class TimeoutException (line 132) | class TimeoutException(TransportError):
  class ConnectTimeout (line 140) | class ConnectTimeout(TimeoutException):
  class ReadTimeout (line 146) | class ReadTimeout(TimeoutException):
  class WriteTimeout (line 152) | class WriteTimeout(TimeoutException):
  class PoolTimeout (line 158) | class PoolTimeout(TimeoutException):
  class NetworkError (line 167) | class NetworkError(TransportError):
  class ReadError (line 175) | class ReadError(NetworkError):
  class WriteError (line 181) | class WriteError(NetworkError):
  class ConnectError (line 187) | class ConnectError(NetworkError):
  class CloseError (line 193) | class CloseError(NetworkError):
  class ProxyError (line 202) | class ProxyError(TransportError):
  class UnsupportedProtocol (line 208) | class UnsupportedProtocol(TransportError):
  class ProtocolError (line 216) | class ProtocolError(TransportError):
  class LocalProtocolError (line 222) | class LocalProtocolError(ProtocolError):
  class RemoteProtocolError (line 232) | class RemoteProtocolError(ProtocolError):
  class DecodingError (line 243) | class DecodingError(RequestError):
  class TooManyRedirects (line 249) | class TooManyRedirects(RequestError):
  class HTTPStatusError (line 258) | class HTTPStatusError(HTTPError):
    method __init__ (line 265) | def __init__(self, message: str, *, request: Request, response: Respon...
  class InvalidURL (line 271) | class InvalidURL(Exception):
    method __init__ (line 276) | def __init__(self, message: str) -> None:
  class CookieConflict (line 280) | class CookieConflict(Exception):
    method __init__ (line 287) | def __init__(self, message: str) -> None:
  class StreamError (line 297) | class StreamError(RuntimeError):
    method __init__ (line 305) | def __init__(self, message: str) -> None:
  class StreamConsumed (line 309) | class StreamConsumed(StreamError):
    method __init__ (line 315) | def __init__(self) -> None:
  class StreamClosed (line 327) | class StreamClosed(StreamError):
    method __init__ (line 333) | def __init__(self) -> None:
  class ResponseNotRead (line 338) | class ResponseNotRead(StreamError):
    method __init__ (line 343) | def __init__(self) -> None:
  class RequestNotRead (line 351) | class RequestNotRead(StreamError):
    method __init__ (line 356) | def __init__(self) -> None:
  function request_context (line 365) | def request_context(

FILE: httpx/_main.py
  function print_help (line 26) | def print_help() -> None:
  function get_lexer_for_response (line 103) | def get_lexer_for_response(response: Response) -> str:
  function format_request_headers (line 116) | def format_request_headers(request: httpcore.Request, http2: bool = Fals...
  function format_response_headers (line 129) | def format_response_headers(
  function print_request_headers (line 147) | def print_request_headers(request: httpcore.Request, http2: bool = False...
  function print_response_headers (line 156) | def print_response_headers(
  function print_response (line 170) | def print_response(response: Response) -> None:
  function format_certificate (line 194) | def format_certificate(cert: _PeerCertRetDictType) -> str:  # pragma: no...
  function trace (line 212) | def trace(
  function download_response (line 251) | def download_response(response: Response, download: typing.BinaryIO) -> ...
  function validate_json (line 273) | def validate_json(
  function validate_auth (line 287) | def validate_auth(
  function handle_help (line 301) | def handle_help(
  function main (line 452) | def main(

FILE: httpx/_models.py
  function _is_known_encoding (line 56) | def _is_known_encoding(encoding: str) -> bool:
  function _normalize_header_key (line 67) | def _normalize_header_key(key: str | bytes, encoding: str | None = None)...
  function _normalize_header_value (line 74) | def _normalize_header_value(value: str | bytes, encoding: str | None = N...
  function _parse_content_type_charset (line 85) | def _parse_content_type_charset(content_type: str) -> str | None:
  function _parse_header_links (line 93) | def _parse_header_links(value: str) -> list[dict[str, str]]:
  function _obfuscate_sensitive_headers (line 130) | def _obfuscate_sensitive_headers(
  class Headers (line 139) | class Headers(typing.MutableMapping[str, str]):
    method __init__ (line 144) | def __init__(
    method encoding (line 167) | def encoding(self) -> str:
    method encoding (line 192) | def encoding(self, value: str) -> None:
    method raw (line 196) | def raw(self) -> list[tuple[bytes, bytes]]:
    method keys (line 202) | def keys(self) -> typing.KeysView[str]:
    method values (line 205) | def values(self) -> typing.ValuesView[str]:
    method items (line 216) | def items(self) -> typing.ItemsView[str, str]:
    method multi_items (line 231) | def multi_items(self) -> list[tuple[str, str]]:
    method get (line 242) | def get(self, key: str, default: typing.Any = None) -> typing.Any:
    method get_list (line 252) | def get_list(self, key: str, split_commas: bool = False) -> list[str]:
    method update (line 274) | def update(self, headers: HeaderTypes | None = None) -> None:  # type:...
    method copy (line 281) | def copy(self) -> Headers:
    method __getitem__ (line 284) | def __getitem__(self, key: str) -> str:
    method __setitem__ (line 304) | def __setitem__(self, key: str, value: str) -> None:
    method __delitem__ (line 328) | def __delitem__(self, key: str) -> None:
    method __contains__ (line 346) | def __contains__(self, key: typing.Any) -> bool:
    method __iter__ (line 350) | def __iter__(self) -> typing.Iterator[typing.Any]:
    method __len__ (line 353) | def __len__(self) -> int:
    method __eq__ (line 356) | def __eq__(self, other: typing.Any) -> bool:
    method __repr__ (line 366) | def __repr__(self) -> str:
  class Request (line 382) | class Request:
    method __init__ (line 383) | def __init__(
    method _prepare (line 441) | def _prepare(self, default_headers: dict[str, str]) -> None:
    method content (line 463) | def content(self) -> bytes:
    method read (line 468) | def read(self) -> bytes:
    method aread (line 482) | async def aread(self) -> bytes:
    method __repr__ (line 496) | def __repr__(self) -> str:
    method __getstate__ (line 501) | def __getstate__(self) -> dict[str, typing.Any]:
    method __setstate__ (line 508) | def __setstate__(self, state: dict[str, typing.Any]) -> None:
  class Response (line 515) | class Response:
    method __init__ (line 516) | def __init__(
    method _prepare (line 571) | def _prepare(self, default_headers: dict[str, str]) -> None:
    method elapsed (line 579) | def elapsed(self) -> datetime.timedelta:
    method elapsed (line 592) | def elapsed(self, elapsed: datetime.timedelta) -> None:
    method request (line 596) | def request(self) -> Request:
    method request (line 607) | def request(self, value: Request) -> None:
    method http_version (line 611) | def http_version(self) -> str:
    method reason_phrase (line 620) | def reason_phrase(self) -> str:
    method url (line 629) | def url(self) -> URL:
    method content (line 636) | def content(self) -> bytes:
    method text (line 642) | def text(self) -> str:
    method encoding (line 653) | def encoding(self) -> str | None:
    method encoding (line 675) | def encoding(self, value: str) -> None:
    method charset_encoding (line 689) | def charset_encoding(self) -> str | None:
    method _get_content_decoder (line 699) | def _get_content_decoder(self) -> ContentDecoder:
    method is_informational (line 725) | def is_informational(self) -> bool:
    method is_success (line 732) | def is_success(self) -> bool:
    method is_redirect (line 739) | def is_redirect(self) -> bool:
    method is_client_error (line 751) | def is_client_error(self) -> bool:
    method is_server_error (line 758) | def is_server_error(self) -> bool:
    method is_error (line 765) | def is_error(self) -> bool:
    method has_redirect_location (line 772) | def has_redirect_location(self) -> bool:
    method raise_for_status (line 794) | def raise_for_status(self) -> Response:
    method json (line 831) | def json(self, **kwargs: typing.Any) -> typing.Any:
    method cookies (line 835) | def cookies(self) -> Cookies:
    method links (line 842) | def links(self) -> dict[str | None, dict[str, str]]:
    method num_bytes_downloaded (line 856) | def num_bytes_downloaded(self) -> int:
    method __repr__ (line 859) | def __repr__(self) -> str:
    method __getstate__ (line 862) | def __getstate__(self) -> dict[str, typing.Any]:
    method __setstate__ (line 869) | def __setstate__(self, state: dict[str, typing.Any]) -> None:
    method read (line 876) | def read(self) -> bytes:
    method iter_bytes (line 884) | def iter_bytes(self, chunk_size: int | None = None) -> typing.Iterator...
    method iter_text (line 907) | def iter_text(self, chunk_size: int | None = None) -> typing.Iterator[...
    method iter_lines (line 926) | def iter_lines(self) -> typing.Iterator[str]:
    method iter_raw (line 935) | def iter_raw(self, chunk_size: int | None = None) -> typing.Iterator[b...
    method close (line 961) | def close(self) -> None:
    method aread (line 974) | async def aread(self) -> bytes:
    method aiter_bytes (line 982) | async def aiter_bytes(
    method aiter_text (line 1007) | async def aiter_text(
    method aiter_lines (line 1028) | async def aiter_lines(self) -> typing.AsyncIterator[str]:
    method aiter_raw (line 1037) | async def aiter_raw(
    method aclose (line 1065) | async def aclose(self) -> None:
  class Cookies (line 1079) | class Cookies(typing.MutableMapping[str, str]):
    method __init__ (line 1084) | def __init__(self, cookies: CookieTypes | None = None) -> None:
    method extract_cookies (line 1101) | def extract_cookies(self, response: Response) -> None:
    method set_cookie_header (line 1110) | def set_cookie_header(self, request: Request) -> None:
    method set (line 1117) | def set(self, name: str, value: str, domain: str = "", path: str = "/"...
    method get (line 1143) | def get(  # type: ignore
    method delete (line 1168) | def delete(
    method clear (line 1192) | def clear(self, domain: str | None = None, path: str | None = None) ->...
    method update (line 1205) | def update(self, cookies: CookieTypes | None = None) -> None:  # type:...
    method __setitem__ (line 1210) | def __setitem__(self, name: str, value: str) -> None:
    method __getitem__ (line 1213) | def __getitem__(self, name: str) -> str:
    method __delitem__ (line 1219) | def __delitem__(self, name: str) -> None:
    method __len__ (line 1222) | def __len__(self) -> int:
    method __iter__ (line 1225) | def __iter__(self) -> typing.Iterator[str]:
    method __bool__ (line 1228) | def __bool__(self) -> bool:
    method __repr__ (line 1233) | def __repr__(self) -> str:
    class _CookieCompatRequest (line 1243) | class _CookieCompatRequest(urllib.request.Request):
      method __init__ (line 1249) | def __init__(self, request: Request) -> None:
      method add_unredirected_header (line 1257) | def add_unredirected_header(self, key: str, value: str) -> None:
    class _CookieCompatResponse (line 1261) | class _CookieCompatResponse:
      method __init__ (line 1267) | def __init__(self, response: Response) -> None:
      method info (line 1270) | def info(self) -> email.message.Message:

FILE: httpx/_multipart.py
  function _format_form_param (line 33) | def _format_form_param(name: str, value: str) -> bytes:
  function _guess_content_type (line 45) | def _guess_content_type(filename: str | None) -> str | None:
  function get_multipart_boundary_from_content_type (line 56) | def get_multipart_boundary_from_content_type(
  class DataField (line 70) | class DataField:
    method __init__ (line 75) | def __init__(self, name: str, value: str | bytes | int | float | None)...
    method render_headers (line 90) | def render_headers(self) -> bytes:
    method render_data (line 99) | def render_data(self) -> bytes:
    method get_length (line 105) | def get_length(self) -> int:
    method render (line 110) | def render(self) -> typing.Iterator[bytes]:
  class FileField (line 115) | class FileField:
    method __init__ (line 122) | def __init__(self, name: str, value: FileTypes) -> None:
    method get_length (line 171) | def get_length(self) -> int | None:
    method render_headers (line 186) | def render_headers(self) -> bytes:
    method render_data (line 203) | def render_data(self) -> typing.Iterator[bytes]:
    method render (line 219) | def render(self) -> typing.Iterator[bytes]:
  class MultipartStream (line 224) | class MultipartStream(SyncByteStream, AsyncByteStream):
    method __init__ (line 229) | def __init__(
    method _iter_fields (line 244) | def _iter_fields(
    method iter_chunks (line 258) | def iter_chunks(self) -> typing.Iterator[bytes]:
    method get_content_length (line 265) | def get_content_length(self) -> int | None:
    method get_headers (line 287) | def get_headers(self) -> dict[str, str]:
    method __iter__ (line 294) | def __iter__(self) -> typing.Iterator[bytes]:
    method __aiter__ (line 298) | async def __aiter__(self) -> typing.AsyncIterator[bytes]:

FILE: httpx/_status_codes.py
  class codes (line 8) | class codes(IntEnum):
    method __new__ (line 28) | def __new__(cls, value: int, phrase: str = "") -> codes:
    method __str__ (line 35) | def __str__(self) -> str:
    method get_reason_phrase (line 39) | def get_reason_phrase(cls, value: int) -> str:
    method is_informational (line 46) | def is_informational(cls, value: int) -> bool:
    method is_success (line 53) | def is_success(cls, value: int) -> bool:
    method is_redirect (line 60) | def is_redirect(cls, value: int) -> bool:
    method is_client_error (line 67) | def is_client_error(cls, value: int) -> bool:
    method is_server_error (line 74) | def is_server_error(cls, value: int) -> bool:
    method is_error (line 81) | def is_error(cls, value: int) -> bool:

FILE: httpx/_transports/asgi.py
  function is_running_trio (line 29) | def is_running_trio() -> bool:
  function create_event (line 44) | def create_event() -> Event:
  class ASGIResponseStream (line 55) | class ASGIResponseStream(AsyncByteStream):
    method __init__ (line 56) | def __init__(self, body: list[bytes]) -> None:
    method __aiter__ (line 59) | async def __aiter__(self) -> typing.AsyncIterator[bytes]:
  class ASGITransport (line 63) | class ASGITransport(AsyncBaseTransport):
    method __init__ (line 87) | def __init__(
    method handle_async_request (line 99) | async def handle_async_request(

FILE: httpx/_transports/base.py
  class BaseTransport (line 14) | class BaseTransport:
    method __enter__ (line 15) | def __enter__(self: T) -> T:
    method __exit__ (line 18) | def __exit__(
    method handle_request (line 26) | def handle_request(self, request: Request) -> Response:
    method close (line 61) | def close(self) -> None:
  class AsyncBaseTransport (line 65) | class AsyncBaseTransport:
    method __aenter__ (line 66) | async def __aenter__(self: A) -> A:
    method __aexit__ (line 69) | async def __aexit__(
    method handle_async_request (line 77) | async def handle_async_request(
    method aclose (line 85) | async def aclose(self) -> None:

FILE: httpx/_transports/default.py
  function _load_httpcore_exceptions (line 74) | def _load_httpcore_exceptions() -> dict[type[Exception], type[httpx.HTTP...
  function map_httpcore_exceptions (line 96) | def map_httpcore_exceptions() -> typing.Iterator[None]:
  class ResponseStream (line 121) | class ResponseStream(SyncByteStream):
    method __init__ (line 122) | def __init__(self, httpcore_stream: typing.Iterable[bytes]) -> None:
    method __iter__ (line 125) | def __iter__(self) -> typing.Iterator[bytes]:
    method close (line 130) | def close(self) -> None:
  class HTTPTransport (line 135) | class HTTPTransport(BaseTransport):
    method __init__ (line 136) | def __init__(
    method __enter__ (line 217) | def __enter__(self: T) -> T:  # Use generics for subclass support.
    method __exit__ (line 221) | def __exit__(
    method handle_request (line 230) | def handle_request(
    method close (line 261) | def close(self) -> None:
  class AsyncResponseStream (line 265) | class AsyncResponseStream(AsyncByteStream):
    method __init__ (line 266) | def __init__(self, httpcore_stream: typing.AsyncIterable[bytes]) -> None:
    method __aiter__ (line 269) | async def __aiter__(self) -> typing.AsyncIterator[bytes]:
    method aclose (line 274) | async def aclose(self) -> None:
  class AsyncHTTPTransport (line 279) | class AsyncHTTPTransport(AsyncBaseTransport):
    method __init__ (line 280) | def __init__(
    method __aenter__ (line 361) | async def __aenter__(self: A) -> A:  # Use generics for subclass support.
    method __aexit__ (line 365) | async def __aexit__(
    method handle_async_request (line 374) | async def handle_async_request(
    method aclose (line 405) | async def aclose(self) -> None:

FILE: httpx/_transports/mock.py
  class MockTransport (line 15) | class MockTransport(AsyncBaseTransport, BaseTransport):
    method __init__ (line 16) | def __init__(self, handler: SyncHandler | AsyncHandler) -> None:
    method handle_request (line 19) | def handle_request(
    method handle_async_request (line 29) | async def handle_async_request(

FILE: httpx/_transports/wsgi.py
  function _skip_leading_empty_chunks (line 22) | def _skip_leading_empty_chunks(body: typing.Iterable[_T]) -> typing.Iter...
  class WSGIByteStream (line 30) | class WSGIByteStream(SyncByteStream):
    method __init__ (line 31) | def __init__(self, result: typing.Iterable[bytes]) -> None:
    method __iter__ (line 35) | def __iter__(self) -> typing.Iterator[bytes]:
    method close (line 39) | def close(self) -> None:
  class WSGITransport (line 44) | class WSGITransport(BaseTransport):
    method __init__ (line 77) | def __init__(
    method handle_request (line 91) | def handle_request(self, request: Request) -> Response:

FILE: httpx/_types.py
  class SyncByteStream (line 92) | class SyncByteStream:
    method __iter__ (line 93) | def __iter__(self) -> Iterator[bytes]:
    method close (line 99) | def close(self) -> None:
  class AsyncByteStream (line 106) | class AsyncByteStream:
    method __aiter__ (line 107) | async def __aiter__(self) -> AsyncIterator[bytes]:
    method aclose (line 113) | async def aclose(self) -> None:

FILE: httpx/_urlparse.py
  class ParseResult (line 158) | class ParseResult(typing.NamedTuple):
    method authority (line 168) | def authority(self) -> str:
    method netloc (line 178) | def netloc(self) -> str:
    method copy_with (line 186) | def copy_with(self, **kwargs: str | None) -> ParseResult:
    method __str__ (line 200) | def __str__(self) -> str:
  function urlparse (line 213) | def urlparse(url: str = "", **kwargs: str | None) -> ParseResult:
  function encode_host (line 348) | def encode_host(host: str) -> str:
  function normalize_port (line 395) | def normalize_port(port: str | int | None, scheme: str) -> int | None:
  function validate_path (line 422) | def validate_path(path: str, has_scheme: bool, has_authority: bool) -> N...
  function normalize_path (line 447) | def normalize_path(path: str) -> str:
  function PERCENT (line 478) | def PERCENT(string: str) -> str:
  function percent_encoded (line 482) | def percent_encoded(string: str, safe: str) -> str:
  function quote (line 497) | def quote(string: str, safe: str) -> str:

FILE: httpx/_urls.py
  class URL (line 15) | class URL:
    method __init__ (line 77) | def __init__(self, url: URL | str = "", **kwargs: typing.Any) -> None:
    method scheme (line 127) | def scheme(self) -> str:
    method raw_scheme (line 135) | def raw_scheme(self) -> bytes:
    method userinfo (line 143) | def userinfo(self) -> bytes:
    method username (line 151) | def username(self) -> str:
    method password (line 160) | def password(self) -> str:
    method host (line 169) | def host(self) -> str:
    method raw_host (line 196) | def raw_host(self) -> bytes:
    method port (line 218) | def port(self) -> int | None:
    method netloc (line 234) | def netloc(self) -> bytes:
    method path (line 245) | def path(self) -> str:
    method query (line 258) | def query(self) -> bytes:
    method params (line 275) | def params(self) -> QueryParams:
    method raw_path (line 283) | def raw_path(self) -> bytes:
    method fragment (line 300) | def fragment(self) -> str:
    method is_absolute_url (line 308) | def is_absolute_url(self) -> bool:
    method is_relative_url (line 320) | def is_relative_url(self) -> bool:
    method copy_with (line 327) | def copy_with(self, **kwargs: typing.Any) -> URL:
    method copy_set_param (line 342) | def copy_set_param(self, key: str, value: typing.Any = None) -> URL:
    method copy_add_param (line 345) | def copy_add_param(self, key: str, value: typing.Any = None) -> URL:
    method copy_remove_param (line 348) | def copy_remove_param(self, key: str) -> URL:
    method copy_merge_params (line 351) | def copy_merge_params(self, params: QueryParamTypes) -> URL:
    method join (line 354) | def join(self, url: URL | str) -> URL:
    method __hash__ (line 368) | def __hash__(self) -> int:
    method __eq__ (line 371) | def __eq__(self, other: typing.Any) -> bool:
    method __str__ (line 374) | def __str__(self) -> str:
    method __repr__ (line 377) | def __repr__(self) -> str:
    method raw (line 404) | def raw(self) -> tuple[bytes, bytes, int, bytes]:  # pragma: nocover
  class QueryParams (line 420) | class QueryParams(typing.Mapping[str, str]):
    method __init__ (line 425) | def __init__(self, *args: QueryParamTypes | None, **kwargs: typing.Any...
    method keys (line 463) | def keys(self) -> typing.KeysView[str]:
    method values (line 474) | def values(self) -> typing.ValuesView[str]:
    method items (line 486) | def items(self) -> typing.ItemsView[str, str]:
    method multi_items (line 498) | def multi_items(self) -> list[tuple[str, str]]:
    method get (line 512) | def get(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
    method get_list (line 526) | def get_list(self, key: str) -> list[str]:
    method set (line 537) | def set(self, key: str, value: typing.Any = None) -> QueryParams:
    method add (line 552) | def add(self, key: str, value: typing.Any = None) -> QueryParams:
    method remove (line 567) | def remove(self, key: str) -> QueryParams:
    method merge (line 582) | def merge(self, params: QueryParamTypes | None = None) -> QueryParams:
    method __getitem__ (line 600) | def __getitem__(self, key: typing.Any) -> str:
    method __contains__ (line 603) | def __contains__(self, key: typing.Any) -> bool:
    method __iter__ (line 606) | def __iter__(self) -> typing.Iterator[typing.Any]:
    method __len__ (line 609) | def __len__(self) -> int:
    method __bool__ (line 612) | def __bool__(self) -> bool:
    method __hash__ (line 615) | def __hash__(self) -> int:
    method __eq__ (line 618) | def __eq__(self, other: typing.Any) -> bool:
    method __str__ (line 623) | def __str__(self) -> str:
    method __repr__ (line 626) | def __repr__(self) -> str:
    method update (line 631) | def update(self, params: QueryParamTypes | None = None) -> None:
    method __setitem__ (line 637) | def __setitem__(self, key: str, value: str) -> None:

FILE: httpx/_utils.py
  function primitive_value_to_str (line 15) | def primitive_value_to_str(value: PrimitiveData) -> str:
  function get_environment_proxies (line 30) | def get_environment_proxies() -> dict[str, str | None]:
  function to_bytes (line 79) | def to_bytes(value: str | bytes, encoding: str = "utf-8") -> bytes:
  function to_str (line 83) | def to_str(value: str | bytes, encoding: str = "utf-8") -> str:
  function to_bytes_or_str (line 87) | def to_bytes_or_str(value: str, match_type_of: typing.AnyStr) -> typing....
  function unquote (line 91) | def unquote(value: str) -> str:
  function peek_filelike_length (line 95) | def peek_filelike_length(stream: typing.Any) -> int | None:
  class URLPattern (line 120) | class URLPattern:
    method __init__ (line 162) | def __init__(self, pattern: str) -> None:
    method matches (line 192) | def matches(self, other: URL) -> bool:
    method priority (line 206) | def priority(self) -> tuple[int, int, int]:
    method __hash__ (line 219) | def __hash__(self) -> int:
    method __lt__ (line 222) | def __lt__(self, other: URLPattern) -> bool:
    method __eq__ (line 225) | def __eq__(self, other: typing.Any) -> bool:
  function is_ipv4_hostname (line 229) | def is_ipv4_hostname(hostname: str) -> bool:
  function is_ipv6_hostname (line 237) | def is_ipv6_hostname(hostname: str) -> bool:

FILE: tests/client/test_async_client.py
  function test_get (line 12) | async def test_get(server):
  function test_get_invalid_url (line 33) | async def test_get_invalid_url(server, url):
  function test_build_request (line 40) | async def test_build_request(server):
  function test_post (line 55) | async def test_post(server):
  function test_post_json (line 63) | async def test_post_json(server):
  function test_stream_response (line 71) | async def test_stream_response(server):
  function test_access_content_stream_response (line 82) | async def test_access_content_stream_response(server):
  function test_stream_request (line 93) | async def test_stream_request(server):
  function test_cannot_stream_sync_request (line 104) | async def test_cannot_stream_sync_request(server):
  function test_raise_for_status (line 115) | async def test_raise_for_status(server):
  function test_options (line 131) | async def test_options(server):
  function test_head (line 139) | async def test_head(server):
  function test_put (line 147) | async def test_put(server):
  function test_patch (line 154) | async def test_patch(server):
  function test_delete (line 161) | async def test_delete(server):
  function test_100_continue (line 169) | async def test_100_continue(server):
  function test_context_managed_transport (line 183) | async def test_context_managed_transport():
  function test_context_managed_transport_and_mount (line 215) | async def test_context_managed_transport_and_mount():
  function hello_world (line 255) | def hello_world(request):
  function test_client_closed_state_using_implicit_open (line 260) | async def test_client_closed_state_using_implicit_open():
  function test_client_closed_state_using_with_block (line 281) | async def test_client_closed_state_using_with_block():
  function unmounted (line 291) | def unmounted(request: httpx.Request) -> httpx.Response:
  function mounted (line 296) | def mounted(request: httpx.Request) -> httpx.Response:
  function test_mounted_transport (line 302) | async def test_mounted_transport():
  function test_async_mock_transport (line 317) | async def test_async_mock_transport():
  function test_cancellation_during_stream (line 330) | async def test_cancellation_during_stream():
  function test_server_extensions (line 370) | async def test_server_extensions(server):

FILE: tests/client/test_auth.py
  class App (line 23) | class App:
    method __init__ (line 28) | def __init__(self, auth_header: str = "", status_code: int = 200) -> N...
    method __call__ (line 32) | def __call__(self, request: httpx.Request) -> httpx.Response:
  class DigestApp (line 38) | class DigestApp:
    method __init__ (line 39) | def __init__(
    method __call__ (line 52) | def __call__(self, request: httpx.Request) -> httpx.Response:
    method challenge_send (line 59) | def challenge_send(self, request: httpx.Request) -> httpx.Response:
  class RepeatAuth (line 87) | class RepeatAuth(httpx.Auth):
    method __init__ (line 97) | def __init__(self, repeat: int) -> None:
    method auth_flow (line 100) | def auth_flow(
  class ResponseBodyAuth (line 115) | class ResponseBodyAuth(httpx.Auth):
    method __init__ (line 124) | def __init__(self, token: str) -> None:
    method auth_flow (line 127) | def auth_flow(
  class SyncOrAsyncAuth (line 137) | class SyncOrAsyncAuth(httpx.Auth):
    method __init__ (line 143) | def __init__(self) -> None:
    method sync_auth_flow (line 147) | def sync_auth_flow(
    method async_auth_flow (line 154) | async def async_auth_flow(
  function test_basic_auth (line 163) | async def test_basic_auth() -> None:
  function test_basic_auth_with_stream (line 176) | async def test_basic_auth_with_stream() -> None:
  function test_basic_auth_in_url (line 195) | async def test_basic_auth_in_url() -> None:
  function test_basic_auth_on_session (line 207) | async def test_basic_auth_on_session() -> None:
  function test_custom_auth (line 222) | async def test_custom_auth() -> None:
  function test_netrc_auth_credentials_exist (line 237) | def test_netrc_auth_credentials_exist() -> None:
  function test_netrc_auth_credentials_do_not_exist (line 256) | def test_netrc_auth_credentials_do_not_exist() -> None:
  function test_netrc_auth_nopassword_parse_error (line 277) | def test_netrc_auth_nopassword_parse_error() -> None:  # pragma: no cover
  function test_auth_disable_per_request (line 289) | async def test_auth_disable_per_request() -> None:
  function test_auth_hidden_url (line 303) | def test_auth_hidden_url() -> None:
  function test_auth_hidden_header (line 311) | async def test_auth_hidden_header() -> None:
  function test_auth_property (line 323) | async def test_auth_property() -> None:
  function test_auth_invalid_type (line 339) | async def test_auth_invalid_type() -> None:
  function test_digest_auth_returns_no_auth_if_no_digest_header_in_response (line 357) | async def test_digest_auth_returns_no_auth_if_no_digest_header_in_respon...
  function test_digest_auth_returns_no_auth_if_alternate_auth_scheme (line 370) | def test_digest_auth_returns_no_auth_if_alternate_auth_scheme() -> None:
  function test_digest_auth_200_response_including_digest_auth_header (line 385) | async def test_digest_auth_200_response_including_digest_auth_header() -...
  function test_digest_auth_401_response_without_digest_auth_header (line 400) | async def test_digest_auth_401_response_without_digest_auth_header() -> ...
  function test_digest_auth (line 427) | async def test_digest_auth(
  function test_digest_auth_no_specified_qop (line 460) | async def test_digest_auth_no_specified_qop() -> None:
  function test_digest_auth_qop_including_spaces_and_auth_returns_auth (line 492) | async def test_digest_auth_qop_including_spaces_and_auth_returns_auth(qo...
  function test_digest_auth_qop_auth_int_not_implemented (line 505) | async def test_digest_auth_qop_auth_int_not_implemented() -> None:
  function test_digest_auth_qop_must_be_auth_or_auth_int (line 516) | async def test_digest_auth_qop_must_be_auth_or_auth_int() -> None:
  function test_digest_auth_incorrect_credentials (line 527) | async def test_digest_auth_incorrect_credentials() -> None:
  function test_digest_auth_reuses_challenge (line 540) | async def test_digest_auth_reuses_challenge() -> None:
  function test_digest_auth_resets_nonce_count_after_401 (line 557) | async def test_digest_auth_resets_nonce_count_after_401() -> None:
  function test_async_digest_auth_raises_protocol_error_on_malformed_header (line 604) | async def test_async_digest_auth_raises_protocol_error_on_malformed_header(
  function test_sync_digest_auth_raises_protocol_error_on_malformed_header (line 623) | def test_sync_digest_auth_raises_protocol_error_on_malformed_header(
  function test_async_auth_history (line 636) | async def test_async_auth_history() -> None:
  function test_sync_auth_history (line 662) | def test_sync_auth_history() -> None:
  class ConsumeBodyTransport (line 688) | class ConsumeBodyTransport(httpx.MockTransport):
    method handle_async_request (line 689) | async def handle_async_request(self, request: httpx.Request) -> httpx....
  function test_digest_auth_unavailable_streaming_body (line 696) | async def test_digest_auth_unavailable_streaming_body():
  function test_async_auth_reads_response_body (line 710) | async def test_async_auth_reads_response_body() -> None:
  function test_sync_auth_reads_response_body (line 726) | def test_sync_auth_reads_response_body() -> None:
  function test_async_auth (line 743) | async def test_async_auth() -> None:
  function test_sync_auth (line 760) | def test_sync_auth() -> None:

FILE: tests/client/test_client.py
  function autodetect (line 12) | def autodetect(content):
  function test_get (line 16) | def test_get(server):
  function test_get_invalid_url (line 41) | def test_get_invalid_url(server, url):
  function test_build_request (line 47) | def test_build_request(server):
  function test_build_post_request (line 62) | def test_build_post_request(server):
  function test_post (line 78) | def test_post(server):
  function test_post_json (line 85) | def test_post_json(server):
  function test_stream_response (line 92) | def test_stream_response(server):
  function test_stream_iterator (line 100) | def test_stream_iterator(server):
  function test_raw_iterator (line 112) | def test_raw_iterator(server):
  function test_cannot_stream_async_request (line 124) | def test_cannot_stream_async_request(server):
  function test_raise_for_status (line 134) | def test_raise_for_status(server):
  function test_options (line 149) | def test_options(server):
  function test_head (line 156) | def test_head(server):
  function test_put (line 163) | def test_put(server):
  function test_patch (line 170) | def test_patch(server):
  function test_delete (line 177) | def test_delete(server):
  function test_base_url (line 184) | def test_base_url(server):
  function test_merge_absolute_url (line 192) | def test_merge_absolute_url():
  function test_merge_relative_url (line 198) | def test_merge_relative_url():
  function test_merge_relative_url_with_path (line 204) | def test_merge_relative_url_with_path():
  function test_merge_relative_url_with_dotted_path (line 210) | def test_merge_relative_url_with_dotted_path():
  function test_merge_relative_url_with_path_including_colon (line 216) | def test_merge_relative_url_with_path_including_colon():
  function test_merge_relative_url_with_encoded_slashes (line 222) | def test_merge_relative_url_with_encoded_slashes():
  function test_context_managed_transport (line 232) | def test_context_managed_transport():
  function test_context_managed_transport_and_mount (line 263) | def test_context_managed_transport_and_mount():
  function hello_world (line 301) | def hello_world(request):
  function test_client_closed_state_using_implicit_open (line 305) | def test_client_closed_state_using_implicit_open():
  function test_client_closed_state_using_with_block (line 326) | def test_client_closed_state_using_with_block():
  function echo_raw_headers (line 336) | def echo_raw_headers(request: httpx.Request) -> httpx.Response:
  function test_raw_client_header (line 344) | def test_raw_client_header():
  function unmounted (line 367) | def unmounted(request: httpx.Request) -> httpx.Response:
  function mounted (line 372) | def mounted(request: httpx.Request) -> httpx.Response:
  function test_mounted_transport (line 377) | def test_mounted_transport():
  function test_all_mounted_transport (line 392) | def test_all_mounted_transport():
  function test_server_extensions (line 402) | def test_server_extensions(server):
  function test_client_decode_text_using_autodetect (line 410) | def test_client_decode_text_using_autodetect():
  function test_client_decode_text_using_explicit_encoding (line 438) | def test_client_decode_text_using_explicit_encoding():

FILE: tests/client/test_cookies.py
  function get_and_set_cookies (line 8) | def get_and_set_cookies(request: httpx.Request) -> httpx.Response:
  function test_set_cookie (line 18) | def test_set_cookie() -> None:
  function test_set_per_request_cookie_is_deprecated (line 34) | def test_set_per_request_cookie_is_deprecated() -> None:
  function test_set_cookie_with_cookiejar (line 49) | def test_set_cookie_with_cookiejar() -> None:
  function test_setting_client_cookies_to_cookiejar (line 86) | def test_setting_client_cookies_to_cookiejar() -> None:
  function test_set_cookie_with_cookies_model (line 123) | def test_set_cookie_with_cookies_model() -> None:
  function test_get_cookie (line 140) | def test_get_cookie() -> None:
  function test_cookie_persistence (line 151) | def test_cookie_persistence() -> None:

FILE: tests/client/test_event_hooks.py
  function app (line 6) | def app(request: httpx.Request) -> httpx.Response:
  function test_event_hooks (line 16) | def test_event_hooks():
  function test_event_hooks_raising_exception (line 51) | def test_event_hooks_raising_exception(server):
  function test_async_event_hooks (line 67) | async def test_async_event_hooks():
  function test_async_event_hooks_raising_exception (line 103) | async def test_async_event_hooks_raising_exception():
  function test_event_hooks_with_redirect (line 118) | def test_event_hooks_with_redirect():
  function test_async_event_hooks_with_redirect (line 175) | async def test_async_event_hooks_with_redirect():

FILE: tests/client/test_headers.py
  function echo_headers (line 8) | def echo_headers(request: httpx.Request) -> httpx.Response:
  function echo_repeated_headers_multi_items (line 13) | def echo_repeated_headers_multi_items(request: httpx.Request) -> httpx.R...
  function echo_repeated_headers_items (line 18) | def echo_repeated_headers_items(request: httpx.Request) -> httpx.Response:
  function test_client_header (line 23) | def test_client_header():
  function test_header_merge (line 46) | def test_header_merge():
  function test_header_merge_conflicting_headers (line 68) | def test_header_merge_conflicting_headers():
  function test_header_update (line 90) | def test_header_update():
  function test_header_repeated_items (line 123) | def test_header_repeated_items():
  function test_header_repeated_multi_items (line 138) | def test_header_repeated_multi_items():
  function test_remove_default_header (line 152) | def test_remove_default_header():
  function test_header_does_not_exist (line 174) | def test_header_does_not_exist():
  function test_header_with_incorrect_value (line 180) | def test_header_with_incorrect_value():
  function test_host_with_auth_and_port_in_url (line 188) | def test_host_with_auth_and_port_in_url():
  function test_host_with_non_default_port_in_url (line 212) | def test_host_with_non_default_port_in_url():
  function test_request_auto_headers (line 235) | def test_request_auto_headers():
  function test_same_origin (line 240) | def test_same_origin():
  function test_not_same_origin (line 250) | def test_not_same_origin():
  function test_is_https_redirect (line 260) | def test_is_https_redirect():
  function test_is_not_https_redirect (line 272) | def test_is_not_https_redirect():
  function test_is_not_https_redirect_if_not_default_ports (line 284) | def test_is_not_https_redirect_if_not_default_ports():

FILE: tests/client/test_properties.py
  function test_client_base_url (line 4) | def test_client_base_url():
  function test_client_base_url_without_trailing_slash (line 11) | def test_client_base_url_without_trailing_slash():
  function test_client_base_url_with_trailing_slash (line 18) | def test_client_base_url_with_trailing_slash():
  function test_client_headers (line 25) | def test_client_headers():
  function test_client_cookies (line 32) | def test_client_cookies():
  function test_client_timeout (line 41) | def test_client_timeout():
  function test_client_event_hooks (line 54) | def test_client_event_hooks():
  function test_client_trust_env (line 63) | def test_client_trust_env():

FILE: tests/client/test_proxies.py
  function url_to_origin (line 7) | def url_to_origin(url: str) -> httpcore.URL:
  function test_socks_proxy (line 16) | def test_socks_proxy():
  function test_transport_for_request (line 88) | def test_transport_for_request(url, proxies, expected):
  function test_async_proxy_close (line 104) | async def test_async_proxy_close():
  function test_sync_proxy_close (line 114) | def test_sync_proxy_close():
  function test_unsupported_proxy_scheme (line 123) | def test_unsupported_proxy_scheme():
  function test_proxies_environ (line 226) | def test_proxies_environ(monkeypatch, client_class, url, env, expected):
  function test_for_deprecated_proxy_params (line 250) | def test_for_deprecated_proxy_params(proxies, is_valid):
  function test_proxy_with_mounts (line 260) | def test_proxy_with_mounts():

FILE: tests/client/test_queryparams.py
  function hello_world (line 4) | def hello_world(request: httpx.Request) -> httpx.Response:
  function test_client_queryparams (line 8) | def test_client_queryparams():
  function test_client_queryparams_string (line 14) | def test_client_queryparams_string():
  function test_client_queryparams_echo (line 25) | def test_client_queryparams_echo():

FILE: tests/client/test_redirects.py
  function redirects (line 8) | def redirects(request: httpx.Request) -> httpx.Response:
  function test_redirect_301 (line 116) | def test_redirect_301():
  function test_redirect_302 (line 124) | def test_redirect_302():
  function test_redirect_303 (line 132) | def test_redirect_303():
  function test_next_request (line 140) | def test_next_request():
  function test_async_next_request (line 155) | async def test_async_next_request():
  function test_head_redirect (line 169) | def test_head_redirect():
  function test_relative_redirect (line 182) | def test_relative_redirect():
  function test_malformed_redirect (line 192) | def test_malformed_redirect():
  function test_invalid_redirect (line 203) | def test_invalid_redirect():
  function test_no_scheme_redirect (line 209) | def test_no_scheme_redirect():
  function test_fragment_redirect (line 219) | def test_fragment_redirect():
  function test_multiple_redirects (line 229) | def test_multiple_redirects():
  function test_async_too_many_redirects (line 244) | async def test_async_too_many_redirects():
  function test_sync_too_many_redirects (line 252) | def test_sync_too_many_redirects():
  function test_redirect_loop (line 260) | def test_redirect_loop():
  function test_cross_domain_redirect_with_auth_header (line 266) | def test_cross_domain_redirect_with_auth_header():
  function test_cross_domain_https_redirect_with_auth_header (line 275) | def test_cross_domain_https_redirect_with_auth_header():
  function test_cross_domain_redirect_with_auth (line 284) | def test_cross_domain_redirect_with_auth():
  function test_same_domain_redirect (line 292) | def test_same_domain_redirect():
  function test_same_domain_https_redirect_with_auth_header (line 301) | def test_same_domain_https_redirect_with_auth_header():
  function test_body_redirect (line 310) | def test_body_redirect():
  function test_no_body_redirect (line 323) | def test_no_body_redirect():
  function test_can_stream_if_no_redirect (line 336) | def test_can_stream_if_no_redirect():
  class ConsumeBodyTransport (line 345) | class ConsumeBodyTransport(httpx.MockTransport):
    method handle_request (line 346) | def handle_request(self, request: httpx.Request) -> httpx.Response:
  function test_cannot_redirect_streaming_body (line 352) | def test_cannot_redirect_streaming_body():
  function test_cross_subdomain_redirect (line 363) | def test_cross_subdomain_redirect():
  function cookie_sessions (line 370) | def cookie_sessions(request: httpx.Request) -> httpx.Response:
  function test_redirect_cookie_behavior (line 403) | def test_redirect_cookie_behavior():
  function test_redirect_custom_scheme (line 434) | def test_redirect_custom_scheme():
  function test_async_invalid_redirect (line 442) | async def test_async_invalid_redirect():

FILE: tests/concurrency.py
  function sleep (line 11) | async def sleep(seconds: float) -> None:

FILE: tests/conftest.py
  function clean_environ (line 35) | def clean_environ():
  function app (line 59) | async def app(scope: Scope, receive: Receive, send: Send) -> None:
  function hello_world (line 79) | async def hello_world(scope: Scope, receive: Receive, send: Send) -> None:
  function hello_world_json (line 90) | async def hello_world_json(scope: Scope, receive: Receive, send: Send) -...
  function slow_response (line 101) | async def slow_response(scope: Scope, receive: Receive, send: Send) -> N...
  function status_code (line 113) | async def status_code(scope: Scope, receive: Receive, send: Send) -> None:
  function echo_body (line 125) | async def echo_body(scope: Scope, receive: Receive, send: Send) -> None:
  function echo_binary (line 144) | async def echo_binary(scope: Scope, receive: Receive, send: Send) -> None:
  function echo_headers (line 163) | async def echo_headers(scope: Scope, receive: Receive, send: Send) -> None:
  function redirect_301 (line 178) | async def redirect_301(scope: Scope, receive: Receive, send: Send) -> None:
  function cert_authority (line 186) | def cert_authority():
  function localhost_cert (line 191) | def localhost_cert(cert_authority):
  function cert_pem_file (line 196) | def cert_pem_file(localhost_cert):
  function cert_private_key_file (line 202) | def cert_private_key_file(localhost_cert):
  function cert_encrypted_private_key_file (line 208) | def cert_encrypted_private_key_file(localhost_cert):
  class TestServer (line 224) | class TestServer(Server):
    method url (line 226) | def url(self) -> httpx.URL:
    method install_signal_handlers (line 230) | def install_signal_handlers(self) -> None:
    method serve (line 235) | async def serve(self, sockets=None):
    method restart (line 245) | async def restart(self) -> None:  # pragma: no cover
    method watch_restarts (line 256) | async def watch_restarts(self) -> None:  # pragma: no cover
  function serve_in_thread (line 271) | def serve_in_thread(server: TestServer) -> typing.Iterator[TestServer]:
  function server (line 284) | def server() -> typing.Iterator[TestServer]:

FILE: tests/models/test_cookies.py
  function test_cookies (line 8) | def test_cookies():
  function test_cookies_update (line 23) | def test_cookies_update():
  function test_cookies_with_domain (line 33) | def test_cookies_with_domain():
  function test_cookies_with_domain_and_path (line 45) | def test_cookies_with_domain_and_path():
  function test_multiple_set_cookie (line 55) | def test_multiple_set_cookie():
  function test_cookies_can_be_a_list_of_tuples (line 80) | def test_cookies_can_be_a_list_of_tuples():
  function test_cookies_repr (line 90) | def test_cookies_repr():

FILE: tests/models/test_headers.py
  function test_headers (line 6) | def test_headers():
  function test_header_mutations (line 37) | def test_header_mutations():
  function test_copy_headers_method (line 53) | def test_copy_headers_method():
  function test_copy_headers_init (line 60) | def test_copy_headers_init():
  function test_headers_insert_retains_ordering (line 66) | def test_headers_insert_retains_ordering():
  function test_headers_insert_appends_if_new (line 72) | def test_headers_insert_appends_if_new():
  function test_headers_insert_removes_all_existing (line 78) | def test_headers_insert_removes_all_existing():
  function test_headers_delete_removes_all_existing (line 84) | def test_headers_delete_removes_all_existing():
  function test_headers_dict_repr (line 90) | def test_headers_dict_repr():
  function test_headers_encoding_in_repr (line 98) | def test_headers_encoding_in_repr():
  function test_headers_list_repr (line 106) | def test_headers_list_repr():
  function test_headers_decode_ascii (line 116) | def test_headers_decode_ascii():
  function test_headers_decode_utf_8 (line 126) | def test_headers_decode_utf_8():
  function test_headers_decode_iso_8859_1 (line 136) | def test_headers_decode_iso_8859_1():
  function test_headers_decode_explicit_encoding (line 146) | def test_headers_decode_explicit_encoding():
  function test_multiple_headers (line 158) | def test_multiple_headers():
  function test_sensitive_headers (line 170) | def test_sensitive_headers(header):
  function test_obfuscate_sensitive_headers (line 187) | def test_obfuscate_sensitive_headers(headers, output):
  function test_parse_header_links (line 212) | def test_parse_header_links(value, expected):
  function test_parse_header_links_no_link (line 217) | def test_parse_header_links_no_link():

FILE: tests/models/test_queryparams.py
  function test_queryparams (line 16) | def test_queryparams(source):
  function test_queryparam_types (line 53) | def test_queryparam_types():
  function test_empty_query_params (line 79) | def test_empty_query_params():
  function test_queryparam_update_is_hard_deprecated (line 90) | def test_queryparam_update_is_hard_deprecated():
  function test_queryparam_setter_is_hard_deprecated (line 96) | def test_queryparam_setter_is_hard_deprecated():
  function test_queryparam_set (line 102) | def test_queryparam_set():
  function test_queryparam_add (line 108) | def test_queryparam_add():
  function test_queryparam_remove (line 114) | def test_queryparam_remove():
  function test_queryparam_merge (line 120) | def test_queryparam_merge():
  function test_queryparams_are_hashable (line 128) | def test_queryparams_are_hashable():

FILE: tests/models/test_requests.py
  function test_request_repr (line 9) | def test_request_repr():
  function test_no_content (line 14) | def test_no_content():
  function test_content_length_header (line 19) | def test_content_length_header():
  function test_iterable_content (line 24) | def test_iterable_content():
  function test_generator_with_transfer_encoding_header (line 33) | def test_generator_with_transfer_encoding_header():
  function test_generator_with_content_length_header (line 41) | def test_generator_with_content_length_header():
  function test_url_encoded_data (line 52) | def test_url_encoded_data():
  function test_json_encoded_data (line 60) | def test_json_encoded_data():
  function test_headers (line 68) | def test_headers():
  function test_read_and_stream_data (line 78) | def test_read_and_stream_data():
  function test_aread_and_stream_data (line 90) | async def test_aread_and_stream_data():
  function test_cannot_access_streaming_content_without_read (line 101) | def test_cannot_access_streaming_content_without_read():
  function test_transfer_encoding_header (line 111) | def test_transfer_encoding_header():
  function test_ignore_transfer_encoding_header_if_content_length_exists (line 122) | def test_ignore_transfer_encoding_header_if_content_length_exists():
  function test_override_host_header (line 139) | def test_override_host_header():
  function test_override_accept_encoding_header (line 146) | def test_override_accept_encoding_header():
  function test_override_content_length_header (line 153) | def test_override_content_length_header():
  function test_url (line 164) | def test_url():
  function test_request_picklable (line 180) | def test_request_picklable():
  function test_request_async_streaming_content_picklable (line 196) | async def test_request_async_streaming_content_picklable():
  function test_request_generator_content_picklable (line 214) | def test_request_generator_content_picklable():
  function test_request_params (line 231) | def test_request_params():

FILE: tests/models/test_responses.py
  class StreamingBody (line 11) | class StreamingBody:
    method __iter__ (line 12) | def __iter__(self):
  function streaming_body (line 17) | def streaming_body() -> typing.Iterator[bytes]:
  function async_streaming_body (line 22) | async def async_streaming_body() -> typing.AsyncIterator[bytes]:
  function autodetect (line 27) | def autodetect(content):
  function test_response (line 31) | def test_response():
  function test_response_content (line 46) | def test_response_content():
  function test_response_text (line 55) | def test_response_text():
  function test_response_html (line 67) | def test_response_html():
  function test_response_json (line 79) | def test_response_json():
  function test_raise_for_status (line 91) | def test_raise_for_status():
  function test_response_repr (line 149) | def test_response_repr():
  function test_response_content_type_encoding (line 157) | def test_response_content_type_encoding():
  function test_response_default_to_utf8_encoding (line 172) | def test_response_default_to_utf8_encoding():
  function test_response_fallback_to_utf8_encoding (line 185) | def test_response_fallback_to_utf8_encoding():
  function test_response_no_charset_with_ascii_content (line 200) | def test_response_no_charset_with_ascii_content():
  function test_response_no_charset_with_utf8_content (line 217) | def test_response_no_charset_with_utf8_content():
  function test_response_no_charset_with_iso_8859_1_content (line 233) | def test_response_no_charset_with_iso_8859_1_content():
  function test_response_no_charset_with_cp_1252_content (line 247) | def test_response_no_charset_with_cp_1252_content():
  function test_response_non_text_encoding (line 261) | def test_response_non_text_encoding():
  function test_response_set_explicit_encoding (line 275) | def test_response_set_explicit_encoding():
  function test_response_force_encoding (line 289) | def test_response_force_encoding():
  function test_response_force_encoding_after_text_accessed (line 301) | def test_response_force_encoding_after_text_accessed():
  function test_read (line 318) | def test_read():
  function test_empty_read (line 336) | def test_empty_read():
  function test_aread (line 352) | async def test_aread():
  function test_empty_aread (line 371) | async def test_empty_aread():
  function test_iter_raw (line 386) | def test_iter_raw():
  function test_iter_raw_with_chunksize (line 398) | def test_iter_raw_with_chunksize():
  function test_iter_raw_doesnt_return_empty_chunks (line 416) | def test_iter_raw_doesnt_return_empty_chunks():
  function test_iter_raw_on_iterable (line 429) | def test_iter_raw_on_iterable():
  function test_iter_raw_on_async (line 441) | def test_iter_raw_on_async():
  function test_close_on_async (line 451) | def test_close_on_async():
  function test_iter_raw_increments_updates_counter (line 461) | def test_iter_raw_increments_updates_counter():
  function test_aiter_raw (line 471) | async def test_aiter_raw():
  function test_aiter_raw_with_chunksize (line 481) | async def test_aiter_raw_with_chunksize():
  function test_aiter_raw_on_sync (line 499) | async def test_aiter_raw_on_sync():
  function test_aclose_on_sync (line 510) | async def test_aclose_on_sync():
  function test_aiter_raw_increments_updates_counter (line 521) | async def test_aiter_raw_increments_updates_counter():
  function test_iter_bytes (line 530) | def test_iter_bytes():
  function test_iter_bytes_with_chunk_size (line 539) | def test_iter_bytes_with_chunk_size():
  function test_iter_bytes_with_empty_response (line 553) | def test_iter_bytes_with_empty_response():
  function test_iter_bytes_doesnt_return_empty_chunks (line 559) | def test_iter_bytes_doesnt_return_empty_chunks():
  function test_aiter_bytes (line 573) | async def test_aiter_bytes():
  function test_aiter_bytes_with_chunk_size (line 586) | async def test_aiter_bytes_with_chunk_size():
  function test_iter_text (line 600) | def test_iter_text():
  function test_iter_text_with_chunk_size (line 612) | def test_iter_text_with_chunk_size():
  function test_aiter_text (line 635) | async def test_aiter_text():
  function test_aiter_text_with_chunk_size (line 648) | async def test_aiter_text_with_chunk_size():
  function test_iter_lines (line 662) | def test_iter_lines():
  function test_aiter_lines (line 672) | async def test_aiter_lines():
  function test_sync_streaming_response (line 684) | def test_sync_streaming_response():
  function test_async_streaming_response (line 701) | async def test_async_streaming_response():
  function test_cannot_read_after_stream_consumed (line 717) | def test_cannot_read_after_stream_consumed():
  function test_cannot_aread_after_stream_consumed (line 732) | async def test_cannot_aread_after_stream_consumed():
  function test_cannot_read_after_response_closed (line 746) | def test_cannot_read_after_response_closed():
  function test_cannot_aread_after_response_closed (line 758) | async def test_cannot_aread_after_response_closed():
  function test_elapsed_not_available_until_closed (line 770) | async def test_elapsed_not_available_until_closed():
  function test_unknown_status_code (line 780) | def test_unknown_status_code():
  function test_json_with_specified_encoding (line 789) | def test_json_with_specified_encoding():
  function test_json_with_options (line 801) | def test_json_with_options():
  function test_json_without_specified_charset (line 826) | def test_json_without_specified_charset(encoding):
  function test_json_with_specified_charset (line 851) | def test_json_with_specified_charset(encoding):
  function test_link_headers (line 879) | def test_link_headers(headers, expected):
  function test_decode_error_with_request (line 889) | def test_decode_error_with_request(header_value):
  function test_value_error_without_request (line 909) | def test_value_error_without_request(header_value):
  function test_response_with_unset_request (line 916) | def test_response_with_unset_request():
  function test_set_request_after_init (line 925) | def test_set_request_after_init():
  function test_cannot_access_unset_request (line 934) | def test_cannot_access_unset_request():
  function test_generator_with_transfer_encoding_header (line 941) | def test_generator_with_transfer_encoding_header():
  function test_generator_with_content_length_header (line 949) | def test_generator_with_content_length_header():
  function test_response_picklable (line 958) | def test_response_picklable():
  function test_response_async_streaming_picklable (line 977) | async def test_response_async_streaming_picklable():
  function test_response_decode_text_using_autodetect (line 996) | def test_response_decode_text_using_autodetect():
  function test_response_decode_text_using_explicit_encoding (line 1021) | def test_response_decode_text_using_explicit_encoding():

FILE: tests/models/test_url.py
  function test_basic_url (line 8) | def test_basic_url():
  function test_complete_url (line 24) | def test_complete_url():
  function test_url_with_empty_query (line 40) | def test_url_with_empty_query():
  function test_url_no_scheme (line 56) | def test_url_no_scheme():
  function test_url_no_authority (line 63) | def test_url_no_authority():
  function test_path_query_fragment (line 135) | def test_path_query_fragment(url, raw_path, path, query, fragment):
  function test_url_query_encoding (line 143) | def test_url_query_encoding():
  function test_url_params (line 154) | def test_url_params():
  function test_url_username_and_password (line 207) | def test_url_username_and_password(url, userinfo, username, password):
  function test_url_valid_host (line 217) | def test_url_valid_host():
  function test_url_normalized_host (line 222) | def test_url_normalized_host():
  function test_url_percent_escape_host (line 227) | def test_url_percent_escape_host():
  function test_url_ipv4_like_host (line 232) | def test_url_ipv4_like_host():
  function test_url_valid_port (line 241) | def test_url_valid_port():
  function test_url_normalized_port (line 246) | def test_url_normalized_port():
  function test_url_invalid_port (line 252) | def test_url_invalid_port():
  function test_url_normalized_path (line 261) | def test_url_normalized_path():
  function test_url_escaped_path (line 266) | def test_url_escaped_path():
  function test_url_leading_dot_prefix_on_absolute_url (line 271) | def test_url_leading_dot_prefix_on_absolute_url():
  function test_url_leading_dot_prefix_on_relative_url (line 276) | def test_url_leading_dot_prefix_on_relative_url():
  function test_param_with_space (line 286) | def test_param_with_space():
  function test_param_requires_encoding (line 293) | def test_param_requires_encoding():
  function test_param_with_percent_encoded (line 299) | def test_param_with_percent_encoded():
  function test_param_with_existing_escape_requires_encoding (line 307) | def test_param_with_existing_escape_requires_encoding():
  function test_query_with_existing_percent_encoding (line 320) | def test_query_with_existing_percent_encoding():
  function test_query_requiring_percent_encoding (line 326) | def test_query_requiring_percent_encoding():
  function test_query_with_mixed_percent_encoding (line 332) | def test_query_with_mixed_percent_encoding():
  function test_url_invalid_hostname (line 343) | def test_url_invalid_hostname():
  function test_url_excessively_long_url (line 351) | def test_url_excessively_long_url():
  function test_url_excessively_long_component (line 357) | def test_url_excessively_long_component():
  function test_url_non_printing_character_in_url (line 363) | def test_url_non_printing_character_in_url():
  function test_url_non_printing_character_in_component (line 371) | def test_url_non_printing_character_in_component():
  function test_url_with_components (line 383) | def test_url_with_components():
  function test_urlparse_with_invalid_component (line 397) | def test_urlparse_with_invalid_component():
  function test_urlparse_with_invalid_scheme (line 403) | def test_urlparse_with_invalid_scheme():
  function test_urlparse_with_invalid_path (line 409) | def test_urlparse_with_invalid_path():
  function test_url_with_relative_path (line 423) | def test_url_with_relative_path():
  function test_url_eq_str (line 432) | def test_url_eq_str():
  function test_url_set (line 441) | def test_url_set():
  function test_url_invalid_type (line 458) | def test_url_invalid_type():
  function test_url_with_invalid_component (line 470) | def test_url_with_invalid_component():
  function test_url_join (line 479) | def test_url_join():
  function test_relative_url_join (line 494) | def test_relative_url_join():
  function test_url_join_rfc3986 (line 502) | def test_url_join_rfc3986():
  function test_resolution_error_1833 (line 557) | def test_resolution_error_1833():
  function test_copy_with (line 568) | def test_copy_with():
  function test_url_copywith_authority_subcomponents (line 585) | def test_url_copywith_authority_subcomponents():
  function test_url_copywith_netloc (line 597) | def test_url_copywith_netloc():
  function test_url_copywith_userinfo_subcomponents (line 606) | def test_url_copywith_userinfo_subcomponents():
  function test_url_copywith_invalid_component (line 619) | def test_url_copywith_invalid_component():
  function test_url_copywith_urlencoded_path (line 627) | def test_url_copywith_urlencoded_path():
  function test_url_copywith_query (line 635) | def test_url_copywith_query():
  function test_url_copywith_raw_path (line 643) | def test_url_copywith_raw_path():
  function test_url_copywith_security (line 663) | def test_url_copywith_security():
  function test_url_set_param_manipulation (line 684) | def test_url_set_param_manipulation():
  function test_url_add_param_manipulation (line 692) | def test_url_add_param_manipulation():
  function test_url_remove_param_manipulation (line 700) | def test_url_remove_param_manipulation():
  function test_url_merge_params_manipulation (line 708) | def test_url_merge_params_manipulation():
  function test_idna_url (line 780) | def test_idna_url(given, idna, host, raw_host, scheme, port):
  function test_url_unescaped_idna_host (line 789) | def test_url_unescaped_idna_host():
  function test_url_escaped_idna_host (line 794) | def test_url_escaped_idna_host():
  function test_url_invalid_idna_host (line 799) | def test_url_invalid_idna_host():
  function test_url_valid_ipv4 (line 808) | def test_url_valid_ipv4():
  function test_url_invalid_ipv4 (line 813) | def test_url_invalid_ipv4():
  function test_ipv6_url (line 822) | def test_ipv6_url():
  function test_url_valid_ipv6 (line 829) | def test_url_valid_ipv6():
  function test_url_invalid_ipv6 (line 834) | def test_url_invalid_ipv6():
  function test_ipv6_url_from_raw_url (line 841) | def test_ipv6_url_from_raw_url(host):
  function test_ipv6_url_copy_with_host (line 858) | def test_ipv6_url_copy_with_host(url_str, new_host):

FILE: tests/models/test_whatwg.py
  function test_urlparse (line 23) | def test_urlparse(test_case):

FILE: tests/test_api.py
  function test_get (line 8) | def test_get(server):
  function test_post (line 16) | def test_post(server):
  function test_post_byte_iterator (line 22) | def test_post_byte_iterator(server):
  function test_post_byte_stream (line 33) | def test_post_byte_stream(server):
  function test_options (line 45) | def test_options(server):
  function test_head (line 51) | def test_head(server):
  function test_put (line 57) | def test_put(server):
  function test_patch (line 63) | def test_patch(server):
  function test_delete (line 69) | def test_delete(server):
  function test_stream (line 75) | def test_stream(server):
  function test_get_invalid_url (line 85) | def test_get_invalid_url():
  function test_httpcore_lazy_loading (line 91) | def test_httpcore_lazy_loading(server):

FILE: tests/test_asgi.py
  function hello_world (line 8) | async def hello_world(scope, receive, send):
  function echo_path (line 17) | async def echo_path(scope, receive, send):
  function echo_raw_path (line 26) | async def echo_raw_path(scope, receive, send):
  function echo_body (line 35) | async def echo_body(scope, receive, send):
  function echo_headers (line 48) | async def echo_headers(scope, receive, send):
  function raise_exc (line 59) | async def raise_exc(scope, receive, send):
  function raise_exc_after_response (line 63) | async def raise_exc_after_response(scope, receive, send):
  function test_asgi_transport (line 74) | async def test_asgi_transport():
  function test_asgi_transport_no_body (line 84) | async def test_asgi_transport_no_body():
  function test_asgi (line 94) | async def test_asgi():
  function test_asgi_urlencoded_path (line 104) | async def test_asgi_urlencoded_path():
  function test_asgi_raw_path (line 115) | async def test_asgi_raw_path():
  function test_asgi_raw_path_should_not_include_querystring_portion (line 126) | async def test_asgi_raw_path_should_not_include_querystring_portion():
  function test_asgi_upload (line 140) | async def test_asgi_upload():
  function test_asgi_headers (line 150) | async def test_asgi_headers():
  function test_asgi_exc (line 168) | async def test_asgi_exc():
  function test_asgi_exc_after_response (line 176) | async def test_asgi_exc_after_response():
  function test_asgi_disconnect_after_response_complete (line 184) | async def test_asgi_disconnect_after_response_complete():
  function test_asgi_exc_no_raise (line 219) | async def test_asgi_exc_no_raise():

FILE: tests/test_auth.py
  function test_basic_auth (line 14) | def test_basic_auth():
  function test_digest_auth_with_200 (line 29) | def test_digest_auth_with_200():
  function test_digest_auth_with_401 (line 44) | def test_digest_auth_with_401():
  function test_digest_auth_with_401_nonce_counting (line 69) | def test_digest_auth_with_401_nonce_counting():
  function set_cookies (line 107) | def set_cookies(request: httpx.Request) -> httpx.Response:
  function test_digest_auth_setting_cookie_in_request (line 120) | def test_digest_auth_setting_cookie_in_request():
  function test_digest_auth_rfc_2069 (line 146) | def test_digest_auth_rfc_2069():
  function test_digest_auth_rfc_7616_md5 (line 191) | def test_digest_auth_rfc_7616_md5(monkeypatch):
  function test_digest_auth_rfc_7616_sha_256 (line 251) | def test_digest_auth_rfc_7616_sha_256(monkeypatch):

FILE: tests/test_config.py
  function test_load_ssl_config (line 11) | def test_load_ssl_config():
  function test_load_ssl_config_verify_non_existing_file (line 17) | def test_load_ssl_config_verify_non_existing_file():
  function test_load_ssl_with_keylog (line 23) | def test_load_ssl_with_keylog(monkeypatch: typing.Any) -> None:
  function test_load_ssl_config_verify_existing_file (line 29) | def test_load_ssl_config_verify_existing_file():
  function test_load_ssl_config_verify_directory (line 36) | def test_load_ssl_config_verify_directory():
  function test_load_ssl_config_cert_and_key (line 43) | def test_load_ssl_config_cert_and_key(cert_pem_file, cert_private_key_fi...
  function test_load_ssl_config_cert_and_encrypted_key (line 51) | def test_load_ssl_config_cert_and_encrypted_key(
  function test_load_ssl_config_cert_and_key_invalid_password (line 60) | def test_load_ssl_config_cert_and_key_invalid_password(
  function test_load_ssl_config_cert_without_key_raises (line 70) | def test_load_ssl_config_cert_without_key_raises(cert_pem_file):
  function test_load_ssl_config_no_verify (line 76) | def test_load_ssl_config_no_verify():
  function test_SSLContext_with_get_request (line 82) | def test_SSLContext_with_get_request(server, cert_pem_file):
  function test_limits_repr (line 89) | def test_limits_repr():
  function test_limits_eq (line 98) | def test_limits_eq():
  function test_timeout_eq (line 103) | def test_timeout_eq():
  function test_timeout_all_parameters_set (line 108) | def test_timeout_all_parameters_set():
  function test_timeout_from_nothing (line 113) | def test_timeout_from_nothing():
  function test_timeout_from_none (line 121) | def test_timeout_from_none():
  function test_timeout_from_one_none_value (line 126) | def test_timeout_from_one_none_value():
  function test_timeout_from_one_value (line 131) | def test_timeout_from_one_value():
  function test_timeout_from_one_value_and_default (line 136) | def test_timeout_from_one_value_and_default():
  function test_timeout_missing_default (line 141) | def test_timeout_missing_default():
  function test_timeout_from_tuple (line 146) | def test_timeout_from_tuple():
  function test_timeout_from_config_instance (line 151) | def test_timeout_from_config_instance():
  function test_timeout_repr (line 156) | def test_timeout_repr():
  function test_proxy_from_url (line 164) | def test_proxy_from_url():
  function test_proxy_with_auth_from_url (line 173) | def test_proxy_with_auth_from_url():
  function test_invalid_proxy_scheme (line 182) | def test_invalid_proxy_scheme():

FILE: tests/test_content.py
  function test_empty_content (line 13) | async def test_empty_content():
  function test_bytes_content (line 27) | async def test_bytes_content():
  function test_bytesio_content (line 54) | async def test_bytesio_content():
  function test_async_bytesio_content (line 66) | async def test_async_bytesio_content():
  function test_iterator_content (line 94) | async def test_iterator_content():
  function test_aiterator_content (line 130) | async def test_aiterator_content():
  function test_json_content (line 166) | async def test_json_content():
  function test_urlencoded_content (line 184) | async def test_urlencoded_content():
  function test_urlencoded_boolean (line 202) | async def test_urlencoded_boolean():
  function test_urlencoded_none (line 220) | async def test_urlencoded_none():
  function test_urlencoded_list (line 238) | async def test_urlencoded_list():
  function test_multipart_files_content (line 256) | async def test_multipart_files_content():
  function test_multipart_data_and_files_content (line 299) | async def test_multipart_data_and_files_content():
  function test_empty_request (line 346) | async def test_empty_request():
  function test_invalid_argument (line 359) | def test_invalid_argument():
  function test_multipart_multiple_files_single_input_content (line 368) | async def test_multipart_multiple_files_single_input_content():
  function test_response_empty_content (line 419) | async def test_response_empty_content():
  function test_response_bytes_content (line 433) | async def test_response_bytes_content():
  function test_response_iterator_content (line 447) | async def test_response_iterator_content():
  function test_response_aiterator_content (line 466) | async def test_response_aiterator_content():
  function test_response_invalid_argument (line 484) | def test_response_invalid_argument():
  function test_ensure_ascii_false_with_french_characters (line 489) | def test_ensure_ascii_false_with_french_characters():
  function test_separators_for_compact_json (line 498) | def test_separators_for_compact_json():
  function test_allow_nan_false (line 507) | def test_allow_nan_false():

FILE: tests/test_decoders.py
  function test_deflate (line 14) | def test_deflate():
  function test_zlib (line 33) | def test_zlib():
  function test_gzip (line 51) | def test_gzip():
  function test_brotli (line 65) | def test_brotli():
  function test_zstd (line 78) | def test_zstd():
  function test_zstd_decoding_error (line 91) | def test_zstd_decoding_error():
  function test_zstd_empty (line 103) | def test_zstd_empty():
  function test_zstd_truncated (line 109) | def test_zstd_truncated():
  function test_zstd_multiframe (line 122) | def test_zstd_multiframe():
  function test_multi (line 144) | def test_multi():
  function test_multi_with_identity (line 164) | def test_multi_with_identity():
  function test_streaming (line 186) | async def test_streaming():
  function test_empty_content (line 205) | def test_empty_content(header_value):
  function test_decoders_empty_cases (line 216) | def test_decoders_empty_cases(header_value):
  function test_decoding_errors (line 223) | def test_decoding_errors(header_value):
  function test_text_decoder_with_autodetect (line 244) | async def test_text_decoder_with_autodetect(data, encoding):
  function test_text_decoder_known_encoding (line 267) | async def test_text_decoder_known_encoding():
  function test_text_decoder_empty_cases (line 283) | def test_text_decoder_empty_cases():
  function test_streaming_text_decoder (line 296) | def test_streaming_text_decoder(
  function test_line_decoder_nl (line 303) | def test_line_decoder_nl():
  function test_line_decoder_cr (line 317) | def test_line_decoder_cr():
  function test_line_decoder_crnl (line 331) | def test_line_decoder_crnl():
  function test_invalid_content_encoding_header (line 346) | def test_invalid_content_encoding_header():

FILE: tests/test_exceptions.py
  function test_httpcore_all_exceptions_mapped (line 14) | def test_httpcore_all_exceptions_mapped() -> None:
  function test_httpcore_exception_mapping (line 39) | def test_httpcore_exception_mapping(server: TestServer) -> None:
  function test_request_attribute (line 54) | def test_request_attribute() -> None:

FILE: tests/test_exported_members.py
  function test_all_imports_are_exported (line 4) | def test_all_imports_are_exported() -> None:

FILE: tests/test_main.py
  function splitlines (line 9) | def splitlines(output: str) -> typing.Iterable[str]:
  function remove_date_header (line 13) | def remove_date_header(lines: typing.Iterable[str]) -> typing.Iterable[s...
  function test_help (line 17) | def test_help():
  function test_get (line 24) | def test_get(server):
  function test_json (line 39) | def test_json(server):
  function test_binary (line 56) | def test_binary(server):
  function test_redirects (line 72) | def test_redirects(server):
  function test_follow_redirects (line 86) | def test_follow_redirects(server):
  function test_post (line 106) | def test_post(server):
  function test_verbose (line 121) | def test_verbose(server):
  function test_auth (line 145) | def test_auth(server):
  function test_download (line 171) | def test_download(server):
  function test_errors (line 181) | def test_errors():

FILE: tests/test_multipart.py
  function echo_request_content (line 12) | def echo_request_content(request: httpx.Request) -> httpx.Response:
  function test_multipart (line 17) | def test_multipart(value, output):
  function test_multipart_explicit_boundary (line 57) | def test_multipart_explicit_boundary(header: str) -> None:
  function test_multipart_header_without_boundary (line 86) | def test_multipart_header_without_boundary(header: str) -> None:
  function test_multipart_invalid_key (line 98) | def test_multipart_invalid_key(key):
  function test_multipart_invalid_value (line 114) | def test_multipart_invalid_value(value):
  function test_multipart_file_tuple (line 124) | def test_multipart_file_tuple():
  function test_multipart_file_tuple_headers (line 153) | def test_multipart_file_tuple_headers(file_content_type: str | None) -> ...
  function test_multipart_headers_include_content_type (line 178) | def test_multipart_headers_include_content_type() -> None:
  function test_multipart_encode (line 208) | def test_multipart_encode(tmp_path: typing.Any) -> None:
  function test_multipart_encode_unicode_file_contents (line 251) | def test_multipart_encode_unicode_file_contents() -> None:
  function test_multipart_encode_files_allows_filenames_as_none (line 272) | def test_multipart_encode_files_allows_filenames_as_none() -> None:
  function test_multipart_encode_files_guesses_correct_content_type (line 300) | def test_multipart_encode_files_guesses_correct_content_type(
  function test_multipart_encode_files_allows_bytes_content (line 323) | def test_multipart_encode_files_allows_bytes_content() -> None:
  function test_multipart_encode_files_allows_str_content (line 345) | def test_multipart_encode_files_allows_str_content() -> None:
  function test_multipart_encode_files_raises_exception_with_StringIO_content (line 367) | def test_multipart_encode_files_raises_exception_with_StringIO_content()...
  function test_multipart_encode_files_raises_exception_with_text_mode_file (line 374) | def test_multipart_encode_files_raises_exception_with_text_mode_file() -...
  function test_multipart_encode_non_seekable_filelike (line 382) | def test_multipart_encode_non_seekable_filelike() -> None:
  function test_multipart_rewinds_files (line 423) | def test_multipart_rewinds_files():
  class TestHeaderParamHTML5Formatting (line 442) | class TestHeaderParamHTML5Formatting:
    method test_unicode (line 443) | def test_unicode(self):
    method test_ascii (line 450) | def test_ascii(self):
    method test_unicode_escape (line 457) | def test_unicode_escape(self):
    method test_unicode_with_control_character (line 464) | def test_unicode_with_control_character(self):

FILE: tests/test_status_codes.py
  function test_status_code_as_int (line 4) | def test_status_code_as_int():
  function test_status_code_value_lookup (line 10) | def test_status_code_value_lookup():
  function test_status_code_phrase_lookup (line 14) | def test_status_code_phrase_lookup():
  function test_lowercase_status_code (line 18) | def test_lowercase_status_code():
  function test_reason_phrase_for_status_code (line 22) | def test_reason_phrase_for_status_code():
  function test_reason_phrase_for_unknown_status_code (line 26) | def test_reason_phrase_for_unknown_status_code():

FILE: tests/test_timeouts.py
  function test_read_timeout (line 7) | async def test_read_timeout(server):
  function test_write_timeout (line 16) | async def test_write_timeout(server):
  function test_connect_timeout (line 27) | async def test_connect_timeout(server):
  function test_pool_timeout (line 37) | async def test_pool_timeout(server):
  function test_async_client_new_request_send_timeout (line 48) | async def test_async_client_new_request_send_timeout(server):

FILE: tests/test_utils.py
  function test_encoded (line 25) | def test_encoded(encoding):
  function test_bad_utf_like_encoding (line 31) | def test_bad_utf_like_encoding():
  function test_guess_by_bom (line 47) | def test_guess_by_bom(encoding, expected):
  function test_logging_request (line 53) | def test_logging_request(server, caplog):
  function test_logging_redirect_chain (line 68) | def test_logging_redirect_chain(server, caplog):
  function test_get_environment_proxies (line 109) | def test_get_environment_proxies(environment, proxies):
  function test_url_matches (line 132) | def test_url_matches(pattern, url, expected):
  function test_pattern_priority (line 137) | def test_pattern_priority():

FILE: tests/test_wsgi.py
  function application_factory (line 17) | def application_factory(output: typing.Iterable[bytes]) -> WSGIApplication:
  function echo_body (line 33) | def echo_body(
  function echo_body_with_response_stream (line 48) | def echo_body_with_response_stream(
  function raise_exc (line 67) | def raise_exc(
  function log_to_wsgi_log_buffer (line 88) | def log_to_wsgi_log_buffer(environ, start_response):
  function test_wsgi (line 94) | def test_wsgi():
  function test_wsgi_upload (line 102) | def test_wsgi_upload():
  function test_wsgi_upload_with_response_stream (line 110) | def test_wsgi_upload_with_response_stream():
  function test_wsgi_exc (line 118) | def test_wsgi_exc():
  function test_wsgi_http_error (line 125) | def test_wsgi_http_error():
  function test_wsgi_generator (line 132) | def test_wsgi_generator():
  function test_wsgi_generator_empty (line 141) | def test_wsgi_generator_empty():
  function test_logging (line 150) | def test_logging():
  function test_wsgi_server_port (line 168) | def test_wsgi_server_port(url: str, expected_server_port: str) -> None:
  function test_wsgi_server_protocol (line 188) | def test_wsgi_server_protocol():