GitHub

API reference for Headers.

Header names (lowercased) to values. Equal to another Headers with the same entries; repr hides the values of CurrentRedactedNames.

Functions

__init__

__init__(entries=None) -> None
ParameterTypeDescription
entriesMapping[str, str] | None = None
def __init__(self, entries: Mapping[str, str] | None = None) -> None:
    self._entries: dict[str, str] = {k.lower(): v for k, v in (entries or {}).items()}

has

has(key) -> bool
ParameterTypeDescription
keystr

Returns bool

def has(self, key: str) -> bool:
    return key.lower() in self._entries

set

set(key, value) -> Headers
ParameterTypeDescription
keystr
valuestr

Returns Headers

def set(self, key: str, value: str) -> Headers:
    return Headers._unsafe({**self._entries, key.lower(): value})

set_all

set_all(headers) -> Headers
ParameterTypeDescription
headersInput

Returns Headers

def set_all(self, headers: Input) -> Headers:
    return Headers._unsafe({**self._entries, **from_input(headers)._entries})

merge

merge(headers) -> Headers
ParameterTypeDescription
headersHeaders

Returns Headers

def merge(self, headers: Headers) -> Headers:
    return Headers._unsafe({**self._entries, **headers._entries})

remove

remove(key) -> Headers
ParameterTypeDescription
keystr

Returns Headers

def remove(self, key: str) -> Headers:
    return self.remove_many((key,))

remove_many

remove_many(keys) -> Headers
ParameterTypeDescription
keysIterable[str]

Returns Headers

def remove_many(self, keys: Iterable[str]) -> Headers:
    drop = {k.lower() for k in keys}
    return Headers._unsafe({k: v for k, v in self._entries.items() if k not in drop})

redact

redact(key) -> dict[str, str | Redacted[str]]

The entries, with the values of the names matching key hidden in Redacted.

ParameterTypeDescription
keyPattern | Sequence[Pattern]

Returns dict[str, str | Redacted[str]]

def redact(self, key: Pattern | Sequence[Pattern]) -> dict[str, str | Redacted[str]]:
    """The entries, with the values of the names matching ``key``
    hidden in ``Redacted``."""
    patterns: Sequence[Pattern] = (key,) if isinstance(key, (str, re.Pattern)) else key
    return {
        name: Redacted(value) if is_redacted_name(name, patterns) else value
        for name, value in self._entries.items()
    }

to_json

to_json() -> dict[str, str]

The entries, with "<redacted>" for the redacted names.

Returns dict[str, str]

def to_json(self) -> dict[str, str]:
    """The entries, with ``"<redacted>"`` for the redacted names."""
    return {k: str(v) for k, v in self.__redacted__().items()}