Skip to content

Upgrading Werkzeug 1 to 2

Unknown1.0.1 → 2.3.8Security3

UnknownUpgrade verdict

DepDelta hasn't looked for the notes of 1 of 26 releases in its newest sources yet, so breaking changes can't be ruled out.

  • DepDelta hasn't finished looking for the notes in this range, so it can't rule out breaking changes yet.
  • Their commits are listed with this comparison.
3 items need code or config changes

Python requirement changed in 2.3.0: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.* → >=3.8.

Adds markupsafe >=2.1.1.

Installs 1 package in all (was 0).

Security3
Werkzeug is a comprehensive WSGI web application library. If an upload of a file that starts with CR or LF and then is followed by megabytes of data without these characters: all of these bytes are appended chunk by chunk into internal bytearray and lookup for boundary is performed on growing buffer. This allows an attacker to cause a denial of service by sending crafted multipart data to an endpoint that will parse it. The amount of CPU time required can block worker processes from handling legitimate requests. This vulnerability has been patched in version 3.0.1.
High · CVSS 7.5
Fixes security issues covered by advisories GHSA-xg9f-g7g7-2323 and GHSA-px8h-6qxv-m22q.
** DISPUTED ** Improper parsing of HTTP requests in Pallets Werkzeug v2.1.0 and below allows attackers to perform HTTP Request Smuggling using a crafted HTTP request with multiple requests included inside the body. NOTE: the vendor's position is that this behavior can only occur in unsupported configurations involving development mode and an HTTP server from outside the Werkzeug project.

