SYMBOL INDEX (1196 symbols across 116 files)

FILE: docs/contributors/fetch.py
  class FinishedForNow (line 40) | class FinishedForNow(Exception):
  function main (line 44) | def main(previous_release: str, current_release: str) -> int:
  function find_committers (line 71) | def find_committers(since: str, until: str) -> FullNames:
  function find_reporters (line 101) | def find_reporters(since: str, until: str) -> GitHubLogins:
  function merge_all_the_people (line 129) | def merge_all_the_people(release: str, contributors: People, committers:...
  function release_date (line 180) | def release_date(release: str) -> str:
  function load_awesome_people (line 185) | def load_awesome_people() -> People:
  function fetch (line 193) | def fetch(url: str, params: Optional[Dict[str, str]] = None) -> UserInfo:
  function new_person (line 218) | def new_person(**kwargs: str) -> Person:
  function user (line 224) | def user(fullname: Optional[str] = '', github_username: Optional[str] = ...
  function fetch_missing_users_details (line 241) | def fetch_missing_users_details(people: People) -> None:
  function save_awesome_people (line 252) | def save_awesome_people(people: People) -> None:
  function debug (line 258) | def debug(*args: Any) -> None:

FILE: docs/contributors/generate.py
  function generate_snippets (line 26) | def generate_snippets(release: str) -> str:

FILE: docs/installation/generate.py
  function generate_documentation (line 26) | def generate_documentation() -> str:
  function save_doc_file (line 35) | def save_doc_file(content: str) -> None:
  function build_docs_structure (line 52) | def build_docs_structure(database: Database):
  function clean_template_output (line 64) | def clean_template_output(output):
  function load_database (line 70) | def load_database() -> Database:
  function load_doc_file (line 74) | def load_doc_file() -> str:
  function main (line 78) | def main() -> int:

FILE: docs/packaging/brew/httpie.rb
  class Httpie (line 1) | class Httpie < Formula
    method install (line 72) | def install

FILE: extras/packaging/linux/build.py
  function build_binaries (line 23) | def build_binaries() -> Iterator[Tuple[str, Path]]:
  function build_packages (line 47) | def build_packages(http_binary: Path, httpie_binary: Path) -> None:
  function main (line 98) | def main():

FILE: extras/packaging/linux/scripts/hooks/hook-pip.py
  function hook (line 4) | def hook(hook_api):

FILE: extras/profiling/benchmarks.py
  class QuietSimpleHTTPServer (line 55) | class QuietSimpleHTTPServer(SimpleHTTPRequestHandler):
    method log_message (line 56) | def log_message(self, *args, **kwargs):
  function start_server (line 61) | def start_server():
  class Context (line 90) | class Context:
    method run (line 95) | def run(self) -> pyperf.BenchmarkSuite:
    method cmd (line 100) | def cmd(self) -> List[str]:
    method server (line 109) | def server(self) -> str:
    method __enter__ (line 112) | def __enter__(self):
    method __exit__ (line 115) | def __exit__(self, *exc_info):
  class BaseRunner (line 120) | class BaseRunner:
    method __post_init__ (line 129) | def __post_init__(self):
    method run (line 132) | def run(self, context: Context) -> pyperf.Benchmark:
    method name (line 136) | def name(self) -> str:
  class CommandRunner (line 141) | class CommandRunner(BaseRunner):
    method run (line 148) | def run(self, context: Context) -> pyperf.Benchmark:
  class DownloadRunner (line 153) | class DownloadRunner(BaseRunner):
    method run (line 161) | def run(self, context: Context) -> pyperf.Benchmark:
  function main (line 188) | def main() -> None:

FILE: extras/profiling/run.py
  function call (line 60) | def call(*args, **kwargs):
  class Environment (line 65) | class Environment:
    method on_repo (line 73) | def on_repo(self) -> Generator[Tuple[Path, Dict[str, str]], None, None]:
  class HTTPieEnvironment (line 83) | class HTTPieEnvironment(Environment):
    method on_repo (line 89) | def on_repo(self) -> Generator[Path, None, None]:
  class LocalCommandEnvironment (line 140) | class LocalCommandEnvironment(Environment):
    method on_repo (line 144) | def on_repo(self) -> Generator[Path, None, None]:
  function dump_results (line 148) | def dump_results(
  function compare (line 168) | def compare(*args, directory: Path, min_speed: Optional[str] = None):
  function run (line 179) | def run(
  function main (line 223) | def main() -> None:

FILE: extras/scripts/generate_man_pages.py
  class ManPageBuilder (line 41) | class ManPageBuilder:
    method __init__ (line 42) | def __init__(self):
    method title_line (line 45) | def title_line(
    method set_name (line 57) | def set_name(self, program_name: str) -> None:
    method write (line 61) | def write(self, text: str, *, bold: bool = False) -> None:
    method separate (line 66) | def separate(self) -> None:
    method format_desc (line 69) | def format_desc(self, desc: str) -> str:
    method add_comment (line 78) | def add_comment(self, comment: str) -> None:
    method add_options (line 81) | def add_options(self, options: Iterable[str], *, metavar: Optional[str...
    method build (line 87) | def build(self) -> str:
    method section (line 91) | def section(self, section_name: str) -> Iterator[None]:
    method underline (line 97) | def underline(self, text: str) -> str:
    method boldify (line 100) | def boldify(self, text: str) -> str:
  function _escape_and_dedent (line 104) | def _escape_and_dedent(text: str) -> str:
  function to_man_page (line 116) | def to_man_page(program_name: str, spec: ParserSpec, *, is_top_level_cmd...
  function main (line 177) | def main() -> None:

FILE: httpie/__main__.py
  function main (line 6) | def main():

FILE: httpie/adapters.py
  class HTTPieHTTPAdapter (line 5) | class HTTPieHTTPAdapter(HTTPAdapter):
    method build_response (line 7) | def build_response(self, req, resp):

FILE: httpie/cli/argparser.py
  class HTTPieHelpFormatter (line 32) | class HTTPieHelpFormatter(RawDescriptionHelpFormatter):
    method __init__ (line 42) | def __init__(self, max_help_position=6, *args, **kwargs):
    method _split_lines (line 47) | def _split_lines(self, text, width):
    method add_usage (line 51) | def add_usage(self, usage, actions, groups, prefix=None):
  class BaseHTTPieArgumentParser (line 81) | class BaseHTTPieArgumentParser(argparse.ArgumentParser):
    method __init__ (line 82) | def __init__(self, *args, **kwargs):
    method parse_args (line 90) | def parse_args(
    method _print_message (line 109) | def _print_message(self, message, file=None):
  class HTTPieManagerArgumentParser (line 128) | class HTTPieManagerArgumentParser(BaseHTTPieArgumentParser):
    method parse_known_args (line 129) | def parse_known_args(self, args=None, namespace=None):
  class HTTPieArgumentParser (line 138) | class HTTPieArgumentParser(BaseHTTPieArgumentParser):
    method __init__ (line 146) | def __init__(self, *args, formatter_class=HTTPieHelpFormatter, **kwargs):
    method parse_args (line 151) | def parse_args(
    method _process_request_type (line 196) | def _process_request_type(self):
    method _process_url (line 205) | def _process_url(self):
    method _setup_standard_streams (line 227) | def _setup_standard_streams(self):
    method _process_ssl_cert (line 269) | def _process_ssl_cert(self):
    method _process_auth (line 282) | def _process_auth(self):
    method _apply_no_options (line 357) | def _apply_no_options(self, no_options):
    method _body_from_file (line 382) | def _body_from_file(self, fd):
    method _body_from_input (line 391) | def _body_from_input(self, data):
    method _ensure_one_data_source (line 399) | def _ensure_one_data_source(self, *other_sources):
    method _guess_method (line 409) | def _guess_method(self):
    method _parse_items (line 448) | def _parse_items(self):
    method _process_output_options (line 492) | def _process_output_options(self):
    method _process_pretty_options (line 531) | def _process_pretty_options(self):
    method _process_download_options (line 542) | def _process_download_options(self):
    method _process_format_options (line 554) | def _process_format_options(self):
    method print_manual (line 561) | def print_manual(self):
    method print_usage (line 575) | def print_usage(self, file):
    method error (line 598) | def error(self, message):

FILE: httpie/cli/argtypes.py
  class KeyValueArg (line 12) | class KeyValueArg:
    method __init__ (line 15) | def __init__(self, key: str, value: Optional[str], sep: str, orig: str):
    method __eq__ (line 21) | def __eq__(self, other: 'KeyValueArg'):
    method __repr__ (line 24) | def __repr__(self):
  class SessionNameValidator (line 28) | class SessionNameValidator:
    method __init__ (line 30) | def __init__(self, error_message: str):
    method __call__ (line 33) | def __call__(self, value: str) -> str:
  class Escaped (line 41) | class Escaped(str):
    method __repr__ (line 44) | def __repr__(self):
  class KeyValueArgType (line 48) | class KeyValueArgType:
    method __init__ (line 58) | def __init__(self, *separators: str):
    method __call__ (line 64) | def __call__(self, s: str) -> KeyValueArg:
    method tokenize (line 110) | def tokenize(self, s: str) -> List[Union[str, Escaped]]:
  class PromptMixin (line 133) | class PromptMixin:
    method _prompt_password (line 134) | def _prompt_password(self, prompt: str) -> str:
    method _getpass (line 143) | def _getpass(prompt):
  class SSLCredentials (line 148) | class SSLCredentials(PromptMixin):
    method __init__ (line 151) | def __init__(self, value: Optional[str]) -> None:
    method prompt_password (line 154) | def prompt_password(self, key_file: str) -> None:
  class AuthCredentials (line 158) | class AuthCredentials(KeyValueArg, PromptMixin):
    method has_password (line 161) | def has_password(self) -> bool:
    method prompt_password (line 164) | def prompt_password(self, host: str) -> None:
  class AuthCredentialsArgType (line 168) | class AuthCredentialsArgType(KeyValueArgType):
    method __call__ (line 173) | def __call__(self, s):
  function readable_file_arg (line 194) | def readable_file_arg(filename):
  function parse_format_options (line 202) | def parse_format_options(s: str, defaults: Optional[dict]) -> dict:
  function response_charset_type (line 262) | def response_charset_type(encoding: str) -> str:
  function response_mime_type (line 271) | def response_mime_type(mime_type: str) -> str:

FILE: httpie/cli/constants.py
  class PrettyOptions (line 96) | class PrettyOptions(enum.Enum):
  class RequestType (line 131) | class RequestType(enum.Enum):

FILE: httpie/cli/definition.py
  function format_style_help (line 249) | def format_style_help(available_styles, *, isolation_mode: bool = False):
  function format_auth_help (line 626) | def format_auth_help(auth_plugins_mapping, *, isolation_mode: bool = Fal...

FILE: httpie/cli/dicts.py
  class BaseMultiDict (line 6) | class BaseMultiDict(MultiDict):
  class HTTPHeadersDict (line 12) | class HTTPHeadersDict(CIMultiDict, BaseMultiDict):
    method add (line 18) | def add(self, key, value):
    method remove_item (line 38) | def remove_item(self, key, value):
  class RequestJSONDataDict (line 49) | class RequestJSONDataDict(OrderedDict):
  class MultiValueOrderedDict (line 53) | class MultiValueOrderedDict(OrderedDict):
    method __setitem__ (line 56) | def __setitem__(self, key, value):
    method items (line 73) | def items(self):
  class RequestQueryParamsDict (line 81) | class RequestQueryParamsDict(MultiValueOrderedDict):
  class RequestDataDict (line 85) | class RequestDataDict(MultiValueOrderedDict):
  class MultipartRequestDataDict (line 89) | class MultipartRequestDataDict(MultiValueOrderedDict):
  class RequestFilesDict (line 93) | class RequestFilesDict(RequestDataDict):

FILE: httpie/cli/exceptions.py
  class ParseError (line 1) | class ParseError(Exception):

FILE: httpie/cli/nested_json/errors.py
  class NestedJSONSyntaxError (line 6) | class NestedJSONSyntaxError(ValueError):
    method __init__ (line 7) | def __init__(
    method __str__ (line 19) | def __str__(self):

FILE: httpie/cli/nested_json/interpret.py
  function interpret_nested_json (line 23) | def interpret_nested_json(pairs: Iterable[Tuple[str, str]]) -> dict:
  function interpret (line 30) | def interpret(context: Any, key: str, value: Any) -> Any:
  function wrap_with_dict (line 107) | def wrap_with_dict(context):
  function unwrap_top_level_list_if_needed (line 119) | def unwrap_top_level_list_if_needed(data: dict):

FILE: httpie/cli/nested_json/parse.py
  function parse (line 23) | def parse(source: str) -> Iterator[Path]:
  function tokenize (line 127) | def tokenize(source: str) -> Iterator[Token]:
  function check_escaped_int (line 181) | def check_escaped_int(value: str) -> str:
  function assert_cant_happen (line 192) | def assert_cant_happen():

FILE: httpie/cli/nested_json/tokens.py
  class TokenKind (line 11) | class TokenKind(Enum):
    method to_name (line 18) | def to_name(self) -> str:
  class Token (line 37) | class Token(NamedTuple):
  class PathAction (line 44) | class PathAction(Enum):
    method to_string (line 51) | def to_string(self) -> str:
  class Path (line 55) | class Path:
    method __init__ (line 56) | def __init__(
    method reconstruct (line 68) | def reconstruct(self) -> str:
  class NestedJSONArray (line 79) | class NestedJSONArray(list):

FILE: httpie/cli/options.py
  class Qualifiers (line 12) | class Qualifiers(Enum):
  function map_qualifiers (line 19) | def map_qualifiers(
  function drop_keys (line 28) | def drop_keys(
  class ParserSpec (line 42) | class ParserSpec:
    method finalize (line 50) | def finalize(self) -> 'ParserSpec':
    method add_group (line 59) | def add_group(self, name: str, **kwargs) -> 'Group':
    method serialize (line 64) | def serialize(self) -> Dict[str, Any]:
  class Group (line 73) | class Group:
    method finalize (line 79) | def finalize(self) -> None:
    method add_argument (line 83) | def add_argument(self, *args, **kwargs):
    method serialize (line 89) | def serialize(self) -> Dict[str, Any]:
  class Argument (line 98) | class Argument(typing.NamedTuple):
    method post_init (line 102) | def post_init(self):
    method serialize (line 113) | def serialize(self, *, isolation_mode: bool = False) -> Dict[str, Any]:
    method is_positional (line 168) | def is_positional(self):
    method is_hidden (line 172) | def is_hidden(self):
    method __getattr__ (line 175) | def __getattr__(self, attribute_name):
  function to_argparse (line 193) | def to_argparse(
  function to_data (line 238) | def to_data(abstract_options: ParserSpec) -> Dict[str, Any]:
  function parser_to_parser_spec (line 242) | def parser_to_parser_spec(parser: argparse.ArgumentParser, **kwargs) -> ...

FILE: httpie/cli/requestitems.py
  class RequestItems (line 24) | class RequestItems:
    method __init__ (line 26) | def __init__(self, request_type: Optional[RequestType] = None):
    method from_args (line 37) | def from_args(
  function process_header_arg (line 126) | def process_header_arg(arg: KeyValueArg) -> Optional[str]:
  function process_embed_header_arg (line 130) | def process_embed_header_arg(arg: KeyValueArg) -> str:
  function process_empty_header_arg (line 134) | def process_empty_header_arg(arg: KeyValueArg) -> str:
  function process_query_param_arg (line 142) | def process_query_param_arg(arg: KeyValueArg) -> str:
  function process_embed_query_param_arg (line 146) | def process_embed_query_param_arg(arg: KeyValueArg) -> str:
  function process_file_upload_arg (line 150) | def process_file_upload_arg(arg: KeyValueArg) -> Tuple[str, IO, str]:
  function convert_json_value_to_form_if_needed (line 165) | def convert_json_value_to_form_if_needed(in_json_mode: bool, processor: ...
  function process_data_item_arg (line 189) | def process_data_item_arg(arg: KeyValueArg) -> str:
  function process_data_embed_file_contents_arg (line 193) | def process_data_embed_file_contents_arg(arg: KeyValueArg) -> str:
  function process_data_embed_raw_json_file_arg (line 197) | def process_data_embed_raw_json_file_arg(arg: KeyValueArg) -> JSONType:
  function process_data_raw_json_embed_arg (line 203) | def process_data_raw_json_embed_arg(arg: KeyValueArg) -> JSONType:
  function process_data_nested_json_embed_args (line 208) | def process_data_nested_json_embed_args(pairs) -> Dict[str, JSONType]:
  function load_text_file (line 212) | def load_text_file(item: KeyValueArg) -> str:
  function load_json (line 226) | def load_json(arg: KeyValueArg, contents: str) -> JSONType:

FILE: httpie/cli/utils.py
  class Manual (line 7) | class Manual(argparse.Action):
    method __init__ (line 8) | def __init__(
    method __call__ (line 23) | def __call__(self, parser, namespace, values, option_string=None):
  class LazyChoices (line 28) | class LazyChoices(argparse.Action, Generic[T]):
    method __init__ (line 29) | def __init__(
    method load (line 49) | def load(self) -> T:
    method help (line 57) | def help(self) -> str:
    method help (line 66) | def help(self, value: Any) -> None:
    method __contains__ (line 69) | def __contains__(self, item: Any) -> bool:
    method __iter__ (line 72) | def __iter__(self) -> Iterator[T]:
    method __call__ (line 78) | def __call__(self, parser, namespace, values, option_string=None):

FILE: httpie/client.py
  function collect_messages (line 43) | def collect_messages(
  function max_headers (line 145) | def max_headers(limit):
  function build_requests_session (line 156) | def build_requests_session(
  function dump_request (line 187) | def dump_request(kwargs: dict):
  function finalize_headers (line 192) | def finalize_headers(headers: HTTPHeadersDict) -> HTTPHeadersDict:
  function transform_headers (line 212) | def transform_headers(
  function apply_missing_repeated_headers (line 233) | def apply_missing_repeated_headers(
  function make_default_headers (line 263) | def make_default_headers(args: argparse.Namespace) -> HTTPHeadersDict:
  function make_send_kwargs (line 281) | def make_send_kwargs(args: argparse.Namespace) -> dict:
  function make_send_kwargs_mergeable_from_env (line 288) | def make_send_kwargs_mergeable_from_env(args: argparse.Namespace) -> dict:
  function json_dict_to_request_body (line 314) | def json_dict_to_request_body(data: Dict[str, Any]) -> str:
  function make_request_kwargs (line 325) | def make_request_kwargs(
  function ensure_path_as_is (line 377) | def ensure_path_as_is(orig_url: str, prepped_url: str) -> str:

FILE: httpie/compat.py
  class cached_property (line 25) | class cached_property:
    method func (line 38) | def func(instance):
    method __init__ (line 44) | def __init__(self, func, name=None):
    method __set_name__ (line 48) | def __set_name__(self, owner, name):
    method __get__ (line 58) | def __get__(self, instance, cls=None):
  function find_entry_points (line 79) | def find_entry_points(entry_points: Any, group: str) -> Iterable[importl...
  function get_dist_name (line 86) | def get_dist_name(entry_point: importlib_metadata.EntryPoint) -> Optiona...
  function ensure_default_certs_loaded (line 104) | def ensure_default_certs_loaded(ssl_context: SSLContext) -> None:

FILE: httpie/config.py
  function get_default_config_dir (line 20) | def get_default_config_dir() -> Path:
  class ConfigFileError (line 61) | class ConfigFileError(Exception):
  function read_raw_config (line 65) | def read_raw_config(config_type: str, path: Path) -> Dict[str, Any]:
  class BaseConfigDict (line 80) | class BaseConfigDict(dict):
    method __init__ (line 85) | def __init__(self, path: Path):
    method ensure_directory (line 89) | def ensure_directory(self):
    method is_new (line 92) | def is_new(self) -> bool:
    method pre_process_data (line 95) | def pre_process_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
    method post_process_data (line 99) | def post_process_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
    method load (line 103) | def load(self):
    method save (line 110) | def save(self, *, bump_version: bool = False):
    method version (line 131) | def version(self):
  class Config (line 137) | class Config(BaseConfigDict):
    method __init__ (line 143) | def __init__(self, directory: Union[str, Path] = DEFAULT_CONFIG_DIR):
    method default_options (line 149) | def default_options(self) -> list:
    method _configured_path (line 152) | def _configured_path(self, config_option: str, default: str) -> None:
    method plugins_dir (line 158) | def plugins_dir(self) -> Path:
    method version_info_file (line 162) | def version_info_file(self) -> Path:
    method developer_mode (line 166) | def developer_mode(self) -> bool:

FILE: httpie/context.py
  class LogLevel (line 27) | class LogLevel(str, Enum):
  class Environment (line 46) | class Environment:
    method __init__ (line 93) | def __init__(self, devnull=None, **kwargs):
    method __str__ (line 123) | def __str__(self):
    method __repr__ (line 134) | def __repr__(self):
    method config (line 140) | def config(self) -> Config:
    method devnull (line 152) | def devnull(self) -> IO:
    method as_silent (line 158) | def as_silent(self) -> Iterator[None]:
    method log_error (line 170) | def log_error(self, msg: str, level: LogLevel = LogLevel.ERROR) -> None:
    method apply_warnings_filter (line 184) | def apply_warnings_filter(self) -> None:
    method _make_rich_console (line 188) | def _make_rich_console(
    method rich_console (line 212) | def rich_console(self):
    method rich_error_console (line 216) | def rich_error_console(self):

FILE: httpie/cookies.py
  class HTTPieCookiePolicy (line 8) | class HTTPieCookiePolicy(cookiejar.DefaultCookiePolicy):
    method return_ok_secure (line 9) | def return_ok_secure(self, cookie, request):
    method _is_local_host (line 22) | def _is_local_host(self, hostname):

FILE: httpie/core.py
  function raw_main (line 32) | def raw_main(
  function main (line 146) | def main(
  function program (line 170) | def program(args: argparse.Namespace, env: Environment) -> ExitStatus:
  function print_debug_info (line 270) | def print_debug_info(env: Environment):
  function decode_raw_args (line 285) | def decode_raw_args(

FILE: httpie/downloads.py
  class ContentRangeError (line 23) | class ContentRangeError(ValueError):
  function parse_content_range (line 27) | def parse_content_range(content_range: str, resumed_from: int) -> int:
  function filename_from_content_disposition (line 85) | def filename_from_content_disposition(
  function filename_from_url (line 106) | def filename_from_url(url: str, content_type: Optional[str]) -> str:
  function trim_filename (line 126) | def trim_filename(filename: str, max_len: int) -> str:
  function get_filename_max_length (line 137) | def get_filename_max_length(directory: str) -> int:
  function trim_filename_if_needed (line 144) | def trim_filename_if_needed(filename: str, directory='.', extra=0) -> str:
  function get_unique_filename (line 151) | def get_unique_filename(filename: str, exists=os.path.exists) -> str:
  class Downloader (line 162) | class Downloader:
    method __init__ (line 164) | def __init__(
    method pre_request (line 186) | def pre_request(self, request_headers: dict):
    method start (line 202) | def start(
    method finish (line 262) | def finish(self):
    method failed (line 267) | def failed(self):
    method interrupted (line 271) | def interrupted(self) -> bool:
    method chunk_downloaded (line 278) | def chunk_downloaded(self, chunk: bytes):
    method _get_output_file_from_response (line 289) | def _get_output_file_from_response(
  class DownloadStatus (line 307) | class DownloadStatus:
    method __init__ (line 310) | def __init__(self, env):
    method started (line 318) | def started(self, output_file, resumed_from=0, total_size=None):
    method start_display (line 325) | def start_display(self, output_file):
    method chunk_downloaded (line 349) | def chunk_downloaded(self, size):
    method has_finished (line 355) | def has_finished(self):
    method time_spent (line 359) | def time_spent(self):
    method finished (line 368) | def finished(self):
    method terminate (line 375) | def terminate(self):

FILE: httpie/encoding.py
  function detect_encoding (line 11) | def detect_encoding(content: ContentBytes) -> str:
  function smart_decode (line 32) | def smart_decode(content: ContentBytes, encoding: str) -> Tuple[str, str]:
  function smart_encode (line 44) | def smart_encode(content: str, encoding: str) -> bytes:

FILE: httpie/internal/daemon_runner.py
  function _check_status (line 12) | def _check_status(env):
  function _parse_options (line 30) | def _parse_options(args: List[str]) -> argparse.Namespace:
  function is_daemon_mode (line 37) | def is_daemon_mode(args: List[str]) -> bool:
  function run_daemon_task (line 41) | def run_daemon_task(env: Environment, args: List[str]) -> ExitStatus:

FILE: httpie/internal/daemons.py
  function _start_process (line 22) | def _start_process(cmd: List[str], **kwargs) -> Popen:
  function _spawn_windows (line 32) | def _spawn_windows(cmd: List[str], process_context: ProcessContext) -> N...
  function _spawn_posix (line 55) | def _spawn_posix(args: List[str], process_context: ProcessContext) -> None:
  function _spawn (line 102) | def _spawn(args: List[str], process_context: ProcessContext) -> None:
  function spawn_daemon (line 112) | def spawn_daemon(task: str) -> None:

FILE: httpie/internal/update_warnings.py
  function _read_data_error_free (line 31) | def _read_data_error_free(file: Path) -> Any:
  function _fetch_updates (line 40) | def _fetch_updates(env: Environment) -> str:
  function fetch_updates (line 55) | def fetch_updates(env: Environment, lazy: bool = True):
  function maybe_fetch_updates (line 62) | def maybe_fetch_updates(env: Environment) -> None:
  function _get_suppress_context (line 78) | def _get_suppress_context(env: Environment) -> Any:
  function _update_checker (line 91) | def _update_checker(
  function _get_update_status (line 107) | def _get_update_status(env: Environment) -> Optional[str]:
  function get_update_status (line 136) | def get_update_status(env: Environment) -> str:
  function check_updates (line 141) | def check_updates(env: Environment) -> None:

FILE: httpie/legacy/v3_1_0_session_cookie_format.py
  function pre_process (line 36) | def pre_process(session: 'Session', cookies: Any) -> List[Dict[str, Any]]:
  function post_process (line 67) | def post_process(
  function fix_layout (line 84) | def fix_layout(session: 'Session', hostname: str, args: argparse.Namespa...

FILE: httpie/legacy/v3_2_0_session_header_format.py
  function pre_process (line 26) | def pre_process(session: 'Session', headers: Any) -> List[Dict[str, Any]]:
  function post_process (line 49) | def post_process(
  function fix_layout (line 67) | def fix_layout(session: 'Session', *args, **kwargs) -> None:

FILE: httpie/manager/__main__.py
  function is_http_command (line 12) | def is_http_command(args: List[Union[str, bytes]], env: Environment) -> ...
  function main (line 32) | def main(args: List[Union[str, bytes]] = sys.argv, env: Environment = En...
  function program (line 51) | def program():

FILE: httpie/manager/cli.py
  function missing_subcommand (line 95) | def missing_subcommand(*args) -> str:
  function generate_subparsers (line 105) | def generate_subparsers(root, parent_parser, definitions, spec):

FILE: httpie/manager/compat.py
  class PipError (line 10) | class PipError(Exception):
    method __init__ (line 13) | def __init__(self, stdout, stderr):
  function _discover_system_pip (line 18) | def _discover_system_pip() -> List[str]:
  function _run_pip_subprocess (line 45) | def _run_pip_subprocess(pip_executable: List[str], args: List[str]) -> b...
  function run_pip (line 62) | def run_pip(args: List[str]) -> bytes:

FILE: httpie/manager/core.py
  function dispatch_cli_task (line 26) | def dispatch_cli_task(env: Environment, action: Optional[str], args: arg...
  function program (line 33) | def program(args: argparse.Namespace, env: Environment) -> ExitStatus:

FILE: httpie/manager/tasks/check_updates.py
  function cli_check_updates (line 7) | def cli_check_updates(env: Environment, args: argparse.Namespace) -> Exi...

FILE: httpie/manager/tasks/export_args.py
  function cli_export_args (line 16) | def cli_export_args(env: Environment, args: argparse.Namespace) -> ExitS...

FILE: httpie/manager/tasks/plugins.py
  class PluginInstaller (line 21) | class PluginInstaller:
    method __init__ (line 23) | def __init__(self, env: Environment, debug: bool = False) -> None:
    method setup_plugins_dir (line 30) | def setup_plugins_dir(self) -> None:
    method fail (line 45) | def fail(
    method _install (line 60) | def _install(self, targets: List[str], mode='install') -> Tuple[
    method install (line 105) | def install(self, targets: List[str]) -> ExitStatus:
    method _clear_metadata (line 111) | def _clear_metadata(self, targets: List[str]) -> None:
    method upgrade (line 132) | def upgrade(self, targets: List[str]) -> ExitStatus:
    method _uninstall (line 148) | def _uninstall(self, target: str) -> Optional[ExitStatus]:
    method uninstall (line 184) | def uninstall(self, targets: List[str]) -> ExitStatus:
    method list (line 196) | def list(self) -> None:
    method run (line 217) | def run(
  function cli_plugins (line 240) | def cli_plugins(env: Environment, args: argparse.Namespace) -> ExitStatus:

FILE: httpie/manager/tasks/sessions.py
  function cli_sessions (line 17) | def cli_sessions(env: Environment, args: argparse.Namespace) -> ExitStatus:
  function upgrade_session (line 30) | def upgrade_session(env: Environment, args: argparse.Namespace, hostname...
  function cli_upgrade_session (line 63) | def cli_upgrade_session(env: Environment, args: argparse.Namespace) -> E...
  function cli_upgrade_all_sessions (line 72) | def cli_upgrade_all_sessions(env: Environment, args: argparse.Namespace)...

FILE: httpie/models.py
  class HTTPMessage (line 23) | class HTTPMessage:
    method __init__ (line 26) | def __init__(self, orig):
    method iter_body (line 29) | def iter_body(self, chunk_size: int) -> Iterable[bytes]:
    method iter_lines (line 33) | def iter_lines(self, chunk_size: int) -> Iterable[bytes]:
    method headers (line 38) | def headers(self) -> str:
    method metadata (line 43) | def metadata(self) -> str:
    method encoding (line 48) | def encoding(self) -> str:
    method content_type (line 53) | def content_type(self) -> str:
  class HTTPResponse (line 61) | class HTTPResponse(HTTPMessage):
    method iter_body (line 64) | def iter_body(self, chunk_size=1):
    method iter_lines (line 67) | def iter_lines(self, chunk_size):
    method headers (line 71) | def headers(self):
    method metadata (line 89) | def metadata(self) -> str:
    method version (line 104) | def version(self) -> str:
  class HTTPRequest (line 130) | class HTTPRequest(HTTPMessage):
    method iter_body (line 133) | def iter_body(self, chunk_size):
    method iter_lines (line 136) | def iter_lines(self, chunk_size):
    method headers (line 140) | def headers(self):
    method body (line 164) | def body(self):
  class RequestsMessageKind (line 175) | class RequestsMessageKind(Enum):
  function infer_requests_message_kind (line 180) | def infer_requests_message_kind(message: RequestsMessage) -> RequestsMes...
  class OutputOptions (line 202) | class OutputOptions(NamedTuple):
    method any (line 208) | def any(self):
    method from_message (line 216) | def from_message(

FILE: httpie/output/formatters/colors.py
  function get_available_styles (line 36) | def get_available_styles():
  class ColorFormatter (line 40) | class ColorFormatter(FormatterPlugin):
    method __init__ (line 51) | def __init__(
    method format_headers (line 81) | def format_headers(self, headers: str) -> str:
    method format_body (line 88) | def format_body(self, body: str, mime: str) -> str:
    method format_metadata (line 98) | def format_metadata(self, metadata: str) -> str:
    method get_lexer_for_body (line 105) | def get_lexer_for_body(
    method get_formatters (line 115) | def get_formatters(self, color_scheme: str) -> Tuple[
    method get_style_class (line 135) | def get_style_class(color_scheme: str) -> Type[pygments.style.Style]:
  function get_lexer (line 142) | def get_lexer(
  class Solarized256Style (line 197) | class Solarized256Style(pygments.style.Style):
  function make_style (line 354) | def make_style(name, raw_styles, shade):
  function make_styles (line 371) | def make_styles():

FILE: httpie/output/formatters/headers.py
  class HeadersFormatter (line 4) | class HeadersFormatter(FormatterPlugin):
    method __init__ (line 6) | def __init__(self, **kwargs):
    method format_headers (line 10) | def format_headers(self, headers: str) -> str:

FILE: httpie/output/formatters/json.py
  class JSONFormatter (line 6) | class JSONFormatter(FormatterPlugin):
    method __init__ (line 8) | def __init__(self, **kwargs):
    method format_body (line 12) | def format_body(self, body: str, mime: str) -> str:

FILE: httpie/output/formatters/xml.py
  function parse_xml (line 14) | def parse_xml(data: str) -> 'Document':
  function parse_declaration (line 20) | def parse_declaration(raw_body: str) -> Optional[str]:
  function pretty_xml (line 29) | def pretty_xml(document: 'Document',
  class XMLFormatter (line 53) | class XMLFormatter(FormatterPlugin):
    method __init__ (line 55) | def __init__(self, **kwargs):
    method format_body (line 59) | def format_body(self, body: str, mime: str):

FILE: httpie/output/lexers/common.py
  function precise (line 1) | def precise(lexer, precise_token, parent_token):

FILE: httpie/output/lexers/http.py
  function http_response_type (line 25) | def http_response_type(lexer, match, ctx):
  function request_method (line 45) | def request_method(lexer, match, ctx):
  class SimplifiedHTTPLexer (line 54) | class SimplifiedHTTPLexer(pygments.lexer.RegexLexer):

FILE: httpie/output/lexers/json.py
  class EnhancedJsonLexer (line 11) | class EnhancedJsonLexer(RegexLexer):

FILE: httpie/output/lexers/metadata.py
  function speed_based_token (line 13) | def speed_based_token(lexer, match, ctx):
  class MetadataLexer (line 33) | class MetadataLexer(pygments.lexer.RegexLexer):

FILE: httpie/output/models.py
  class ProcessingOptions (line 10) | class ProcessingOptions(NamedTuple):
    method get_prettify (line 28) | def get_prettify(self, env: Environment) -> List[str]:
    method from_raw_args (line 35) | def from_raw_args(cls, options: argparse.Namespace) -> 'ProcessingOpti...
    method show_traceback (line 43) | def show_traceback(self):

FILE: httpie/output/processing.py
  function is_valid_mime (line 12) | def is_valid_mime(mime):
  class Conversion (line 16) | class Conversion:
    method get_converter (line 19) | def get_converter(mime: str) -> Optional[ConverterPlugin]:
  class Formatting (line 26) | class Formatting:
    method __init__ (line 29) | def __init__(self, groups: List[str], env=Environment(), **kwargs):
    method format_headers (line 44) | def format_headers(self, headers: str) -> str:
    method format_body (line 49) | def format_body(self, content: str, mime: str) -> str:
    method format_metadata (line 55) | def format_metadata(self, metadata: str) -> str:

FILE: httpie/output/streams.py
  class DataSuppressedError (line 20) | class DataSuppressedError(Exception):
  class BinarySuppressedError (line 24) | class BinarySuppressedError(DataSuppressedError):
  class BaseStream (line 30) | class BaseStream(metaclass=ABCMeta):
    method __init__ (line 33) | def __init__(
    method get_headers (line 51) | def get_headers(self) -> bytes:
    method get_metadata (line 55) | def get_metadata(self) -> bytes:
    method iter_body (line 60) | def iter_body(self) -> Iterable[bytes]:
    method __iter__ (line 63) | def __iter__(self) -> Iterable[bytes]:
  class RawStream (line 88) | class RawStream(BaseStream):
    method __init__ (line 94) | def __init__(self, chunk_size=CHUNK_SIZE, **kwargs):
    method iter_body (line 98) | def iter_body(self) -> Iterable[bytes]:
  class EncodedStream (line 105) | class EncodedStream(BaseStream):
    method __init__ (line 115) | def __init__(
    method iter_body (line 138) | def iter_body(self) -> Iterable[bytes]:
    method decode_chunk (line 145) | def decode_chunk(self, raw_chunk: str) -> str:
    method encoding (line 151) | def encoding(self) -> Optional[str]:
    method encoding (line 166) | def encoding(self, value) -> None:
  class PrettyStream (line 170) | class PrettyStream(EncodedStream):
    method __init__ (line 181) | def __init__(
    method get_headers (line 190) | def get_headers(self) -> bytes:
    method get_metadata (line 194) | def get_metadata(self) -> bytes:
    method iter_body (line 198) | def iter_body(self) -> Iterable[bytes]:
    method process_body (line 219) | def process_body(self, chunk: Union[str, bytes]) -> bytes:
  class BufferedPrettyStream (line 228) | class BufferedPrettyStream(PrettyStream):
    method iter_body (line 238) | def iter_body(self) -> Iterable[bytes]:

FILE: httpie/output/ui/man_pages.py
  function is_available (line 16) | def is_available(program: str) -> bool:
  function display_for (line 39) | def display_for(env: Environment, program: str) -> None:

FILE: httpie/output/ui/palette.py
  class Styles (line 11) | class Styles(Enum):
  class PieStyle (line 16) | class PieStyle(str, Enum):
  class ColorString (line 32) | class ColorString(str):
    method __or__ (line 33) | def __or__(self, other: str) -> 'ColorString':
  class PieColor (line 55) | class PieColor(ColorString, Enum):
  class GenericColor (line 74) | class GenericColor(Enum):
    method apply_style (line 91) | def apply_style(
  class _StyledGenericColor (line 105) | class _StyledGenericColor:
  function boldify (line 255) | def boldify(color: PieColor) -> str:
  function get_color (line 260) | def get_color(

FILE: httpie/output/ui/rich_help.py
  class OptionsHighlighter (line 44) | class OptionsHighlighter(RegexHighlighter):
  function unpack_argument (line 54) | def unpack_argument(
  function to_usage (line 72) | def to_usage(
  function to_help_message (line 128) | def to_help_message(

FILE: httpie/output/ui/rich_palette.py
  class _GenericColorCaster (line 26) | class _GenericColorCaster(dict):
    method _translate (line 32) | def _translate(self, key: Any) -> Any:
    method __getitem__ (line 38) | def __getitem__(self, key: Any) -> Any:
    method get (line 41) | def get(self, key: Any) -> Any:
  function _make_rich_color_theme (line 45) | def _make_rich_color_theme(style_name: Optional[str] = None) -> 'Theme':

FILE: httpie/output/ui/rich_progress.py
  class BaseDisplay (line 11) | class BaseDisplay:
    method start (line 14) | def start(
    method update (line 19) | def update(self, steps: float) -> None:
    method stop (line 22) | def stop(self, time_spent: float) -> None:
    method console (line 26) | def console(self) -> 'Console':
    method _print_summary (line 30) | def _print_summary(
  class DummyDisplay (line 55) | class DummyDisplay(BaseDisplay):
  class StatusDisplay (line 62) | class StatusDisplay(BaseDisplay):
    method start (line 63) | def start(
    method update (line 74) | def update(self, steps: float) -> None:
    method stop (line 86) | def stop(self, time_spent: float) -> None:
  class ProgressDisplay (line 97) | class ProgressDisplay(BaseDisplay):
    method start (line 98) | def start(
    method update (line 129) | def update(self, steps: float) -> None:
    method stop (line 132) | def stop(self, time_spent: Optional[float]) -> None:

FILE: httpie/output/ui/rich_utils.py
  function render_as_string (line 12) | def render_as_string(renderable: RenderableType) -> str:
  function enable_highlighter (line 23) | def enable_highlighter(

FILE: httpie/output/utils.py
  function load_prefixed_json (line 9) | def load_prefixed_json(data: str) -> Tuple[str, json.JSONDecoder]:
  function parse_prefixed_json (line 27) | def parse_prefixed_json(data: str) -> Tuple[str, str]:

FILE: httpie/output/writer.py
  function write_message (line 27) | def write_message(
  function write_stream (line 61) | def write_stream(
  function write_stream_with_colors_win (line 79) | def write_stream_with_colors_win(
  function write_raw_data (line 100) | def write_raw_data(
  function build_output_stream_for_message (line 122) | def build_output_stream_for_message(
  function get_stream_type_and_kwargs (line 153) | def get_stream_type_and_kwargs(

FILE: httpie/plugins/base.py
  class BasePlugin (line 4) | class BasePlugin:
  class AuthPlugin (line 16) | class AuthPlugin(BasePlugin):
    method get_auth (line 58) | def get_auth(self, username: str = None, password: str = None):
  class TransportPlugin (line 72) | class TransportPlugin(BasePlugin):
    method get_adapter (line 87) | def get_adapter(self):
  class ConverterPlugin (line 96) | class ConverterPlugin(BasePlugin):
    method __init__ (line 106) | def __init__(self, mime: str):
    method convert (line 109) | def convert(self, body: bytes) -> Tuple[str, str]:
    method supports (line 120) | def supports(cls, mime: str) -> bool:
  class FormatterPlugin (line 124) | class FormatterPlugin(BasePlugin):
    method __init__ (line 131) | def __init__(self, **kwargs):
    method format_headers (line 142) | def format_headers(self, headers: str) -> str:
    method format_body (line 150) | def format_body(self, content: str, mime: str) -> str:
    method format_metadata (line 159) | def format_metadata(self, metadata: str) -> str:

FILE: httpie/plugins/builtin.py
  class BuiltinAuthPlugin (line 9) | class BuiltinAuthPlugin(AuthPlugin):
  class HTTPBasicAuth (line 13) | class HTTPBasicAuth(requests.auth.HTTPBasicAuth):
    method __call__ (line 15) | def __call__(
    method make_header (line 31) | def make_header(username: str, password: str) -> str:
  class HTTPBearerAuth (line 37) | class HTTPBearerAuth(requests.auth.AuthBase):
    method __init__ (line 39) | def __init__(self, token: str) -> None:
    method __call__ (line 42) | def __call__(self, request: requests.PreparedRequest) -> requests.Prep...
  class BasicAuthPlugin (line 47) | class BasicAuthPlugin(BuiltinAuthPlugin):
    method get_auth (line 53) | def get_auth(self, username: str, password: str) -> HTTPBasicAuth:
  class DigestAuthPlugin (line 57) | class DigestAuthPlugin(BuiltinAuthPlugin):
    method get_auth (line 63) | def get_auth(
  class BearerAuthPlugin (line 71) | class BearerAuthPlugin(BuiltinAuthPlugin):
    method get_auth (line 78) | def get_auth(self, **kwargs) -> requests.auth.HTTPDigestAuth:

FILE: httpie/plugins/manager.py
  function _load_directories (line 28) | def _load_directories(site_dirs: Iterable[Path]) -> Iterator[None]:
  function enable_plugins (line 41) | def enable_plugins(plugins_dir: Optional[Path]) -> ContextManager[None]:
  class PluginManager (line 48) | class PluginManager(list):
    method register (line 49) | def register(self, *plugins: Type[BasePlugin]):
    method unregister (line 53) | def unregister(self, plugin: Type[BasePlugin]):
    method filter (line 56) | def filter(self, by_type=Type[BasePlugin]):
    method iter_entry_points (line 59) | def iter_entry_points(self, directory: Optional[Path] = None):
    method load_installed_plugins (line 66) | def load_installed_plugins(self, directory: Optional[Path] = None):
    method get_auth_plugins (line 83) | def get_auth_plugins(self) -> List[Type[AuthPlugin]]:
    method get_auth_plugin_mapping (line 86) | def get_auth_plugin_mapping(self) -> Dict[str, Type[AuthPlugin]]:
    method get_auth_plugin (line 91) | def get_auth_plugin(self, auth_type: str) -> Type[AuthPlugin]:
    method get_formatters (line 95) | def get_formatters(self) -> List[Type[FormatterPlugin]]:
    method get_formatters_grouped (line 98) | def get_formatters_grouped(self) -> Dict[str, List[Type[FormatterPlugi...
    method get_converters (line 105) | def get_converters(self) -> List[Type[ConverterPlugin]]:
    method get_transport_plugins (line 109) | def get_transport_plugins(self) -> List[Type[TransportPlugin]]:
    method __str__ (line 112) | def __str__(self):
    method __repr__ (line 120) | def __repr__(self):

FILE: httpie/sessions.py
  function is_anonymous_session (line 42) | def is_anonymous_session(session_name: str) -> bool:
  function session_hostname_to_dirname (line 46) | def session_hostname_to_dirname(hostname: str, session_name: str) -> str:
  function strip_port (line 56) | def strip_port(hostname: str) -> str:
  function materialize_cookie (line 60) | def materialize_cookie(cookie: Cookie) -> Dict[str, Any]:
  function materialize_cookies (line 75) | def materialize_cookies(jar: RequestsCookieJar) -> List[Dict[str, Any]]:
  function materialize_headers (line 82) | def materialize_headers(headers: Dict[str, str]) -> List[Dict[str, Any]]:
  function get_httpie_session (line 92) | def get_httpie_session(
  class Session (line 124) | class Session(BaseConfigDict):
    method __init__ (line 128) | def __init__(
    method _add_cookies (line 158) | def _add_cookies(self, cookies: List[Dict[str, Any]]) -> None:
    method pre_process_data (line 170) | def pre_process_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
    method post_process_data (line 185) | def post_process_data(self, data: Dict[str, Any]) -> Dict[str, Any]:
    method _compute_new_headers (line 200) | def _compute_new_headers(self, request_headers: HTTPHeadersDict) -> HT...
    method update_headers (line 230) | def update_headers(self, request_headers: HTTPHeadersDict):
    method headers (line 251) | def headers(self) -> HTTPHeadersDict:
    method cookies (line 255) | def cookies(self) -> RequestsCookieJar:
    method cookies (line 260) | def cookies(self, jar: RequestsCookieJar):
    method remove_cookies (line 263) | def remove_cookies(self, cookies: List[Dict[str, str]]):
    method auth (line 273) | def auth(self) -> Optional[AuthBase]:
    method auth (line 302) | def auth(self, auth: dict):
    method is_anonymous (line 307) | def is_anonymous(self):
    method warn_legacy_usage (line 310) | def warn_legacy_usage(self, warning: str) -> None:

FILE: httpie/ssl_.py
  class HTTPieCertificate (line 29) | class HTTPieCertificate(NamedTuple):
    method to_raw_cert (line 34) | def to_raw_cert(self):
  class HTTPieHTTPSAdapter (line 40) | class HTTPieHTTPSAdapter(HTTPAdapter):
    method __init__ (line 41) | def __init__(
    method init_poolmanager (line 55) | def init_poolmanager(self, *args, **kwargs):
    method proxy_manager_for (line 59) | def proxy_manager_for(self, *args, **kwargs):
    method cert_verify (line 63) | def cert_verify(self, conn, url, verify, cert):
    method _create_ssl_context (line 71) | def _create_ssl_context(
    method get_default_ciphers_names (line 88) | def get_default_ciphers_names(cls):
  function _is_key_file_encrypted (line 92) | def _is_key_file_encrypted(key_file):

FILE: httpie/status.py
  class ExitStatus (line 5) | class ExitStatus(IntEnum):
  function http_status_to_exit_status (line 23) | def http_status_to_exit_status(http_status: int, follow=False) -> ExitSt...

FILE: httpie/uploads.py
  class ChunkedStream (line 20) | class ChunkedStream:
    method __iter__ (line 21) | def __iter__(self) -> Iterable[Union[str, bytes]]:
  class ChunkedUploadStream (line 25) | class ChunkedUploadStream(ChunkedStream):
    method __init__ (line 26) | def __init__(
    method __iter__ (line 36) | def __iter__(self) -> Iterable[Union[str, bytes]]:
  class ChunkedMultipartUploadStream (line 44) | class ChunkedMultipartUploadStream(ChunkedStream):
    method __init__ (line 47) | def __init__(
    method __iter__ (line 55) | def __iter__(self) -> Iterable[Union[str, bytes]]:
  function as_bytes (line 65) | def as_bytes(data: Union[str, bytes]) -> bytes:
  function _wrap_function_with_callback (line 75) | def _wrap_function_with_callback(
  function is_stdin (line 87) | def is_stdin(file: IO) -> bool:
  function observe_stdin_for_data_thread (line 99) | def observe_stdin_for_data_thread(env: Environment, file: IO, read_event...
  function _read_file_with_selectors (line 130) | def _read_file_with_selectors(file: IO, read_event: threading.Event) -> ...
  function _prepare_file_for_upload (line 146) | def _prepare_file_for_upload(
  function prepare_request_body (line 191) | def prepare_request_body(
  function get_multipart_data_and_content_type (line 230) | def get_multipart_data_and_content_type(
  function compress_request (line 252) | def compress_request(

FILE: httpie/utils.py
  class JsonDictPreservingDuplicateKeys (line 27) | class JsonDictPreservingDuplicateKeys(OrderedDict):
    method __init__ (line 36) | def __init__(self, items: Items):
    method _ensure_items_used (line 40) | def _ensure_items_used(self) -> None:
    method items (line 65) | def items(self) -> Items:
  function load_json_preserve_order_and_dupe_keys (line 72) | def load_json_preserve_order_and_dupe_keys(s):
  function repr_dict (line 76) | def repr_dict(d: dict) -> str:
  function humanize_bytes (line 80) | def humanize_bytes(n, precision=2):
  class ExplicitNullAuth (line 124) | class ExplicitNullAuth(requests.auth.AuthBase):
    method __call__ (line 129) | def __call__(self, r):
  function get_content_type (line 133) | def get_content_type(filename):
  function split_cookies (line 143) | def split_cookies(cookies):
  function get_expired_cookies (line 156) | def get_expired_cookies(
  function _max_age_to_expires (line 188) | def _max_age_to_expires(cookies, now):
  function parse_content_type_header (line 203) | def parse_content_type_header(header):
  function as_site (line 221) | def as_site(path: Path, **extra_vars) -> Path:
  function get_site_paths (line 229) | def get_site_paths(path: Path) -> Iterable[Path]:
  function split_iterable (line 248) | def split_iterable(iterable: Iterable[T], key: Callable[[T], bool]) -> T...
  function unwrap_context (line 258) | def unwrap_context(exc: Exception) -> Optional[Exception]:
  function url_as_host (line 266) | def url_as_host(url: str) -> str:
  class LockFileError (line 270) | class LockFileError(ValueError):
  function open_with_lockfile (line 275) | def open_with_lockfile(file: Path, *args, **kwargs) -> Generator[IO[Any]...
  function is_version_greater (line 293) | def is_version_greater(version_1: str, version_2: str) -> bool:

FILE: tests/conftest.py
  function httpbin_add_ca_bundle (line 30) | def httpbin_add_ca_bundle(monkeypatch):
  function httpbin_secure_untrusted (line 41) | def httpbin_secure_untrusted(monkeypatch, httpbin_secure):
  function _httpbin_with_chunked_support_available (line 52) | def _httpbin_with_chunked_support_available():
  function httpbin_with_chunked_support (line 61) | def httpbin_with_chunked_support(_httpbin_with_chunked_support_available):
  function _remote_httpbin_available (line 68) | def _remote_httpbin_available():
  function remote_httpbin (line 77) | def remote_httpbin(_remote_httpbin_available):
  function pyopenssl_inject (line 84) | def pyopenssl_inject():

FILE: tests/fixtures/__init__.py
  function patharg (line 11) | def patharg(path):
  function read_session_file (line 58) | def read_session_file(session_file: Path, *, extra_variables: Optional[D...

FILE: tests/test_auth.py
  function test_basic_auth (line 13) | def test_basic_auth(httpbin_both):
  function test_digest_auth (line 21) | def test_digest_auth(httpbin_both, argument_name):
  function test_bearer_auth (line 33) | def test_bearer_auth(httpbin_both, token):
  function test_password_prompt (line 43) | def test_password_prompt(httpbin):
  function test_credentials_in_url (line 50) | def test_credentials_in_url(httpbin_both):
  function test_credentials_in_url_auth_flag_has_priority (line 58) | def test_credentials_in_url_auth_flag_has_priority(httpbin_both):
  function test_only_username_in_url (line 72) | def test_only_username_in_url(url):
  function test_missing_auth (line 83) | def test_missing_auth(httpbin):
  function test_netrc (line 94) | def test_netrc(httpbin_both):
  function test_ignore_netrc (line 104) | def test_ignore_netrc(httpbin_both):
  function test_ignore_netrc_together_with_auth (line 112) | def test_ignore_netrc_together_with_auth():
  function test_ignore_netrc_with_auth_type_resulting_in_missing_auth (line 120) | def test_ignore_netrc_with_auth_type_resulting_in_missing_auth(httpbin):
  function test_auth_plugin_netrc_parse (line 141) | def test_auth_plugin_netrc_parse(auth_type, endpoint, httpbin):
  function test_ignore_netrc_null_auth (line 150) | def test_ignore_netrc_null_auth():

FILE: tests/test_auth_plugins.py
  function basic_auth (line 20) | def basic_auth(header=BASIC_AUTH_HEADER_VALUE):
  function test_auth_plugin_parse_auth_false (line 29) | def test_auth_plugin_parse_auth_false(httpbin):
  function test_auth_plugin_require_auth_false (line 56) | def test_auth_plugin_require_auth_false(httpbin):
  function test_auth_plugin_require_auth_false_and_auth_provided (line 81) | def test_auth_plugin_require_auth_false_and_auth_provided(httpbin):
  function test_auth_plugin_prompt_password_false (line 110) | def test_auth_plugin_prompt_password_false(httpbin):

FILE: tests/test_binary.py
  class TestBinaryRequestData (line 9) | class TestBinaryRequestData:
    method test_binary_stdin (line 11) | def test_binary_stdin(self, httpbin):
    method test_binary_file_path (line 21) | def test_binary_file_path(self, httpbin):
    method test_binary_file_form (line 27) | def test_binary_file_form(self, httpbin):
  class TestBinaryResponseData (line 34) | class TestBinaryResponseData:
    method test_binary_suppresses_when_terminal (line 36) | def test_binary_suppresses_when_terminal(self, httpbin):
    method test_binary_suppresses_when_not_terminal_but_pretty (line 40) | def test_binary_suppresses_when_not_terminal_but_pretty(self, httpbin):
    method test_binary_included_and_correct_when_suitable (line 45) | def test_binary_included_and_correct_when_suitable(self, httpbin):

FILE: tests/test_cli.py
  class TestItemParsing (line 22) | class TestItemParsing:
    method test_invalid_items (line 25) | def test_invalid_items(self):
    method test_escape_separator (line 30) | def test_escape_separator(self):
    method test_backslash_before_non_special_character_does_not_escape (line 59) | def test_backslash_before_non_special_character_does_not_escape(
    method test_escape_longsep (line 66) | def test_escape_longsep(self):
    method test_valid_items (line 74) | def test_valid_items(self):
    method test_multiple_file_fields_with_same_field_name (line 130) | def test_multiple_file_fields_with_same_field_name(self):
    method test_multiple_text_fields_with_same_field_name (line 137) | def test_multiple_text_fields_with_same_field_name(self):
  class TestQuerystring (line 152) | class TestQuerystring:
    method test_query_string_params_in_url (line 153) | def test_query_string_params_in_url(self, httpbin):
    method test_query_string_params_items (line 161) | def test_query_string_params_items(self, httpbin):
    method test_query_string_params_in_url_and_items_with_duplicates (line 169) | def test_query_string_params_in_url_and_items_with_duplicates(self,
  function test_url_leading_colon_slash_slash (line 184) | def test_url_leading_colon_slash_slash(program_name, url_arg, parsed_url):
  function test_url_colon_slash_slash_only (line 190) | def test_url_colon_slash_slash_only():
  class TestLocalhostShorthand (line 195) | class TestLocalhostShorthand:
    method test_expand_localhost_shorthand (line 196) | def test_expand_localhost_shorthand(self):
    method test_expand_localhost_shorthand_with_slash (line 200) | def test_expand_localhost_shorthand_with_slash(self):
    method test_expand_localhost_shorthand_with_port (line 204) | def test_expand_localhost_shorthand_with_port(self):
    method test_expand_localhost_shorthand_with_path (line 208) | def test_expand_localhost_shorthand_with_path(self):
    method test_expand_localhost_shorthand_with_port_and_slash (line 212) | def test_expand_localhost_shorthand_with_port_and_slash(self):
    method test_expand_localhost_shorthand_with_port_and_path (line 216) | def test_expand_localhost_shorthand_with_port_and_path(self):
    method test_dont_expand_shorthand_ipv6_as_shorthand (line 220) | def test_dont_expand_shorthand_ipv6_as_shorthand(self):
    method test_dont_expand_longer_ipv6_as_shorthand (line 224) | def test_dont_expand_longer_ipv6_as_shorthand(self):
    method test_dont_expand_full_ipv6_as_shorthand (line 231) | def test_dont_expand_full_ipv6_as_shorthand(self):
  class TestArgumentParser (line 239) | class TestArgumentParser:
    method setup_method (line 241) | def setup_method(self, method):
    method test_guess_when_method_set_and_valid (line 244) | def test_guess_when_method_set_and_valid(self):
    method test_guess_when_method_not_set (line 256) | def test_guess_when_method_not_set(self):
    method test_guess_when_method_set_but_invalid_and_data_field (line 268) | def test_guess_when_method_set_but_invalid_and_data_field(self):
    method test_guess_when_method_set_but_invalid_and_header_field (line 285) | def test_guess_when_method_set_but_invalid_and_header_field(self):
    method test_guess_when_method_set_but_invalid_and_item_exists (line 302) | def test_guess_when_method_set_but_invalid_and_item_exists(self):
  class TestNoOptions (line 320) | class TestNoOptions:
    method test_valid_no_options (line 322) | def test_valid_no_options(self, httpbin):
    method test_invalid_no_options (line 326) | def test_invalid_no_options(self, httpbin):
  class TestStdin (line 334) | class TestStdin:
    method test_ignore_stdin (line 336) | def test_ignore_stdin(self, httpbin):
    method test_ignore_stdin_cannot_prompt_password (line 346) | def test_ignore_stdin_cannot_prompt_password(self, httpbin):
    method test_stdin_closed (line 352) | def test_stdin_closed(self, httpbin):
  class TestSchemes (line 357) | class TestSchemes:
    method test_invalid_custom_scheme (line 359) | def test_invalid_custom_scheme(self):
    method test_invalid_scheme_via_via_default_scheme (line 365) | def test_invalid_scheme_via_via_default_scheme(self):
    method test_default_scheme_option (line 371) | def test_default_scheme_option(self, httpbin_secure):
    method test_scheme_when_invoked_as_https (line 375) | def test_scheme_when_invoked_as_https(self, httpbin_secure):

FILE: tests/test_cli_ui.py
  function ignore_terminal_size (line 38) | def ignore_terminal_size(monkeypatch):
  function test_naked_invocation (line 63) | def test_naked_invocation(ignore_terminal_size, args, expected_msg):

FILE: tests/test_cli_utils.py
  function test_lazy_choices (line 7) | def test_lazy_choices():
  function test_lazy_choices_help (line 52) | def test_lazy_choices_help():

FILE: tests/test_compress.py
  function assert_decompressed_equal (line 19) | def assert_decompressed_equal(base64_compressed_data, expected_str):
  function test_cannot_combine_compress_with_chunked (line 31) | def test_cannot_combine_compress_with_chunked(httpbin):
  function test_cannot_combine_compress_with_multipart (line 38) | def test_cannot_combine_compress_with_multipart(httpbin):
  function test_compress_skip_negative_ratio (line 45) | def test_compress_skip_negative_ratio(httpbin_both):
  function test_compress_force_with_negative_ratio (line 56) | def test_compress_force_with_negative_ratio(httpbin_both):
  function test_compress_json (line 68) | def test_compress_json(httpbin_both):
  function test_compress_form (line 81) | def test_compress_form(httpbin_both):
  function test_compress_raw (line 95) | def test_compress_raw(httpbin_both):
  function test_compress_stdin (line 108) | def test_compress_stdin(httpbin_both):
  function test_compress_file (line 126) | def test_compress_file(httpbin_both):

FILE: tests/test_config.py
  function test_default_options (line 16) | def test_default_options(httpbin):
  function test_config_file_not_valid (line 26) | def test_config_file_not_valid(httpbin):
  function test_config_file_inaccessible (line 37) | def test_config_file_inaccessible(httpbin):
  function test_default_options_overwrite (line 50) | def test_default_options_overwrite(httpbin):
  function test_explicit_xdg_config_home (line 61) | def test_explicit_xdg_config_home(monkeypatch: MonkeyPatch, tmp_path: Pa...
  function test_default_xdg_config_home (line 72) | def test_default_xdg_config_home(monkeypatch: MonkeyPatch, tmp_path: Path):
  function test_legacy_config_dir (line 86) | def test_legacy_config_dir(monkeypatch: MonkeyPatch, tmp_path: Path):
  function test_custom_config_dir (line 95) | def test_custom_config_dir(monkeypatch: MonkeyPatch, tmp_path: Path):
  function test_windows_config_dir (line 102) | def test_windows_config_dir(monkeypatch: MonkeyPatch):

FILE: tests/test_cookie.py
  class TestIntegration (line 8) | class TestIntegration:
    method setup_mock_server (line 10) | def setup_mock_server(self, handler):
    method test_cookie_parser (line 22) | def test_cookie_parser(self):

FILE: tests/test_cookie_on_redirects.py
  function test_explicit_user_set_cookie (line 9) | def test_explicit_user_set_cookie(httpbin, target_httpbin, request):
  function test_explicit_user_set_cookie_in_session (line 25) | def test_explicit_user_set_cookie_in_session(tmp_path, httpbin, target_h...
  function test_saved_user_set_cookie_in_session (line 43) | def test_saved_user_set_cookie_in_session(tmp_path, httpbin, target_http...
  function test_explicit_user_set_headers (line 68) | def test_explicit_user_set_headers(httpbin, tmp_path, target_httpbin, se...
  function test_server_set_cookie_on_redirect_same_domain (line 91) | def test_server_set_cookie_on_redirect_same_domain(tmp_path, httpbin, se...
  function test_server_set_cookie_on_redirect_different_domain (line 108) | def test_server_set_cookie_on_redirect_different_domain(tmp_path, http_s...
  function test_saved_session_cookies_on_same_domain (line 129) | def test_saved_session_cookies_on_same_domain(tmp_path, httpbin):
  function test_saved_session_cookies_on_different_domain (line 144) | def test_saved_session_cookies_on_different_domain(tmp_path, httpbin, re...
  function test_saved_session_cookies_on_redirect (line 197) | def test_saved_session_cookies_on_redirect(
  function test_saved_session_cookie_pool (line 221) | def test_saved_session_cookie_pool(tmp_path, httpbin, remote_httpbin):

FILE: tests/test_defaults.py
  function test_default_headers_case_insensitive (line 12) | def test_default_headers_case_insensitive(httpbin):
  class TestImplicitHTTPMethod (line 28) | class TestImplicitHTTPMethod:
    method test_implicit_GET (line 29) | def test_implicit_GET(self, httpbin):
    method test_implicit_GET_with_headers (line 33) | def test_implicit_GET_with_headers(self, httpbin):
    method test_implicit_POST_json (line 38) | def test_implicit_POST_json(self, httpbin):
    method test_implicit_POST_form (line 43) | def test_implicit_POST_form(self, httpbin):
    method test_implicit_POST_raw (line 48) | def test_implicit_POST_raw(self, httpbin):
    method test_implicit_POST_stdin (line 53) | def test_implicit_POST_stdin(self, httpbin):
  class TestAutoContentTypeAndAcceptHeaders (line 62) | class TestAutoContentTypeAndAcceptHeaders:
    method test_GET_no_data_no_auto_headers (line 70) | def test_GET_no_data_no_auto_headers(self, httpbin):
    method test_POST_no_data_no_auto_headers (line 77) | def test_POST_no_data_no_auto_headers(self, httpbin):
    method test_POST_with_data_auto_JSON_headers (line 84) | def test_POST_with_data_auto_JSON_headers(self, httpbin):
    method test_GET_with_data_auto_JSON_headers (line 90) | def test_GET_with_data_auto_JSON_headers(self, httpbin):
    method test_POST_explicit_JSON_JSON_ACCEPT (line 97) | def test_POST_explicit_JSON_JSON_ACCEPT(self, httpbin):
    method test_GET_explicit_JSON_explicit_headers (line 105) | def test_GET_explicit_JSON_explicit_headers(self, httpbin):
    method test_POST_form_auto_Content_Type (line 113) | def test_POST_form_auto_Content_Type(self, httpbin):
    method test_POST_form_Content_Type_override (line 118) | def test_POST_form_Content_Type_override(self, httpbin):
    method test_print_only_body_when_stdout_redirected_by_default (line 124) | def test_print_only_body_when_stdout_redirected_by_default(self, httpb...
    method test_print_overridable_when_stdout_redirected (line 129) | def test_print_overridable_when_stdout_redirected(self, httpbin):

FILE: tests/test_downloads.py
  class Response (line 18) | class Response(requests.Response):
    method __init__ (line 20) | def __init__(self, url, headers={}, status_code=200):
  class TestDownloadUtils (line 26) | class TestDownloadUtils:
    method test_Content_Range_parsing (line 28) | def test_Content_Range_parsing(self):
    method test_Content_Disposition_parsing (line 60) | def test_Content_Disposition_parsing(self, header, expected_filename):
    method test_filename_from_url (line 63) | def test_filename_from_url(self):
    method test_unique_filename (line 102) | def test_unique_filename(self, get_filename_max_length,
  class TestDownloads (line 123) | class TestDownloads:
    method test_actual_download (line 125) | def test_actual_download(self, httpbin_both, httpbin):
    method test_download_with_Content_Length (line 133) | def test_download_with_Content_Length(self, mock_env, httpbin_both):
    method test_download_no_Content_Length (line 150) | def test_download_no_Content_Length(self, mock_env, httpbin_both):
    method test_download_output_from_content_disposition (line 162) | def test_download_output_from_content_disposition(self, mock_env, http...
    method test_download_interrupted (line 190) | def test_download_interrupted(self, mock_env, httpbin_both):
    method test_download_resumed (line 204) | def test_download_resumed(self, mock_env, httpbin_both):
    method test_download_with_redirect_original_url_used_for_filename (line 250) | def test_download_with_redirect_original_url_used_for_filename(self, h...

FILE: tests/test_encoding.py
  function test_charset_text_pairs (line 23) | def test_charset_text_pairs():
  function test_unicode_headers (line 32) | def test_unicode_headers(httpbin):
  function test_unicode_headers_verbose (line 38) | def test_unicode_headers_verbose(httpbin):
  function test_unicode_raw (line 45) | def test_unicode_raw(httpbin):
  function test_unicode_raw_verbose (line 51) | def test_unicode_raw_verbose(httpbin):
  function test_unicode_form_item (line 58) | def test_unicode_form_item(httpbin):
  function test_unicode_form_item_verbose (line 64) | def test_unicode_form_item_verbose(httpbin):
  function test_unicode_json_item (line 71) | def test_unicode_json_item(httpbin):
  function test_unicode_json_item_verbose (line 77) | def test_unicode_json_item_verbose(httpbin):
  function test_unicode_raw_json_item (line 84) | def test_unicode_raw_json_item(httpbin):
  function test_unicode_raw_json_item_verbose (line 91) | def test_unicode_raw_json_item_verbose(httpbin):
  function test_unicode_url_query_arg_item (line 98) | def test_unicode_url_query_arg_item(httpbin):
  function test_unicode_url_query_arg_item_verbose (line 104) | def test_unicode_url_query_arg_item_verbose(httpbin):
  function test_unicode_url (line 110) | def test_unicode_url(httpbin):
  function test_unicode_url_verbose (line 116) | def test_unicode_url_verbose(httpbin):
  function test_unicode_basic_auth (line 122) | def test_unicode_basic_auth(httpbin):
  function test_unicode_digest_auth (line 129) | def test_unicode_digest_auth(httpbin):
  function test_terminal_output_response_charset_detection (line 139) | def test_terminal_output_response_charset_detection(text, charset):
  function test_terminal_output_response_content_type_charset (line 152) | def test_terminal_output_response_content_type_charset(charset, text):
  function test_terminal_output_response_content_type_charset_with_stream (line 166) | def test_terminal_output_response_content_type_charset_with_stream(chars...
  function test_terminal_output_response_charset_override (line 181) | def test_terminal_output_response_charset_override(charset, text, pretty):
  function test_terminal_output_request_content_type_charset (line 198) | def test_terminal_output_request_content_type_charset(charset, text):
  function test_terminal_output_request_charset_detection (line 212) | def test_terminal_output_request_charset_detection(charset, text):

FILE: tests/test_errors.py
  function test_error (line 13) | def test_error(program):
  function test_error_traceback (line 28) | def test_error_traceback(program):
  function test_error_custom_dns (line 41) | def test_error_custom_dns(program, error_code, expected_message):
  function test_max_headers_limit (line 51) | def test_max_headers_limit(httpbin_both):
  function test_max_headers_no_limit (line 57) | def test_max_headers_no_limit(httpbin_both):
  function test_response_charset_option_unknown_encoding (line 61) | def test_response_charset_option_unknown_encoding(httpbin_both):
  function test_response_mime_option_invalid_mime_type (line 70) | def test_response_mime_option_invalid_mime_type(httpbin_both):

FILE: tests/test_exit_status.py
  function test_keyboard_interrupt_during_arg_parsing_exit_status (line 7) | def test_keyboard_interrupt_during_arg_parsing_exit_status(httpbin):
  function test_keyboard_interrupt_in_program_exit_status (line 14) | def test_keyboard_interrupt_in_program_exit_status(httpbin):
  function test_ok_response_exits_0 (line 21) | def test_ok_response_exits_0(httpbin):
  function test_error_response_exits_0_without_check_status (line 27) | def test_error_response_exits_0_without_check_status(httpbin):
  function test_timeout_exit_status (line 34) | def test_timeout_exit_status(httpbin):
  function test_3xx_check_status_exits_3_and_stderr_when_stdout_redirected (line 41) | def test_3xx_check_status_exits_3_and_stderr_when_stdout_redirected(
  function test_3xx_check_status_redirects_allowed_exits_0 (line 52) | def test_3xx_check_status_redirects_allowed_exits_0(httpbin):
  function test_4xx_check_status_exits_4 (line 61) | def test_4xx_check_status_exits_4(httpbin):
  function test_5xx_check_status_exits_5 (line 70) | def test_5xx_check_status_exits_5(httpbin):

FILE: tests/test_httpie.py
  function test_main_entry_point (line 17) | def test_main_entry_point():
  function test_main_entry_point_keyboard_interrupt (line 24) | def test_main_entry_point_keyboard_interrupt(main):
  function test_debug (line 30) | def test_debug():
  function test_help (line 36) | def test_help():
  function test_version (line 42) | def test_version():
  function test_GET (line 48) | def test_GET(httpbin_both):
  function test_path_dot_normalization (line 53) | def test_path_dot_normalization():
  function test_path_as_is (line 62) | def test_path_as_is():
  function test_DELETE (line 72) | def test_DELETE(httpbin_both):
  function test_PUT (line 77) | def test_PUT(httpbin_both):
  function test_POST_JSON_data (line 83) | def test_POST_JSON_data(httpbin_both):
  function test_POST_form (line 89) | def test_POST_form(httpbin_both):
  function test_POST_form_multiple_values (line 95) | def test_POST_form_multiple_values(httpbin_both):
  function test_POST_raw (line 103) | def test_POST_raw(httpbin_both):
  function test_POST_stdin (line 109) | def test_POST_stdin(httpbin_both):
  function test_POST_file (line 119) | def test_POST_file(httpbin_both):
  function test_form_POST_file_redirected_stdin (line 125) | def test_form_POST_file_redirected_stdin(httpbin):
  function test_raw_POST_key_values_supplied (line 146) | def test_raw_POST_key_values_supplied(httpbin):
  function test_raw_POST_redirected_stdin (line 159) | def test_raw_POST_redirected_stdin(httpbin):
  function test_headers (line 175) | def test_headers(httpbin_both):
  function test_headers_unset (line 182) | def test_headers_unset(httpbin_both):
  function test_unset_host_header (line 191) | def test_unset_host_header(httpbin_both):
  function test_unset_useragent_header (line 199) | def test_unset_useragent_header(httpbin_both):
  function test_headers_empty_value (line 207) | def test_headers_empty_value(httpbin_both):
  function test_headers_empty_value_with_value_gives_error (line 215) | def test_headers_empty_value_with_value_gives_error(httpbin):
  function test_headers_omit (line 220) | def test_headers_omit(httpbin_both):
  function test_headers_multiple_omit (line 225) | def test_headers_multiple_omit(httpbin_both):
  function test_headers_same_after_omit (line 233) | def test_headers_same_after_omit(httpbin_both):
  function test_headers_fully_omit (line 239) | def test_headers_fully_omit(httpbin_both):
  function test_headers_multiple_values (line 245) | def test_headers_multiple_values(httpbin_both):
  function test_headers_multiple_values_repeated (line 250) | def test_headers_multiple_values_repeated(httpbin_both):
  function test_headers_multiple_values_with_empty (line 270) | def test_headers_multiple_values_with_empty(httpbin_both, headers, expec...
  function test_headers_multiple_values_mixed (line 275) | def test_headers_multiple_values_mixed(httpbin_both):
  function test_headers_preserve_prepared_headers (line 282) | def test_headers_preserve_prepared_headers(httpbin_both):
  function test_headers_multiple_headers_representation (line 289) | def test_headers_multiple_headers_representation(httpbin_both, pretty):
  function test_response_headers_multiple (line 302) | def test_response_headers_multiple(http_server):
  function test_response_headers_multiple_repeated (line 308) | def test_response_headers_multiple_repeated(http_server):
  function test_response_headers_multiple_representation (line 316) | def test_response_headers_multiple_representation(http_server, pretty):
  function test_json_input_preserve_order (line 329) | def test_json_input_preserve_order(httpbin_both):
  function test_options_content_length_preservation (line 355) | def test_options_content_length_preservation(httpbin, extra_args, expect...
  function test_options_dropping_redundant_content_length (line 366) | def test_options_dropping_redundant_content_length(httpbin, method):

FILE: tests/test_httpie_cli.py
  function test_plugins_cli_error_message_without_args (line 15) | def test_plugins_cli_error_message_without_args():
  function test_plugins_cli_error_messages_with_example (line 33) | def test_plugins_cli_error_messages_with_example(example):
  function test_plugins_cli_error_messages_invalid_example (line 53) | def test_plugins_cli_error_messages_invalid_example(example):
  function test_httpie_sessions_upgrade (line 82) | def test_httpie_sessions_upgrade(tmp_path, old_session_file, new_session...
  function test_httpie_sessions_upgrade_on_non_existent_file (line 95) | def test_httpie_sessions_upgrade_on_non_existent_file(tmp_path):
  function test_httpie_sessions_upgrade_all (line 106) | def test_httpie_sessions_upgrade_all(tmp_path, mock_env, extra_args, ext...
  function test_cli_export (line 135) | def test_cli_export(load_func, extra_options):

FILE: tests/test_json.py
  function test_json_formatter_with_body_preceded_by_non_json_data (line 62) | def test_json_formatter_with_body_preceded_by_non_json_data(
  function test_duplicate_keys_support_from_response (line 95) | def test_duplicate_keys_support_from_response():
  function test_duplicate_keys_support_from_input_file (line 115) | def test_duplicate_keys_support_from_input_file():
  function test_simple_json_arguments_with_non_json (line 135) | def test_simple_json_arguments_with_non_json(httpbin, value):
  function test_complex_json_arguments_with_non_json (line 152) | def test_complex_json_arguments_with_non_json(httpbin, request_type, val...
  function test_nested_json_syntax (line 454) | def test_nested_json_syntax(input_json, expected_json, httpbin):
  function test_nested_json_errors (line 567) | def test_nested_json_errors(input_json, expected_error, httpbin):
  function test_nested_json_sparse_array (line 581) | def test_nested_json_sparse_array(httpbin_both):

FILE: tests/test_meta.py
  function test_meta_elapsed_time (line 8) | def test_meta_elapsed_time(httpbin):
  function test_meta_elapsed_time_colors (line 14) | def test_meta_elapsed_time_colors(httpbin, style):

FILE: tests/test_offline.py
  function test_offline (line 5) | def test_offline():
  function test_offline_raw (line 13) | def test_offline_raw():
  function test_offline_raw_empty_should_use_POST (line 24) | def test_offline_raw_empty_should_use_POST():
  function test_offline_form (line 34) | def test_offline_form():
  function test_offline_json (line 45) | def test_offline_json():
  function test_offline_multipart (line 55) | def test_offline_multipart():
  function test_offline_from_file (line 66) | def test_offline_from_file():
  function test_offline_chunked (line 76) | def test_offline_chunked():
  function test_offline_download (line 89) | def test_offline_download():

FILE: tests/test_output.py
  function test_output_option (line 33) | def test_output_option(tmp_path, httpbin, stdout_isatty):
  class TestQuietFlag (line 47) | class TestQuietFlag:
    method test_quiet (line 51) | def test_quiet(self, httpbin, quiet_flags):
    method test_quiet_with_check_status_non_zero (line 64) | def test_quiet_with_check_status_non_zero(self, httpbin):
    method test_quiet_with_check_status_non_zero_pipe (line 71) | def test_quiet_with_check_status_non_zero_pipe(self, httpbin):
    method test_quiet_quiet_with_check_status_non_zero (line 79) | def test_quiet_quiet_with_check_status_non_zero(self, httpbin):
    method test_quiet_quiet_with_check_status_non_zero_pipe (line 86) | def test_quiet_quiet_with_check_status_non_zero_pipe(self, httpbin):
    method test_quiet_on_python_warnings (line 102) | def test_quiet_on_python_warnings(self, test_patch, httpbin, flags, ex...
    method test_double_quiet_on_error (line 113) | def test_double_quiet_on_error(self, httpbin):
    method test_quiet_with_password_prompt (line 124) | def test_quiet_with_password_prompt(self, httpbin, quiet_flags):
    method test_quiet_with_explicit_output_options (line 148) | def test_quiet_with_explicit_output_options(self, httpbin, quiet_flags...
    method test_quiet_with_output_redirection (line 158) | def test_quiet_with_output_redirection(self, tmp_path, httpbin, quiet_...
  class TestVerboseFlag (line 188) | class TestVerboseFlag:
    method test_verbose (line 189) | def test_verbose(self, httpbin):
    method test_verbose_raw (line 195) | def test_verbose_raw(self, httpbin):
    method test_verbose_form (line 201) | def test_verbose_form(self, httpbin):
    method test_verbose_json (line 208) | def test_verbose_json(self, httpbin):
    method test_verbose_implies_all (line 214) | def test_verbose_implies_all(self, httpbin):
  class TestColors (line 222) | class TestColors:
    method test_get_lexer (line 242) | def test_get_lexer(self, mime, explicit_json, body, expected_lexer_name):
    method test_get_lexer_not_found (line 247) | def test_get_lexer_not_found(self):
  function test_ensure_contents_colored (line 257) | def test_ensure_contents_colored(httpbin, endpoint):
  function test_ensure_meta_is_colored (line 264) | def test_ensure_meta_is_colored(httpbin, style):
  function test_ensure_status_code_is_shown_on_all_themes (line 278) | def test_ensure_status_code_is_shown_on_all_themes(http_server, style, m...
  class TestPrettyOptions (line 288) | class TestPrettyOptions:
    method test_pretty_enabled_by_default (line 291) | def test_pretty_enabled_by_default(self, httpbin):
    method test_pretty_enabled_by_default_unless_stdout_redirected (line 296) | def test_pretty_enabled_by_default_unless_stdout_redirected(self, http...
    method test_force_pretty (line 300) | def test_force_pretty(self, httpbin):
    method test_force_ugly (line 305) | def test_force_ugly(self, httpbin):
    method test_subtype_based_pygments_lexer_match (line 309) | def test_subtype_based_pygments_lexer_match(self, httpbin):
    method test_colors_option (line 319) | def test_colors_option(self, httpbin):
    method test_format_option (line 328) | def test_format_option(self, httpbin):
  class TestLineEndings (line 338) | class TestLineEndings:
    method _validate_crlf (line 345) | def _validate_crlf(self, msg):
    method test_CRLF_headers_only (line 357) | def test_CRLF_headers_only(self, httpbin):
    method test_CRLF_ugly_response (line 362) | def test_CRLF_ugly_response(self, httpbin):
    method test_CRLF_formatted_response (line 366) | def test_CRLF_formatted_response(self, httpbin):
    method test_CRLF_ugly_request (line 371) | def test_CRLF_ugly_request(self, httpbin):
    method test_CRLF_formatted_request (line 375) | def test_CRLF_formatted_request(self, httpbin):
  class TestFormatOptions (line 380) | class TestFormatOptions:
    method test_header_formatting_options (line 381) | def test_header_formatting_options(self):
    method test_json_formatting_options (line 414) | def test_json_formatting_options(self, options: str, expected_json: str):
    method test_parse_format_options (line 432) | def test_parse_format_options(self, defaults, options_string, expected):
    method test_parse_format_options_errors (line 444) | def test_parse_format_options_errors(self, options_string, expected_er...
    method test_format_options_accumulation (line 594) | def test_format_options_accumulation(self, args, expected_format_optio...
  function test_response_mime_overwrite (line 603) | def test_response_mime_overwrite():
  function test_response_mime_overwrite_incorrect (line 622) | def test_response_mime_overwrite_incorrect():

FILE: tests/test_parser_schema.py
  function test_parser_serialization (line 4) | def test_parser_serialization():

FILE: tests/test_plugins_cli.py
  function test_plugins_installation (line 9) | def test_plugins_installation(httpie_plugins_success, interface, dummy_p...
  function test_plugin_installation_with_custom_config (line 19) | def test_plugin_installation_with_custom_config(httpie_plugins_success, ...
  function test_plugins_listing (line 33) | def test_plugins_listing(httpie_plugins_success, interface, dummy_plugin...
  function test_plugins_listing_multiple (line 43) | def test_plugins_listing_multiple(interface, httpie_plugins_success, dum...
  function test_plugins_uninstall (line 56) | def test_plugins_uninstall(interface, httpie_plugins_success, dummy_plug...
  function test_plugins_listing_after_uninstall (line 63) | def test_plugins_listing_after_uninstall(interface, httpie_plugins_succe...
  function test_plugins_uninstall_specific (line 72) | def test_plugins_uninstall_specific(interface, httpie_plugins_success):
  function test_plugins_installation_failed (line 86) | def test_plugins_installation_failed(httpie_plugins, interface):
  function test_plugins_uninstall_non_existent (line 95) | def test_plugins_uninstall_non_existent(httpie_plugins, interface):
  function test_plugins_double_uninstall (line 107) | def test_plugins_double_uninstall(httpie_plugins, httpie_plugins_success...
  function test_plugins_upgrade (line 123) | def test_plugins_upgrade(httpie_plugins, httpie_plugins_success, dummy_p...
  function test_broken_plugins (line 136) | def test_broken_plugins(httpie_plugins, httpie_plugins_success, dummy_pl...

FILE: tests/test_redirects.py
  function test_follow_all_redirects_shown (line 15) | def test_follow_all_redirects_shown(httpbin):
  function test_follow_without_all_redirects_hidden (line 23) | def test_follow_without_all_redirects_hidden(httpbin, follow_flag):
  function test_follow_output_options_used_for_redirects (line 30) | def test_follow_output_options_used_for_redirects(httpbin):
  function test_follow_all_output_options_used_for_redirects (line 36) | def test_follow_all_output_options_used_for_redirects(httpbin):
  function test_max_redirects (line 60) | def test_max_redirects(httpbin):
  function test_follow_redirect_with_repost (line 72) | def test_follow_redirect_with_repost(httpbin, status_code):
  function test_verbose_follow_redirect_with_repost (line 91) | def test_verbose_follow_redirect_with_repost(httpbin, status_code):

FILE: tests/test_regressions.py
  function test_Host_header_overwrite (line 9) | def test_Host_header_overwrite(httpbin):
  function test_output_devnull (line 23) | def test_output_devnull(httpbin):
  function test_verbose_redirected_stdout_separator (line 31) | def test_verbose_redirected_stdout_separator(httpbin):

FILE: tests/test_sessions.py
  class SessionTestBase (line 25) | class SessionTestBase:
    method start_session (line 27) | def start_session(self, httpbin):
    method teardown_method (line 31) | def teardown_method(self, method):
    method env (line 34) | def env(self):
  class CookieTestBase (line 46) | class CookieTestBase:
    method setup_method (line 47) | def setup_method(self, method):
    method teardown_method (line 63) | def teardown_method(self, method):
  class TestSessionFlow (line 67) | class TestSessionFlow(SessionTestBase):
    method start_session (line 73) | def start_session(self, httpbin):
    method test_session_created_and_reused (line 91) | def test_session_created_and_reused(self, httpbin):
    method test_session_update (line 101) | def test_session_update(self, httpbin):
    method test_session_read_only (line 124) | def test_session_read_only(self, httpbin):
    method test_session_overwrite_header (line 151) | def test_session_overwrite_header(self, httpbin):
  class TestSession (line 170) | class TestSession(SessionTestBase):
    method test_session_ignored_header_prefixes (line 173) | def test_session_ignored_header_prefixes(self, httpbin):
    method test_session_with_upload (line 186) | def test_session_with_upload(self, httpbin):
    method test_session_by_path (line 192) | def test_session_by_path(self, httpbin):
    method test_session_with_cookie_followed_by_another_header (line 204) | def test_session_with_cookie_followed_by_another_header(self, httpbin):
    method test_session_unicode (line 222) | def test_session_unicode(self, httpbin):
    method test_session_default_header_value_overwritten (line 240) | def test_session_default_header_value_overwritten(self, httpbin):
    method test_download_in_session (line 253) | def test_download_in_session(self, tmp_path, httpbin):
    method test_auth_type_reused_in_session (line 272) | def test_auth_type_reused_in_session(self, auth_require_param, auth_pa...
    method test_auth_plugin_prompt_password_in_session (line 306) | def test_auth_plugin_prompt_password_in_session(self, httpbin):
    method test_auth_type_stored_in_session_file (line 346) | def test_auth_type_stored_in_session_file(self, httpbin):
  class TestExpiredCookies (line 370) | class TestExpiredCookies(CookieTestBase):
    method test_removes_expired_cookies_from_session_obj (line 379) | def test_removes_expired_cookies_from_session_obj(self, initial_cookie...
    method test_expired_cookies (line 385) | def test_expired_cookies(self, httpbin):
    method test_get_expired_cookies_using_max_age (line 397) | def test_get_expired_cookies_using_max_age(self):
    method test_get_expired_cookies_manages_multiple_cookie_headers (line 442) | def test_get_expired_cookies_manages_multiple_cookie_headers(self, coo...
  class TestCookieStorage (line 446) | class TestCookieStorage(CookieTestBase):
    method test_existing_and_new_cookies_sent_in_request (line 477) | def test_existing_and_new_cookies_sent_in_request(
    method test_cookie_storage_priority (line 531) | def test_cookie_storage_priority(self, cli_cookie, set_cookie, expecte...
  function basic_session (line 549) | def basic_session(httpbin, tmp_path):
  function open_session (line 559) | def open_session(path: Path, env: Environment, read_only: bool = False) ...
  function open_raw_session (line 568) | def open_raw_session(path: Path, read_only: bool = False) -> None:
  function read_stderr (line 579) | def read_stderr(env: Environment) -> bytes:
  function test_old_session_version_saved_as_is (line 588) | def test_old_session_version_saved_as_is(basic_session, mock_env):
  function test_old_session_cookie_layout_warning (line 596) | def test_old_session_cookie_layout_warning(basic_session, mock_env):
  function test_cookie_security_warnings_on_raw_cookies (line 652) | def test_cookie_security_warnings_on_raw_cookies(basic_session, mock_env...
  function test_old_session_cookie_layout_loading (line 666) | def test_old_session_cookie_layout_loading(basic_session, httpbin, mock_...
  function test_session_cookie_layout_preservation (line 682) | def test_session_cookie_layout_preservation(basic_session, mock_env, lay...
  function test_session_cookie_layout_preservation_on_new_cookies (line 695) | def test_session_cookie_layout_preservation_on_new_cookies(basic_session...
  function test_headers_old_layout_warning (line 730) | def test_headers_old_layout_warning(basic_session, mock_env, headers, ex...
  function test_outdated_layout_mixed (line 744) | def test_outdated_layout_mixed(basic_session, mock_env):
  function test_old_session_header_layout_loading (line 759) | def test_old_session_header_layout_loading(basic_session, httpbin, mock_...
  function test_session_header_layout_preservation (line 775) | def test_session_header_layout_preservation(basic_session, mock_env, lay...
  function test_session_header_layout_preservation_on_new_headers (line 787) | def test_session_header_layout_preservation_on_new_headers(basic_session...
  function test_session_multiple_headers_with_same_name (line 802) | def test_session_multiple_headers_with_same_name(basic_session, httpbin):
  function test_secure_cookies_on_localhost (line 833) | def test_secure_cookies_on_localhost(mock_env, tmp_path, server, expecte...

FILE: tests/test_ssl.py
  function test_ssl_version (line 54) | def test_ssl_version(httpbin_secure, ssl_version):
  class TestClientCert (line 77) | class TestClientCert:
    method test_cert_and_key (line 79) | def test_cert_and_key(self, httpbin_secure):
    method test_cert_pem (line 85) | def test_cert_pem(self, httpbin_secure):
    method test_cert_file_not_found (line 90) | def test_cert_file_not_found(self, httpbin_secure):
    method test_cert_file_invalid (line 97) | def test_cert_file_invalid(self, httpbin_secure):
    method test_cert_ok_but_missing_key (line 102) | def test_cert_ok_but_missing_key(self, httpbin_secure):
  class TestServerCert (line 108) | class TestServerCert:
    method test_verify_no_OK (line 110) | def test_verify_no_OK(self, httpbin_secure):
    method test_verify_false_OK (line 117) | def test_verify_false_OK(self, httpbin_secure, verify_value):
    method test_verify_custom_ca_bundle_path (line 122) | def test_verify_custom_ca_bundle_path(
    method test_self_signed_server_cert_by_default_raises_ssl_error (line 128) | def test_self_signed_server_cert_by_default_raises_ssl_error(
    method test_verify_custom_ca_bundle_invalid_path (line 135) | def test_verify_custom_ca_bundle_invalid_path(self, httpbin_secure):
    method test_verify_custom_ca_bundle_invalid_bundle (line 140) | def test_verify_custom_ca_bundle_invalid_bundle(self, httpbin_secure):
  function test_ciphers (line 145) | def test_ciphers(httpbin_secure):
  function test_ciphers_none_can_be_selected (line 155) | def test_ciphers_none_can_be_selected(httpbin_secure):
  function test_pyopenssl_presence (line 171) | def test_pyopenssl_presence():
  function test_password_protected_cert_prompt (line 182) | def test_password_protected_cert_prompt(httpbin_secure):
  function test_password_protected_cert_prompt_invalid (line 191) | def test_password_protected_cert_prompt_invalid(httpbin_secure):
  function test_password_protected_cert_cli_arg (line 198) | def test_password_protected_cert_cli_arg(httpbin_secure):
  function test_password_protected_cert_cli_arg_invalid (line 206) | def test_password_protected_cert_cli_arg_invalid(httpbin_secure):

FILE: tests/test_stream.py
  class SortJSONConverterPlugin (line 24) | class SortJSONConverterPlugin(ConverterPlugin):
    method supports (line 26) | def supports(cls, mime):
    method convert (line 29) | def convert(self, body):
  function test_pretty_redirected_stream (line 40) | def test_pretty_redirected_stream(httpbin):
  function test_pretty_stream_ensure_full_stream_is_retrieved (line 53) | def test_pretty_stream_ensure_full_stream_is_retrieved(httpbin):
  function test_pretty_options_with_and_without_stream_with_converter (line 67) | def test_pretty_options_with_and_without_stream_with_converter(pretty, s...
  function test_encoded_stream (line 93) | def test_encoded_stream(httpbin):
  function test_redirected_stream (line 105) | def test_redirected_stream(httpbin):
  function test_auto_streaming (line 136) | def test_auto_streaming(http_server, extras, expected):
  function test_streaming_encoding_detection (line 147) | def test_streaming_encoding_detection(http_server):

FILE: tests/test_tokens.py
  function test_headers (line 16) | def test_headers():
  function test_redirected_headers (line 21) | def test_redirected_headers():
  function test_terminal_headers_and_body (line 26) | def test_terminal_headers_and_body():
  function test_terminal_request_headers_response_body (line 31) | def test_terminal_request_headers_response_body(httpbin):
  function test_raw_request_headers_response_body (line 36) | def test_raw_request_headers_response_body(httpbin):
  function test_terminal_request_headers_response_headers (line 41) | def test_terminal_request_headers_response_headers(httpbin):
  function test_raw_request_headers_response_headers (line 46) | def test_raw_request_headers_response_headers(httpbin):
  function test_terminal_request_body_response_body (line 51) | def test_terminal_request_body_response_body(httpbin):
  function test_raw_headers_and_body (line 56) | def test_raw_headers_and_body():
  function test_raw_body (line 64) | def test_raw_body():
  function test_raw_exchange (line 69) | def test_raw_exchange(httpbin):
  function test_terminal_exchange (line 75) | def test_terminal_exchange(httpbin):
  function test_headers_multipart_body_separator (line 81) | def test_headers_multipart_body_separator():
  function test_redirected_headers_multipart_no_separator (line 86) | def test_redirected_headers_multipart_no_separator():
  function test_verbose_chunked (line 94) | def test_verbose_chunked(httpbin_with_chunked_support):
  function test_request_headers_response_body (line 101) | def test_request_headers_response_body(httpbin):
  function test_request_single_verbose (line 106) | def test_request_single_verbose(httpbin):
  function test_request_double_verbose (line 111) | def test_request_double_verbose(httpbin):
  function test_request_meta (line 116) | def test_request_meta(httpbin):

FILE: tests/test_transport_plugin.py
  class FakeAdapter (line 15) | class FakeAdapter(BaseAdapter):
    method send (line 16) | def send(self, request, **kwargs):
  class FakeTransportPlugin (line 28) | class FakeTransportPlugin(TransportPlugin):
    method get_adapter (line 33) | def get_adapter(self):
  function test_transport_from_requests_response (line 37) | def test_transport_from_requests_response(httpbin):

FILE: tests/test_update_warnings.py
  function check_update_warnings (line 29) | def check_update_warnings(text):
  function test_daemon_runner (line 34) | def test_daemon_runner():
  function test_fetch (line 59) | def test_fetch(static_fetch_data, without_warnings):
  function test_fetch_dont_override_existing_layout (line 77) | def test_fetch_dont_override_existing_layout(
  function test_fetch_broken_json (line 103) | def test_fetch_broken_json(static_fetch_data, without_warnings):
  function test_check_updates_disable_warnings (line 118) | def test_check_updates_disable_warnings(
  function test_check_updates_first_invocation (line 126) | def test_check_updates_first_invocation(
  function test_check_updates_first_time_after_data_fetch (line 141) | def test_check_updates_first_time_after_data_fetch(
  function test_check_updates_first_time_after_data_fetch_unknown_build_channel (line 158) | def test_check_updates_first_time_after_data_fetch_unknown_build_channel(
  function test_cli_check_updates (line 172) | def test_cli_check_updates(
  function test_cli_check_updates_not_shown (line 186) | def test_cli_check_updates_not_shown(
  function with_warnings (line 196) | def with_warnings(tmp_path):
  function without_warnings (line 204) | def without_warnings(tmp_path):
  function fetch_update_mock (line 212) | def fetch_update_mock(mocker):
  function static_fetch_data (line 218) | def static_fetch_data(mocker):
  function unknown_build_channel (line 229) | def unknown_build_channel(mocker):
  function higher_build_channel (line 234) | def higher_build_channel(mocker):
  function lower_build_channel (line 239) | def lower_build_channel(mocker):

FILE: tests/test_uploads.py
  function test_chunked_json (line 24) | def test_chunked_json(httpbin_with_chunked_support):
  function test_chunked_form (line 36) | def test_chunked_form(httpbin_with_chunked_support):
  function test_chunked_stdin (line 49) | def test_chunked_stdin(httpbin_with_chunked_support):
  function test_chunked_stdin_multiple_chunks (line 64) | def test_chunked_stdin_multiple_chunks(httpbin_with_chunked_support):
  function test_chunked_raw (line 82) | def test_chunked_raw(httpbin_with_chunked_support):
  function stdin_processes (line 95) | def stdin_processes(httpbin, *args, warn_threshold=0.1):
  function test_reading_from_stdin (line 128) | def test_reading_from_stdin(httpbin, wait):
  function test_stdin_read_warning (line 146) | def test_stdin_read_warning(httpbin):
  function test_stdin_read_warning_with_quiet (line 162) | def test_stdin_read_warning_with_quiet(httpbin):
  function test_stdin_read_warning_blocking_exit (line 178) | def test_stdin_read_warning_blocking_exit(httpbin):
  class TestMultipartFormDataFileUpload (line 190) | class TestMultipartFormDataFileUpload:
    method test_non_existent_file_raises_parse_error (line 192) | def test_non_existent_file_raises_parse_error(self, httpbin):
    method test_upload_ok (line 197) | def test_upload_ok(self, httpbin):
    method test_upload_multiple_fields_with_the_same_name (line 208) | def test_upload_multiple_fields_with_the_same_name(self, httpbin):
    method test_upload_custom_content_type (line 220) | def test_upload_custom_content_type(self, httpbin):
    method test_form_no_files_urlencoded (line 234) | def test_form_no_files_urlencoded(self, httpbin):
    method test_multipart (line 245) | def test_multipart(self, httpbin):
    method test_form_multipart_custom_boundary (line 257) | def test_form_multipart_custom_boundary(self, httpbin):
    method test_multipart_custom_content_type_boundary_added (line 271) | def test_multipart_custom_content_type_boundary_added(self, httpbin):
    method test_multipart_custom_content_type_boundary_preserved (line 286) | def test_multipart_custom_content_type_boundary_preserved(self, httpbin):
    method test_multipart_chunked (line 303) | def test_multipart_chunked(self, httpbin_with_chunked_support):
    method test_multipart_preserve_order (line 316) | def test_multipart_preserve_order(self, httpbin):
  class TestRequestBodyFromFilePath (line 336) | class TestRequestBodyFromFilePath:
    method test_request_body_from_file_by_path (line 342) | def test_request_body_from_file_by_path(self, httpbin):
    method test_request_body_from_file_by_path_chunked (line 352) | def test_request_body_from_file_by_path_chunked(self, httpbin_with_chu...
    method test_request_body_from_file_by_path_with_explicit_content_type (line 363) | def test_request_body_from_file_by_path_with_explicit_content_type(
    method test_request_body_from_file_by_path_no_field_name_allowed (line 372) | def test_request_body_from_file_by_path_no_field_name_allowed(
    method test_request_body_from_file_by_path_no_data_items_allowed (line 379) | def test_request_body_from_file_by_path_no_data_items_allowed(
    method test_multiple_request_bodies_from_file_by_path (line 392) | def test_multiple_request_bodies_from_file_by_path(self, httpbin):

FILE: tests/test_windows.py
  class TestWindowsOnly (line 9) | class TestWindowsOnly:
    method test_windows_colorized_output (line 13) | def test_windows_colorized_output(self, httpbin):
  class TestFakeWindows (line 18) | class TestFakeWindows:
    method test_output_file_pretty_not_allowed_on_windows (line 19) | def test_output_file_pretty_not_allowed_on_windows(self, tmp_path, htt...

FILE: tests/test_xml.py
  function test_xml_format_options (line 22) | def test_xml_format_options(options, expected_xml):
  function test_valid_xml (line 36) | def test_valid_xml(file):
  function test_xml_xhtml (line 58) | def test_xml_xhtml():
  function test_invalid_xml (line 85) | def test_invalid_xml(file):

FILE: tests/utils/__init__.py
  function strip_colors (line 57) | def strip_colors(colorized_msg: str) -> str:
  function mk_config_dir (line 61) | def mk_config_dir() -> Path:
  function add_auth (line 66) | def add_auth(url, auth):
  class Encoder (line 71) | class Encoder:
    method __init__ (line 89) | def __init__(self):
    method substitute (line 92) | def substitute(self, data: bytes) -> str:
    method decode (line 97) | def decode(self, data: str) -> Union[str, bytes]:
  class FakeBytesIOBuffer (line 108) | class FakeBytesIOBuffer(BytesIO):
    method __init__ (line 110) | def __init__(self, original, encoder, *args, **kwargs):
    method write (line 115) | def write(self, data):
  class StdinBytesIO (line 124) | class StdinBytesIO(BytesIO):
  class MockEnvironment (line 129) | class MockEnvironment(Environment):
    method __init__ (line 137) | def __init__(self, create_temp_config_dir=True, **kwargs):
    method config (line 159) | def config(self) -> Config:
    method create_temp_config_dir (line 165) | def create_temp_config_dir(self):
    method cleanup (line 169) | def cleanup(self):
    method __del__ (line 179) | def __del__(self):
  class PersistentMockEnvironment (line 187) | class PersistentMockEnvironment(MockEnvironment):
    method cleanup (line 188) | def cleanup(self):
  class BaseCLIResponse (line 192) | class BaseCLIResponse:
    method command (line 213) | def command(self):  # noqa: F811
    method from_raw_data (line 219) | def from_raw_data(self, data: Union[str, bytes]) -> 'BaseCLIResponse':
  class BytesCLIResponse (line 230) | class BytesCLIResponse(bytes, BaseCLIResponse):
  class StrCLIResponse (line 241) | class StrCLIResponse(str, BaseCLIResponse):
    method json (line 244) | def json(self) -> Optional[dict]:
  class ExitStatusError (line 275) | class ExitStatusError(Exception):
  function mock_env (line 280) | def mock_env() -> MockEnvironment:
  function normalize_args (line 286) | def normalize_args(args: Iterable[Any]) -> List[str]:
  function httpie (line 290) | def httpie(
  function http (line 326) | def http(

FILE: tests/utils/http_server.py
  class TestHandler (line 14) | class TestHandler(BaseHTTPRequestHandler):
    method handler (line 18) | def handler(cls, method, path):
    method do_generic (line 24) | def do_generic(self):
  function get_headers (line 37) | def get_headers(handler):
  function chunked_drip (line 46) | def chunked_drip(handler):
  function random_encoding (line 62) | def random_encoding(handler):
  function status_custom_msg (line 83) | def status_custom_msg(handler):
  function get_cookies (line 92) | def get_cookies(handler):
  function set_cookies (line 109) | def set_cookies(handler):
  function set_cookie_and_redirect (line 120) | def set_cookie_and_redirect(handler):
  function _http_server (line 133) | def _http_server():
  function http_server (line 143) | def http_server():
  function localhost_http_server (line 153) | def localhost_http_server():

FILE: tests/utils/matching/__init__.py
  function assert_output_matches (line 21) | def assert_output_matches(output: str, tokens: Iterable[Expect]):
  function assert_output_does_not_match (line 33) | def assert_output_does_not_match(output: str, tokens: Iterable[Expect]):

FILE: tests/utils/matching/parsing.py
  function make_headers_re (line 13) | def make_headers_re(message_type: Expect):
  class OutputMatchingError (line 52) | class OutputMatchingError(ValueError):
  function expect_tokens (line 56) | def expect_tokens(tokens: Iterable[Expect], s: str):
  function expect_token (line 63) | def expect_token(token: Expect, s: str) -> str:
  function expect_regex (line 71) | def expect_regex(token: Expect, s: str) -> str:
  function expect_body (line 78) | def expect_body(s: str) -> str:

FILE: tests/utils/matching/test_matching.py
  function test_assert_output_matches_headers_incomplete (line 11) | def test_assert_output_matches_headers_incomplete():
  function test_assert_output_matches_headers_unterminated (line 15) | def test_assert_output_matches_headers_unterminated():
  function test_assert_output_matches_response_headers (line 26) | def test_assert_output_matches_response_headers():
  function test_assert_output_matches_request_headers (line 37) | def test_assert_output_matches_request_headers():
  function test_assert_output_matches_headers_and_separator (line 48) | def test_assert_output_matches_headers_and_separator():
  function test_assert_output_matches_body_unmatched_crlf (line 60) | def test_assert_output_matches_body_unmatched_crlf():
  function test_assert_output_matches_body_unmatched_separator (line 64) | def test_assert_output_matches_body_unmatched_separator():
  function test_assert_output_matches_body_and_separator (line 68) | def test_assert_output_matches_body_and_separator():
  function test_assert_output_matches_body_r (line 72) | def test_assert_output_matches_body_r():
  function test_assert_output_matches_body_n (line 76) | def test_assert_output_matches_body_n():
  function test_assert_output_matches_body_r_body (line 80) | def test_assert_output_matches_body_r_body():
  function test_assert_output_matches_body_n_body (line 84) | def test_assert_output_matches_body_n_body():
  function test_assert_output_matches_headers_and_body (line 88) | def test_assert_output_matches_headers_and_body():
  function test_assert_output_matches_headers_with_body_and_separator (line 100) | def test_assert_output_matches_headers_with_body_and_separator():
  function test_assert_output_matches_response_meta (line 111) | def test_assert_output_matches_response_meta():
  function test_assert_output_matches_whole_response (line 121) | def test_assert_output_matches_whole_response():
  function test_assert_output_matches_multiple_messages (line 134) | def test_assert_output_matches_multiple_messages():
  function test_assert_output_matches_multipart_body (line 161) | def test_assert_output_matches_multipart_body():
  function test_assert_output_matches_multipart_body_with_separator (line 185) | def test_assert_output_matches_multipart_body_with_separator():
  function test_assert_output_matches_multiple_separators (line 210) | def test_assert_output_matches_multiple_separators():

FILE: tests/utils/matching/tokens.py
  class Expect (line 4) | class Expect(Enum):
  class ExpectSequence (line 16) | class ExpectSequence:

FILE: tests/utils/plugins_cli.py
  function make_name (line 23) | def make_name() -> str:
  class EntryPoint (line 28) | class EntryPoint:
    method dump (line 32) | def dump(self) -> Dict[str, str]:
  class Plugin (line 37) | class Plugin:
    method build (line 44) | def build(self) -> None:
    method dump (line 87) | def dump(self) -> Dict[str, Any]:
    method path (line 97) | def path(self) -> Path:
    method import_name (line 101) | def import_name(self) -> str:
  class Interface (line 106) | class Interface:
    method get_plugin (line 110) | def get_plugin(self, target: str) -> importlib_metadata.Distribution:
    method is_installed (line 114) | def is_installed(self, target: str) -> bool:
    method make_dummy_plugin (line 122) | def make_dummy_plugin(self, build=True, **kwargs) -> Plugin:
  function parse_listing (line 131) | def parse_listing(lines: List[str]) -> Dict[str, Any]:
  function interface (line 167) | def interface(tmp_path):
  function dummy_plugin (line 177) | def dummy_plugin(interface):
  function broken_plugin (line 182) | def broken_plugin(interface):
  function dummy_plugins (line 190) | def dummy_plugins(interface):
  function httpie_plugins (line 207) | def httpie_plugins(interface):
  function httpie_plugins_success (line 230) | def httpie_plugins_success(httpie_plugins):