Generated by DepDelta from published Python source. Not mixed with prose notes.

  • removed: class Accept(ImmutableList)
  • removed: class Authorization(ImmutableDictMixin, dict)
  • removed: class CallbackDict(UpdateDictMixin, dict)
  • removed: class CharsetAccept(Accept)
  • removed: class CombinedMultiDict(ImmutableMultiDictMixin, MultiDict)
  • removed: class ContentRange(object)
  • removed: class ContentSecurityPolicy(UpdateDictMixin, dict)
  • removed: class ETags(collections_abc.Container, collections_abc.Iterable)
  • removed: class EnvironHeaders(ImmutableHeadersMixin, Headers)
  • removed: class FileMultiDict(MultiDict)
  • removed: class FileStorage(object)
  • removed: class HeaderSet(collections_abc.MutableSet)
  • removed: class Headers(object)
  • removed: class IfRange(object)
  • removed: class ImmutableDict(ImmutableDictMixin, dict)
  • removed: class ImmutableDictMixin(object)
  • removed: class ImmutableHeadersMixin(object)
  • removed: class ImmutableList(ImmutableListMixin, list)
  • removed: class ImmutableListMixin(object)
  • removed: class ImmutableMultiDict(ImmutableMultiDictMixin, MultiDict)
  • removed: class ImmutableMultiDictMixin(ImmutableDictMixin)
  • removed: class ImmutableOrderedMultiDict(ImmutableMultiDictMixin, OrderedMultiDict)
  • removed: class ImmutableTypeConversionDict(ImmutableDictMixin, TypeConversionDict)
  • removed: class LanguageAccept(Accept)
  • removed: class MIMEAccept(Accept)
  • removed: class MultiDict(TypeConversionDict)
  • removed: class OrderedMultiDict(MultiDict)
  • removed: class Range(object)
  • removed: class RequestCacheControl(ImmutableDictMixin, _CacheControl)
  • removed: class ResponseCacheControl(_CacheControl)
  • removed: class TypeConversionDict(dict)
  • removed: class UpdateDictMixin(object)
  • removed: class ViewItems(object)
  • removed: class WWWAuthenticate(UpdateDictMixin, dict)
  • removed: constructor Accept(values=…)
  • removed: constructor Authorization(auth_type, data=…)
  • removed: constructor CallbackDict(initial=…, on_update=…)
  • removed: constructor CombinedMultiDict(dicts=…)
  • removed: constructor ContentRange(units, start, stop, length=…, on_update=…)
  • removed: constructor ContentSecurityPolicy(values=…, on_update=…)
  • removed: constructor ETags(strong_etags=…, weak_etags=…, star_tag=…)
  • removed: constructor EnvironHeaders(environ)
  • removed: constructor FileStorage(stream=…, filename=…, name=…, content_type=…, content_length=…, headers=…)
  • removed: constructor HeaderSet(headers=…, on_update=…)
  • removed: constructor Headers(defaults=…)
  • removed: constructor IfRange(etag=…, date=…)
  • removed: constructor MultiDict(mapping=…)
  • removed: constructor OrderedMultiDict(mapping=…)
  • removed: constructor Range(units, ranges)
  • removed: constructor ViewItems(multi_dict, method, repr_name, *a, **kw)
  • removed: constructor WWWAuthenticate(auth_type=…, values=…, on_update=…)
  • removed: field CombinedMultiDict.has_key
  • removed: field ContentRange.length
  • removed: field ContentRange.start
  • removed: field ContentRange.stop
  • removed: field ContentRange.units
  • removed: field ContentSecurityPolicy.base_uri
  • removed: field ContentSecurityPolicy.child_src
  • removed: field ContentSecurityPolicy.connect_src
  • removed: field ContentSecurityPolicy.default_src
  • removed: field ContentSecurityPolicy.font_src
  • removed: field ContentSecurityPolicy.form_action
  • removed: field ContentSecurityPolicy.frame_ancestors
  • removed: field ContentSecurityPolicy.frame_src
  • removed: field ContentSecurityPolicy.img_src
  • removed: field ContentSecurityPolicy.manifest_src
  • removed: field ContentSecurityPolicy.media_src
  • removed: field ContentSecurityPolicy.navigate_to
  • removed: field ContentSecurityPolicy.object_src
  • removed: field ContentSecurityPolicy.plugin_types
  • removed: field ContentSecurityPolicy.prefetch_src
  • removed: field ContentSecurityPolicy.report_to
  • removed: field ContentSecurityPolicy.report_uri
  • removed: field ContentSecurityPolicy.sandbox
  • removed: field ContentSecurityPolicy.script_src
  • removed: field ContentSecurityPolicy.script_src_attr
  • removed: field ContentSecurityPolicy.script_src_elem
  • removed: field ContentSecurityPolicy.style_src
  • removed: field ContentSecurityPolicy.style_src_attr
  • removed: field ContentSecurityPolicy.style_src_elem
  • removed: field ContentSecurityPolicy.worker_src
  • removed: field Headers.has_key
  • removed: field ImmutableListMixin.remove
  • removed: field RequestCacheControl.max_stale
  • removed: field RequestCacheControl.min_fresh
  • removed: field RequestCacheControl.only_if_cached
  • removed: field ResponseCacheControl.immutable
  • removed: field ResponseCacheControl.must_revalidate
  • removed: field ResponseCacheControl.private
  • removed: field ResponseCacheControl.proxy_revalidate
  • removed: field ResponseCacheControl.public
  • removed: field ResponseCacheControl.s_maxage
  • removed: field UpdateDictMixin.clear
  • removed: field UpdateDictMixin.on_update
  • removed: field UpdateDictMixin.popitem
  • removed: field UpdateDictMixin.update
  • removed: field WWWAuthenticate.algorithm
  • removed: field WWWAuthenticate.auth_property
  • removed: field WWWAuthenticate.domain
  • removed: field WWWAuthenticate.nonce
  • removed: field WWWAuthenticate.opaque
  • removed: field WWWAuthenticate.qop
  • removed: field WWWAuthenticate.realm
  • removed: field WWWAuthenticate.type
  • removed: function cache_property(key, empty, type)
  • removed: function csp_property(key)
  • removed: function is_immutable(self)
  • removed: function iter_multi_items(mapping)
  • removed: function native_itermethods(names)
  • removed: method Accept.best_match(matches, default=…)
  • removed: method Accept.find(key)
  • removed: method Accept.index(key)
  • removed: method Accept.quality(key)
  • removed: method Accept.to_header()
  • removed: method Accept.values()
  • removed: method CombinedMultiDict.copy()
  • removed: method CombinedMultiDict.get(key, default=…, type=…)
  • removed: method CombinedMultiDict.getlist(key, type=…)
  • removed: method CombinedMultiDict.items(multi=…)
  • removed: method CombinedMultiDict.keys()
  • removed: method CombinedMultiDict.lists()
  • removed: method CombinedMultiDict.listvalues()
  • removed: method CombinedMultiDict.to_dict(flat=…)
  • removed: method CombinedMultiDict.values()
  • removed: method ContentRange.set(start, stop, length=…, units=…)
  • removed: method ContentRange.to_header()
  • removed: method ContentRange.unset()
  • removed: method ContentSecurityPolicy.to_header()
  • removed: method ETags.as_set(include_weak=…)
  • removed: method ETags.contains(etag)
  • removed: method ETags.contains_raw(etag)
  • removed: method ETags.contains_weak(etag)
  • removed: method ETags.is_strong(etag)
  • removed: method ETags.is_weak(etag)
  • removed: method ETags.to_header()
  • removed: method EnvironHeaders.copy()
  • removed: method FileMultiDict.add_file(name, file, filename=…, content_type=…)
  • removed: method FileStorage.close()
  • removed: method FileStorage.save(dst, buffer_size=…)
  • removed: method HeaderSet.add(header)
  • removed: method HeaderSet.as_set(preserve_casing=…)
  • removed: method HeaderSet.clear()
  • removed: method HeaderSet.discard(header)
  • removed: method HeaderSet.find(header)
  • removed: method HeaderSet.index(header)
  • removed: method HeaderSet.remove(header)
  • removed: method HeaderSet.to_header()
  • removed: method HeaderSet.update(iterable)
  • removed: method Headers.add(_key, _value, **kw)
  • removed: method Headers.add_header(_key, _value, **_kw)
  • removed: method Headers.clear()
  • removed: method Headers.copy()
  • removed: method Headers.extend(*args, **kwargs)
  • removed: method Headers.get(key, default=…, type=…, as_bytes=…)
  • removed: method Headers.get_all(name)
  • removed: method Headers.getlist(key, type=…, as_bytes=…)
  • removed: method Headers.items(lower=…)
  • removed: method Headers.keys(lower=…)
  • removed: method Headers.pop(key=…, default=…)
  • removed: method Headers.popitem()
  • removed: method Headers.remove(key)
  • removed: method Headers.set(_key, _value, **kw)
  • removed: method Headers.setdefault(key, default)
  • removed: method Headers.setlist(key, values)
  • removed: method Headers.setlistdefault(key, default)
  • removed: method Headers.to_wsgi_list()
  • removed: method Headers.update(*args, **kwargs)
  • removed: method Headers.values()
  • removed: method IfRange.to_header()
  • removed: method ImmutableDict.copy()
  • removed: method ImmutableDictMixin.clear()
  • removed: method ImmutableDictMixin.pop(key, default=…)
  • removed: method ImmutableDictMixin.popitem()
  • removed: method ImmutableDictMixin.setdefault(key, default=…)
  • removed: method ImmutableDictMixin.update(*args, **kwargs)
  • removed: method ImmutableHeadersMixin.add(item)
  • removed: method ImmutableHeadersMixin.add_header(item)
  • removed: method ImmutableHeadersMixin.extend(*args, **kwargs)
  • removed: method ImmutableHeadersMixin.insert(pos, value)
  • removed: method ImmutableHeadersMixin.pop(index=…)
  • removed: method ImmutableHeadersMixin.popitem()
  • removed: method ImmutableHeadersMixin.remove(item)
  • removed: method ImmutableHeadersMixin.set(key, value)
  • removed: method ImmutableHeadersMixin.setdefault(key, default)
  • removed: method ImmutableHeadersMixin.setlist(key, value)
  • removed: method ImmutableHeadersMixin.setlistdefault(key, default)
  • removed: method ImmutableHeadersMixin.update(*args, **kwargs)
  • removed: method ImmutableListMixin.append(item)
  • removed: method ImmutableListMixin.extend(iterable)
  • removed: method ImmutableListMixin.insert(pos, value)
  • removed: method ImmutableListMixin.pop(index=…)
  • removed: method ImmutableListMixin.reverse()
  • removed: method ImmutableListMixin.sort(cmp=…, key=…, reverse=…)
  • removed: method ImmutableMultiDict.copy()
  • removed: method ImmutableMultiDictMixin.add(key, value)
  • removed: method ImmutableMultiDictMixin.popitemlist()
  • removed: method ImmutableMultiDictMixin.poplist(key)
  • removed: method ImmutableMultiDictMixin.setlist(key, new_list)
  • removed: method ImmutableMultiDictMixin.setlistdefault(key, default_list=…)
  • removed: method ImmutableOrderedMultiDict.copy()
  • removed: method ImmutableTypeConversionDict.copy()
  • removed: method LanguageAccept.best_match(matches, default=…)
  • removed: method MultiDict.add(key, value)
  • removed: method MultiDict.copy()
  • removed: method MultiDict.deepcopy(memo=…)
  • removed: method MultiDict.getlist(key, type=…)
  • removed: method MultiDict.items(multi=…)
  • removed: method MultiDict.keys()
  • removed: method MultiDict.lists()
  • removed: method MultiDict.listvalues()
  • removed: method MultiDict.pop(key, default=…)
  • removed: method MultiDict.popitem()
  • removed: method MultiDict.popitemlist()
  • removed: method MultiDict.poplist(key)
  • removed: method MultiDict.setdefault(key, default=…)
  • removed: method MultiDict.setlist(key, new_list)
  • removed: method MultiDict.setlistdefault(key, default_list=…)
  • removed: method MultiDict.to_dict(flat=…)
  • removed: method MultiDict.update(other_dict)
  • removed: method MultiDict.values()
  • removed: method OrderedMultiDict.add(key, value)
  • removed: method OrderedMultiDict.getlist(key, type=…)
  • removed: method OrderedMultiDict.items(multi=…)
  • removed: method OrderedMultiDict.keys()
  • removed: method OrderedMultiDict.lists()
  • removed: method OrderedMultiDict.listvalues()
  • removed: method OrderedMultiDict.pop(key, default=…)
  • removed: method OrderedMultiDict.popitem()
  • removed: method OrderedMultiDict.popitemlist()
  • removed: method OrderedMultiDict.poplist(key)
  • removed: method OrderedMultiDict.setlist(key, new_list)
  • removed: method OrderedMultiDict.setlistdefault(key, default_list=…)
  • removed: method OrderedMultiDict.update(mapping)
  • removed: method OrderedMultiDict.values()
  • removed: method Range.make_content_range(length)
  • removed: method Range.range_for_length(length)
  • removed: method Range.to_content_range_header(length)
  • removed: method Range.to_header()
  • removed: method TypeConversionDict.get(key, default=…, type=…)
  • removed: method UpdateDictMixin.calls_update()
  • removed: method UpdateDictMixin.pop(key, default=…)
  • removed: method UpdateDictMixin.setdefault(key, default=…)
  • removed: method WWWAuthenticate.auth_property(doc=…)
  • removed: method WWWAuthenticate.set_basic(realm=…)
  • removed: method WWWAuthenticate.set_digest(realm, nonce, qop=…, opaque=…, algorithm=…, stale=…)
  • removed: method WWWAuthenticate.to_header()
  • removed: property Accept.best
  • removed: property Authorization.cnonce
  • removed: property Authorization.nc
  • removed: property Authorization.nonce
  • removed: property Authorization.opaque
  • removed: property Authorization.password
  • removed: property Authorization.qop
  • removed: property Authorization.realm
  • removed: property Authorization.response
  • removed: property Authorization.uri
  • removed: property Authorization.username
  • removed: property FileStorage.content_length
  • removed: property FileStorage.content_type
  • removed: property FileStorage.mimetype
  • removed: property FileStorage.mimetype_params
  • removed: property MIMEAccept.accept_html
  • removed: property MIMEAccept.accept_json
  • removed: property MIMEAccept.accept_xhtml
  • removed: property WWWAuthenticate.stale
  • removed: static method CombinedMultiDict.fromkeys()
  • removed: static method ImmutableDictMixin.fromkeys(keys, value=…)
  • added: export Accept
  • added: export Authorization
  • added: export CallbackDict
  • added: export CharsetAccept
  • added: export CombinedMultiDict
  • added: export ContentRange
  • added: export ContentSecurityPolicy
  • added: export ETags
  • added: export EnvironHeaders
  • added: export FileMultiDict
  • added: export FileStorage
  • added: export HeaderSet
  • added: export Headers
  • added: export IfRange
  • added: export ImmutableDict
  • added: export ImmutableDictMixin
  • added: export ImmutableHeadersMixin
  • added: export ImmutableList
  • added: export ImmutableListMixin
  • added: export ImmutableMultiDict
  • added: export ImmutableMultiDictMixin
  • added: export ImmutableOrderedMultiDict
  • added: export ImmutableTypeConversionDict
  • added: export LanguageAccept
  • added: export MIMEAccept
  • added: export MultiDict
  • added: export OrderedMultiDict
  • added: export Range
  • added: export RequestCacheControl
  • added: export ResponseCacheControl
  • added: export TypeConversionDict
  • added: export UpdateDictMixin
  • added: export WWWAuthenticate
  • added: export iter_multi_items
  • added: class Accept(ImmutableList[tuple[str, int]])
  • added: class CharsetAccept(Accept)
  • added: class LanguageAccept(Accept)
  • added: class MIMEAccept(Accept)
  • added: constructor Accept(values: Accept | Iterable[tuple[str, float]] | None=…) -> None
  • added: field Accept.provided: bool
  • added: method Accept.best_match(matches: Iterable[str], default: str) -> str | (matches: Iterable[str], default: str | None=…) -> str | None
  • added: method Accept.find(key: str) -> int
  • added: method Accept.index(key: str) -> int
  • added: method Accept.quality(key: str) -> int
  • added: method Accept.to_header() -> str
  • added: method Accept.values() -> Iterator[str]
  • added: property Accept.best -> str
  • added: property MIMEAccept.accept_html -> bool
  • added: property MIMEAccept.accept_json -> bool
  • added: property MIMEAccept.accept_xhtml -> bool
  • added: class Authorization
  • added: class WWWAuthenticate
  • added: constructor Authorization(auth_type: str, data: dict[str, str] | None=…, token: str | None=…) -> None
  • added: constructor WWWAuthenticate(auth_type: str | None=…, values: dict[str, str] | None=…, token: str | None=…)
  • added: field WWWAuthenticate.auth_property
  • added: function auth_property(name: str, doc: str | None=…) -> property
  • added: method Authorization.get(key: str, default: str | None=…) -> str | None
  • added: method Authorization.to_header() -> str
  • added: method WWWAuthenticate.get(key: str, default: str | None=…) -> str | None
  • added: method WWWAuthenticate.set_basic(realm: str=…) -> None
  • added: method WWWAuthenticate.set_digest(realm: str, nonce: str, qop: t.Sequence[str]=…, opaque: str | None=…, algorithm: str | None=…, stale: bool=…) -> None
  • added: method WWWAuthenticate.to_header() -> str
  • added: property WWWAuthenticate.parameters -> dict[str, str]
  • added: property WWWAuthenticate.qop -> set[str]
  • added: property WWWAuthenticate.stale -> bool | None
  • added: property WWWAuthenticate.token -> str | None
  • added: property WWWAuthenticate.type -> str
  • added: static method Authorization.from_header(value: str | None) -> te.Self | None
  • added: static method WWWAuthenticate.from_header(value: str | None) -> te.Self | None
  • added: class RequestCacheControl(ImmutableDictMixin[str, _OptCPT], _CacheControl)
  • added: class ResponseCacheControl(_CacheControl)
  • added: function cache_control_property(key: str, empty: _OptCPT, type: type[_CPT]) -> property
  • added: property RequestCacheControl.max_stale -> int | None
  • added: property RequestCacheControl.min_fresh -> int | None
  • added: property RequestCacheControl.only_if_cached -> bool | None
  • added: property ResponseCacheControl.immutable -> bool | None
  • added: property ResponseCacheControl.must_revalidate -> bool | None
  • added: property ResponseCacheControl.private -> bool | None
  • added: property ResponseCacheControl.proxy_revalidate -> bool | None
  • added: property ResponseCacheControl.public -> bool | None
  • added: property ResponseCacheControl.s_maxage -> int | None
  • added: variable T
  • added: class ContentSecurityPolicy(UpdateDictMixin[str, str], dict[str, str])
  • added: constructor ContentSecurityPolicy(values: Mapping[str, str] | Iterable[tuple[str, str]]=…, on_update: Callable[[ContentSecurityPolicy], None] | None=…) -> None
  • added: field ContentSecurityPolicy.provided: bool
  • added: function csp_property(key: str) -> property
  • added: method ContentSecurityPolicy.to_header() -> str
  • added: property ContentSecurityPolicy.base_uri -> str | None
  • added: property ContentSecurityPolicy.child_src -> str | None
  • added: property ContentSecurityPolicy.connect_src -> str | None
  • added: property ContentSecurityPolicy.default_src -> str | None
  • added: property ContentSecurityPolicy.font_src -> str | None
  • added: property ContentSecurityPolicy.form_action -> str | None
  • added: property ContentSecurityPolicy.frame_ancestors -> str | None
  • added: property ContentSecurityPolicy.frame_src -> str | None
  • added: property ContentSecurityPolicy.img_src -> str | None
  • added: property ContentSecurityPolicy.manifest_src -> str | None
  • added: property ContentSecurityPolicy.media_src -> str | None
  • added: property ContentSecurityPolicy.navigate_to -> str | None
  • added: property ContentSecurityPolicy.object_src -> str | None
  • added: property ContentSecurityPolicy.plugin_types -> str | None
  • added: property ContentSecurityPolicy.prefetch_src -> str | None
  • added: property ContentSecurityPolicy.report_to -> str | None
  • added: property ContentSecurityPolicy.report_uri -> str | None
  • added: property ContentSecurityPolicy.sandbox -> str | None
  • added: property ContentSecurityPolicy.script_src -> str | None
  • added: property ContentSecurityPolicy.script_src_attr -> str | None
  • added: property ContentSecurityPolicy.script_src_elem -> str | None
  • added: property ContentSecurityPolicy.style_src -> str | None
  • added: property ContentSecurityPolicy.style_src_attr -> str | None
  • added: property ContentSecurityPolicy.style_src_elem -> str | None
  • added: property ContentSecurityPolicy.worker_src -> str | None
  • added: class ETags(Collection[str])
  • added: constructor ETags(strong_etags: Iterable[str] | None=…, weak_etags: Iterable[str] | None=…, star_tag: bool=…) -> None
  • added: field ETags.star_tag: bool
  • added: method ETags.as_set(include_weak: bool=…) -> set[str]
  • added: method ETags.contains(etag: str) -> bool
  • added: method ETags.contains_raw(etag: str) -> bool
  • added: method ETags.contains_weak(etag: str) -> bool
  • added: method ETags.is_strong(etag: str) -> bool
  • added: method ETags.is_weak(etag: str) -> bool
  • added: method ETags.to_header() -> str
  • added: class FileMultiDict(MultiDict[str, FileStorage])
  • added: class FileStorage
  • added: constructor FileStorage(stream: IO[bytes] | None=…, filename: str | PathLike | None=…, name: str | None=…, content_type: str | None=…, content_length: int | None=…, headers: Headers | None=…) -> None
  • added: field FileStorage.filename: str | None
  • added: field FileStorage.headers: Headers
  • added: field FileStorage.name: str | None
  • added: field FileStorage.stream: IO[bytes]
  • added: method FileMultiDict.add_file(name: str, file: FileStorage | str | IO[bytes], filename: str | None=…, content_type: str | None=…) -> None
  • added: method FileStorage.close() -> None
  • added: method FileStorage.save(dst: str | PathLike | IO[bytes], buffer_size: int=…) -> None
  • added: property FileStorage.content_length -> int
  • added: property FileStorage.content_type -> str
  • added: property FileStorage.mimetype -> str
  • added: property FileStorage.mimetype_params -> dict[str, str]
  • added: class EnvironHeaders(ImmutableHeadersMixin, Headers)
  • added: class Headers(dict[str, str])
  • added: constructor EnvironHeaders(environ: WSGIEnvironment) -> None
  • added: constructor Headers(defaults: Mapping[str, str | Iterable[str]] | Iterable[tuple[str, str]] | None=…) -> None
  • added: field EnvironHeaders.environ: WSGIEnvironment
  • added: method EnvironHeaders.copy() -> NoReturn
  • added: method Headers.add(_key: str, _value: str, **kw: str) -> None
  • added: method Headers.add_header(_key: str, _value: str, **_kw: str) -> None
  • added: method Headers.clear() -> None
  • added: method Headers.copy() -> Headers
  • added: method Headers.extend(*args: Mapping[str, str | Iterable[str]] | Iterable[tuple[str, str]], **kwargs: str | Iterable[str]) -> None
  • added: method Headers.get(key: str, default: str) -> str | (key: str, default: str | None=…) -> str | None | (key: str, default: T | None=…, type: Callable[[str], T]=…) -> T | None
  • added: method Headers.get_all(name: str) -> list[str]
  • added: method Headers.getlist(key: str) -> list[str] | (key: str, type: Callable[[str], T]) -> list[T]
  • added: method Headers.has_key(key: str) -> bool
  • added: method Headers.items(lower: bool=…) -> Iterator[tuple[str, str]]
  • added: method Headers.keys(lower: bool=…) -> Iterator[str]
  • added: method Headers.pop(key: str, default: str | None=…) -> str | (key: int | None=…, default: tuple[str, str] | None=…) -> tuple[str, str]
  • added: method Headers.popitem() -> tuple[str, str]
  • added: method Headers.remove(key: str) -> None
  • added: method Headers.set(_key: str, _value: str, **kw: str) -> None
  • added: method Headers.setdefault(key: str, default: str) -> str
  • added: method Headers.setlist(key: str, values: Iterable[str]) -> None
  • added: method Headers.setlistdefault(key: str, default: Iterable[str]) -> None
  • added: method Headers.to_wsgi_list() -> list[tuple[str, str]]
  • added: method Headers.update(__m: SupportsKeysAndGetItem[str, str], **kwargs: str | Iterable[str]) -> None | (__m: Iterable[tuple[str, str]], **kwargs: str | Iterable[str]) -> None | (**kwargs: str | Iterable[str]) -> None
  • added: method Headers.values() -> Iterator[str]
  • added: variable D
  • added: variable T
  • added: class ImmutableDictMixin(dict[K, V])
  • added: class ImmutableHeadersMixin(Headers)
  • added: class ImmutableListMixin(list[V])
  • added: class ImmutableMultiDictMixin(ImmutableDictMixin[K, V])
  • added: class UpdateDictMixin(dict[K, V])
  • added: field UpdateDictMixin.on_update: Callable[[UpdateDictMixin[K, V] | None, None], None]
  • added: function is_immutable(self: object) -> NoReturn
  • added: method ImmutableDictMixin.clear() -> NoReturn
  • added: method ImmutableDictMixin.pop(key: K, default: V | None=…) -> NoReturn
  • added: method ImmutableDictMixin.popitem() -> NoReturn
  • added: method ImmutableDictMixin.setdefault(key: K, default: V | None=…) -> NoReturn
  • added: method ImmutableDictMixin.update(*args: Any, **kwargs: V) -> NoReturn
  • added: method ImmutableHeadersMixin.add(_key: Any, _value: Any, **kw: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.add_header(_key: Any, _value: Any, **_kw: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.extend(*args: Any, **kwargs: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.insert(pos: Any, value: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.pop(key: Any=…, default: Any=…) -> NoReturn
  • added: method ImmutableHeadersMixin.popitem() -> NoReturn
  • added: method ImmutableHeadersMixin.remove(key: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.set(_key: Any, _value: Any, **kw: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.setdefault(key: Any, default: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.setlist(key: Any, values: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.setlistdefault(key: Any, default: Any) -> NoReturn
  • added: method ImmutableHeadersMixin.update(*args: Any, **kwargs: Any) -> NoReturn
  • added: method ImmutableListMixin.append(value: V) -> NoReturn
  • added: method ImmutableListMixin.extend(values: Iterable[V]) -> NoReturn
  • added: method ImmutableListMixin.insert(pos: SupportsIndex, value: V) -> NoReturn
  • added: method ImmutableListMixin.pop(index: SupportsIndex=…) -> NoReturn
  • added: method ImmutableListMixin.remove(value: V) -> NoReturn
  • added: method ImmutableListMixin.reverse() -> NoReturn
  • added: method ImmutableListMixin.sort(key: Callable[[V], Any] | None=…, reverse: bool=…) -> NoReturn
  • added: method ImmutableMultiDictMixin.add(key: K, value: V) -> NoReturn
  • added: method ImmutableMultiDictMixin.popitemlist() -> NoReturn
  • added: method ImmutableMultiDictMixin.poplist(key: K) -> NoReturn
  • added: method ImmutableMultiDictMixin.setlist(key: K, new_list: Iterable[V]) -> NoReturn
  • added: method ImmutableMultiDictMixin.setlistdefault(key: K, default_list: Iterable[V] | None=…) -> NoReturn
  • added: method UpdateDictMixin.clear() -> None
  • added: method UpdateDictMixin.pop(key: K) -> V | (key: K, default: V | T=…) -> V | T
  • added: method UpdateDictMixin.popitem() -> tuple[K, V]
  • added: method UpdateDictMixin.setdefault(key: K, default: V | None=…) -> V
  • added: method UpdateDictMixin.update(__m: SupportsKeysAndGetItem[K, V], **kwargs: V) -> None | (__m: Iterable[tuple[K, V]], **kwargs: V) -> None | (**kwargs: V) -> None
  • added: static method ImmutableDictMixin.fromkeys(keys: Iterable[K], value: V | None=…) -> ImmutableDictMixin[K, V]
  • added: variable K
  • added: variable T
  • added: variable V
  • added: class ContentRange
  • added: class IfRange
  • added: class Range
  • added: constructor ContentRange(units: str | None, start: int | None, stop: int | None, length: int | None=…, on_update: Callable[[ContentRange], None] | None=…) -> None
  • added: constructor IfRange(etag: str | None=…, date: datetime | None=…) -> None
  • added: constructor Range(units: str, ranges: list[tuple[int, int | None]]) -> None
  • added: field ContentRange.on_update: Callable[[ContentRange], None] | None
  • added: field IfRange.date: datetime | None
  • added: field IfRange.etag: str | None
  • added: field Range.ranges: list[tuple[int, int | None]]
  • added: field Range.units: str
  • added: method ContentRange.set(start: int | None, stop: int | None, length: int | None=…, units: str | None=…) -> None
  • added: method ContentRange.to_header() -> str
  • added: method ContentRange.unset() -> None
  • added: method IfRange.to_header() -> str
  • added: method Range.make_content_range(length: int | None) -> ContentRange | None
  • added: method Range.range_for_length(length: int | None) -> tuple[int, int] | None
  • added: method Range.to_content_range_header(length: int | None) -> str | None
  • added: method Range.to_header() -> str
  • added: property ContentRange.length -> int | None
  • added: property ContentRange.start -> int | None
  • added: property ContentRange.stop -> int | None
  • added: property ContentRange.units -> str | None
  • added: class CallbackDict(UpdateDictMixin[K, V], dict[K, V])
  • added: class CombinedMultiDict(ImmutableMultiDictMixin[K, V], MultiDict[K, V])
  • added: class HeaderSet(set[str])
  • added: class ImmutableDict(ImmutableDictMixin[K, V], dict[K, V])
  • added: class ImmutableList(ImmutableListMixin[V])
  • added: class ImmutableMultiDict(ImmutableMultiDictMixin[K, V], MultiDict[K, V])
  • added: class ImmutableOrderedMultiDict(ImmutableMultiDictMixin[K, V], OrderedMultiDict[K, V])
  • added: class ImmutableTypeConversionDict(ImmutableDictMixin[K, V], TypeConversionDict[K, V])
  • added: class MultiDict(TypeConversionDict[K, V])
  • added: class OrderedMultiDict(MultiDict[K, V])
  • added: class TypeConversionDict(dict[K, V])
  • added: constructor CallbackDict(initial: Mapping[K, V] | Iterable[tuple[K, V]] | None=…, on_update: Callable[[_CD], None] | None=…) -> None
  • added: constructor CombinedMultiDict(dicts: Iterable[MultiDict[K, V]] | None) -> None
  • added: constructor HeaderSet(headers: Iterable[str] | None=…, on_update: Callable[[HeaderSet], None] | None=…) -> None
  • added: constructor MultiDict(mapping: Mapping[K, Iterable[V] | V] | Iterable[tuple[K, V]] | None=…) -> None
  • added: constructor OrderedMultiDict(mapping: Mapping[K, V] | None=…) -> None
  • added: field CombinedMultiDict.dicts: list[MultiDict[K, V]]
  • added: field HeaderSet.on_update: Callable[[HeaderSet], None] | None
  • added: function is_immutable(self: object) -> NoReturn
  • added: function iter_multi_items(mapping: Mapping[K, V | Iterable[V]] | Iterable[tuple[K, V]]) -> Iterator[tuple[K, V]]
  • added: method CombinedMultiDict.copy() -> MultiDict[K, V]
  • added: method CombinedMultiDict.get(key: K) -> V | None | (key: K, default: V | T=…) -> V | T | (key: K, default: T | None=…, type: Callable[[V], T]=…) -> T | None
  • added: method CombinedMultiDict.getlist(key: K) -> list[V] | (key: K, type: Callable[[V], T]=…) -> list[T]
  • added: method CombinedMultiDict.has_key(key: K) -> bool
  • added: method CombinedMultiDict.items(multi: bool=…) -> Iterator[tuple[K, V]]
  • added: method CombinedMultiDict.keys() -> set[K]
  • added: method CombinedMultiDict.lists() -> Iterator[tuple[K, list[V]]]
  • added: method CombinedMultiDict.listvalues() -> Iterator[list[V]]
  • added: method CombinedMultiDict.to_dict() -> dict[K, V] | (flat: Literal[False]) -> dict[K, list[V]]
  • added: method CombinedMultiDict.values() -> Iterator[V]
  • added: method HeaderSet.add(header: str) -> None
  • added: method HeaderSet.as_set(preserve_casing: bool=…) -> set[str]
  • added: method HeaderSet.clear() -> None
  • added: method HeaderSet.discard(header: str) -> None
  • added: method HeaderSet.find(header: str) -> int
  • added: method HeaderSet.index(header: str) -> int
  • added: method HeaderSet.remove(header: str) -> None
  • added: method HeaderSet.to_header() -> str
  • added: method HeaderSet.update(iterable: Iterable[str]) -> None
  • added: method ImmutableDict.copy() -> dict[K, V]
  • added: method ImmutableMultiDict.copy() -> MultiDict[K, V]
  • added: method ImmutableOrderedMultiDict.copy() -> OrderedMultiDict[K, V]
  • added: method ImmutableTypeConversionDict.copy() -> TypeConversionDict[K, V]
  • added: method MultiDict.add(key: K, value: V) -> None
  • added: method MultiDict.copy() -> MultiDict[K, V]
  • added: method MultiDict.deepcopy(memo: Any=…) -> MultiDict[K, V]
  • added: method MultiDict.getlist(key: K) -> list[V] | (key: K, type: Callable[[V], T]=…) -> list[T]
  • added: method MultiDict.items(multi: bool=…) -> Iterator[tuple[K, V]]
  • added: method MultiDict.lists() -> Iterator[tuple[K, list[V]]]
  • added: method MultiDict.listvalues() -> Iterator[list[V]]
  • added: method MultiDict.pop(key: K) -> V | (key: K, default: V | T=…) -> V | T
  • added: method MultiDict.popitem() -> tuple[K, V]
  • added: method MultiDict.popitemlist() -> tuple[K, list[V]]
  • added: method MultiDict.poplist(key: K) -> list[V]
  • added: method MultiDict.setdefault(key: K, default: V | None=…) -> V
  • added: method MultiDict.setlist(key: K, new_list: Iterable[V]) -> None
  • added: method MultiDict.setlistdefault(key: K, default_list: Iterable[V] | None=…) -> list[V]
  • added: method MultiDict.to_dict() -> dict[K, V] | (flat: Literal[False]) -> dict[K, list[V]]
  • added: method MultiDict.update(mapping: Mapping[K, Iterable[V] | V] | Iterable[tuple[K, V]]) -> None
  • added: method MultiDict.values() -> Iterator[V]
  • added: method OrderedMultiDict.add(key: K, value: V) -> None
  • added: method OrderedMultiDict.getlist(key: K) -> list[V] | (key: K, type: Callable[[V], T]=…) -> list[T]
  • added: method OrderedMultiDict.items(multi: bool=…) -> Iterator[tuple[K, V]]
  • added: method OrderedMultiDict.keys() -> Iterator[K]
  • added: method OrderedMultiDict.lists() -> Iterator[tuple[K, list[V]]]
  • added: method OrderedMultiDict.listvalues() -> Iterator[list[V]]
  • added: method OrderedMultiDict.pop(key: K) -> V | (key: K, default: V | T=…) -> V | T
  • added: method OrderedMultiDict.popitem() -> tuple[K, V]
  • added: method OrderedMultiDict.popitemlist() -> tuple[K, list[V]]
  • added: method OrderedMultiDict.poplist(key: K) -> list[V]
  • added: method OrderedMultiDict.setlist(key: K, new_list: Iterable[V]) -> None
  • added: method OrderedMultiDict.setlistdefault(key: K, default_list: Iterable[V] | None=…) -> list[V]
  • added: method OrderedMultiDict.update(mapping: Mapping[K, V] | Iterable[tuple[K, V]]) -> None
  • added: method OrderedMultiDict.values() -> Iterator[V]
  • added: method TypeConversionDict.get(key: K, default: None=…, type: None=…) -> V | None | (key: K, default: D, type: None=…) -> D | V | (key: K, default: D, type: Callable[[V], T]) -> D | T | (key: K, type: Callable[[V], T]) -> T | None
  • added: static method CombinedMultiDict.fromkeys(keys: Any, value: Any=…) -> NoReturn
  • added: variable D
  • added: variable K
  • added: variable T
  • added: variable V
  • removed: export get_current_traceback
  • removed: export text_type
  • removed: method DebuggedApplication.paste_traceback(request, traceback)
  • removed: property DebuggedApplication.pin
  • removed: property DebuggedApplication.pin_cookie_name
  • changed: class DebuggedApplication(object) → class DebuggedApplication
  • changed: constructor DebuggedApplication(app, evalex=…, request_key=…, console_path=…, console_init_func=…, show_hidden_frames=…, pin_security=…, pin_logging=…) → constructor DebuggedApplication(app: WSGIApplication, evalex: bool=…, request_key: str=…, console_path: str=…, console_init_func: t.Callable[[], dict[str, t.Any]] | None=…, show_hidden_frames: bool=…, pin_security: bool=…, pin_logging: bool=…) -> None
  • changed: function get_machine_id() → function get_machine_id() -> str | bytes | None
  • changed: function get_pin_and_cookie_name(app) → function get_pin_and_cookie_name(app: WSGIApplication) -> tuple[str, str] | tuple[None, None]
  • changed: function hash_pin(pin) → function hash_pin(pin: str) -> str
  • changed: method DebuggedApplication.check_pin_trust(environ) → method DebuggedApplication.check_pin_trust(environ: WSGIEnvironment) -> bool | None
  • changed: method DebuggedApplication.debug_application(environ, start_response) → method DebuggedApplication.debug_application(environ: WSGIEnvironment, start_response: StartResponse) -> t.Iterator[bytes]
  • changed: method DebuggedApplication.display_console(request) → method DebuggedApplication.display_console(request: Request) -> Response
  • changed: method DebuggedApplication.execute_command(request, command, frame) → method DebuggedApplication.execute_command(request: Request, command: str, frame: DebugFrameSummary | _ConsoleFrame) -> Response
  • changed: method DebuggedApplication.get_resource(request, filename) → method DebuggedApplication.get_resource(request: Request, filename: str) -> Response
  • changed: method DebuggedApplication.log_pin_request() → method DebuggedApplication.log_pin_request() -> Response
  • changed: method DebuggedApplication.pin_auth(request) → method DebuggedApplication.pin_auth(request: Request) -> Response
  • added: export DebugFrameSummary
  • added: export DebugTraceback
  • added: export NotFound
  • added: export send_file
  • added: property DebuggedApplication.pin -> str | None
  • added: property DebuggedApplication.pin_cookie_name -> str
  • changed: class Console(object) → class Console
  • changed: class HTMLStringO(object) → class HTMLStringO
  • changed: class ThreadedStream(object) → class ThreadedStream
  • changed: constructor Console(globals=…, locals=…) → constructor Console(globals: dict[str, t.Any] | None=…, locals: dict[str, t.Any] | None=…) -> None
  • changed: constructor HTMLStringO() → constructor HTMLStringO() -> None
  • changed: method Console.eval(code) → method Console.eval(code: str) -> str
  • changed: method HTMLStringO.close() → method HTMLStringO.close() -> None
  • changed: method HTMLStringO.flush() → method HTMLStringO.flush() -> None
  • changed: method HTMLStringO.isatty() → method HTMLStringO.isatty() -> bool
  • changed: method HTMLStringO.readline() → method HTMLStringO.readline() -> str
  • changed: method HTMLStringO.reset() → method HTMLStringO.reset() -> str
  • changed: method HTMLStringO.seek(n, mode=…) → method HTMLStringO.seek(n: int, mode: int=…) -> None
  • changed: method HTMLStringO.write(x) → method HTMLStringO.write(x: str) -> None
  • changed: method HTMLStringO.writelines(x) → method HTMLStringO.writelines(x: t.Iterable[str]) -> None
  • changed: static method ThreadedStream.displayhook(obj) → static method ThreadedStream.displayhook(obj: object) -> None
  • changed: static method ThreadedStream.fetch() → static method ThreadedStream.fetch() -> str
  • changed: static method ThreadedStream.push() → static method ThreadedStream.push() -> None
  • changed: class DebugReprGenerator(object) → class DebugReprGenerator
  • changed: constructor DebugReprGenerator() → constructor DebugReprGenerator() -> None
  • changed: function debug_repr(obj) → function debug_repr(obj: object) -> str
  • changed: function dump(obj=…) → function dump(obj: object=…) -> None
  • changed: method DebugReprGenerator.dict_repr(d, recursive, limit=…) → method DebugReprGenerator.dict_repr(d: dict[int, None] | dict[str, int] | dict[str | int, int], recursive: bool, limit: int=…) -> str
  • changed: method DebugReprGenerator.dispatch_repr(obj, recursive) → method DebugReprGenerator.dispatch_repr(obj: t.Any, recursive: bool) -> str
  • changed: method DebugReprGenerator.dump_locals(d) → method DebugReprGenerator.dump_locals(d: dict[str, t.Any]) -> str
  • changed: method DebugReprGenerator.dump_object(obj) → method DebugReprGenerator.dump_object(obj: object) -> str
  • changed: method DebugReprGenerator.fallback_repr() → method DebugReprGenerator.fallback_repr() -> str
  • changed: method DebugReprGenerator.object_repr(obj) → method DebugReprGenerator.object_repr(obj: type[dict] | t.Callable | type[list] | None) -> str
  • changed: method DebugReprGenerator.regex_repr(obj) → method DebugReprGenerator.regex_repr(obj: t.Pattern) -> str
  • changed: method DebugReprGenerator.render_object_dump(items, title, repr=…) → method DebugReprGenerator.render_object_dump(items: list[tuple[str, str]], title: str, repr: str | None=…) -> str
  • changed: method DebugReprGenerator.repr(obj) → method DebugReprGenerator.repr(obj: object) -> str
  • changed: method DebugReprGenerator.string_repr(obj, limit=…) → method DebugReprGenerator.string_repr(obj: str | bytes, limit: int=…) -> str
  • removed: class Frame(object)
  • removed: class Group(object)
  • removed: class Line(object)
  • removed: class Traceback(object)
  • removed: constructor Frame(exc_type, exc_value, tb)
  • removed: constructor Group(exc_type, exc_value, tb)
  • removed: constructor Line(lineno, code)
  • removed: constructor Traceback(exc_type, exc_value, tb)
  • removed: function get_current_traceback(ignore_system_exceptions=…, show_hidden_frames=…, skip=…)
  • removed: method Frame.eval(code, mode=…)
  • removed: method Frame.get_annotated_lines()
  • removed: method Frame.get_context_lines(context=…)
  • removed: method Frame.render(mark_lib=…)
  • removed: method Frame.render_line_context()
  • removed: method Frame.render_text()
  • removed: method Group.filter_hidden_frames()
  • removed: method Group.render(mark_lib=…)
  • removed: method Group.render_text()
  • removed: method Line.render()
  • removed: method Traceback.filter_hidden_frames()
  • removed: method Traceback.log(logfile=…)
  • removed: method Traceback.paste()
  • removed: method Traceback.render_full(evalex=…, secret=…, evalex_trusted=…)
  • removed: method Traceback.render_summary(include_title=…)
  • removed: property Frame.console
  • removed: property Frame.current_line
  • removed: property Frame.id
  • removed: property Frame.is_library
  • removed: property Frame.sourcelines
  • removed: property Group.exception
  • removed: property Line.classes
  • removed: property Traceback.exception
  • removed: property Traceback.id
  • removed: property Traceback.is_syntax_error
  • removed: property Traceback.plaintext
  • removed: variable SOURCE_LINE_HTML
  • removed: variable UTF8_COOKIE
  • removed: variable system_exceptions
  • changed: function render_console_html(secret, evalex_trusted=…) → function render_console_html(secret: str, evalex_trusted: bool) -> str
  • added: class DebugFrameSummary(traceback.FrameSummary)
  • added: class DebugTraceback
  • added: constructor DebugFrameSummary(*, locals: dict[str, t.Any], globals: dict[str, t.Any], **kwargs: t.Any) -> None
  • added: constructor DebugTraceback(exc: BaseException, te: traceback.TracebackException | None=…, *, skip: int=…, hide: bool=…) -> None
  • added: method DebugFrameSummary.eval(code: str) -> t.Any
  • added: method DebugFrameSummary.render_html(mark_library: bool) -> str
  • added: method DebugTraceback.render_debugger_html(evalex: bool, secret: str, evalex_trusted: bool) -> str
  • added: method DebugTraceback.render_traceback_html(include_title: bool=…) -> str
  • added: method DebugTraceback.render_traceback_text() -> str
  • added: property DebugFrameSummary.console -> Console
  • added: property DebugFrameSummary.info -> str | None
  • added: property DebugFrameSummary.is_library -> bool
  • added: property DebugTraceback.all_frames -> list[DebugFrameSummary]
  • added: property DebugTraceback.all_tracebacks -> list[tuple[str | None, traceback.TracebackException]]
  • removed: property HTTPException.name
  • removed: static method HTTPException.wrap(exception, name=…)
  • changed: constructor HTTPException(description=…, response=…) → constructor HTTPException(description: str | None=…, response: Response | None=…) -> None
  • changed: field HTTPException.code → field HTTPException.code: int | None
  • changed: field HTTPException.description → field HTTPException.description: str | None
  • changed: method HTTPException.get_body(environ=…) → method HTTPException.get_body(environ: WSGIEnvironment | None=…, scope: dict | None=…) -> str
  • changed: method HTTPException.get_description(environ=…) → method HTTPException.get_description(environ: WSGIEnvironment | None=…, scope: dict | None=…) -> str
  • changed: method HTTPException.get_headers(environ=…) → method HTTPException.get_headers(environ: WSGIEnvironment | None=…, scope: dict | None=…) -> list[tuple[str, str]]
  • changed: method HTTPException.get_response(environ=…) → method HTTPException.get_response(environ: WSGIEnvironment | WSGIRequest | None=…, scope: dict | None=…) -> Response
  • added: class Aborter
  • added: class BadGateway(HTTPException)
  • added: class BadHost(BadRequest)
  • added: class BadRequest(HTTPException)
  • added: class BadRequestKeyError(BadRequest, KeyError)
  • added: class ClientDisconnected(BadRequest)
  • added: class Conflict(HTTPException)
  • added: class ExpectationFailed(HTTPException)
  • added: class FailedDependency(HTTPException)
  • added: class Forbidden(HTTPException)
  • added: class GatewayTimeout(HTTPException)
  • added: class Gone(HTTPException)
  • added: class HTTPVersionNotSupported(HTTPException)
  • added: class ImATeapot(HTTPException)
  • added: class InternalServerError(HTTPException)
  • added: class LengthRequired(HTTPException)
  • added: class Locked(HTTPException)
  • added: class MethodNotAllowed(HTTPException)
  • added: class NotAcceptable(HTTPException)
  • added: class NotFound(HTTPException)
  • added: class NotImplemented(HTTPException)
  • added: class PreconditionFailed(HTTPException)
  • added: class PreconditionRequired(HTTPException)
  • added: class RequestEntityTooLarge(HTTPException)
  • added: class RequestHeaderFieldsTooLarge(HTTPException)
  • added: class RequestTimeout(HTTPException)
  • added: class RequestURITooLarge(HTTPException)
  • added: class RequestedRangeNotSatisfiable(HTTPException)
  • added: class SecurityError(BadRequest)
  • added: class ServiceUnavailable(_RetryAfter)
  • added: class TooManyRequests(_RetryAfter)
  • added: class Unauthorized(HTTPException)
  • added: class UnavailableForLegalReasons(HTTPException)
  • added: class UnprocessableEntity(HTTPException)
  • added: class UnsupportedMediaType(HTTPException)
  • added: constructor Aborter(mapping: dict[int, type[HTTPException]] | None=…, extra: dict[int, type[HTTPException]] | None=…) -> None
  • added: constructor BadRequestKeyError(arg: str | None=…, *args: t.Any, **kwargs: t.Any)
  • added: constructor InternalServerError(description: str | None=…, response: Response | None=…, original_exception: BaseException | None=…) -> None
  • added: constructor MethodNotAllowed(valid_methods: t.Iterable[str] | None=…, description: str | None=…, response: Response | None=…) -> None
  • added: constructor RequestedRangeNotSatisfiable(length: int | None=…, units: str=…, description: str | None=…, response: Response | None=…) -> None
  • added: constructor Unauthorized(description: str | None=…, response: Response | None=…, www_authenticate: None | (WWWAuthenticate | t.Iterable[WWWAuthenticate])=…) -> None
  • added: field BadGateway.code
  • added: field BadGateway.description
  • added: field BadRequest.code
  • added: field BadRequest.description
  • added: field BadRequestKeyError.show_exception
  • added: field Conflict.code
  • added: field Conflict.description
  • added: field ExpectationFailed.code
  • added: field ExpectationFailed.description
  • added: field FailedDependency.code
  • added: field FailedDependency.description
  • added: field Forbidden.code
  • added: field Forbidden.description
  • added: field GatewayTimeout.code
  • added: field GatewayTimeout.description
  • added: field Gone.code
  • added: field Gone.description
  • added: field HTTPVersionNotSupported.code
  • added: field HTTPVersionNotSupported.description
  • added: field ImATeapot.code
  • added: field ImATeapot.description
  • added: field InternalServerError.code
  • added: field InternalServerError.description
  • added: field LengthRequired.code
  • added: field LengthRequired.description
  • added: field Locked.code
  • added: field Locked.description
  • added: field MethodNotAllowed.code
  • added: field MethodNotAllowed.description
  • added: field NotAcceptable.code
  • added: field NotAcceptable.description
  • added: field NotFound.code
  • added: field NotFound.description
  • added: field NotImplemented.code
  • added: field NotImplemented.description
  • added: field PreconditionFailed.code
  • added: field PreconditionFailed.description
  • added: field PreconditionRequired.code
  • added: field PreconditionRequired.description
  • added: field RequestEntityTooLarge.code
  • added: field RequestEntityTooLarge.description
  • added: field RequestHeaderFieldsTooLarge.code
  • added: field RequestHeaderFieldsTooLarge.description
  • added: field RequestTimeout.code
  • added: field RequestTimeout.description
  • added: field RequestURITooLarge.code
  • added: field RequestURITooLarge.description
  • added: field RequestedRangeNotSatisfiable.code
  • added: field RequestedRangeNotSatisfiable.description
  • added: field ServiceUnavailable.code
  • added: field ServiceUnavailable.description
  • added: field TooManyRequests.code
  • added: field TooManyRequests.description
  • added: field Unauthorized.code
  • added: field Unauthorized.description
  • added: field UnavailableForLegalReasons.code
  • added: field UnavailableForLegalReasons.description
  • added: field UnprocessableEntity.code
  • added: field UnprocessableEntity.description
  • added: field UnsupportedMediaType.code
  • added: field UnsupportedMediaType.description
  • added: function abort(status: int | Response, *args: t.Any, **kwargs: t.Any) -> t.NoReturn
  • added: method MethodNotAllowed.get_headers(environ: WSGIEnvironment | None=…, scope: dict | None=…) -> list[tuple[str, str]]
  • added: method RequestedRangeNotSatisfiable.get_headers(environ: WSGIEnvironment | None=…, scope: dict | None=…) -> list[tuple[str, str]]
  • added: method Unauthorized.get_headers(environ: WSGIEnvironment | None=…, scope: dict | None=…) -> list[tuple[str, str]]
  • added: property BadRequestKeyError.description -> str
  • added: property HTTPException.name -> str
  • added: variable default_exceptions: dict[int, type[HTTPException]]
  • removed: class BrokenFilesystemWarning(RuntimeWarning, UnicodeWarning)
  • removed: function get_filesystem_encoding()
  • removed: variable has_likely_buggy_unicode_filesystem
  • removed: function exhaust_stream(f)
  • removed: function is_valid_multipart_boundary(boundary)
  • removed: function parse_multipart_headers(iterable)
  • removed: method MultiPartParser.get_part_encoding(headers)
  • removed: method MultiPartParser.in_memory_threshold_reached(bytes)
  • removed: method MultiPartParser.parse_lines(file, boundary, content_length, cap_at_buffer=…)
  • removed: method MultiPartParser.parse_parts(file, boundary, content_length)
  • removed: method MultiPartParser.validate_boundary(boundary)
  • changed: class FormDataParser(object) → class FormDataParser
  • changed: class MultiPartParser(object) → class MultiPartParser
  • changed: constructor FormDataParser(stream_factory=…, charset=…, errors=…, max_form_memory_size=…, max_content_length=…, cls=…, silent=…) → constructor FormDataParser(stream_factory: TStreamFactory | None=…, charset: str | None=…, errors: str | None=…, max_form_memory_size: int | None=…, max_content_length: int | None=…, cls: type[MultiDict] | None=…, silent: bool=…, *, max_form_parts: int | None=…) -> None
  • changed: constructor MultiPartParser(stream_factory=…, charset=…, errors=…, max_form_memory_size=…, cls=…, buffer_size=…) → constructor MultiPartParser(stream_factory: TStreamFactory | None=…, charset: str | None=…, errors: str | None=…, max_form_memory_size: int | None=…, cls: type[MultiDict] | None=…, buffer_size: int=…, max_form_parts: int | None=…) -> None
  • changed: field FormDataParser.parse_functions → field FormDataParser.parse_functions: dict[str, t.Callable[[FormDataParser, t.IO[bytes], str, int | None, dict[str, str]], t_parse_result]]
  • changed: function default_stream_factory(total_content_length, filename, content_type, content_length=…) → function default_stream_factory(total_content_length: int | None, content_type: str | None, filename: str | None, content_length: int | None=…) -> t.IO[bytes]
  • changed: function parse_form_data(environ, stream_factory=…, charset=…, errors=…, max_form_memory_size=…, max_content_length=…, cls=…, silent=…) → function parse_form_data(environ: WSGIEnvironment, stream_factory: TStreamFactory | None=…, charset: str | None=…, errors: str | None=…, max_form_memory_size: int | None=…, max_content_length: int | None=…, cls: type[MultiDict] | None=…, silent: bool=…, *, max_form_parts: int | None=…) -> t_parse_result
  • changed: method FormDataParser.get_parse_func(mimetype, options) → method FormDataParser.get_parse_func(mimetype: str, options: dict[str, str]) -> None | t.Callable[[FormDataParser, t.IO[bytes], str, int | None, dict[str, str]], t_parse_result]
  • changed: method FormDataParser.parse(stream, mimetype, content_length, options=…) → method FormDataParser.parse(stream: t.IO[bytes], mimetype: str, content_length: int | None, options: dict[str, str] | None=…) -> t_parse_result
  • changed: method FormDataParser.parse_from_environ(environ) → method FormDataParser.parse_from_environ(environ: WSGIEnvironment) -> t_parse_result
  • changed: method MultiPartParser.fail(message) → method MultiPartParser.fail(message: str) -> te.NoReturn
  • changed: method MultiPartParser.get_part_charset(headers) → method MultiPartParser.get_part_charset(headers: Headers) -> str
  • changed: method MultiPartParser.parse(file, boundary, content_length) → method MultiPartParser.parse(stream: t.IO[bytes], boundary: bytes, content_length: int | None) -> tuple[MultiDict, MultiDict]
  • changed: method MultiPartParser.start_file_streaming(filename, headers, total_content_length) → method MultiPartParser.start_file_streaming(event: File, total_content_length: int | None) -> t.IO[bytes]
  • added: class TStreamFactory(te.Protocol)
  • added: variable F
  • added: variable t_parse_result
  • removed: function bytes_to_wsgi(data)
  • removed: function cookie_date(expires=…)
  • removed: function wsgi_to_bytes(data)
  • changed: function dump_age(age=…) → function dump_age(age: timedelta | int | None=…) -> str | None
  • changed: function dump_cookie(key, value=…, max_age=…, expires=…, path=…, domain=…, secure=…, httponly=…, charset=…, sync_expires=…, max_size=…, samesite=…) → function dump_cookie(key: str, value: str=…, max_age: timedelta | int | None=…, expires: str | datetime | int | float | None=…, path: str | None=…, domain: str | None=…, secure: bool=…, httponly: bool=…, charset: str | None=…, sync_expires: bool=…, max_size: int=…, samesite: str | None=…) -> str
  • changed: function dump_csp_header(header) → function dump_csp_header(header: ds.ContentSecurityPolicy) -> str
  • changed: function dump_header(iterable, allow_token=…) → function dump_header(iterable: dict[str, t.Any] | t.Iterable[t.Any], allow_token: bool | None=…) -> str
  • changed: function dump_options_header(header, options) → function dump_options_header(header: str | None, options: t.Mapping[str, t.Any]) -> str
  • changed: function generate_etag(data) → function generate_etag(data: bytes) -> str
  • changed: function http_date(timestamp=…) → function http_date(timestamp: datetime | date | int | float | struct_time | None=…) -> str
  • changed: function is_byte_range_valid(start, stop, length) → function is_byte_range_valid(start: int | None, stop: int | None, length: int | None) -> bool
  • changed: function is_entity_header(header) → function is_entity_header(header: str) -> bool
  • changed: function is_hop_by_hop_header(header) → function is_hop_by_hop_header(header: str) -> bool
  • changed: function is_resource_modified(environ, etag=…, data=…, last_modified=…, ignore_if_range=…) → function is_resource_modified(environ: WSGIEnvironment, etag: str | None=…, data: bytes | None=…, last_modified: datetime | str | None=…, ignore_if_range: bool=…) -> bool
  • changed: function parse_accept_header(value, cls=…) → function parse_accept_header(value: str | None) -> ds.Accept | (value: str | None, cls: type[_TAnyAccept]) -> _TAnyAccept
  • changed: function parse_age(value=…) → function parse_age(value: str | None=…) -> timedelta | None
  • changed: function parse_authorization_header(value) → function parse_authorization_header(value: str | None) -> ds.Authorization | None
  • changed: function parse_cache_control_header(value, on_update=…, cls=…) → function parse_cache_control_header(value: str | None, on_update: _t_cc_update, cls: None=…) -> ds.RequestCacheControl | (value: str | None, on_update: _t_cc_update, cls: type[_TAnyCC]) -> _TAnyCC
  • changed: function parse_content_range_header(value, on_update=…) → function parse_content_range_header(value: str | None, on_update: t.Callable[[ds.ContentRange], None] | None=…) -> ds.ContentRange | None
  • changed: function parse_cookie(header, charset=…, errors=…, cls=…) → function parse_cookie(header: WSGIEnvironment | str | None, charset: str | None=…, errors: str | None=…, cls: type[ds.MultiDict] | None=…) -> ds.MultiDict[str, str]
  • changed: function parse_csp_header(value, on_update=…, cls=…) → function parse_csp_header(value: str | None, on_update: _t_csp_update, cls: None=…) -> ds.ContentSecurityPolicy | (value: str | None, on_update: _t_csp_update, cls: type[_TAnyCSP]) -> _TAnyCSP
  • changed: function parse_date(value) → function parse_date(value: str | None) -> datetime | None
  • changed: function parse_dict_header(value, cls=…) → function parse_dict_header(value: str, cls: type[dict] | None=…) -> dict[str, str]
  • changed: function parse_etags(value) → function parse_etags(value: str | None) -> ds.ETags
  • changed: function parse_if_range_header(value) → function parse_if_range_header(value: str | None) -> ds.IfRange
  • changed: function parse_list_header(value) → function parse_list_header(value: str) -> list[str]
  • changed: function parse_options_header(value, multiple=…) → function parse_options_header(value: str | None) -> tuple[str, dict[str, str]]
  • changed: function parse_range_header(value, make_inclusive=…) → function parse_range_header(value: str | None, make_inclusive: bool=…) -> ds.Range | None
  • changed: function parse_set_header(value, on_update=…) → function parse_set_header(value: str | None, on_update: t.Callable[[ds.HeaderSet], None] | None=…) -> ds.HeaderSet
  • changed: function parse_www_authenticate_header(value, on_update=…) → function parse_www_authenticate_header(value: str | None, on_update: t.Callable[[ds.WWWAuthenticate], None] | None=…) -> ds.WWWAuthenticate
  • changed: function quote_etag(etag, weak=…) → function quote_etag(etag: str, weak: bool=…) -> str
  • changed: function quote_header_value(value, extra_chars=…, allow_token=…) → function quote_header_value(value: t.Any, extra_chars: str | None=…, allow_token: bool=…) -> str
  • changed: function remove_entity_headers(headers, allowed=…) → function remove_entity_headers(headers: ds.Headers | list[tuple[str, str]], allowed: t.Iterable[str]=…) -> None
  • changed: function remove_hop_by_hop_headers(headers) → function remove_hop_by_hop_headers(headers: ds.Headers | list[tuple[str, str]]) -> None
  • changed: function unquote_etag(etag) → function unquote_etag(etag: str | None) -> tuple[str, bool] | tuple[None, None]
  • changed: function unquote_header_value(value, is_filename=…) → function unquote_header_value(value: str, is_filename: bool | None=…) -> str
  • added: class COEP(Enum)
  • added: class COOP(Enum)
  • added: field COEP.REQUIRE_CORP
  • added: field COEP.UNSAFE_NONE
  • added: field COOP.SAME_ORIGIN
  • added: field COOP.SAME_ORIGIN_ALLOW_POPUPS
  • added: field COOP.UNSAFE_NONE
  • removed: method LocalManager.get_ident()
  • removed: property LocalStack.top
  • changed: class Local(object) → class Local
  • changed: class LocalManager(object) → class LocalManager
  • changed: class LocalProxy(object) → class LocalProxy(t.Generic[T])
  • changed: class LocalStack(object) → class LocalStack(t.Generic[T])
  • changed: constructor Local() → constructor Local(context_var: ContextVar[dict[str, t.Any]] | None=…) -> None
  • changed: constructor LocalManager(locals=…, ident_func=…) → constructor LocalManager(locals: None | (Local | LocalStack | t.Iterable[Local | LocalStack])=…) -> None
  • changed: constructor LocalProxy(local, name=…) → constructor LocalProxy(local: ContextVar[T] | Local | LocalStack[T] | t.Callable[[], T], name: str | None=…, *, unbound_message: str | None=…) -> None
  • changed: constructor LocalStack() → constructor LocalStack(context_var: ContextVar[list[T]] | None=…) -> None
  • changed: function release_local(local) → function release_local(local: Local | LocalStack) -> None
  • changed: method LocalManager.cleanup() → method LocalManager.cleanup() -> None
  • changed: method LocalManager.make_middleware(app) → method LocalManager.make_middleware(app: WSGIApplication) -> WSGIApplication
  • changed: method LocalManager.middleware(func) → method LocalManager.middleware(func: WSGIApplication) -> WSGIApplication
  • changed: method LocalStack.pop() → method LocalStack.pop() -> T | None
  • changed: method LocalStack.push(obj) → method LocalStack.push(obj: T) -> list[T]
  • added: property LocalStack.top -> T | None
  • added: variable F
  • added: variable T
  • changed: class DispatcherMiddleware(object) → class DispatcherMiddleware
  • changed: constructor DispatcherMiddleware(app, mounts=…) → constructor DispatcherMiddleware(app: WSGIApplication, mounts: dict[str, WSGIApplication] | None=…) -> None
  • changed: class ProxyMiddleware(object) → class ProxyMiddleware
  • changed: constructor ProxyMiddleware(app, targets, chunk_size=…, timeout=…) → constructor ProxyMiddleware(app: WSGIApplication, targets: t.Mapping[str, dict[str, t.Any]], chunk_size: int=…, timeout: int=…) -> None
  • changed: method ProxyMiddleware.proxy_to(opts, path, prefix) → method ProxyMiddleware.proxy_to(opts: dict[str, t.Any], path: str, prefix: str) -> WSGIApplication
  • removed: function check_string(context, obj, stacklevel=…)
  • changed: class ErrorStream(object) → class ErrorStream
  • changed: class GuardedIterator(object) → class GuardedIterator
  • changed: class GuardedWrite(object) → class GuardedWrite
  • changed: class InputStream(object) → class InputStream
  • changed: class LintMiddleware(object) → class LintMiddleware
  • changed: constructor ErrorStream(stream) → constructor ErrorStream(stream: t.IO[str]) -> None
  • changed: constructor GuardedIterator(iterator, headers_set, chunks) → constructor GuardedIterator(iterator: t.Iterable[bytes], headers_set: tuple[int, Headers], chunks: list[int]) -> None
  • changed: constructor GuardedWrite(write, chunks) → constructor GuardedWrite(write: t.Callable[[bytes], object], chunks: list[int]) -> None
  • changed: constructor InputStream(stream) → constructor InputStream(stream: t.IO[bytes]) -> None
  • changed: constructor LintMiddleware(app) → constructor LintMiddleware(app: WSGIApplication) -> None
  • changed: method ErrorStream.close() → method ErrorStream.close() -> None
  • changed: method ErrorStream.flush() → method ErrorStream.flush() -> None
  • changed: method ErrorStream.write(s) → method ErrorStream.write(s: str) -> None
  • changed: method ErrorStream.writelines(seq) → method ErrorStream.writelines(seq: t.Iterable[str]) -> None
  • changed: method GuardedIterator.close() → method GuardedIterator.close() -> None
  • changed: method InputStream.close() → method InputStream.close() -> None
  • changed: method InputStream.read(*args) → method InputStream.read(*args: t.Any) -> bytes
  • changed: method InputStream.readline(*args) → method InputStream.readline(*args: t.Any) -> bytes
  • changed: method LintMiddleware.check_environ(environ) → method LintMiddleware.check_environ(environ: WSGIEnvironment) -> None
  • changed: method LintMiddleware.check_headers(headers) → method LintMiddleware.check_headers(headers: Headers) -> None
  • changed: method LintMiddleware.check_iterator(app_iter) → method LintMiddleware.check_iterator(app_iter: t.Iterable[bytes]) -> None
  • changed: method LintMiddleware.check_start_response(status, headers, exc_info) → method LintMiddleware.check_start_response(status: str, headers: list[tuple[str, str]], exc_info: None | tuple[type[BaseException], BaseException, TracebackType]) -> tuple[int, Headers]
  • added: function check_type(context: str, obj: object, need: t.Type=…) -> None
  • changed: class ProfilerMiddleware(object) → class ProfilerMiddleware
  • changed: constructor ProfilerMiddleware(app, stream=…, sort_by=…, restrictions=…, profile_dir=…, filename_format=…) → constructor ProfilerMiddleware(app: WSGIApplication, stream: t.IO[str] | None=…, sort_by: t.Iterable[str]=…, restrictions: t.Iterable[str | int | float]=…, profile_dir: str | None=…, filename_format: str=…) -> None
  • changed: class ProxyFix(object) → class ProxyFix
  • changed: constructor ProxyFix(app, x_for=…, x_proto=…, x_host=…, x_port=…, x_prefix=…) → constructor ProxyFix(app: WSGIApplication, x_for: int=…, x_proto: int=…, x_host: int=…, x_port: int=…, x_prefix: int=…) -> None
  • changed: class SharedDataMiddleware(object) → class SharedDataMiddleware
  • changed: constructor SharedDataMiddleware(app, exports, disallow=…, cache=…, cache_timeout=…, fallback_mimetype=…) → constructor SharedDataMiddleware(app: WSGIApplication, exports: dict[str, str | tuple[str, str]] | t.Iterable[tuple[str, str | tuple[str, str]]], disallow: None=…, cache: bool=…, cache_timeout: int=…, fallback_mimetype: str=…) -> None
  • changed: method SharedDataMiddleware.generate_etag(mtime, file_size, real_filename) → method SharedDataMiddleware.generate_etag(mtime: datetime, file_size: int, real_filename: str) -> str
  • changed: method SharedDataMiddleware.get_directory_loader(directory) → method SharedDataMiddleware.get_directory_loader(directory: str) -> _TLoader
  • changed: method SharedDataMiddleware.get_file_loader(filename) → method SharedDataMiddleware.get_file_loader(filename: str) -> _TLoader
  • changed: method SharedDataMiddleware.get_package_loader(package, package_path) → method SharedDataMiddleware.get_package_loader(package: str, package_path: str) -> _TLoader
  • changed: method SharedDataMiddleware.is_allowed(filename) → method SharedDataMiddleware.is_allowed(filename: str) -> bool
  • removed: function rename(src, dst)
  • removed: variable can_rename_open_file
  • removed: variable rename
  • removed: class AnyConverter(BaseConverter)
  • removed: class BaseConverter(object)
  • removed: class BuildError(RoutingException, LookupError)
  • removed: class EndpointPrefix(RuleFactory)
  • removed: class FloatConverter(NumberConverter)
  • removed: class IntegerConverter(NumberConverter)
  • removed: class Map(object)
  • removed: class MapAdapter(object)
  • removed: class NumberConverter(BaseConverter)
  • removed: class PathConverter(BaseConverter)
  • removed: class RequestAliasRedirect(RoutingException)
  • removed: class RequestPath(RoutingException)
  • removed: class RequestRedirect(HTTPException, RoutingException)
  • removed: class RoutingException(Exception)
  • removed: class Rule(RuleFactory)
  • removed: class RuleFactory(object)
  • removed: class RuleTemplate(object)
  • removed: class RuleTemplateFactory(RuleFactory)
  • removed: class Subdomain(RuleFactory)
  • removed: class Submount(RuleFactory)
  • removed: class UUIDConverter(BaseConverter)
  • removed: class UnicodeConverter(BaseConverter)
  • removed: class ValidationError(ValueError)
  • removed: class WebsocketMismatch(BadRequest)
  • removed: constructor AnyConverter(map, *items)
  • removed: constructor BaseConverter(map)
  • removed: constructor BuildError(endpoint, values, method, adapter=…)
  • removed: constructor EndpointPrefix(prefix, rules)
  • removed: constructor FloatConverter(map, min=…, max=…, signed=…)
  • removed: constructor Map(rules=…, default_subdomain=…, charset=…, strict_slashes=…, merge_slashes=…, redirect_defaults=…, converters=…, sort_parameters=…, sort_key=…, encoding_errors=…, host_matching=…)
  • removed: constructor MapAdapter(map, server_name, script_name, subdomain, url_scheme, path_info, default_method, query_args=…)
  • removed: constructor NumberConverter(map, fixed_digits=…, min=…, max=…, signed=…)
  • removed: constructor RequestAliasRedirect(matched_values)
  • removed: constructor RequestPath(path_info)
  • removed: constructor RequestRedirect(new_url)
  • removed: constructor Rule(string, defaults=…, subdomain=…, methods=…, build_only=…, endpoint=…, strict_slashes=…, merge_slashes=…, redirect_to=…, alias=…, host=…, websocket=…)
  • removed: constructor RuleTemplate(rules)
  • removed: constructor RuleTemplateFactory(rules, context)
  • removed: constructor Subdomain(subdomain, rules)
  • removed: constructor Submount(path, rules)
  • removed: constructor UnicodeConverter(map, minlength=…, maxlength=…, length=…)
  • removed: field BaseConverter.regex
  • removed: field BaseConverter.weight
  • removed: field FloatConverter.num_convert
  • removed: field FloatConverter.regex
  • removed: field IntegerConverter.num_convert
  • removed: field IntegerConverter.regex
  • removed: field Map.default_converters
  • removed: field Map.lock_class
  • removed: field NumberConverter.weight
  • removed: field PathConverter.regex
  • removed: field PathConverter.weight
  • removed: field RequestRedirect.code
  • removed: field UUIDConverter.regex
  • removed: function parse_converter_args(argstr)
  • removed: function parse_rule(rule)
  • removed: method BaseConverter.to_python(value)
  • removed: method BaseConverter.to_url(value)
  • removed: method BuildError.closest_rule(adapter)
  • removed: method EndpointPrefix.get_rules(map)
  • removed: method Map.add(rulefactory)
  • removed: method Map.bind(server_name, script_name=…, subdomain=…, url_scheme=…, default_method=…, path_info=…, query_args=…)
  • removed: method Map.bind_to_environ(environ, server_name=…, subdomain=…)
  • removed: method Map.is_endpoint_expecting(endpoint, *arguments)
  • removed: method Map.iter_rules(endpoint=…)
  • removed: method Map.update()
  • removed: method MapAdapter.allowed_methods(path_info=…)
  • removed: method MapAdapter.build(endpoint, values=…, method=…, force_external=…, append_unknown=…)
  • removed: method MapAdapter.dispatch(view_func, path_info=…, method=…, catch_http_exceptions=…)
  • removed: method MapAdapter.encode_query_args(query_args)
  • removed: method MapAdapter.get_default_redirect(rule, method, values, query_args)
  • removed: method MapAdapter.get_host(domain_part)
  • removed: method MapAdapter.make_alias_redirect_url(path, endpoint, values, method, query_args)
  • removed: method MapAdapter.make_redirect_url(path_info, query_args=…, domain_part=…)
  • removed: method MapAdapter.match(path_info=…, method=…, return_rule=…, query_args=…, websocket=…)
  • removed: method MapAdapter.test(path_info=…, method=…)
  • removed: method NumberConverter.to_python(value)
  • removed: method NumberConverter.to_url(value)
  • removed: method RequestRedirect.get_response(environ=…)
  • removed: method Rule.bind(map, rebind=…)
  • removed: method Rule.build(values, append_unknown=…)
  • removed: method Rule.build_compare_key()
  • removed: method Rule.compile()
  • removed: method Rule.empty()
  • removed: method Rule.get_converter(variable_name, converter_name, args, kwargs)
  • removed: method Rule.get_empty_kwargs()
  • removed: method Rule.get_rules(map)
  • removed: method Rule.match(path, method=…)
  • removed: method Rule.match_compare_key()
  • removed: method Rule.provides_defaults_for(rule)
  • removed: method Rule.refresh()
  • removed: method Rule.suitable_for(values, method=…)
  • removed: method RuleFactory.get_rules(map)
  • removed: method RuleTemplateFactory.get_rules(map)
  • removed: method Subdomain.get_rules(map)
  • removed: method Submount.get_rules(map)
  • removed: method UUIDConverter.to_python(value)
  • removed: method UUIDConverter.to_url(value)
  • removed: property BuildError.suggested
  • removed: property NumberConverter.signed_regex
  • removed: variable DEFAULT_CONVERTERS
  • added: export AnyConverter
  • added: export BaseConverter
  • added: export BuildError
  • added: export EndpointPrefix
  • added: export FloatConverter
  • added: export IntegerConverter
  • added: export Map
  • added: export MapAdapter
  • added: export NoMatch
  • added: export PathConverter
  • added: export RequestAliasRedirect
  • added: export RequestPath
  • added: export RequestRedirect
  • added: export RoutingException
  • added: export Rule
  • added: export RuleFactory
  • added: export RuleTemplate
  • added: export RuleTemplateFactory
  • added: export StateMachineMatcher
  • added: export Subdomain
  • added: export Submount
  • added: export UUIDConverter
  • added: export UnicodeConverter
  • added: export ValidationError
  • added: export WebsocketMismatch
  • added: export parse_converter_args
  • added: class AnyConverter(BaseConverter)
  • added: class BaseConverter
  • added: class FloatConverter(NumberConverter)
  • added: class IntegerConverter(NumberConverter)
  • added: class NumberConverter(BaseConverter)
  • added: class PathConverter(BaseConverter)
  • added: class UUIDConverter(BaseConverter)
  • added: class UnicodeConverter(BaseConverter)
  • added: class ValidationError(ValueError)
  • added: constructor AnyConverter(map: Map, *items: str) -> None
  • added: constructor BaseConverter(map: Map, *args: t.Any, **kwargs: t.Any) -> None
  • added: constructor FloatConverter(map: Map, min: float | None=…, max: float | None=…, signed: bool=…) -> None
  • added: constructor NumberConverter(map: Map, fixed_digits: int=…, min: int | None=…, max: int | None=…, signed: bool=…) -> None
  • added: constructor UnicodeConverter(map: Map, minlength: int=…, maxlength: int | None=…, length: int | None=…) -> None
  • added: field BaseConverter.part_isolating
  • added: field BaseConverter.regex
  • added: field BaseConverter.weight
  • added: field FloatConverter.num_convert
  • added: field FloatConverter.regex
  • added: field IntegerConverter.regex
  • added: field NumberConverter.num_convert: t.Callable
  • added: field NumberConverter.weight
  • added: field PathConverter.regex
  • added: field PathConverter.weight
  • added: field UUIDConverter.regex
  • added: method AnyConverter.to_url(value: t.Any) -> str
  • added: method BaseConverter.to_python(value: str) -> t.Any
  • added: method BaseConverter.to_url(value: t.Any) -> str
  • added: method NumberConverter.to_python(value: str) -> t.Any
  • added: method NumberConverter.to_url(value: t.Any) -> str
  • added: method UUIDConverter.to_python(value: str) -> uuid.UUID
  • added: method UUIDConverter.to_url(value: uuid.UUID) -> str
  • added: property NumberConverter.signed_regex -> str
  • added: variable DEFAULT_CONVERTERS: t.Mapping[str, type[BaseConverter]]
  • added: class BuildError(RoutingException, LookupError)
  • added: class NoMatch(Exception)
  • added: class RequestAliasRedirect(RoutingException)
  • added: class RequestPath(RoutingException)
  • added: class RequestRedirect(HTTPException, RoutingException)
  • added: class RoutingException(Exception)
  • added: class WebsocketMismatch(BadRequest)
  • added: constructor BuildError(endpoint: str, values: t.Mapping[str, t.Any], method: str | None, adapter: MapAdapter | None=…) -> None
  • added: constructor NoMatch(have_match_for: set[str], websocket_mismatch: bool) -> None
  • added: constructor RequestAliasRedirect(matched_values: t.Mapping[str, t.Any], endpoint: str) -> None
  • added: constructor RequestPath(path_info: str) -> None
  • added: constructor RequestRedirect(new_url: str) -> None
  • added: field RequestRedirect.code
  • added: method BuildError.closest_rule(adapter: MapAdapter | None) -> Rule | None
  • added: method RequestRedirect.get_response(environ: WSGIEnvironment | Request | None=…, scope: dict | None=…) -> Response
  • added: property BuildError.suggested -> Rule | None
  • added: class Map
  • added: class MapAdapter
  • added: constructor Map(rules: t.Iterable[RuleFactory] | None=…, default_subdomain: str=…, charset: str | None=…, strict_slashes: bool=…, merge_slashes: bool=…, redirect_defaults: bool=…, converters: t.Mapping[str, type[BaseConverter]] | None=…, sort_parameters: bool=…, sort_key: t.Callable[[t.Any], t.Any] | None=…, encoding_errors: str | None=…, host_matching: bool=…) -> None
  • added: constructor MapAdapter(map: Map, server_name: str, script_name: str, subdomain: str | None, url_scheme: str, path_info: str, default_method: str, query_args: t.Mapping[str, t.Any] | str | None=…)
  • added: field Map.default_converters
  • added: field Map.lock_class
  • added: method Map.add(rulefactory: RuleFactory) -> None
  • added: method Map.bind(server_name: str, script_name: str | None=…, subdomain: str | None=…, url_scheme: str=…, default_method: str=…, path_info: str | None=…, query_args: t.Mapping[str, t.Any] | str | None=…) -> MapAdapter
  • added: method Map.bind_to_environ(environ: WSGIEnvironment | Request, server_name: str | None=…, subdomain: str | None=…) -> MapAdapter
  • added: method Map.is_endpoint_expecting(endpoint: str, *arguments: str) -> bool
  • added: method Map.iter_rules(endpoint: str | None=…) -> t.Iterator[Rule]
  • added: method Map.update() -> None
  • added: method MapAdapter.allowed_methods(path_info: str | None=…) -> t.Iterable[str]
  • added: method MapAdapter.build(endpoint: str, values: t.Mapping[str, t.Any] | None=…, method: str | None=…, force_external: bool=…, append_unknown: bool=…, url_scheme: str | None=…) -> str
  • added: method MapAdapter.dispatch(view_func: t.Callable[[str, t.Mapping[str, t.Any]], WSGIApplication], path_info: str | None=…, method: str | None=…, catch_http_exceptions: bool=…) -> WSGIApplication
  • added: method MapAdapter.encode_query_args(query_args: t.Mapping[str, t.Any] | str) -> str
  • added: method MapAdapter.get_default_redirect(rule: Rule, method: str, values: t.MutableMapping[str, t.Any], query_args: t.Mapping[str, t.Any] | str) -> str | None
  • added: method MapAdapter.get_host(domain_part: str | None) -> str
  • added: method MapAdapter.make_alias_redirect_url(path: str, endpoint: str, values: t.Mapping[str, t.Any], method: str, query_args: t.Mapping[str, t.Any] | str) -> str
  • added: method MapAdapter.make_redirect_url(path_info: str, query_args: t.Mapping[str, t.Any] | str | None=…, domain_part: str | None=…) -> str
  • added: method MapAdapter.match(path_info: str | None=…, method: str | None=…, return_rule: t.Literal[False]=…, query_args: t.Mapping[str, t.Any] | str | None=…, websocket: bool | None=…) -> tuple[str, t.Mapping[str, t.Any]] | (path_info: str | None=…, method: str | None=…, return_rule: t.Literal[True]=…, query_args: t.Mapping[str, t.Any] | str | None=…, websocket: bool | None=…) -> tuple[Rule, t.Mapping…
  • added: method MapAdapter.test(path_info: str | None=…, method: str | None=…) -> bool
  • added: class SlashRequired(Exception)
  • added: class State
  • added: class StateMachineMatcher
  • added: constructor StateMachineMatcher(merge_slashes: bool) -> None
  • added: field State.dynamic: list[tuple[RulePart, State]]
  • added: field State.rules: list[Rule]
  • added: field State.static: dict[str, State]
  • added: method StateMachineMatcher.add(rule: Rule) -> None
  • added: method StateMachineMatcher.match(domain: str, path: str, method: str, websocket: bool) -> tuple[Rule, t.MutableMapping[str, t.Any]]
  • added: method StateMachineMatcher.update() -> None
  • added: class EndpointPrefix(RuleFactory)
  • added: class Rule(RuleFactory)
  • added: class RuleFactory
  • added: class RulePart
  • added: class RuleTemplate
  • added: class RuleTemplateFactory(RuleFactory)
  • added: class Subdomain(RuleFactory)
  • added: class Submount(RuleFactory)
  • added: class Weighting(t.NamedTuple)
  • added: constructor EndpointPrefix(prefix: str, rules: t.Iterable[RuleFactory]) -> None
  • added: constructor Rule(string: str, defaults: t.Mapping[str, t.Any] | None=…, subdomain: str | None=…, methods: t.Iterable[str] | None=…, build_only: bool=…, endpoint: str | None=…, strict_slashes: bool | None=…, merge_slashes: bool | None=…, redirect_to: str | t.Callable[..., str] | None=…, alias: bool=…, host: str | None=…, websocket: bool=…) -> None
  • added: constructor RuleTemplate(rules: t.Iterable[Rule]) -> None
  • added: constructor RuleTemplateFactory(rules: t.Iterable[RuleFactory], context: dict[str, t.Any]) -> None
  • added: constructor Subdomain(subdomain: str, rules: t.Iterable[RuleFactory]) -> None
  • added: constructor Submount(path: str, rules: t.Iterable[RuleFactory]) -> None
  • added: field RulePart.content: str
  • added: field RulePart.final: bool
  • added: field RulePart.static: bool
  • added: field RulePart.suffixed: bool
  • added: field RulePart.weight: Weighting
  • added: field Weighting.argument_weights: list[int]
  • added: field Weighting.number_argument_weights: int
  • added: field Weighting.number_static_weights: int
  • added: field Weighting.static_weights: list[tuple[int, int]]
  • added: function parse_converter_args(argstr: str) -> tuple[t.Tuple, dict[str, t.Any]]
  • added: method EndpointPrefix.get_rules(map: Map) -> t.Iterator[Rule]
  • added: method Rule.bind(map: Map, rebind: bool=…) -> None
  • added: method Rule.build(values: t.Mapping[str, t.Any], append_unknown: bool=…) -> tuple[str, str] | None
  • added: method Rule.build_compare_key() -> tuple[int, int, int]
  • added: method Rule.compile() -> None
  • added: method Rule.empty() -> Rule
  • added: method Rule.get_converter(variable_name: str, converter_name: str, args: t.Tuple, kwargs: t.Mapping[str, t.Any]) -> BaseConverter
  • added: method Rule.get_empty_kwargs() -> t.Mapping[str, t.Any]
  • added: method Rule.get_rules(map: Map) -> t.Iterator[Rule]
  • added: method Rule.provides_defaults_for(rule: Rule) -> bool
  • added: method Rule.refresh() -> None
  • added: method Rule.suitable_for(values: t.Mapping[str, t.Any], method: str | None=…) -> bool
  • added: method RuleFactory.get_rules(map: Map) -> t.Iterable[Rule]
  • added: method RuleTemplateFactory.get_rules(map: Map) -> t.Iterator[Rule]
  • added: method Subdomain.get_rules(map: Map) -> t.Iterator[Rule]
  • added: method Submount.get_rules(map: Map) -> t.Iterator[Rule]
  • added: function is_resource_modified(http_range: str | None=…, http_if_range: str | None=…, http_if_modified_since: str | None=…, http_if_none_match: str | None=…, http_if_match: str | None=…, etag: str | None=…, data: bytes | None=…, last_modified: datetime | str | None=…, ignore_if_range: bool=…) -> bool
  • added: function parse_cookie(cookie: str | None=…, charset: str | None=…, errors: str | None=…, cls: type[ds.MultiDict] | None=…) -> ds.MultiDict[str, str]
  • added: class Data(Event)
  • added: class Epilogue(Event)
  • added: class Event
  • added: class Field(Event)
  • added: class File(Event)
  • added: class MultipartDecoder
  • added: class MultipartEncoder
  • added: class NeedData(Event)
  • added: class Preamble(Event)
  • added: class State(Enum)
  • added: constructor MultipartDecoder(boundary: bytes, max_form_memory_size: int | None=…, *, max_parts: int | None=…) -> None
  • added: constructor MultipartEncoder(boundary: bytes) -> None
  • added: field Data.data: bytes
  • added: field Data.more_data: bool
  • added: field Epilogue.data: bytes
  • added: field Field.headers: Headers
  • added: field Field.name: str
  • added: field File.filename: str
  • added: field File.headers: Headers
  • added: field File.name: str
  • added: field Preamble.data: bytes
  • added: field State.COMPLETE
  • added: field State.DATA
  • added: field State.DATA_START
  • added: field State.EPILOGUE
  • added: field State.PART
  • added: field State.PREAMBLE
  • added: method MultipartDecoder.last_newline(data: bytes) -> int
  • added: method MultipartDecoder.next_event() -> Event
  • added: method MultipartDecoder.receive_data(data: bytes | None) -> None
  • added: method MultipartEncoder.send_event(event: Event) -> bytes
  • added: variable BLANK_LINE_RE
  • added: variable HEADER_CONTINUATION_RE
  • added: variable LINE_BREAK
  • added: variable LINE_BREAK_RE
  • added: variable NEED_DATA
  • added: variable SEARCH_EXTRA_LENGTH
  • added: class Request
  • added: constructor Request(method: str, scheme: str, server: tuple[str, int | None] | None, root_path: str, path: str, query_string: bytes, headers: Headers, remote_addr: str | None) -> None
  • added: field Request.access_control_request_headers
  • added: field Request.access_control_request_method
  • added: field Request.content_encoding
  • added: field Request.content_md5
  • added: field Request.content_type
  • added: field Request.date
  • added: field Request.dict_storage_class: type[MultiDict]
  • added: field Request.list_storage_class: type[t.List]
  • added: field Request.max_forwards
  • added: field Request.origin
  • added: field Request.parameter_storage_class: type[MultiDict]
  • added: field Request.referrer
  • added: field Request.trusted_hosts: list[str] | None
  • added: field Request.user_agent_class: type[UserAgent]
  • added: property Request.accept_charsets -> CharsetAccept
  • added: property Request.accept_encodings -> Accept
  • added: property Request.accept_languages -> LanguageAccept
  • added: property Request.accept_mimetypes -> MIMEAccept
  • added: property Request.access_route -> list[str]
  • added: property Request.args -> MultiDict[str, str]
  • added: property Request.authorization -> Authorization | None
  • added: property Request.base_url -> str
  • added: property Request.cache_control -> RequestCacheControl
  • added: property Request.charset -> str
  • added: property Request.content_length -> int | None
  • added: property Request.cookies -> ImmutableMultiDict[str, str]
  • added: property Request.encoding_errors -> str
  • added: property Request.full_path -> str
  • added: property Request.host -> str
  • added: property Request.host_url -> str
  • added: property Request.if_match -> ETags
  • added: property Request.if_modified_since -> datetime | None
  • added: property Request.if_none_match -> ETags
  • added: property Request.if_range -> IfRange
  • added: property Request.if_unmodified_since -> datetime | None
  • added: property Request.is_json -> bool
  • added: property Request.is_secure -> bool
  • added: property Request.mimetype -> str
  • added: property Request.mimetype_params -> dict[str, str]
  • added: property Request.pragma -> HeaderSet
  • added: property Request.range -> Range | None
  • added: property Request.root_url -> str
  • added: property Request.url -> str
  • added: property Request.url_charset -> str
  • added: property Request.user_agent -> UserAgent
  • added: class Response
  • added: constructor Response(status: int | str | HTTPStatus | None=…, headers: t.Mapping[str, str | t.Iterable[str]] | t.Iterable[tuple[str, str]] | None=…, mimetype: str | None=…, content_type: str | None=…) -> None
  • added: field Response.accept_ranges
  • added: field Response.access_control_allow_headers
  • added: field Response.access_control_allow_methods
  • added: field Response.access_control_allow_origin
  • added: field Response.access_control_expose_headers
  • added: field Response.access_control_max_age
  • added: field Response.age
  • added: field Response.allow
  • added: field Response.content_encoding
  • added: field Response.content_language
  • added: field Response.content_length
  • added: field Response.content_location
  • added: field Response.content_md5
  • added: field Response.content_type
  • added: field Response.cross_origin_embedder_policy
  • added: field Response.cross_origin_opener_policy
  • added: field Response.date
  • added: field Response.default_mimetype: str | None
  • added: field Response.default_status
  • added: field Response.expires
  • added: field Response.headers: Headers
  • added: field Response.last_modified
  • added: field Response.location
  • added: field Response.max_cookie_size
  • added: field Response.vary
  • added: method Response.delete_cookie(key: str, path: str | None=…, domain: str | None=…, secure: bool=…, httponly: bool=…, samesite: str | None=…) -> None
  • added: method Response.get_etag() -> tuple[str, bool] | tuple[None, None]
  • added: method Response.set_cookie(key: str, value: str=…, max_age: timedelta | int | None=…, expires: str | datetime | int | float | None=…, path: str | None=…, domain: str | None=…, secure: bool=…, httponly: bool=…, samesite: str | None=…) -> None
  • added: method Response.set_etag(etag: str, weak: bool=…) -> None
  • added: property Response.access_control_allow_credentials -> bool
  • added: property Response.cache_control -> ResponseCacheControl
  • added: property Response.charset -> str
  • added: property Response.content_range -> ContentRange
  • added: property Response.content_security_policy -> ContentSecurityPolicy
  • added: property Response.content_security_policy_report_only -> ContentSecurityPolicy
  • added: property Response.is_json -> bool
  • added: property Response.mimetype -> str | None
  • added: property Response.mimetype_params -> dict[str, str]
  • added: property Response.retry_after -> datetime | None
  • added: property Response.status -> str
  • added: property Response.status_code -> int
  • added: property Response.www_authenticate -> WWWAuthenticate
  • added: function get_content_length(http_content_length: str | None=…, http_transfer_encoding: str | None=…) -> int | None
  • added: function get_current_url(scheme: str, host: str, root_path: str | None=…, path: str | None=…, query_string: bytes | None=…) -> str
  • added: function get_host(scheme: str, host_header: str | None, server: tuple[str, int | None] | None=…, trusted_hosts: t.Iterable[str] | None=…) -> str
  • added: function host_is_trusted(hostname: str, trusted_list: t.Iterable[str]) -> bool
  • removed: function pbkdf2_bin(data, salt, iterations=…, keylen=…, hashfunc=…)
  • removed: function pbkdf2_hex(data, salt, iterations=…, keylen=…, hashfunc=…)
  • removed: function safe_str_cmp(a, b)
  • changed: function check_password_hash(pwhash, password) → function check_password_hash(pwhash: str, password: str) -> bool
  • changed: function gen_salt(length) → function gen_salt(length: int) -> str
  • changed: function generate_password_hash(password, method=…, salt_length=…) → function generate_password_hash(password: str, method: str=…, salt_length: int=…) -> str
  • changed: function safe_join(directory, *pathnames) → function safe_join(directory: str, *pathnames: str) -> str | None
  • removed: function main()
  • removed: function run_with_reloader(*args, **kwargs)
  • removed: method BaseWSGIServer.get_request()
  • removed: method WSGIRequestHandler.get_header_items()
  • removed: method WSGIRequestHandler.handle_one_request()
  • removed: method WSGIRequestHandler.initiate_shutdown()
  • removed: method WSGIRequestHandler.send_response(code, message=…)
  • removed: method WSGIRequestHandler.version_string()
  • removed: property WSGIRequestHandler.server_version
  • removed: variable BaseRequestHandler
  • removed: variable ThreadingMixIn
  • removed: variable can_open_by_fd
  • removed: variable click
  • changed: class BaseWSGIServer(HTTPServer, object) → class BaseWSGIServer(HTTPServer)
  • changed: class ForkingMixIn(object) → class ForkingMixIn
  • changed: class ThreadedWSGIServer(ThreadingMixIn, BaseWSGIServer) → class ThreadedWSGIServer(socketserver.ThreadingMixIn, BaseWSGIServer)
  • changed: class WSGIRequestHandler(BaseHTTPRequestHandler, object) → class WSGIRequestHandler(BaseHTTPRequestHandler)
  • changed: constructor BaseWSGIServer(host, port, app, handler=…, passthrough_errors=…, ssl_context=…, fd=…) → constructor BaseWSGIServer(host: str, port: int, app: WSGIApplication, handler: type[WSGIRequestHandler] | None=…, passthrough_errors: bool=…, ssl_context: _TSSLContextArg | None=…, fd: int | None=…) -> None
  • changed: constructor DechunkedInput(rfile) → constructor DechunkedInput(rfile: t.IO[bytes]) -> None
  • changed: constructor ForkingWSGIServer(host, port, app, processes=…, handler=…, passthrough_errors=…, ssl_context=…, fd=…) → constructor ForkingWSGIServer(host: str, port: int, app: WSGIApplication, processes: int=…, handler: type[WSGIRequestHandler] | None=…, passthrough_errors: bool=…, ssl_context: _TSSLContextArg | None=…, fd: int | None=…) -> None
  • changed: function generate_adhoc_ssl_context() → function generate_adhoc_ssl_context() -> ssl.SSLContext
  • changed: function generate_adhoc_ssl_pair(cn=…) → function generate_adhoc_ssl_pair(cn: str | None=…) -> tuple[Certificate, RSAPrivateKeyWithSerialization]
  • changed: function get_sockaddr(host, port, family) → function get_sockaddr(host: str, port: int, family: socket.AddressFamily) -> tuple[str, int] | str
  • changed: function is_running_from_reloader() → function is_running_from_reloader() -> bool
  • changed: function is_ssl_error(error=…) → function is_ssl_error(error: Exception | None=…) -> bool
  • changed: function load_ssl_context(cert_file, pkey_file=…, protocol=…) → function load_ssl_context(cert_file: str, pkey_file: str | None=…, protocol: int | None=…) -> ssl.SSLContext
  • changed: function make_server(host=…, port=…, app=…, threaded=…, processes=…, request_handler=…, passthrough_errors=…, ssl_context=…, fd=…) → function make_server(host: str, port: int, app: WSGIApplication, threaded: bool=…, processes: int=…, request_handler: type[WSGIRequestHandler] | None=…, passthrough_errors: bool=…, ssl_context: _TSSLContextArg | None=…, fd: int | None=…) -> BaseWSGIServer
  • changed: function make_ssl_devcert(base_path, host=…, cn=…) → function make_ssl_devcert(base_path: str, host: str | None=…, cn: str | None=…) -> tuple[str, str]
  • changed: function run_simple(hostname, port, application, use_reloader=…, use_debugger=…, use_evalex=…, extra_files=…, reloader_interval=…, reloader_type=…, threaded=…, processes=…, request_handler=…, static_files=…, passthrough_errors=…, ssl_context=…) → function run_simple(hostname: str, port: int, application: WSGIApplication, use_reloader: bool=…, use_debugger: bool=…, use_evalex: bool=…, extra_files: t.Iterable[str] | None=…, exclude_patterns: t.Iterable[str] | None=…, reloader_interval: int=…, reloader_type: str=…, threaded: bool=…, processes: int=…, request_handler: type[WSGIRequestHandler] | None=…, static_files: dict[str, str | tuple[str,…
  • changed: function select_address_family(host, port) → function select_address_family(host: str, port: int) -> socket.AddressFamily
  • changed: method BaseWSGIServer.handle_error(request, client_address) → method BaseWSGIServer.handle_error(request: t.Any, client_address: tuple[str, int] | str) -> None
  • changed: method BaseWSGIServer.log(type, message, *args) → method BaseWSGIServer.log(type: str, message: str, *args: t.Any) -> None
  • changed: method BaseWSGIServer.serve_forever() → method BaseWSGIServer.serve_forever(poll_interval: float=…) -> None
  • changed: method DechunkedInput.read_chunk_len() → method DechunkedInput.read_chunk_len() -> int
  • changed: method DechunkedInput.readable() → method DechunkedInput.readable() -> bool
  • changed: method DechunkedInput.readinto(buf) → method DechunkedInput.readinto(buf: bytearray) -> int
  • changed: method WSGIRequestHandler.address_string() → method WSGIRequestHandler.address_string() -> str
  • changed: method WSGIRequestHandler.connection_dropped(error, environ=…) → method WSGIRequestHandler.connection_dropped(error: BaseException, environ: WSGIEnvironment | None=…) -> None
  • changed: method WSGIRequestHandler.handle() → method WSGIRequestHandler.handle() -> None
  • changed: method WSGIRequestHandler.log(type, message, *args) → method WSGIRequestHandler.log(type: str, message: str, *args: t.Any) -> None
  • changed: method WSGIRequestHandler.log_error(*args) → method WSGIRequestHandler.log_error(format: str, *args: t.Any) -> None
  • changed: method WSGIRequestHandler.log_message(format, *args) → method WSGIRequestHandler.log_message(format: str, *args: t.Any) -> None
  • changed: method WSGIRequestHandler.log_request(code=…, size=…) → method WSGIRequestHandler.log_request(code: int | str=…, size: int | str=…) -> None
  • changed: method WSGIRequestHandler.make_environ() → method WSGIRequestHandler.make_environ() -> WSGIEnvironment
  • changed: method WSGIRequestHandler.port_integer() → method WSGIRequestHandler.port_integer() -> int
  • changed: method WSGIRequestHandler.run_wsgi() → method WSGIRequestHandler.run_wsgi() -> None
  • added: field BaseWSGIServer.allow_reuse_address
  • added: field WSGIRequestHandler.server: BaseWSGIServer
  • added: function get_interface_ip(family: socket.AddressFamily) -> str
  • added: method BaseWSGIServer.log_startup() -> None
  • added: property WSGIRequestHandler.server_version -> str
  • removed: function render_testapp(req)
  • removed: variable logo
  • changed: function iter_sys_path() → function iter_sys_path() -> t.Iterator[tuple[str, bool, bool]]
  • changed: function test_app(environ, start_response) → function test_app(req: Request) -> Response
  • removed: class Href(object)
  • removed: constructor Href(base=…, charset=…, sort=…, key=…)
  • removed: method URL.encode_netloc()
  • removed: property BaseURL.ascii_host
  • removed: property BaseURL.auth
  • removed: property BaseURL.host
  • removed: property BaseURL.password
  • removed: property BaseURL.port
  • removed: property BaseURL.raw_password
  • removed: property BaseURL.raw_username
  • removed: property BaseURL.username
  • changed: function iri_to_uri(iri, charset=…, errors=…, safe_conversion=…) → function iri_to_uri(iri: str | tuple[str, str, str, str, str], charset: str | None=…, errors: str | None=…, safe_conversion: bool | None=…) -> str
  • changed: function uri_to_iri(uri, charset=…, errors=…) → function uri_to_iri(uri: str | tuple[str, str, str, str, str], charset: str | None=…, errors: str | None=…) -> str
  • changed: function url_decode(s, charset=…, decode_keys=…, include_empty=…, errors=…, separator=…, cls=…) → function url_decode(s: t.AnyStr, charset: str=…, include_empty: bool=…, errors: str=…, separator: str=…, cls: type[ds.MultiDict] | None=…) -> ds.MultiDict[str, str]
  • changed: function url_decode_stream(stream, charset=…, decode_keys=…, include_empty=…, errors=…, separator=…, cls=…, limit=…, return_iterator=…) → function url_decode_stream(stream: t.IO[bytes], charset: str=…, include_empty: bool=…, errors: str=…, separator: bytes=…, cls: type[ds.MultiDict] | None=…, limit: int | None=…) -> ds.MultiDict[str, str]
  • changed: function url_encode(obj, charset=…, encode_keys=…, sort=…, key=…, separator=…) → function url_encode(obj: t.Mapping[str, str] | t.Iterable[tuple[str, str]], charset: str=…, sort: bool=…, key: t.Callable[[tuple[str, str]], t.Any] | None=…, separator: str=…) -> str
  • changed: function url_encode_stream(obj, stream=…, charset=…, encode_keys=…, sort=…, key=…, separator=…) → function url_encode_stream(obj: t.Mapping[str, str] | t.Iterable[tuple[str, str]], stream: t.IO[str] | None=…, charset: str=…, sort: bool=…, key: t.Callable[[tuple[str, str]], t.Any] | None=…, separator: str=…) -> None
  • changed: function url_fix(s, charset=…) → function url_fix(s: str, charset: str=…) -> str
  • changed: function url_join(base, url, allow_fragments=…) → function url_join(base: str | tuple[str, str, str, str, str], url: str | tuple[str, str, str, str, str], allow_fragments: bool=…) -> str
  • changed: function url_parse(url, scheme=…, allow_fragments=…) → function url_parse(url: str, scheme: str | None=…, allow_fragments: bool=…) -> BaseURL
  • changed: function url_quote(string, charset=…, errors=…, safe=…, unsafe=…) → function url_quote(string: str | bytes, charset: str=…, errors: str=…, safe: str | bytes=…, unsafe: str | bytes=…) -> str
  • changed: function url_quote_plus(string, charset=…, errors=…, safe=…) → function url_quote_plus(string: str, charset: str=…, errors: str=…, safe: str=…) -> str
  • changed: function url_unparse(components) → function url_unparse(components: tuple[str, str, str, str, str]) -> str
  • changed: function url_unquote(string, charset=…, errors=…, unsafe=…) → function url_unquote(s: str | bytes, charset: str=…, errors: str=…, unsafe: str=…) -> str
  • changed: function url_unquote_plus(s, charset=…, errors=…) → function url_unquote_plus(s: str | bytes, charset: str=…, errors: str=…) -> str
  • changed: method BaseURL.decode_netloc() → method BaseURL.decode_netloc() -> str
  • changed: method BaseURL.decode_query(*args, **kwargs) → method BaseURL.decode_query(*args: t.Any, **kwargs: t.Any) -> ds.MultiDict[str, str]
  • changed: method BaseURL.get_file_location(pathformat=…) → method BaseURL.get_file_location(pathformat: str | None=…) -> tuple[str | None, str | None]
  • changed: method BaseURL.join(*args, **kwargs) → method BaseURL.join(*args: t.Any, **kwargs: t.Any) -> BaseURL
  • changed: method BaseURL.replace(**kwargs) → method BaseURL.replace(**kwargs: t.Any) -> BaseURL
  • changed: method BaseURL.to_iri_tuple() → method BaseURL.to_iri_tuple() -> BaseURL
  • changed: method BaseURL.to_uri_tuple() → method BaseURL.to_uri_tuple() -> BaseURL
  • changed: method BaseURL.to_url() → method BaseURL.to_url() -> str
  • changed: method BytesURL.decode(charset=…, errors=…) → method BytesURL.decode(charset: str=…, errors: str=…) -> URL
  • changed: method BytesURL.encode_netloc() → method BytesURL.encode_netloc() -> bytes
  • changed: method URL.encode(charset=…, errors=…) → method URL.encode(charset: str=…, errors: str=…) -> BytesURL
  • added: method BaseURL.encode_netloc() -> str
  • added: property BaseURL.ascii_host -> str | None
  • added: property BaseURL.auth -> str | None
  • added: property BaseURL.host -> str | None
  • added: property BaseURL.password -> str | None
  • added: property BaseURL.port -> int | None
  • added: property BaseURL.raw_password -> str | None
  • added: property BaseURL.raw_username -> str | None
  • added: property BaseURL.username -> str | None
  • added: class UserAgent
  • added: constructor UserAgent(string: str) -> None
  • added: field UserAgent.browser: str | None
  • added: field UserAgent.language: str | None
  • added: field UserAgent.platform: str | None
  • added: field UserAgent.version: str | None
  • added: method UserAgent.to_header() -> str
  • removed: class UserAgent(object)
  • removed: class UserAgentParser(object)
  • removed: constructor UserAgent(environ_or_string)
  • removed: constructor UserAgentParser()
  • removed: field UserAgentParser.browsers
  • removed: field UserAgentParser.platforms
  • removed: method UserAgent.to_header()
  • removed: class ArgumentValidationError(ValueError)
  • removed: class HTMLBuilder(object)
  • removed: constructor ArgumentValidationError(missing=…, extra=…, extra_positional=…)
  • removed: constructor HTMLBuilder(dialect)
  • removed: function bind_arguments(func, args, kwargs)
  • removed: function detect_utf_encoding(data)
  • removed: function escape(s)
  • removed: function format_string(string, context)
  • removed: function invalidate_cached_property(obj, name)
  • removed: function unescape(s)
  • removed: function validate_arguments(func, args, kwargs, drop_extra=…)
  • removed: variable html
  • removed: variable xhtml
  • changed: class cached_property(property) → class cached_property(property, t.Generic[_T])
  • changed: class environ_property(_DictAccessorProperty) → class environ_property(_DictAccessorProperty[_TAccessorValue])
  • changed: class header_property(_DictAccessorProperty) → class header_property(_DictAccessorProperty[_TAccessorValue])
  • changed: constructor ImportStringError(import_name, exception) → constructor ImportStringError(import_name: str, exception: BaseException) -> None
  • changed: constructor cached_property(func, name=…, doc=…) → constructor cached_property(fget: t.Callable[[t.Any], _T], name: str | None=…, doc: str | None=…) -> None
  • changed: field ImportStringError.exception → field ImportStringError.exception: BaseException
  • changed: field ImportStringError.import_name → field ImportStringError.import_name: str
  • changed: function append_slash_redirect(environ, code=…) → function append_slash_redirect(environ: WSGIEnvironment, code: int=…) -> Response
  • changed: function find_modules(import_path, include_packages=…, recursive=…) → function find_modules(import_path: str, include_packages: bool=…, recursive: bool=…) -> t.Iterator[str]
  • changed: function get_content_type(mimetype, charset) → function get_content_type(mimetype: str, charset: str) -> str
  • changed: function import_string(import_name, silent=…) → function import_string(import_name: str, silent: bool=…) -> t.Any
  • changed: function redirect(location, code=…, Response=…) → function redirect(location: str, code: int=…, Response: type[Response] | None=…) -> Response
  • changed: function secure_filename(filename) → function secure_filename(filename: str) -> str
  • changed: method environ_property.lookup(obj) → method environ_property.lookup(obj: Request) -> WSGIEnvironment
  • changed: method header_property.lookup(obj) → method header_property.lookup(obj: Request | Response) -> Headers
  • added: function send_file(path_or_file: os.PathLike | str | t.IO[bytes], environ: WSGIEnvironment, mimetype: str | None=…, as_attachment: bool=…, download_name: str | None=…, conditional: bool=…, etag: bool | str=…, last_modified: datetime | int | float | None=…, max_age: None | (int | t.Callable[[str | None], int | None])=…, use_x_sendfile: bool=…, response_class: type[Response] | None=…, _root_path: o…
  • added: function send_from_directory(directory: os.PathLike | str, path: os.PathLike | str, environ: WSGIEnvironment, **kwargs: t.Any) -> Response
  • removed: export AcceptMixin
  • removed: export AuthorizationMixin
  • removed: export BaseRequest
  • removed: export BaseResponse
  • removed: export CommonRequestDescriptorsMixin
  • removed: export CommonResponseDescriptorsMixin
  • removed: export ETagRequestMixin
  • removed: export ETagResponseMixin
  • removed: export PlainRequest
  • removed: export ResponseStreamMixin
  • removed: export StreamOnlyMixin
  • removed: export UserAgentMixin
  • removed: export WWWAuthenticateMixin
  • removed: class AcceptMixin(object)
  • removed: property AcceptMixin.accept_charsets
  • removed: property AcceptMixin.accept_encodings
  • removed: property AcceptMixin.accept_languages
  • removed: property AcceptMixin.accept_mimetypes
  • removed: class AuthorizationMixin(object)
  • removed: class WWWAuthenticateMixin(object)
  • removed: property AuthorizationMixin.authorization
  • removed: property WWWAuthenticateMixin.www_authenticate
  • removed: class BaseRequest(object)
  • removed: constructor BaseRequest(environ, populate_request=…, shallow=…)
  • removed: field BaseRequest.charset
  • removed: field BaseRequest.dict_storage_class
  • removed: field BaseRequest.disable_data_descriptor
  • removed: field BaseRequest.encoding_errors
  • removed: field BaseRequest.form_data_parser_class
  • removed: field BaseRequest.input_stream
  • removed: field BaseRequest.is_multiprocess
  • removed: field BaseRequest.is_multithread
  • removed: field BaseRequest.is_run_once
  • removed: field BaseRequest.is_secure
  • removed: field BaseRequest.list_storage_class
  • removed: field BaseRequest.max_content_length
  • removed: field BaseRequest.max_form_memory_size
  • removed: field BaseRequest.method
  • removed: field BaseRequest.parameter_storage_class
  • removed: field BaseRequest.query_string
  • removed: field BaseRequest.remote_user
  • removed: field BaseRequest.scheme
  • removed: field BaseRequest.trusted_hosts
  • removed: method BaseRequest.close()
  • removed: method BaseRequest.get_data(cache=…, as_text=…, parse_form_data=…)
  • removed: method BaseRequest.make_form_data_parser()
  • removed: property BaseRequest.access_route
  • removed: property BaseRequest.args
  • removed: property BaseRequest.base_url
  • removed: property BaseRequest.cookies
  • removed: property BaseRequest.data
  • removed: property BaseRequest.files
  • removed: property BaseRequest.form
  • removed: property BaseRequest.full_path
  • removed: property BaseRequest.headers
  • removed: property BaseRequest.host
  • removed: property BaseRequest.host_url
  • removed: property BaseRequest.path
  • removed: property BaseRequest.remote_addr
  • removed: property BaseRequest.script_root
  • removed: property BaseRequest.stream
  • removed: property BaseRequest.url
  • removed: property BaseRequest.url_charset
  • removed: property BaseRequest.url_root
  • removed: property BaseRequest.values
  • removed: property BaseRequest.want_form_data_parsed
  • removed: static method BaseRequest.application(f)
  • removed: static method BaseRequest.from_values(*args, **kwargs)
  • removed: class BaseResponse(object)
  • removed: constructor BaseResponse(response=…, status=…, headers=…, mimetype=…, content_type=…, direct_passthrough=…)
  • removed: field BaseResponse.autocorrect_location_header
  • removed: field BaseResponse.automatically_set_content_length
  • removed: field BaseResponse.charset
  • removed: field BaseResponse.data
  • removed: field BaseResponse.default_mimetype
  • removed: field BaseResponse.default_status
  • removed: field BaseResponse.implicit_sequence_conversion
  • removed: field BaseResponse.max_cookie_size
  • removed: method BaseResponse.calculate_content_length()
  • removed: method BaseResponse.call_on_close(func)
  • removed: method BaseResponse.close()
  • removed: method BaseResponse.delete_cookie(key, path=…, domain=…)
  • removed: method BaseResponse.freeze()
  • removed: method BaseResponse.get_app_iter(environ)
  • removed: method BaseResponse.get_data(as_text=…)
  • removed: method BaseResponse.get_wsgi_headers(environ)
  • removed: method BaseResponse.get_wsgi_response(environ)
  • removed: method BaseResponse.iter_encoded()
  • removed: method BaseResponse.make_sequence()
  • removed: method BaseResponse.set_cookie(key, value=…, max_age=…, expires=…, path=…, domain=…, secure=…, httponly=…, samesite=…)
  • removed: method BaseResponse.set_data(value)
  • removed: property BaseResponse.is_sequence
  • removed: property BaseResponse.is_streamed
  • removed: property BaseResponse.status
  • removed: property BaseResponse.status_code
  • removed: static method BaseResponse.force_type(response, environ=…)
  • removed: static method BaseResponse.from_app(app, environ, buffered=…)
  • removed: class CommonRequestDescriptorsMixin(object)
  • removed: class CommonResponseDescriptorsMixin(object)
  • removed: field CommonRequestDescriptorsMixin.content_encoding
  • removed: field CommonRequestDescriptorsMixin.content_md5
  • removed: field CommonRequestDescriptorsMixin.content_type
  • removed: field CommonRequestDescriptorsMixin.date
  • removed: field CommonRequestDescriptorsMixin.max_forwards
  • removed: field CommonRequestDescriptorsMixin.referrer
  • removed: field CommonResponseDescriptorsMixin.age
  • removed: field CommonResponseDescriptorsMixin.allow
  • removed: field CommonResponseDescriptorsMixin.content_encoding
  • removed: field CommonResponseDescriptorsMixin.content_language
  • removed: field CommonResponseDescriptorsMixin.content_length
  • removed: field CommonResponseDescriptorsMixin.content_location
  • removed: field CommonResponseDescriptorsMixin.content_md5
  • removed: field CommonResponseDescriptorsMixin.content_security_policy
  • removed: field CommonResponseDescriptorsMixin.content_security_policy_report_only
  • removed: field CommonResponseDescriptorsMixin.content_type
  • removed: field CommonResponseDescriptorsMixin.date
  • removed: field CommonResponseDescriptorsMixin.expires
  • removed: field CommonResponseDescriptorsMixin.last_modified
  • removed: field CommonResponseDescriptorsMixin.location
  • removed: field CommonResponseDescriptorsMixin.vary
  • removed: property CommonRequestDescriptorsMixin.content_length
  • removed: property CommonRequestDescriptorsMixin.mimetype
  • removed: property CommonRequestDescriptorsMixin.mimetype_params
  • removed: property CommonRequestDescriptorsMixin.pragma
  • removed: property CommonResponseDescriptorsMixin.mimetype
  • removed: property CommonResponseDescriptorsMixin.mimetype_params
  • removed: property CommonResponseDescriptorsMixin.retry_after
  • removed: class CORSRequestMixin(object)
  • removed: class CORSResponseMixin(object)
  • removed: field CORSRequestMixin.access_control_request_headers
  • removed: field CORSRequestMixin.access_control_request_method
  • removed: field CORSRequestMixin.origin
  • removed: field CORSResponseMixin.access_control_allow_headers
  • removed: field CORSResponseMixin.access_control_allow_methods
  • removed: field CORSResponseMixin.access_control_allow_origin
  • removed: field CORSResponseMixin.access_control_expose_headers
  • removed: field CORSResponseMixin.access_control_max_age
  • removed: property CORSResponseMixin.access_control_allow_credentials
  • removed: class ETagRequestMixin(object)
  • removed: class ETagResponseMixin(object)
  • removed: field ETagResponseMixin.accept_ranges
  • removed: method ETagResponseMixin.add_etag(overwrite=…, weak=…)
  • removed: method ETagResponseMixin.freeze(no_etag=…)
  • removed: method ETagResponseMixin.get_etag()
  • removed: method ETagResponseMixin.make_conditional(request_or_environ, accept_ranges=…, complete_length=…)
  • removed: method ETagResponseMixin.set_etag(etag, weak=…)
  • removed: property ETagRequestMixin.cache_control
  • removed: property ETagRequestMixin.if_match
  • removed: property ETagRequestMixin.if_modified_since
  • removed: property ETagRequestMixin.if_none_match
  • removed: property ETagRequestMixin.if_range
  • removed: property ETagRequestMixin.if_unmodified_since
  • removed: property ETagRequestMixin.range
  • removed: property ETagResponseMixin.cache_control
  • removed: property ETagResponseMixin.content_range
  • removed: class JSONMixin(object)
  • removed: field JSONMixin.json_module
  • removed: method JSONMixin.get_json(force=…, silent=…, cache=…)
  • removed: method JSONMixin.on_json_loading_failed(e)
  • removed: property JSONMixin.is_json
  • removed: property JSONMixin.json
  • removed: class PlainRequest(StreamOnlyMixin, Request)
  • removed: class StreamOnlyMixin(object)
  • removed: field StreamOnlyMixin.disable_data_descriptor
  • removed: field StreamOnlyMixin.want_form_data_parsed
  • changed: class Request(BaseRequest, AcceptMixin, ETagRequestMixin, UserAgentMixin, AuthorizationMixin, CORSRequestMixin, CommonRequestDescriptorsMixin) → class Request(_SansIORequest)
  • added: constructor Request(environ: WSGIEnvironment, populate_request: bool=…, shallow: bool=…) -> None
  • added: field Request.environ: WSGIEnvironment
  • added: field Request.form_data_parser_class: type[FormDataParser]
  • added: field Request.input_stream
  • added: field Request.is_multiprocess
  • added: field Request.is_multithread
  • added: field Request.is_run_once
  • added: field Request.json_module
  • added: field Request.max_content_length: int | None
  • added: field Request.max_form_memory_size: int | None
  • added: field Request.max_form_parts
  • added: field Request.remote_user
  • added: field Request.shallow: bool
  • added: method Request.close() -> None
  • added: method Request.get_data(cache: bool=…, as_text: t.Literal[False]=…, parse_form_data: bool=…) -> bytes | (cache: bool=…, as_text: t.Literal[True]=…, parse_form_data: bool=…) -> str
  • added: method Request.get_json(force: bool=…, silent: t.Literal[False]=…, cache: bool=…) -> t.Any | (force: bool=…, silent: bool=…, cache: bool=…) -> t.Any | None
  • added: method Request.make_form_data_parser() -> FormDataParser
  • added: method Request.on_json_loading_failed(e: ValueError | None) -> t.Any
  • added: property Request.data -> bytes
  • added: property Request.files -> ImmutableMultiDict[str, FileStorage]
  • added: property Request.form -> ImmutableMultiDict[str, str]
  • added: property Request.json -> t.Any | None
  • added: property Request.script_root -> str
  • added: property Request.stream -> t.IO[bytes]
  • added: property Request.url_root -> str
  • added: property Request.values -> CombinedMultiDict[str, str]
  • added: property Request.want_form_data_parsed -> bool
  • added: static method Request.application(f: t.Callable[[Request], WSGIApplication]) -> WSGIApplication
  • added: static method Request.from_values(*args: t.Any, **kwargs: t.Any) -> Request
  • removed: class ResponseStreamMixin(object)
  • removed: property ResponseStream.encoding
  • removed: property ResponseStreamMixin.stream
  • changed: class Response(BaseResponse, ETagResponseMixin, WWWAuthenticateMixin, CORSResponseMixin, ResponseStreamMixin, CommonResponseDescriptorsMixin) → class Response(_SansIOResponse)
  • changed: class ResponseStream(object) → class ResponseStream
  • changed: constructor ResponseStream(response) → constructor ResponseStream(response: Response)
  • changed: method ResponseStream.close() → method ResponseStream.close() -> None
  • changed: method ResponseStream.flush() → method ResponseStream.flush() -> None
  • changed: method ResponseStream.isatty() → method ResponseStream.isatty() -> bool
  • changed: method ResponseStream.tell() → method ResponseStream.tell() -> int
  • changed: method ResponseStream.write(value) → method ResponseStream.write(value: bytes) -> int
  • changed: method ResponseStream.writelines(seq) → method ResponseStream.writelines(seq: t.Iterable[bytes]) -> None
  • added: constructor Response(response: t.Iterable[bytes] | bytes | t.Iterable[str] | str | None=…, status: int | str | HTTPStatus | None=…, headers: t.Mapping[str, str | t.Iterable[str]] | t.Iterable[tuple[str, str]] | None=…, mimetype: str | None=…, content_type: str | None=…, direct_passthrough: bool=…) -> None
  • added: field Response.autocorrect_location_header
  • added: field Response.automatically_set_content_length
  • added: field Response.data
  • added: field Response.implicit_sequence_conversion
  • added: field Response.json_module
  • added: field Response.response: t.Iterable[str] | t.Iterable[bytes]
  • added: method Response.add_etag(overwrite: bool=…, weak: bool=…) -> None
  • added: method Response.calculate_content_length() -> int | None
  • added: method Response.call_on_close(func: t.Callable[[], t.Any]) -> t.Callable[[], t.Any]
  • added: method Response.close() -> None
  • added: method Response.freeze() -> None
  • added: method Response.get_app_iter(environ: WSGIEnvironment) -> t.Iterable[bytes]
  • added: method Response.get_data(as_text: t.Literal[False]=…) -> bytes | (as_text: t.Literal[True]) -> str
  • added: method Response.get_json(force: bool=…, silent: t.Literal[False]=…) -> t.Any | (force: bool=…, silent: bool=…) -> t.Any | None
  • added: method Response.get_wsgi_headers(environ: WSGIEnvironment) -> Headers
  • added: method Response.get_wsgi_response(environ: WSGIEnvironment) -> tuple[t.Iterable[bytes], str, list[tuple[str, str]]]
  • added: method Response.iter_encoded() -> t.Iterator[bytes]
  • added: method Response.make_conditional(request_or_environ: WSGIEnvironment | Request, accept_ranges: bool | str=…, complete_length: int | None=…) -> Response
  • added: method Response.make_sequence() -> None
  • added: method Response.set_data(value: bytes | str) -> None
  • added: property Response.is_sequence -> bool
  • added: property Response.is_streamed -> bool
  • added: property Response.json -> t.Any | None
  • added: property Response.stream -> ResponseStream
  • added: property ResponseStream.encoding -> str
  • added: static method Response.force_type(response: Response, environ: WSGIEnvironment | None=…) -> Response
  • added: static method Response.from_app(app: WSGIApplication, environ: WSGIEnvironment, buffered: bool=…) -> Response
  • removed: class UserAgentMixin(object)
  • removed: property UserAgentMixin.user_agent
  • removed: function extract_path_info(environ_or_baseurl, path_or_url, charset=…, errors=…, collapse_http_schemes=…)
  • removed: function get_query_string(environ)
  • removed: function get_script_name(environ, charset=…, errors=…)
  • removed: function host_is_trusted(hostname, trusted_list)
  • removed: function peek_path_info(environ, charset=…, errors=…)
  • removed: function pop_path_info(environ, charset=…, errors=…)
  • removed: method LimitedStream.read(size=…)
  • removed: method LimitedStream.readline(size=…)
  • removed: method LimitedStream.readlines(size=…)
  • removed: property LimitedStream.is_exhausted
  • changed: class ClosingIterator(object) → class ClosingIterator
  • changed: class FileWrapper(object) → class FileWrapper
  • changed: class LimitedStream(io.IOBase) → class LimitedStream(io.RawIOBase)
  • changed: constructor ClosingIterator(iterable, callbacks=…) → constructor ClosingIterator(iterable: t.Iterable[bytes], callbacks: None | (t.Callable[[], None] | t.Iterable[t.Callable[[], None]])=…) -> None
  • changed: constructor FileWrapper(file, buffer_size=…) → constructor FileWrapper(file: t.IO[bytes], buffer_size: int=…) -> None
  • changed: constructor LimitedStream(stream, limit) → constructor LimitedStream(stream: t.IO[bytes], limit: int, is_max: bool=…) -> None
  • changed: function get_content_length(environ) → function get_content_length(environ: WSGIEnvironment) -> int | None
  • changed: function get_current_url(environ, root_only=…, strip_querystring=…, host_only=…, trusted_hosts=…) → function get_current_url(environ: WSGIEnvironment, root_only: bool=…, strip_querystring: bool=…, host_only: bool=…, trusted_hosts: t.Iterable[str] | None=…) -> str
  • changed: function get_host(environ, trusted_hosts=…) → function get_host(environ: WSGIEnvironment, trusted_hosts: t.Iterable[str] | None=…) -> str
  • changed: function get_input_stream(environ, safe_fallback=…) → function get_input_stream(environ: WSGIEnvironment, safe_fallback: bool=…, max_content_length: int | None=…) -> t.IO[bytes]
  • changed: function get_path_info(environ, charset=…, errors=…) → function get_path_info(environ: WSGIEnvironment, charset: t.Any=…, errors: str | None=…) -> str
  • changed: function make_chunk_iter(stream, separator, limit=…, buffer_size=…, cap_at_buffer=…) → function make_chunk_iter(stream: t.Iterable[bytes] | t.IO[bytes], separator: bytes, limit: int | None=…, buffer_size: int=…, cap_at_buffer: bool=…) -> t.Iterator[bytes]
  • changed: function make_line_iter(stream, limit=…, buffer_size=…, cap_at_buffer=…) → function make_line_iter(stream: t.Iterable[bytes] | t.IO[bytes], limit: int | None=…, buffer_size: int=…, cap_at_buffer: bool=…) -> t.Iterator[bytes]
  • changed: function responder(f) → function responder(f: t.Callable[..., WSGIApplication]) -> WSGIApplication
  • changed: function wrap_file(environ, file, buffer_size=…) → function wrap_file(environ: WSGIEnvironment, file: t.IO[bytes], buffer_size: int=…) -> t.Iterable[bytes]
  • changed: method ClosingIterator.close() → method ClosingIterator.close() -> None
  • changed: method FileWrapper.close() → method FileWrapper.close() -> None
  • changed: method FileWrapper.seek(*args) → method FileWrapper.seek(*args: t.Any) -> None
  • changed: method FileWrapper.seekable() → method FileWrapper.seekable() -> bool
  • changed: method FileWrapper.tell() → method FileWrapper.tell() -> int | None
  • changed: method LimitedStream.exhaust(chunk_size=…) → method LimitedStream.exhaust() -> bytes
  • changed: method LimitedStream.on_disconnect() → method LimitedStream.on_disconnect(error: Exception | None=…) -> None
  • changed: method LimitedStream.on_exhausted() → method LimitedStream.on_exhausted() -> None
  • changed: method LimitedStream.readable() → method LimitedStream.readable() -> bool
  • changed: method LimitedStream.tell() → method LimitedStream.tell() -> int
  • added: method LimitedStream.readall() -> bytes
  • added: method LimitedStream.readinto(b: bytearray) -> int | None
  • added: property LimitedStream.is_exhausted -> bool