ProjectFlask/APIs/werkzeug-2.0.1.api

werkzeug._internal._ColorStreamHandler?2()
werkzeug._internal._DictAccessorProperty.lookup?4(instance: t.Any)
werkzeug._internal._DictAccessorProperty.read_only?7
werkzeug._internal._DictAccessorProperty?2(name: str, default: t.Optional[_TAccessorValue] = None, load_func: t.Optional[t.Callable[[str], _TAccessorValue]] = None, dump_func: t.Optional[t.Callable[[_TAccessorValue], str]] = None, read_only: t.Optional[bool] = None, doc: t.Optional[str] = None, )
werkzeug._internal._TAccessorValue?8
werkzeug._internal._check_str_tuple?5(value: t.Tuple[t.AnyStr, ...])
werkzeug._internal._cookie_parse_impl?5(b: bytes)
werkzeug._internal._cookie_quote?5(b: bytes)
werkzeug._internal._cookie_quoting_map?8
werkzeug._internal._cookie_re?8
werkzeug._internal._cookie_unquote?5(b: bytes)
werkzeug._internal._decode_idna?5(domain: t.Union[str, bytes])
werkzeug._internal._default_encoding?8
werkzeug._internal._dt_as_utc?5(dt: None)
werkzeug._internal._dt_as_utc?5(dt: datetime)
werkzeug._internal._dt_as_utc?5(dt: t.Optional[datetime])
werkzeug._internal._easteregg?5(app: t.Optional["WSGIApplication"] = None)
werkzeug._internal._encode_idna?5(domain: str)
werkzeug._internal._epoch_ord?8
werkzeug._internal._get_environ?5(obj: t.Union["WSGIEnvironment", "Request"])
werkzeug._internal._has_level_handler?5(logger: logging.Logger)
werkzeug._internal._legal_cookie_chars?8
werkzeug._internal._legal_cookie_chars_re?8
werkzeug._internal._log?5(type: str, message: str, *args: t.Any, **kwargs: t.Any)
werkzeug._internal._make_cookie_domain?5(domain: None)
werkzeug._internal._make_cookie_domain?5(domain: str)
werkzeug._internal._make_cookie_domain?5(domain: t.Optional[str])
werkzeug._internal._make_encode_wrapper?5(reference: bytes)
werkzeug._internal._make_encode_wrapper?5(reference: str)
werkzeug._internal._make_encode_wrapper?5(reference: t.AnyStr)
werkzeug._internal._missing?8
werkzeug._internal._octal_re?8
werkzeug._internal._parse_signature?5(func)
werkzeug._internal._quote_re?8
werkzeug._internal._signature_cache?8
werkzeug._internal._to_bytes?5(x: t.Union[str, bytes], charset: str = _default_encoding, errors: str = "strict")
werkzeug._internal._to_str?5(x: None, charset: t.Optional[str] = ..., errors: str = ..., allow_none_charset: bool = ..., )
werkzeug._internal._to_str?5(x: t.Any, charset: t.Optional[str] = ..., errors: str = ..., allow_none_charset: bool = ..., )
werkzeug._internal._to_str?5(x: t.Optional[t.Any], charset: t.Optional[str] = _default_encoding, errors: str = "strict", allow_none_charset: bool = False, )
werkzeug._internal._wsgi_decoding_dance?5(s: str, charset: str = "utf-8", errors: str = "replace")
werkzeug._internal._wsgi_encoding_dance?5(s: str, charset: str = "utf-8", errors: str = "replace")
werkzeug._internal.bzzzzzzz?4(gyver: bytes)
werkzeug._internal.decode_part?4(part: bytes)
werkzeug._internal.easteregged?4(environ: "WSGIEnvironment", start_response: "StartResponse")
werkzeug._internal.injecting_start_response?4(status: str, headers: t.List[t.Tuple[str, str]], exc_info: t.Any = None)
werkzeug._internal.parse?4(args, kwargs)
werkzeug._reloader.EventHandler.ignore_patterns?7
werkzeug._reloader.EventHandler.on_any_event?4(event)
werkzeug._reloader.EventHandler.patterns?7
werkzeug._reloader.EventHandler.reloader_name?7
werkzeug._reloader.ReloaderLoop.log_reload?4(filename: str)
werkzeug._reloader.ReloaderLoop.name?7
werkzeug._reloader.ReloaderLoop.restart_with_reloader?4()
werkzeug._reloader.ReloaderLoop.run?4()
werkzeug._reloader.ReloaderLoop.run_step?4()
werkzeug._reloader.ReloaderLoop.trigger_reload?4(filename: str)
werkzeug._reloader.ReloaderLoop?1(extra_files: t.Optional[t.Iterable[str]] = None, exclude_patterns: t.Optional[t.Iterable[str]] = None, interval: t.Union[int, float] = 1, )
werkzeug._reloader.StatReloaderLoop.name?7
werkzeug._reloader.StatReloaderLoop.run_step?4()
werkzeug._reloader.WatchdogReloaderLoop.run?4()
werkzeug._reloader.WatchdogReloaderLoop.run_step?4()
werkzeug._reloader.WatchdogReloaderLoop.trigger_reload?4(filename: str)
werkzeug._reloader.WatchdogReloaderLoop?1(*args: t.Any, **kwargs: t.Any)
werkzeug._reloader._find_common_roots?5(paths: t.Iterable[str])
werkzeug._reloader._find_stat_paths?5(extra_files: t.Set[str], exclude_patterns: t.Set[str])
werkzeug._reloader._find_watchdog_paths?5(extra_files: t.Set[str], exclude_patterns: t.Set[str])
werkzeug._reloader._get_args_for_reloading?5()
werkzeug._reloader._ignore_prefixes?8
werkzeug._reloader._iter_module_paths?5()
werkzeug._reloader._remove_by_pattern?5(paths: t.Set[str], exclude_patterns: t.Set[str])
werkzeug._reloader._walk?5(node: t.Mapping[str, dict], path: t.Tuple[str, ...])
werkzeug._reloader.ensure_echo_on?4()
werkzeug._reloader.prefix?7
werkzeug._reloader.run_with_reloader?4(main_func: t.Callable[[], None], extra_files: t.Optional[t.Iterable[str]] = None, exclude_patterns: t.Optional[t.Iterable[str]] = None, interval: t.Union[int, float] = 1, reloader_type: str = "auto", )
werkzeug.datastructures.Accept._best_single_match?5(match)
werkzeug.datastructures.Accept._specificity?5(value)
werkzeug.datastructures.Accept._value_matches?5(value, item)
werkzeug.datastructures.Accept.best?4()
werkzeug.datastructures.Accept.best_match?4(matches, default=None)
werkzeug.datastructures.Accept.find?4(key)
werkzeug.datastructures.Accept.index?4(key)
werkzeug.datastructures.Accept.quality?4(key)
werkzeug.datastructures.Accept.to_header?4()
werkzeug.datastructures.Accept.values?4()
werkzeug.datastructures.Accept?1(values=())
werkzeug.datastructures.Authorization.cnonce?4()
werkzeug.datastructures.Authorization.nc?4()
werkzeug.datastructures.Authorization.nonce?4()
werkzeug.datastructures.Authorization.opaque?4()
werkzeug.datastructures.Authorization.password?4()
werkzeug.datastructures.Authorization.qop?4()
werkzeug.datastructures.Authorization.realm?4()
werkzeug.datastructures.Authorization.response?4()
werkzeug.datastructures.Authorization.to_header?4()
werkzeug.datastructures.Authorization.uri?4()
werkzeug.datastructures.Authorization.username?4()
werkzeug.datastructures.Authorization?1(auth_type, data=None)
werkzeug.datastructures.CallbackDict?1(initial=None, on_update=None)
werkzeug.datastructures.CharsetAccept._normalize?5()
werkzeug.datastructures.CharsetAccept._value_matches?5(value, item)
werkzeug.datastructures.CombinedMultiDict._keys_impl?5()
werkzeug.datastructures.CombinedMultiDict.copy?4()
werkzeug.datastructures.CombinedMultiDict.fromkeys?4(keys, value=None)
werkzeug.datastructures.CombinedMultiDict.get?4(key, default=None, type=None)
werkzeug.datastructures.CombinedMultiDict.getlist?4(key, type=None)
werkzeug.datastructures.CombinedMultiDict.has_key?4(key)
werkzeug.datastructures.CombinedMultiDict.items?4(multi=False)
werkzeug.datastructures.CombinedMultiDict.keys?4()
werkzeug.datastructures.CombinedMultiDict.lists?4()
werkzeug.datastructures.CombinedMultiDict.listvalues?4()
werkzeug.datastructures.CombinedMultiDict.to_dict?4(flat=True)
werkzeug.datastructures.CombinedMultiDict.values?4()
werkzeug.datastructures.CombinedMultiDict?1(dicts=None)
werkzeug.datastructures.ContentRange.length?7
werkzeug.datastructures.ContentRange.set?4(start, stop, length=None, units="bytes")
werkzeug.datastructures.ContentRange.start?7
werkzeug.datastructures.ContentRange.stop?7
werkzeug.datastructures.ContentRange.to_header?4()
werkzeug.datastructures.ContentRange.units?7
werkzeug.datastructures.ContentRange.unset?4()
werkzeug.datastructures.ContentRange?1(units, start, stop, length=None, on_update=None)
werkzeug.datastructures.ContentSecurityPolicy._del_value?5(key)
werkzeug.datastructures.ContentSecurityPolicy._get_value?5(key)
werkzeug.datastructures.ContentSecurityPolicy._set_value?5(key, value)
werkzeug.datastructures.ContentSecurityPolicy.base_uri?7
werkzeug.datastructures.ContentSecurityPolicy.child_src?7
werkzeug.datastructures.ContentSecurityPolicy.connect_src?7
werkzeug.datastructures.ContentSecurityPolicy.default_src?7
werkzeug.datastructures.ContentSecurityPolicy.font_src?7
werkzeug.datastructures.ContentSecurityPolicy.form_action?7
werkzeug.datastructures.ContentSecurityPolicy.frame_ancestors?7
werkzeug.datastructures.ContentSecurityPolicy.frame_src?7
werkzeug.datastructures.ContentSecurityPolicy.img_src?7
werkzeug.datastructures.ContentSecurityPolicy.manifest_src?7
werkzeug.datastructures.ContentSecurityPolicy.media_src?7
werkzeug.datastructures.ContentSecurityPolicy.navigate_to?7
werkzeug.datastructures.ContentSecurityPolicy.object_src?7
werkzeug.datastructures.ContentSecurityPolicy.plugin_types?7
werkzeug.datastructures.ContentSecurityPolicy.prefetch_src?7
werkzeug.datastructures.ContentSecurityPolicy.report_to?7
werkzeug.datastructures.ContentSecurityPolicy.report_uri?7
werkzeug.datastructures.ContentSecurityPolicy.sandbox?7
werkzeug.datastructures.ContentSecurityPolicy.script_src?7
werkzeug.datastructures.ContentSecurityPolicy.script_src_attr?7
werkzeug.datastructures.ContentSecurityPolicy.script_src_elem?7
werkzeug.datastructures.ContentSecurityPolicy.style_src?7
werkzeug.datastructures.ContentSecurityPolicy.style_src_attr?7
werkzeug.datastructures.ContentSecurityPolicy.style_src_elem?7
werkzeug.datastructures.ContentSecurityPolicy.to_header?4()
werkzeug.datastructures.ContentSecurityPolicy.worker_src?7
werkzeug.datastructures.ContentSecurityPolicy?1(values=(), on_update=None)
werkzeug.datastructures.ETags.as_set?4(include_weak=False)
werkzeug.datastructures.ETags.contains?4(etag)
werkzeug.datastructures.ETags.contains_raw?4(etag)
werkzeug.datastructures.ETags.contains_weak?4(etag)
werkzeug.datastructures.ETags.is_strong?4(etag)
werkzeug.datastructures.ETags.is_weak?4(etag)
werkzeug.datastructures.ETags.to_header?4()
werkzeug.datastructures.ETags?1(strong_etags=None, weak_etags=None, star_tag=False)
werkzeug.datastructures.EnvironHeaders.copy?4()
werkzeug.datastructures.EnvironHeaders?1(environ)
werkzeug.datastructures.FileMultiDict.add_file?4(name, file, filename=None, content_type=None)
werkzeug.datastructures.FileStorage._parse_content_type?5()
werkzeug.datastructures.FileStorage.close?4()
werkzeug.datastructures.FileStorage.content_length?4()
werkzeug.datastructures.FileStorage.content_type?4()
werkzeug.datastructures.FileStorage.mimetype?4()
werkzeug.datastructures.FileStorage.mimetype_params?4()
werkzeug.datastructures.FileStorage.save?4(dst, buffer_size=16384)
werkzeug.datastructures.FileStorage?1(stream=None, filename=None, name=None, content_type=None, content_length=None, headers=None, )
werkzeug.datastructures.HeaderSet.add?4(header)
werkzeug.datastructures.HeaderSet.as_set?4(preserve_casing=False)
werkzeug.datastructures.HeaderSet.clear?4()
werkzeug.datastructures.HeaderSet.discard?4(header)
werkzeug.datastructures.HeaderSet.find?4(header)
werkzeug.datastructures.HeaderSet.index?4(header)
werkzeug.datastructures.HeaderSet.remove?4(header)
werkzeug.datastructures.HeaderSet.to_header?4()
werkzeug.datastructures.HeaderSet.update?4(iterable)
werkzeug.datastructures.HeaderSet?1(headers=None, on_update=None)
werkzeug.datastructures.Headers._validate_value?5(value)
werkzeug.datastructures.Headers.add?4(_key, _value, **kw)
werkzeug.datastructures.Headers.add_header?4(_key, _value, **_kw)
werkzeug.datastructures.Headers.clear?4()
werkzeug.datastructures.Headers.copy?4()
werkzeug.datastructures.Headers.extend?4(*args, **kwargs)
werkzeug.datastructures.Headers.get?4(key, default=None, type=None, as_bytes=False)
werkzeug.datastructures.Headers.get_all?4(name)
werkzeug.datastructures.Headers.getlist?4(key, type=None, as_bytes=False)
werkzeug.datastructures.Headers.has_key?4(key)
werkzeug.datastructures.Headers.items?4(lower=False)
werkzeug.datastructures.Headers.keys?4(lower=False)
werkzeug.datastructures.Headers.lowered?4()
werkzeug.datastructures.Headers.pop?4(key=None, default=_missing)
werkzeug.datastructures.Headers.popitem?4()
werkzeug.datastructures.Headers.remove?4(key)
werkzeug.datastructures.Headers.set?4(_key, _value, **kw)
werkzeug.datastructures.Headers.setdefault?4(key, default)
werkzeug.datastructures.Headers.setlist?4(key, values)
werkzeug.datastructures.Headers.setlistdefault?4(key, default)
werkzeug.datastructures.Headers.to_wsgi_list?4()
werkzeug.datastructures.Headers.update?4(*args, **kwargs)
werkzeug.datastructures.Headers.values?4()
werkzeug.datastructures.Headers?1(defaults=None)
werkzeug.datastructures.IfRange.to_header?4()
werkzeug.datastructures.IfRange?1(etag=None, date=None)
werkzeug.datastructures.ImmutableDict.copy?4()
werkzeug.datastructures.ImmutableDictMixin._hash_cache?8
werkzeug.datastructures.ImmutableDictMixin._iter_hashitems?5()
werkzeug.datastructures.ImmutableDictMixin.clear?4()
werkzeug.datastructures.ImmutableDictMixin.fromkeys?4(keys, value=None)
werkzeug.datastructures.ImmutableDictMixin.pop?4(key, default=None)
werkzeug.datastructures.ImmutableDictMixin.popitem?4()
werkzeug.datastructures.ImmutableDictMixin.setdefault?4(key, default=None)
werkzeug.datastructures.ImmutableDictMixin.update?4(*args, **kwargs)
werkzeug.datastructures.ImmutableHeadersMixin.add?4(_key, _value, **kw)
werkzeug.datastructures.ImmutableHeadersMixin.add_header?4(_key, _value, **_kw)
werkzeug.datastructures.ImmutableHeadersMixin.extend?4(*args, **kwargs)
werkzeug.datastructures.ImmutableHeadersMixin.insert?4(pos, value)
werkzeug.datastructures.ImmutableHeadersMixin.pop?4(key=None, default=_missing)
werkzeug.datastructures.ImmutableHeadersMixin.popitem?4()
werkzeug.datastructures.ImmutableHeadersMixin.remove?4(key)
werkzeug.datastructures.ImmutableHeadersMixin.set?4(_key, _value, **kw)
werkzeug.datastructures.ImmutableHeadersMixin.setdefault?4(key, default)
werkzeug.datastructures.ImmutableHeadersMixin.setlist?4(key, values)
werkzeug.datastructures.ImmutableHeadersMixin.setlistdefault?4(key, default)
werkzeug.datastructures.ImmutableHeadersMixin.update?4(*args, **kwargs)
werkzeug.datastructures.ImmutableListMixin._hash_cache?8
werkzeug.datastructures.ImmutableListMixin.append?4(item)
werkzeug.datastructures.ImmutableListMixin.extend?4(iterable)
werkzeug.datastructures.ImmutableListMixin.insert?4(pos, value)
werkzeug.datastructures.ImmutableListMixin.pop?4(index=-1)
werkzeug.datastructures.ImmutableListMixin.remove?4(item)
werkzeug.datastructures.ImmutableListMixin.reverse?4()
werkzeug.datastructures.ImmutableListMixin.sort?4(key=None, reverse=False)
werkzeug.datastructures.ImmutableMultiDict.copy?4()
werkzeug.datastructures.ImmutableMultiDictMixin._iter_hashitems?5()
werkzeug.datastructures.ImmutableMultiDictMixin.add?4(key, value)
werkzeug.datastructures.ImmutableMultiDictMixin.popitemlist?4()
werkzeug.datastructures.ImmutableMultiDictMixin.poplist?4(key)
werkzeug.datastructures.ImmutableMultiDictMixin.setlist?4(key, new_list)
werkzeug.datastructures.ImmutableMultiDictMixin.setlistdefault?4(key, default_list=None)
werkzeug.datastructures.ImmutableOrderedMultiDict._iter_hashitems?5()
werkzeug.datastructures.ImmutableOrderedMultiDict.copy?4()
werkzeug.datastructures.ImmutableTypeConversionDict.copy?4()
werkzeug.datastructures.LanguageAccept._value_matches?5(value, item)
werkzeug.datastructures.LanguageAccept.best_match?4(matches, default=None)
werkzeug.datastructures.MIMEAccept._specificity?5(value)
werkzeug.datastructures.MIMEAccept._value_matches?5(value, item)
werkzeug.datastructures.MIMEAccept.accept_html?4()
werkzeug.datastructures.MIMEAccept.accept_json?4()
werkzeug.datastructures.MIMEAccept.accept_xhtml?4()
werkzeug.datastructures.MultiDict.add?4(key, value)
werkzeug.datastructures.MultiDict.copy?4()
werkzeug.datastructures.MultiDict.deepcopy?4(memo=None)
werkzeug.datastructures.MultiDict.getlist?4(key, type=None)
werkzeug.datastructures.MultiDict.items?4(multi=False)
werkzeug.datastructures.MultiDict.lists?4()
werkzeug.datastructures.MultiDict.listvalues?4()
werkzeug.datastructures.MultiDict.pop?4(key, default=_missing)
werkzeug.datastructures.MultiDict.popitem?4()
werkzeug.datastructures.MultiDict.popitemlist?4()
werkzeug.datastructures.MultiDict.poplist?4(key)
werkzeug.datastructures.MultiDict.setdefault?4(key, default=None)
werkzeug.datastructures.MultiDict.setlist?4(key, new_list)
werkzeug.datastructures.MultiDict.setlistdefault?4(key, default_list=None)
werkzeug.datastructures.MultiDict.to_dict?4(flat=True)
werkzeug.datastructures.MultiDict.update?4(mapping)
werkzeug.datastructures.MultiDict.values?4()
werkzeug.datastructures.MultiDict?1(mapping=None)
werkzeug.datastructures.OrderedMultiDict.add?4(key, value)
werkzeug.datastructures.OrderedMultiDict.getlist?4(key, type=None)
werkzeug.datastructures.OrderedMultiDict.items?4(multi=False)
werkzeug.datastructures.OrderedMultiDict.keys?4()
werkzeug.datastructures.OrderedMultiDict.lists?4()
werkzeug.datastructures.OrderedMultiDict.listvalues?4()
werkzeug.datastructures.OrderedMultiDict.pop?4(key, default=_missing)
werkzeug.datastructures.OrderedMultiDict.popitem?4()
werkzeug.datastructures.OrderedMultiDict.popitemlist?4()
werkzeug.datastructures.OrderedMultiDict.poplist?4(key)
werkzeug.datastructures.OrderedMultiDict.setlist?4(key, new_list)
werkzeug.datastructures.OrderedMultiDict.setlistdefault?4(key, default_list=None)
werkzeug.datastructures.OrderedMultiDict.update?4(mapping)
werkzeug.datastructures.OrderedMultiDict.values?4()
werkzeug.datastructures.OrderedMultiDict?1(mapping=None)
werkzeug.datastructures.Range.make_content_range?4(length)
werkzeug.datastructures.Range.range_for_length?4(length)
werkzeug.datastructures.Range.to_content_range_header?4(length)
werkzeug.datastructures.Range.to_header?4()
werkzeug.datastructures.Range?1(units, ranges)
werkzeug.datastructures.RequestCacheControl.max_stale?7
werkzeug.datastructures.RequestCacheControl.min_fresh?7
werkzeug.datastructures.RequestCacheControl.only_if_cached?7
werkzeug.datastructures.ResponseCacheControl.immutable?7
werkzeug.datastructures.ResponseCacheControl.must_revalidate?7
werkzeug.datastructures.ResponseCacheControl.private?7
werkzeug.datastructures.ResponseCacheControl.proxy_revalidate?7
werkzeug.datastructures.ResponseCacheControl.public?7
werkzeug.datastructures.ResponseCacheControl.s_maxage?7
werkzeug.datastructures.TypeConversionDict.get?4(key, default=None, type=None)
werkzeug.datastructures.UpdateDictMixin.clear?7
werkzeug.datastructures.UpdateDictMixin.on_update?7
werkzeug.datastructures.UpdateDictMixin.pop?4(key, default=_missing)
werkzeug.datastructures.UpdateDictMixin.popitem?7
werkzeug.datastructures.UpdateDictMixin.setdefault?4(key, default=None)
werkzeug.datastructures.UpdateDictMixin.update?7
werkzeug.datastructures.WWWAuthenticate._require_quoting?8
werkzeug.datastructures.WWWAuthenticate.algorithm?7
werkzeug.datastructures.WWWAuthenticate.auth_property?7
werkzeug.datastructures.WWWAuthenticate.domain?7
werkzeug.datastructures.WWWAuthenticate.nonce?7
werkzeug.datastructures.WWWAuthenticate.opaque?7
werkzeug.datastructures.WWWAuthenticate.qop?7
werkzeug.datastructures.WWWAuthenticate.realm?7
werkzeug.datastructures.WWWAuthenticate.set_basic?4(realm="authentication required")
werkzeug.datastructures.WWWAuthenticate.set_digest?4(realm, nonce, qop=("auth", ), opaque=None, algorithm=None, stale=False)
werkzeug.datastructures.WWWAuthenticate.stale?4(value)
werkzeug.datastructures.WWWAuthenticate.to_header?4()
werkzeug.datastructures.WWWAuthenticate.type?7
werkzeug.datastructures.WWWAuthenticate?1(auth_type=None, values=None, on_update=None)
werkzeug.datastructures._CacheControl._del_cache_value?5(key)
werkzeug.datastructures._CacheControl._get_cache_value?5(key, empty, type)
werkzeug.datastructures._CacheControl._set_cache_value?5(key, value, type)
werkzeug.datastructures._CacheControl.cache_property?7
werkzeug.datastructures._CacheControl.max_age?7
werkzeug.datastructures._CacheControl.no_cache?7
werkzeug.datastructures._CacheControl.no_store?7
werkzeug.datastructures._CacheControl.no_transform?7
werkzeug.datastructures._CacheControl.to_header?4()
werkzeug.datastructures._CacheControl?2(values=(), on_update=None)
werkzeug.datastructures._callback_property?5(name)
werkzeug.datastructures._calls_update?5(name)
werkzeug.datastructures._locale_delim_re?8
werkzeug.datastructures._mime_split_re?8
werkzeug.datastructures._normalize_lang?5(value)
werkzeug.datastructures._normalize_mime?5(value)
werkzeug.datastructures._omd_bucket.unlink?4(omd)
werkzeug.datastructures._omd_bucket?2(omd, key, value)
werkzeug.datastructures._options_header_vkw?5(value, kw)
werkzeug.datastructures._set_property?5(name, doc=None)
werkzeug.datastructures._set_value?5(self, value)
werkzeug.datastructures._unicodify_header_value?5(value)
werkzeug.datastructures.auth_property?4(name, doc=None)
werkzeug.datastructures.cache_control_property?4(key, empty, type)
werkzeug.datastructures.cache_property?4(key, empty, type)
werkzeug.datastructures.csp_property?4(key)
werkzeug.datastructures.fget?4(self)
werkzeug.datastructures.fset?4(self, value)
werkzeug.datastructures.is_immutable?4(self)
werkzeug.datastructures.iter_multi_items?4(mapping)
werkzeug.datastructures.on_update?4(header_set)
werkzeug.datastructures.oncall?4(self, *args, **kw)
werkzeug.debug.DebuggedApplication._fail_pin_auth?5()
werkzeug.debug.DebuggedApplication.check_pin_trust?4(environ: "WSGIEnvironment")
werkzeug.debug.DebuggedApplication.debug_application?4(environ: "WSGIEnvironment", start_response: "StartResponse")
werkzeug.debug.DebuggedApplication.display_console?4(request: Request)
werkzeug.debug.DebuggedApplication.execute_command?4(request: Request, command: str, frame: t.Union[Frame, _ConsoleFrame])
werkzeug.debug.DebuggedApplication.get_resource?4(request: Request, filename: str)
werkzeug.debug.DebuggedApplication.log_pin_request?4()
werkzeug.debug.DebuggedApplication.pin?4(value: str)
werkzeug.debug.DebuggedApplication.pin_auth?4(request: Request)
werkzeug.debug.DebuggedApplication.pin_cookie_name?4()
werkzeug.debug.DebuggedApplication?1(app: "WSGIApplication", evalex: bool = False, request_key: str = "werkzeug.request", console_path: str = "/console", console_init_func: t.Optional[t.Callable[[], t.Dict[str, t.Any]]] = None, show_hidden_frames: bool = False, pin_security: bool = True, pin_logging: bool = True, )
werkzeug.debug.PIN_TIME?7
werkzeug.debug._ConsoleFrame?2(namespace: t.Dict[str, t.Any])
werkzeug.debug._generate?5()
werkzeug.debug.console.Console.eval?4(code: str)
werkzeug.debug.console.Console?1(globals: t.Optional[t.Dict[str, t.Any]] = None, locals: t.Optional[t.Dict[str, t.Any]] = None, )
werkzeug.debug.console.HTMLStringO._write?5(x: str)
werkzeug.debug.console.HTMLStringO.close?4()
werkzeug.debug.console.HTMLStringO.flush?4()
werkzeug.debug.console.HTMLStringO.isatty?4()
werkzeug.debug.console.HTMLStringO.readline?4()
werkzeug.debug.console.HTMLStringO.reset?4()
werkzeug.debug.console.HTMLStringO.seek?4(n: int, mode: int = 0)
werkzeug.debug.console.HTMLStringO.write?4(x: str)
werkzeug.debug.console.HTMLStringO.writelines?4(x: t.Iterable[str])
werkzeug.debug.console.HTMLStringO?1()
werkzeug.debug.console.ThreadedStream.displayhook?4()
werkzeug.debug.console.ThreadedStream.fetch?4()
werkzeug.debug.console.ThreadedStream.push?4()
werkzeug.debug.console._ConsoleLoader.get_source_by_code?4(code: CodeType)
werkzeug.debug.console._ConsoleLoader.register?4(code: CodeType, source: str)
werkzeug.debug.console._ConsoleLoader?2()
werkzeug.debug.console._InteractiveConsole.compile?4(filename: str, symbol: str)
werkzeug.debug.console._InteractiveConsole.runcode?4(code: CodeType)
werkzeug.debug.console._InteractiveConsole.runsource?4(source: str, **kwargs: t.Any)
werkzeug.debug.console._InteractiveConsole.showsyntaxerror?4(filename: t.Optional[str] = None)
werkzeug.debug.console._InteractiveConsole.showtraceback?4()
werkzeug.debug.console._InteractiveConsole.write?4(data: str)
werkzeug.debug.console._InteractiveConsole?2(globals: t.Dict[str, t.Any], locals: t.Dict[str, t.Any])
werkzeug.debug.console._displayhook?8
werkzeug.debug.console._local?8
werkzeug.debug.get_machine_id?4()
werkzeug.debug.get_pin_and_cookie_name?4(app: "WSGIApplication", )
werkzeug.debug.hash_pin?4(pin: str)
werkzeug.debug.repr.DebugReprGenerator.deque_repr?7
werkzeug.debug.repr.DebugReprGenerator.dict_repr?4(d: t.Union[t.Dict[int, None], t.Dict[str, int], t.Dict[t.Union[str, int], int]], recursive: bool, limit: int = 5, )
werkzeug.debug.repr.DebugReprGenerator.dispatch_repr?4(obj: t.Any, recursive: bool)
werkzeug.debug.repr.DebugReprGenerator.dump_locals?4(d: t.Dict[str, t.Any])
werkzeug.debug.repr.DebugReprGenerator.dump_object?4(obj: object)
werkzeug.debug.repr.DebugReprGenerator.fallback_repr?4()
werkzeug.debug.repr.DebugReprGenerator.frozenset_repr?7
werkzeug.debug.repr.DebugReprGenerator.list_repr?7
werkzeug.debug.repr.DebugReprGenerator.object_repr?4(obj: t.Optional[t.Union[t.Type[dict], t.Callable, t.Type[list]]])
werkzeug.debug.repr.DebugReprGenerator.regex_repr?4(obj: t.Pattern)
werkzeug.debug.repr.DebugReprGenerator.render_object_dump?4(items: t.List[t.Tuple[str, str]], title: str, repr: t.Optional[str] = None)
werkzeug.debug.repr.DebugReprGenerator.repr?4(obj: object)
werkzeug.debug.repr.DebugReprGenerator.set_repr?7
werkzeug.debug.repr.DebugReprGenerator.string_repr?4(obj: t.Union[str, bytes], limit: int = 70)
werkzeug.debug.repr.DebugReprGenerator.tuple_repr?7
werkzeug.debug.repr.DebugReprGenerator?1()
werkzeug.debug.repr.HELP_HTML?7
werkzeug.debug.repr.OBJECT_DUMP_HTML?7
werkzeug.debug.repr.RegexType?7
werkzeug.debug.repr._add_subclass_info?5(inner: str, obj: object, base: t.Union[t.Type, t.Tuple[t.Type, ...]])
werkzeug.debug.repr._paragraph_re?8
werkzeug.debug.repr._sequence_repr_maker?5(left: str, right: str, base: t.Type, limit: int = 8)
werkzeug.debug.repr.debug_repr?4(obj: object)
werkzeug.debug.repr.dump?4(obj: object = missing)
werkzeug.debug.repr.helper?7
werkzeug.debug.repr.missing?7
werkzeug.debug.repr.proxy?4(self: "DebugReprGenerator", obj: t.Iterable, recursive: bool)
werkzeug.debug.tbtools.CONSOLE_HTML?7
werkzeug.debug.tbtools.FOOTER?7
werkzeug.debug.tbtools.FRAME_HTML?7
werkzeug.debug.tbtools.Frame.console?4()
werkzeug.debug.tbtools.Frame.current_line?4()
werkzeug.debug.tbtools.Frame.eval?4(code: t.Union[str, CodeType], mode: str = "single")
werkzeug.debug.tbtools.Frame.get_annotated_lines?4()
werkzeug.debug.tbtools.Frame.get_context_lines?4(context: int = 5)
werkzeug.debug.tbtools.Frame.id?4()
werkzeug.debug.tbtools.Frame.is_library?4()
werkzeug.debug.tbtools.Frame.render?4(mark_lib: bool = True)
werkzeug.debug.tbtools.Frame.render_line?4(cls: str)
werkzeug.debug.tbtools.Frame.render_line_context?4()
werkzeug.debug.tbtools.Frame.render_text?4()
werkzeug.debug.tbtools.Frame.sourcelines?4()
werkzeug.debug.tbtools.Frame?1(exc_type: t.Type[BaseException], exc_value: BaseException, tb: TracebackType, )
werkzeug.debug.tbtools.Group.exception?4()
werkzeug.debug.tbtools.Group.filter_hidden_frames?4()
werkzeug.debug.tbtools.Group.render?4(mark_lib: bool = True)
werkzeug.debug.tbtools.Group.render_text?4()
werkzeug.debug.tbtools.Group?1(exc_type: t.Type[BaseException], exc_value: BaseException, tb: TracebackType, )
werkzeug.debug.tbtools.HEADER?7
werkzeug.debug.tbtools.Line.classes?4()
werkzeug.debug.tbtools.Line.render?4()
werkzeug.debug.tbtools.Line?1(lineno: int, code: str)
werkzeug.debug.tbtools.PAGE_HTML?7
werkzeug.debug.tbtools.SOURCE_LINE_HTML?7
werkzeug.debug.tbtools.SUMMARY_HTML?7
werkzeug.debug.tbtools.Traceback.exception?4()
werkzeug.debug.tbtools.Traceback.filter_hidden_frames?4()
werkzeug.debug.tbtools.Traceback.id?4()
werkzeug.debug.tbtools.Traceback.is_syntax_error?4()
werkzeug.debug.tbtools.Traceback.log?4(logfile: t.Optional[t.TextIO] = None)
werkzeug.debug.tbtools.Traceback.plaintext?4()
werkzeug.debug.tbtools.Traceback.render_full?4(evalex: bool = False, secret: t.Optional[str] = None, evalex_trusted: bool = True, )
werkzeug.debug.tbtools.Traceback.render_summary?4(include_title: bool = True)
werkzeug.debug.tbtools.Traceback?1(exc_type: t.Type[BaseException], exc_value: BaseException, tb: TracebackType, )
werkzeug.debug.tbtools._coding_re?8
werkzeug.debug.tbtools._funcdef_re?8
werkzeug.debug.tbtools._line_re?8
werkzeug.debug.tbtools.get_current_traceback?4(ignore_system_exceptions: bool = False, show_hidden_frames: bool = False, skip: int = 0, )
werkzeug.debug.tbtools.render_console_html?4(secret: str, evalex_trusted: bool = True)
werkzeug.exceptions.Aborter?1(mapping: t.Optional[t.Dict[int, t.Type[HTTPException]]] = None, extra: t.Optional[t.Dict[int, t.Type[HTTPException]]] = None, )
werkzeug.exceptions.BadGateway.code?7
werkzeug.exceptions.BadGateway.description?7
werkzeug.exceptions.BadRequest.code?7
werkzeug.exceptions.BadRequest.description?7
werkzeug.exceptions.BadRequestKeyError._description?8
werkzeug.exceptions.BadRequestKeyError.description?4(value: str)
werkzeug.exceptions.BadRequestKeyError.show_exception?7
werkzeug.exceptions.BadRequestKeyError?1(arg: t.Optional[str] = None, *args: t.Any, **kwargs: t.Any)
werkzeug.exceptions.Conflict.code?7
werkzeug.exceptions.Conflict.description?7
werkzeug.exceptions.ExpectationFailed.code?7
werkzeug.exceptions.ExpectationFailed.description?7
werkzeug.exceptions.FailedDependency.code?7
werkzeug.exceptions.FailedDependency.description?7
werkzeug.exceptions.Forbidden.code?7
werkzeug.exceptions.Forbidden.description?7
werkzeug.exceptions.GatewayTimeout.code?7
werkzeug.exceptions.GatewayTimeout.description?7
werkzeug.exceptions.Gone.code?7
werkzeug.exceptions.Gone.description?7
werkzeug.exceptions.HTTPException.get_body?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.exceptions.HTTPException.get_description?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.exceptions.HTTPException.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.exceptions.HTTPException.get_response?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.exceptions.HTTPException.name?4()
werkzeug.exceptions.HTTPException.wrap?4(exception: t.Type[BaseException], name: t.Optional[str] = None)
werkzeug.exceptions.HTTPException?1(description: t.Optional[str] = None, response: t.Optional["Response"] = None, )
werkzeug.exceptions.HTTPVersionNotSupported.code?7
werkzeug.exceptions.HTTPVersionNotSupported.description?7
werkzeug.exceptions.ImATeapot.code?7
werkzeug.exceptions.ImATeapot.description?7
werkzeug.exceptions.InternalServerError.code?7
werkzeug.exceptions.InternalServerError.description?7
werkzeug.exceptions.InternalServerError?1(description: t.Optional[str] = None, response: t.Optional["Response"] = None, original_exception: t.Optional[BaseException] = None, )
werkzeug.exceptions.LengthRequired.code?7
werkzeug.exceptions.LengthRequired.description?7
werkzeug.exceptions.Locked.code?7
werkzeug.exceptions.Locked.description?7
werkzeug.exceptions.MethodNotAllowed.code?7
werkzeug.exceptions.MethodNotAllowed.description?7
werkzeug.exceptions.MethodNotAllowed.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.exceptions.MethodNotAllowed?1(valid_methods: t.Optional[t.Iterable[str]] = None, description: t.Optional[str] = None, response: t.Optional["Response"] = None, )
werkzeug.exceptions.NotAcceptable.code?7
werkzeug.exceptions.NotAcceptable.description?7
werkzeug.exceptions.NotFound.code?7
werkzeug.exceptions.NotFound.description?7
werkzeug.exceptions.NotImplemented.code?7
werkzeug.exceptions.NotImplemented.description?7
werkzeug.exceptions.PreconditionFailed.code?7
werkzeug.exceptions.PreconditionFailed.description?7
werkzeug.exceptions.PreconditionRequired.code?7
werkzeug.exceptions.PreconditionRequired.description?7
werkzeug.exceptions.RequestEntityTooLarge.code?7
werkzeug.exceptions.RequestEntityTooLarge.description?7
werkzeug.exceptions.RequestHeaderFieldsTooLarge.code?7
werkzeug.exceptions.RequestHeaderFieldsTooLarge.description?7
werkzeug.exceptions.RequestTimeout.code?7
werkzeug.exceptions.RequestTimeout.description?7
werkzeug.exceptions.RequestURITooLarge.code?7
werkzeug.exceptions.RequestURITooLarge.description?7
werkzeug.exceptions.RequestedRangeNotSatisfiable.code?7
werkzeug.exceptions.RequestedRangeNotSatisfiable.description?7
werkzeug.exceptions.RequestedRangeNotSatisfiable.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.exceptions.RequestedRangeNotSatisfiable?1(length: t.Optional[int] = None, units: str = "bytes", description: t.Optional[str] = None, response: t.Optional["Response"] = None, )
werkzeug.exceptions.ServiceUnavailable.code?7
werkzeug.exceptions.ServiceUnavailable.description?7
werkzeug.exceptions.TooManyRequests.code?7
werkzeug.exceptions.TooManyRequests.description?7
werkzeug.exceptions.Unauthorized.code?7
werkzeug.exceptions.Unauthorized.description?7
werkzeug.exceptions.Unauthorized.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.exceptions.Unauthorized?1(description: t.Optional[str] = None, response: t.Optional["Response"] = None, www_authenticate: t.Optional[
            t.Union["WWWAuthenticate", t.Iterable["WWWAuthenticate"]]
        ] = None, )
werkzeug.exceptions.UnavailableForLegalReasons.code?7
werkzeug.exceptions.UnavailableForLegalReasons.description?7
werkzeug.exceptions.UnprocessableEntity.code?7
werkzeug.exceptions.UnprocessableEntity.description?7
werkzeug.exceptions.UnsupportedMediaType.code?7
werkzeug.exceptions.UnsupportedMediaType.description?7
werkzeug.exceptions._RetryAfter.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.exceptions._RetryAfter?2(description: t.Optional[str] = None, response: t.Optional["Response"] = None, retry_after: t.Optional[t.Union[datetime, int]] = None, )
werkzeug.exceptions._find_exceptions?5()
werkzeug.exceptions.abort?4(status: t.Union[int, "Response"], *args: t.Any, **kwargs: t.Any)
werkzeug.exceptions.newcls._description?8
werkzeug.exceptions.newcls.description?4(value: str)
werkzeug.exceptions.newcls.show_exception?7
werkzeug.exceptions.newcls?1(arg: t.Optional[t.Any] = None, *args: t.Any, **kwargs: t.Any)
werkzeug.filesystem._is_ascii_encoding?5(encoding: t.Optional[str])
werkzeug.filesystem._warned_about_filesystem_encoding?8
werkzeug.filesystem.get_filesystem_encoding?4()
werkzeug.filesystem.has_likely_buggy_unicode_filesystem?7
werkzeug.formparser.F?7
werkzeug.formparser.FormDataParser._parse_multipart?5(stream: t.BinaryIO, mimetype: str, content_length: t.Optional[int], options: t.Dict[str, str], )
werkzeug.formparser.FormDataParser._parse_urlencoded?5(stream: t.BinaryIO, mimetype: str, content_length: t.Optional[int], options: t.Dict[str, str], )
werkzeug.formparser.FormDataParser.get_parse_func?4(mimetype: str, options: t.Dict[str, str])
werkzeug.formparser.FormDataParser.parse?4(stream: t.BinaryIO, mimetype: str, content_length: t.Optional[int], options: t.Optional[t.Dict[str, str]] = None, )
werkzeug.formparser.FormDataParser.parse_from_environ?4(environ: "WSGIEnvironment")
werkzeug.formparser.FormDataParser?1(stream_factory: t.Optional["TStreamFactory"] = None, charset: str = "utf-8", errors: str = "replace", max_form_memory_size: t.Optional[int] = None, max_content_length: t.Optional[int] = None, cls: t.Optional[t.Type[MultiDict]] = None, silent: bool = True, )
werkzeug.formparser.MultiPartParser.fail?4(message: str)
werkzeug.formparser.MultiPartParser.get_part_charset?4(headers: Headers)
werkzeug.formparser.MultiPartParser.parse?4(stream: t.BinaryIO, boundary: bytes, content_length: t.Optional[int])
werkzeug.formparser.MultiPartParser.start_file_streaming?4(event: File, total_content_length: t.Optional[int])
werkzeug.formparser.MultiPartParser?1(stream_factory: t.Optional["TStreamFactory"] = None, charset: str = "utf-8", errors: str = "replace", max_form_memory_size: t.Optional[int] = None, cls: t.Optional[t.Type[MultiDict]] = None, buffer_size: int = 64 * 1024, )
werkzeug.formparser._exhaust?5(stream: t.BinaryIO)
werkzeug.formparser._line_parse?5(line: str)
werkzeug.formparser.default_stream_factory?4(total_content_length: t.Optional[int], content_type: t.Optional[str], filename: t.Optional[str], content_length: t.Optional[int] = None, )
werkzeug.formparser.exhaust_stream?4(f: F)
werkzeug.formparser.parse_form_data?4(environ: "WSGIEnvironment", stream_factory: t.Optional["TStreamFactory"] = None, charset: str = "utf-8", errors: str = "replace", max_form_memory_size: t.Optional[int] = None, max_content_length: t.Optional[int] = None, cls: t.Optional[t.Type[MultiDict]] = None, silent: bool = True, )
werkzeug.formparser.parse_multipart_headers?4(iterable: t.Iterable[bytes])
werkzeug.formparser.wrapper?4(self, stream, *args, **kwargs)
werkzeug.http.COEP.REQUIRE_CORP?7
werkzeug.http.COEP.UNSAFE_NONE?7
werkzeug.http.COOP.SAME_ORIGIN?7
werkzeug.http.COOP.SAME_ORIGIN_ALLOW_POPUPS?7
werkzeug.http.COOP.UNSAFE_NONE?7
werkzeug.http.HTTP_STATUS_CODES?7
werkzeug.http._TAnyAccept?8
werkzeug.http._TAnyCC?8
werkzeug.http._TAnyCSP?8
werkzeug.http._accept_re?8
werkzeug.http._entity_headers?8
werkzeug.http._etag_re?8
werkzeug.http._hop_by_hop_headers?8
werkzeug.http._option_header_piece_re?8
werkzeug.http._option_header_start_mime_type?8
werkzeug.http._parse_pairs?5()
werkzeug.http._t_cc_update?8
werkzeug.http._t_csp_update?8
werkzeug.http._token_chars?8
werkzeug.http.cookie_date?4(expires: t.Optional[t.Union[datetime, date, int, float, struct_time]] = None)
werkzeug.http.dump_age?4(age: t.Optional[t.Union[timedelta, int]] = None)
werkzeug.http.dump_cookie?4(key: str, value: t.Union[bytes, str] = "", max_age: t.Optional[t.Union[timedelta, int]] = None, expires: t.Optional[t.Union[str, datetime, int, float]] = None, path: t.Optional[str] = "/", domain: t.Optional[str] = None, secure: bool = False, httponly: bool = False, charset: str = "utf-8", sync_expires: bool = True, max_size: int = 4093, samesite: t.Optional[str] = None, )
werkzeug.http.dump_csp_header?4(header: "ds.ContentSecurityPolicy")
werkzeug.http.dump_header?4(iterable: t.Union[t.Dict[str, t.Union[str, int]], t.Iterable[str]], allow_token: bool = True, )
werkzeug.http.dump_options_header?4(header: t.Optional[str], options: t.Mapping[str, t.Optional[t.Union[str, int]]])
werkzeug.http.generate_etag?4(data: bytes)
werkzeug.http.http_date?4(timestamp: t.Optional[t.Union[datetime, date, int, float, struct_time]] = None)
werkzeug.http.is_byte_range_valid?4(start: t.Optional[int], stop: t.Optional[int], length: t.Optional[int])
werkzeug.http.is_entity_header?4(header: str)
werkzeug.http.is_hop_by_hop_header?4(header: str)
werkzeug.http.is_resource_modified?4(environ: "WSGIEnvironment", etag: t.Optional[str] = None, data: t.Optional[bytes] = None, last_modified: t.Optional[t.Union[datetime, str]] = None, ignore_if_range: bool = True, )
werkzeug.http.parse_accept_header?4(value: t.Optional[str])
werkzeug.http.parse_accept_header?4(value: t.Optional[str], cls: t.Optional[t.Type[_TAnyAccept]] = None)
werkzeug.http.parse_accept_header?4(value: t.Optional[str], cls: t.Type[_TAnyAccept])
werkzeug.http.parse_age?4(value: t.Optional[str] = None)
werkzeug.http.parse_authorization_header?4(value: t.Optional[str], )
werkzeug.http.parse_cache_control_header?4(value: t.Optional[str], on_update: _t_cc_update = None, cls: t.Optional[t.Type[_TAnyCC]] = None, )
werkzeug.http.parse_cache_control_header?4(value: t.Optional[str], on_update: _t_cc_update, cls: None = None)
werkzeug.http.parse_cache_control_header?4(value: t.Optional[str], on_update: _t_cc_update, cls: t.Type[_TAnyCC])
werkzeug.http.parse_content_range_header?4(value: t.Optional[str], on_update: t.Optional[t.Callable[["ds.ContentRange"], None]] = None, )
werkzeug.http.parse_cookie?4(header: t.Union["WSGIEnvironment", str, bytes, None], charset: str = "utf-8", errors: str = "replace", cls: t.Optional[t.Type["ds.MultiDict"]] = None, )
werkzeug.http.parse_csp_header?4(value: t.Optional[str], on_update: _t_csp_update = None, cls: t.Optional[t.Type[_TAnyCSP]] = None, )
werkzeug.http.parse_csp_header?4(value: t.Optional[str], on_update: _t_csp_update, cls: None = None)
werkzeug.http.parse_csp_header?4(value: t.Optional[str], on_update: _t_csp_update, cls: t.Type[_TAnyCSP])
werkzeug.http.parse_date?4(value: t.Optional[str])
werkzeug.http.parse_dict_header?4(value: str, cls: t.Type[dict] = dict)
werkzeug.http.parse_etags?4(value: t.Optional[str])
werkzeug.http.parse_if_range_header?4(value: t.Optional[str])
werkzeug.http.parse_list_header?4(value: str)
werkzeug.http.parse_options_header?4(value: t.Optional[str], multiple: "te.Literal[False]" = False)
werkzeug.http.parse_options_header?4(value: t.Optional[str], multiple: "te.Literal[True]")
werkzeug.http.parse_options_header?4(value: t.Optional[str], multiple: bool = False)
werkzeug.http.parse_range_header?4(value: t.Optional[str], make_inclusive: bool = True)
werkzeug.http.parse_set_header?4(value: t.Optional[str], on_update: t.Optional[t.Callable[["ds.HeaderSet"], None]] = None, )
werkzeug.http.parse_www_authenticate_header?4(value: t.Optional[str], on_update: t.Optional[t.Callable[["ds.WWWAuthenticate"], None]] = None, )
werkzeug.http.quote_etag?4(etag: str, weak: bool = False)
werkzeug.http.quote_header_value?4(value: t.Union[str, int], extra_chars: str = "", allow_token: bool = True)
werkzeug.http.remove_entity_headers?4(headers: t.Union["ds.Headers", t.List[t.Tuple[str, str]]], allowed: t.Iterable[str] = ("expires", "content-location"), )
werkzeug.http.remove_hop_by_hop_headers?4(headers: t.Union["ds.Headers", t.List[t.Tuple[str, str]]])
werkzeug.http.unquote_etag?4(etag: t.Optional[str], )
werkzeug.http.unquote_header_value?4(value: str, is_filename: bool = False)
werkzeug.local.ContextVar.get?4(default: t.Dict[str, t.Any])
werkzeug.local.ContextVar.set?4(value: t.Dict[str, t.Any])
werkzeug.local.ContextVar?1(_name: str)
werkzeug.local.F?7
werkzeug.local.Local?1()
werkzeug.local.LocalManager.application?4(start_response: "StartResponse")
werkzeug.local.LocalManager.cleanup?4()
werkzeug.local.LocalManager.get_ident?4()
werkzeug.local.LocalManager.ident_func?4(func: t.Callable[[], int])
werkzeug.local.LocalManager.make_middleware?4(app: "WSGIApplication")
werkzeug.local.LocalManager.middleware?4(func: "WSGIApplication")
werkzeug.local.LocalManager?1(locals: t.Optional[t.Iterable[t.Union[Local, LocalStack]]] = None, ident_func: None = None, )
werkzeug.local.LocalProxy._get_current_object?5()
werkzeug.local.LocalProxy?1(local: t.Union["Local", t.Callable[[], t.Any]], name: t.Optional[str] = None, )
werkzeug.local.LocalStack._lookup?5()
werkzeug.local.LocalStack.pop?4()
werkzeug.local.LocalStack.push?4(obj: t.Any)
werkzeug.local.LocalStack.top?4()
werkzeug.local.LocalStack?1()
werkzeug.local._CannotUseContextVar.greenlet_patched?7
werkzeug.local._ProxyIOp.bind_f?4(obj: t.Any)
werkzeug.local._ProxyIOp.i_op?4(other: t.Any)
werkzeug.local._ProxyIOp?2(f: t.Optional[t.Callable] = None, fallback: t.Optional[t.Callable] = None)
werkzeug.local._ProxyLookup.bind_f?4(obj: t.Any)
werkzeug.local._ProxyLookup?2(f: t.Optional[t.Callable] = None, fallback: t.Optional[t.Callable] = None, class_value: t.Optional[t.Any] = None, )
werkzeug.local._l_to_r_op?5(op: F)
werkzeug.local.get_ident?4()
werkzeug.local.r_op?4(obj: t.Any, other: t.Any)
werkzeug.local.release_local?4(local: t.Union["Local", "LocalStack"])
werkzeug.middleware.dispatcher.DispatcherMiddleware?1(app: "WSGIApplication", mounts: t.Optional[t.Dict[str, "WSGIApplication"]] = None, )
werkzeug.middleware.http_proxy.ProxyMiddleware._set_defaults?5(t.Any])
werkzeug.middleware.http_proxy.ProxyMiddleware.application?4(start_response: "StartResponse")
werkzeug.middleware.http_proxy.ProxyMiddleware.proxy_to?4(opts: t.Dict[str, t.Any], path: str, prefix: str)
werkzeug.middleware.http_proxy.ProxyMiddleware.read?4()
werkzeug.middleware.http_proxy.ProxyMiddleware?1(app: "WSGIApplication", targets: t.Mapping[str, t.Dict[str, t.Any]], chunk_size: int = 2 << 13, timeout: int = 10, )
werkzeug.middleware.lint.ErrorStream.close?4()
werkzeug.middleware.lint.ErrorStream.flush?4()
werkzeug.middleware.lint.ErrorStream.write?4(s: str)
werkzeug.middleware.lint.ErrorStream.writelines?4(seq: t.Iterable[str])
werkzeug.middleware.lint.ErrorStream?1(stream: t.TextIO)
werkzeug.middleware.lint.GuardedIterator.close?4()
werkzeug.middleware.lint.GuardedIterator?1(iterator: t.Iterable[bytes], headers_set: t.Tuple[int, Headers], chunks: t.List[int], )
werkzeug.middleware.lint.GuardedWrite?1(write: t.Callable[[bytes], None], chunks: t.List[int])
werkzeug.middleware.lint.InputStream.close?4()
werkzeug.middleware.lint.InputStream.read?4(*args: t.Any)
werkzeug.middleware.lint.InputStream.readline?4(*args: t.Any)
werkzeug.middleware.lint.InputStream?1(stream: t.BinaryIO)
werkzeug.middleware.lint.LintMiddleware.check_environ?4(environ: "WSGIEnvironment")
werkzeug.middleware.lint.LintMiddleware.check_headers?4(headers: Headers)
werkzeug.middleware.lint.LintMiddleware.check_iterator?4(app_iter: t.Iterable[bytes])
werkzeug.middleware.lint.LintMiddleware.check_start_response?4(status: str, headers: t.List[t.Tuple[str, str]], exc_info: t.Optional[
            t.Tuple[t.Type[BaseException], BaseException, TracebackType]
        ], )
werkzeug.middleware.lint.LintMiddleware.checking_start_response?4(**kwargs: t.Any)
werkzeug.middleware.lint.LintMiddleware?1(app: "WSGIApplication")
werkzeug.middleware.lint.check_type?4(context: str, obj: object, need: t.Type = str)
werkzeug.middleware.profiler.ProfilerMiddleware.catching_start_response?4(headers, exc_info=None)
werkzeug.middleware.profiler.ProfilerMiddleware.runapp?4()
werkzeug.middleware.profiler.ProfilerMiddleware?1(app: "WSGIApplication", stream: t.TextIO = sys.stdout, sort_by: t.Iterable[str] = ("time", "calls"), restrictions: t.Iterable[t.Union[str, int, float]] = (), profile_dir: t.Optional[str] = None, filename_format: str = "{method}.{path}.{elapsed:.0f}ms.{time:.0f}.prof", )
werkzeug.middleware.proxy_fix.ProxyFix._get_real_value?5(trusted: int, value: t.Optional[str])
werkzeug.middleware.proxy_fix.ProxyFix?1(app: "WSGIApplication", x_for: int = 1, x_proto: int = 1, x_host: int = 0, x_port: int = 0, x_prefix: int = 0, )
werkzeug.middleware.shared_data.SharedDataMiddleware._opener?5(filename: str)
werkzeug.middleware.shared_data.SharedDataMiddleware.generate_etag?4(mtime: datetime, file_size: int, real_filename: str)
werkzeug.middleware.shared_data.SharedDataMiddleware.get_directory_loader?4(directory: str)
werkzeug.middleware.shared_data.SharedDataMiddleware.get_file_loader?4(filename: str)
werkzeug.middleware.shared_data.SharedDataMiddleware.get_package_loader?4(package: str, package_path: str)
werkzeug.middleware.shared_data.SharedDataMiddleware.is_allowed?4(filename: str)
werkzeug.middleware.shared_data.SharedDataMiddleware.loader?4()
werkzeug.middleware.shared_data.SharedDataMiddleware?1(app: "WSGIApplication", exports: t.Union[
            t.Dict[str, t.Union[str, t.Tuple[str, str]]], t.Iterable[t.Tuple[str, t.Union[str, t.Tuple[str, str]]]], ], disallow: None = None, cache: bool = True, cache_timeout: int = 60 * 60 * 12, fallback_mimetype: str = "application/octet-stream", )
werkzeug.middleware.shared_data._TLoader?8
werkzeug.middleware.shared_data._TOpener?8
werkzeug.routing.AnyConverter?1(map: "Map", *items: str)
werkzeug.routing.BaseConverter.regex?7
werkzeug.routing.BaseConverter.to_python?4(value: str)
werkzeug.routing.BaseConverter.to_url?4(value: t.Any)
werkzeug.routing.BaseConverter.weight?7
werkzeug.routing.BaseConverter?1(map: "Map", *args: t.Any, **kwargs: t.Any)
werkzeug.routing.BuildError._score_rule?5()
werkzeug.routing.BuildError.closest_rule?4(adapter: t.Optional["MapAdapter"])
werkzeug.routing.BuildError.suggested?4()
werkzeug.routing.BuildError?1(endpoint: str, values: t.Mapping[str, t.Any], method: t.Optional[str], adapter: t.Optional["MapAdapter"] = None, )
werkzeug.routing.EndpointPrefix.get_rules?4(map: "Map")
werkzeug.routing.EndpointPrefix?1(prefix: str, rules: t.Iterable["Rule"])
werkzeug.routing.FloatConverter.num_convert?7
werkzeug.routing.FloatConverter.regex?7
werkzeug.routing.FloatConverter?1(map: "Map", min: t.Optional[float] = None, max: t.Optional[float] = None, signed: bool = False, )
werkzeug.routing.IntegerConverter.regex?7
werkzeug.routing.Map._get_wsgi_string?5()
werkzeug.routing.Map.add?4(rulefactory: RuleFactory)
werkzeug.routing.Map.bind?4(server_name: str, script_name: t.Optional[str] = None, subdomain: t.Optional[str] = None, url_scheme: str = "http", default_method: str = "GET", path_info: t.Optional[str] = None, query_args: t.Optional[t.Union[t.Mapping[str, t.Any], str]] = None, )
werkzeug.routing.Map.bind_to_environ?4(environ: "WSGIEnvironment", server_name: t.Optional[str] = None, subdomain: t.Optional[str] = None, )
werkzeug.routing.Map.default_converters?7
werkzeug.routing.Map.is_endpoint_expecting?4(endpoint: str, *arguments: str)
werkzeug.routing.Map.iter_rules?4(endpoint: t.Optional[str] = None)
werkzeug.routing.Map.lock_class?7
werkzeug.routing.Map.update?4()
werkzeug.routing.Map?1(rules: t.Optional[t.Iterable[RuleFactory]] = None, default_subdomain: str = "", charset: str = "utf-8", strict_slashes: bool = True, merge_slashes: bool = True, redirect_defaults: bool = True, converters: t.Optional[t.Mapping[str, t.Type[BaseConverter]]] = None, sort_parameters: bool = False, sort_key: t.Optional[t.Callable[[t.Any], t.Any]] = None, encoding_errors: str = "replace", host_matching: bool = False, )
werkzeug.routing.MapAdapter._handle_match?5()
werkzeug.routing.MapAdapter._partial_build?5(endpoint: str, values: t.Mapping[str, t.Any], method: t.Optional[str], append_unknown: bool, )
werkzeug.routing.MapAdapter.allowed_methods?4(path_info: t.Optional[str] = None)
werkzeug.routing.MapAdapter.build?4(endpoint: str, values: t.Optional[t.Mapping[str, t.Any]] = None, method: t.Optional[str] = None, force_external: bool = False, append_unknown: bool = True, url_scheme: t.Optional[str] = None, )
werkzeug.routing.MapAdapter.dispatch?4(view_func: t.Callable[[str, t.Mapping[str, t.Any]], "WSGIApplication"], path_info: t.Optional[str] = None, method: t.Optional[str] = None, catch_http_exceptions: bool = False, )
werkzeug.routing.MapAdapter.encode_query_args?4(query_args: t.Union[t.Mapping[str, t.Any], str])
werkzeug.routing.MapAdapter.get_default_redirect?4(rule: Rule, method: str, values: t.MutableMapping[str, t.Any], query_args: t.Union[t.Mapping[str, t.Any], str], )
werkzeug.routing.MapAdapter.get_host?4(domain_part: t.Optional[str])
werkzeug.routing.MapAdapter.make_alias_redirect_url?4(path: str, endpoint: str, values: t.Mapping[str, t.Any], method: str, query_args: t.Union[t.Mapping[str, t.Any], str], )
werkzeug.routing.MapAdapter.make_redirect_url?4(path_info: str, query_args: t.Optional[t.Union[t.Mapping[str, t.Any], str]] = None, domain_part: t.Optional[str] = None, )
werkzeug.routing.MapAdapter.match?4(path_info: t.Optional[str] = None, method: t.Optional[str] = None, return_rule: bool = False, query_args: t.Optional[t.Union[t.Mapping[str, t.Any], str]] = None, websocket: t.Optional[bool] = None, )
werkzeug.routing.MapAdapter.test?4(path_info: t.Optional[str] = None, method: t.Optional[str] = None)
werkzeug.routing.MapAdapter?1(map: Map, server_name: str, script_name: str, subdomain: t.Optional[str], url_scheme: str, path_info: str, default_method: str, query_args: t.Optional[t.Union[t.Mapping[str, t.Any], str]] = None, )
werkzeug.routing.NumberConverter.signed_regex?4()
werkzeug.routing.NumberConverter.to_python?4(value: str)
werkzeug.routing.NumberConverter.to_url?4(value: t.Any)
werkzeug.routing.NumberConverter.weight?7
werkzeug.routing.NumberConverter?1(map: "Map", fixed_digits: int = 0, min: t.Optional[int] = None, max: t.Optional[int] = None, signed: bool = False, )
werkzeug.routing.PathConverter.regex?7
werkzeug.routing.PathConverter.weight?7
werkzeug.routing.RequestAliasRedirect?1(matched_values: t.Mapping[str, t.Any])
werkzeug.routing.RequestPath?1(path_info: str)
werkzeug.routing.RequestRedirect.code?7
werkzeug.routing.RequestRedirect.get_response?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
werkzeug.routing.RequestRedirect?1(new_url: str)
werkzeug.routing.Rule._build_regex?5()
werkzeug.routing.Rule._compile_builder?5(append_unknown: bool = True)
werkzeug.routing.Rule._convert?5()
werkzeug.routing.Rule._encode_query_vars?5(query_vars: t.Mapping[str, t.Any])
werkzeug.routing.Rule._get_func_code?5(name: str)
werkzeug.routing.Rule._join?5()
werkzeug.routing.Rule._parts?5(str]])
werkzeug.routing.Rule.bind?4(map: "Map", rebind: bool = False)
werkzeug.routing.Rule.build?4(values: t.Mapping[str, t.Any], append_unknown: bool = True)
werkzeug.routing.Rule.build_compare_key?4()
werkzeug.routing.Rule.compile?4()
werkzeug.routing.Rule.empty?4()
werkzeug.routing.Rule.get_converter?4(variable_name: str, converter_name: str, args: t.Tuple, kwargs: t.Mapping[str, t.Any], )
werkzeug.routing.Rule.get_empty_kwargs?4()
werkzeug.routing.Rule.get_rules?4(map: "Map")
werkzeug.routing.Rule.match?4(path: str, method: t.Optional[str] = None)
werkzeug.routing.Rule.match_compare_key?4()
werkzeug.routing.Rule.provides_defaults_for?4(rule: "Rule")
werkzeug.routing.Rule.refresh?4()
werkzeug.routing.Rule.suitable_for?4(values: t.Mapping[str, t.Any], method: t.Optional[str] = None)
werkzeug.routing.Rule?1(string: str, defaults: t.Optional[t.Mapping[str, t.Any]] = None, subdomain: t.Optional[str] = None, methods: t.Optional[t.Iterable[str]] = None, build_only: bool = False, endpoint: t.Optional[str] = None, strict_slashes: t.Optional[bool] = None, merge_slashes: t.Optional[bool] = None, redirect_to: t.Optional[t.Union[str, t.Callable[..., str]]] = None, alias: bool = False, host: t.Optional[str] = None, websocket: bool = False, )
werkzeug.routing.RuleFactory.get_rules?4(map: "Map")
werkzeug.routing.RuleTemplate?1(rules: t.Iterable["Rule"])
werkzeug.routing.RuleTemplateFactory.get_rules?4(map: "Map")
werkzeug.routing.RuleTemplateFactory?1(rules: t.Iterable["Rule"], context: t.Dict[str, t.Any])
werkzeug.routing.Subdomain.get_rules?4(map: "Map")
werkzeug.routing.Subdomain?1(subdomain: str, rules: t.Iterable["Rule"])
werkzeug.routing.Submount.get_rules?4(map: "Map")
werkzeug.routing.Submount?1(path: str, rules: t.Iterable["Rule"])
werkzeug.routing.UUIDConverter.regex?7
werkzeug.routing.UUIDConverter.to_python?4(value: str)
werkzeug.routing.UUIDConverter.to_url?4(value: uuid.UUID)
werkzeug.routing.UnicodeConverter?1(map: "Map", minlength: int = 1, maxlength: t.Optional[int] = None, length: t.Optional[int] = None, )
werkzeug.routing._CALL_CONVERTER_CODE_FMT?8
werkzeug.routing._IF_KWARGS_URL_ENCODE_AST?8
werkzeug.routing._IF_KWARGS_URL_ENCODE_CODE?8
werkzeug.routing._PYTHON_CONSTANTS?8
werkzeug.routing._URL_ENCODE_AST_NAMES?8
werkzeug.routing._converter_args_re?8
werkzeug.routing._prefix_names?5(src: str)
werkzeug.routing._pythonize?5(value: str)
werkzeug.routing._rule_re?8
werkzeug.routing._simple_rule_re?8
werkzeug.routing.parse_converter_args?4(argstr: str)
werkzeug.routing.parse_rule?4(rule: str)
werkzeug.sansio.multipart.BLANK_LINE_RE?7
werkzeug.sansio.multipart.HEADER_CONTINUATION_RE?7
werkzeug.sansio.multipart.LINE_BREAK?7
werkzeug.sansio.multipart.LINE_BREAK_RE?7
werkzeug.sansio.multipart.MultipartDecoder._parse_headers?5(data: bytes)
werkzeug.sansio.multipart.MultipartDecoder.last_newline?4()
werkzeug.sansio.multipart.MultipartDecoder.next_event?4()
werkzeug.sansio.multipart.MultipartDecoder.receive_data?4(data: Optional[bytes])
werkzeug.sansio.multipart.MultipartDecoder?1(boundary: bytes, max_form_memory_size: Optional[int] = None, )
werkzeug.sansio.multipart.MultipartEncoder.send_event?4(event: Event)
werkzeug.sansio.multipart.MultipartEncoder?1(boundary: bytes)
werkzeug.sansio.multipart.NEED_DATA?7
werkzeug.sansio.multipart.State.COMPLETE?7
werkzeug.sansio.multipart.State.DATA?7
werkzeug.sansio.multipart.State.EPILOGUE?7
werkzeug.sansio.multipart.State.PART?7
werkzeug.sansio.multipart.State.PREAMBLE?7
werkzeug.sansio.request.Request._parse_content_type?5()
werkzeug.sansio.request.Request.accept_charsets?4()
werkzeug.sansio.request.Request.accept_encodings?4()
werkzeug.sansio.request.Request.accept_languages?4()
werkzeug.sansio.request.Request.accept_mimetypes?4()
werkzeug.sansio.request.Request.access_control_request_headers?7
werkzeug.sansio.request.Request.access_control_request_method?7
werkzeug.sansio.request.Request.access_route?4()
werkzeug.sansio.request.Request.args?4()
werkzeug.sansio.request.Request.authorization?4()
werkzeug.sansio.request.Request.base_url?4()
werkzeug.sansio.request.Request.cache_control?4()
werkzeug.sansio.request.Request.charset?7
werkzeug.sansio.request.Request.content_encoding?7
werkzeug.sansio.request.Request.content_length?4()
werkzeug.sansio.request.Request.content_md5?7
werkzeug.sansio.request.Request.content_type?7
werkzeug.sansio.request.Request.cookies?4()
werkzeug.sansio.request.Request.date?7
werkzeug.sansio.request.Request.encoding_errors?7
werkzeug.sansio.request.Request.full_path?4()
werkzeug.sansio.request.Request.host?4()
werkzeug.sansio.request.Request.host_url?4()
werkzeug.sansio.request.Request.if_match?4()
werkzeug.sansio.request.Request.if_modified_since?4()
werkzeug.sansio.request.Request.if_none_match?4()
werkzeug.sansio.request.Request.if_range?4()
werkzeug.sansio.request.Request.if_unmodified_since?4()
werkzeug.sansio.request.Request.is_json?4()
werkzeug.sansio.request.Request.is_secure?4()
werkzeug.sansio.request.Request.max_forwards?7
werkzeug.sansio.request.Request.mimetype?4()
werkzeug.sansio.request.Request.mimetype_params?4()
werkzeug.sansio.request.Request.origin?7
werkzeug.sansio.request.Request.pragma?4()
werkzeug.sansio.request.Request.range?4()
werkzeug.sansio.request.Request.referrer?7
werkzeug.sansio.request.Request.root_url?4()
werkzeug.sansio.request.Request.url?4()
werkzeug.sansio.request.Request.url_charset?4()
werkzeug.sansio.request.Request.user_agent?4()
werkzeug.sansio.request.Request.user_agent_class?7
werkzeug.sansio.request.Request?1(method: str, scheme: str, server: t.Optional[t.Tuple[str, t.Optional[int]]], root_path: str, path: str, query_string: bytes, headers: Headers, remote_addr: t.Optional[str], )
werkzeug.sansio.response.Response._clean_status?5(value: t.Union[str, int, HTTPStatus])
werkzeug.sansio.response.Response.accept_ranges?7
werkzeug.sansio.response.Response.access_control_allow_credentials?4(value: t.Optional[bool])
werkzeug.sansio.response.Response.access_control_allow_headers?7
werkzeug.sansio.response.Response.access_control_allow_methods?7
werkzeug.sansio.response.Response.access_control_allow_origin?7
werkzeug.sansio.response.Response.access_control_expose_headers?7
werkzeug.sansio.response.Response.access_control_max_age?7
werkzeug.sansio.response.Response.age?7
werkzeug.sansio.response.Response.allow?7
werkzeug.sansio.response.Response.cache_control?4()
werkzeug.sansio.response.Response.charset?7
werkzeug.sansio.response.Response.content_encoding?7
werkzeug.sansio.response.Response.content_language?7
werkzeug.sansio.response.Response.content_length?7
werkzeug.sansio.response.Response.content_location?7
werkzeug.sansio.response.Response.content_md5?7
werkzeug.sansio.response.Response.content_range?4(value: t.Optional[t.Union[ContentRange, str]])
werkzeug.sansio.response.Response.content_security_policy?7
werkzeug.sansio.response.Response.content_security_policy_report_only?7
werkzeug.sansio.response.Response.content_type?7
werkzeug.sansio.response.Response.cross_origin_embedder_policy?7
werkzeug.sansio.response.Response.cross_origin_opener_policy?7
werkzeug.sansio.response.Response.date?7
werkzeug.sansio.response.Response.default_mimetype?7
werkzeug.sansio.response.Response.default_status?7
werkzeug.sansio.response.Response.delete_cookie?4(key: str, path: str = "/", domain: t.Optional[str] = None, secure: bool = False, httponly: bool = False, samesite: t.Optional[str] = None, )
werkzeug.sansio.response.Response.expires?7
werkzeug.sansio.response.Response.get_etag?4()
werkzeug.sansio.response.Response.is_json?4()
werkzeug.sansio.response.Response.last_modified?7
werkzeug.sansio.response.Response.location?7
werkzeug.sansio.response.Response.max_cookie_size?7
werkzeug.sansio.response.Response.mimetype?4(value: str)
werkzeug.sansio.response.Response.mimetype_params?4()
werkzeug.sansio.response.Response.on_update?4()
werkzeug.sansio.response.Response.retry_after?4(value: t.Optional[t.Union[datetime, int, str]])
werkzeug.sansio.response.Response.set_cookie?4(key: str, value: str = "", max_age: t.Optional[t.Union[timedelta, int]] = None, expires: t.Optional[t.Union[str, datetime, int, float]] = None, path: t.Optional[str] = "/", domain: t.Optional[str] = None, secure: bool = False, httponly: bool = False, samesite: t.Optional[str] = None, )
werkzeug.sansio.response.Response.set_etag?4(etag: str, weak: bool = False)
werkzeug.sansio.response.Response.status?4(value: t.Union[str, int, HTTPStatus])
werkzeug.sansio.response.Response.status_code?4(code: int)
werkzeug.sansio.response.Response.vary?7
werkzeug.sansio.response.Response.www_authenticate?4()
werkzeug.sansio.response.Response?1(status: t.Optional[t.Union[int, str, HTTPStatus]] = None, headers: t.Optional[
            t.Union[
                t.Mapping[str, t.Union[str, int, t.Iterable[t.Union[str, int]]]], t.Iterable[t.Tuple[str, t.Union[str, int]]], ]
        ] = None, mimetype: t.Optional[str] = None, content_type: t.Optional[str] = None, )
werkzeug.sansio.response._set_property?5(name: str, doc: t.Optional[str] = None)
werkzeug.sansio.response.fget?4(self: "Response")
werkzeug.sansio.response.fset?4(self: "Response", value: t.Optional[
            t.Union[str, t.Dict[str, t.Union[str, int]], t.Iterable[str]]
        ], )
werkzeug.sansio.response.on_update?4(header_set: HeaderSet)
werkzeug.sansio.utils._normalize?5(hostname: str)
werkzeug.sansio.utils.get_current_url?4(scheme: str, host: str, root_path: t.Optional[str] = None, path: t.Optional[str] = None, query_string: t.Optional[bytes] = None, )
werkzeug.sansio.utils.get_host?4(scheme: str, host_header: t.Optional[str], server: t.Optional[t.Tuple[str, t.Optional[int]]] = None, trusted_hosts: t.Optional[t.Iterable[str]] = None, )
werkzeug.sansio.utils.host_is_trusted?4(hostname: str, trusted_list: t.Iterable[str])
werkzeug.security.DEFAULT_PBKDF2_ITERATIONS?7
werkzeug.security.SALT_CHARS?7
werkzeug.security._hash_internal?5(method: str, salt: str, password: str)
werkzeug.security.check_password_hash?4(pwhash: str, password: str)
werkzeug.security.gen_salt?4(length: int)
werkzeug.security.generate_password_hash?4(password: str, method: str = "pbkdf2:sha256", salt_length: int = 16)
werkzeug.security.pbkdf2_bin?4(data: t.Union[str, bytes], salt: t.Union[str, bytes], iterations: int = DEFAULT_PBKDF2_ITERATIONS, keylen: t.Optional[int] = None, hashfunc: t.Optional[t.Union[str, t.Callable]] = None, )
werkzeug.security.pbkdf2_hex?4(data: t.Union[str, bytes], salt: t.Union[str, bytes], iterations: int = DEFAULT_PBKDF2_ITERATIONS, keylen: t.Optional[int] = None, hashfunc: t.Optional[t.Union[str, t.Callable]] = None, )
werkzeug.security.safe_join?4(directory: str, *pathnames: str)
werkzeug.security.safe_str_cmp?4(a: str, b: str)
werkzeug.serving.BaseWSGIServer.handle_error?4(request: t.Any, client_address: t.Tuple[str, int])
werkzeug.serving.BaseWSGIServer.log?4(type: str, message: str, *args: t.Any)
werkzeug.serving.BaseWSGIServer.multiprocess?7
werkzeug.serving.BaseWSGIServer.multithread?7
werkzeug.serving.BaseWSGIServer.request_queue_size?7
werkzeug.serving.BaseWSGIServer.serve_forever?4(poll_interval: float = 0.5)
werkzeug.serving.BaseWSGIServer?1(host: str, port: int, app: "WSGIApplication", handler: t.Optional[t.Type[WSGIRequestHandler]] = None, passthrough_errors: bool = False, ssl_context: t.Optional[_TSSLContextArg] = None, fd: t.Optional[int] = None, )
werkzeug.serving.DechunkedInput.read_chunk_len?4()
werkzeug.serving.DechunkedInput.readable?4()
werkzeug.serving.DechunkedInput.readinto?4(buf: bytearray)
werkzeug.serving.DechunkedInput?1(rfile: t.BinaryIO)
werkzeug.serving.ForkingWSGIServer.multiprocess?7
werkzeug.serving.ForkingWSGIServer?1(host: str, port: int, app: "WSGIApplication", processes: int = 40, handler: t.Optional[t.Type[WSGIRequestHandler]] = None, passthrough_errors: bool = False, ssl_context: t.Optional[_TSSLContextArg] = None, fd: t.Optional[int] = None, )
werkzeug.serving.LISTEN_QUEUE?7
werkzeug.serving.ThreadedWSGIServer.daemon_threads?7
werkzeug.serving.ThreadedWSGIServer.multithread?7
werkzeug.serving.WSGIRequestHandler.address_string?4()
werkzeug.serving.WSGIRequestHandler.connection_dropped?4(error: BaseException, environ: t.Optional["WSGIEnvironment"] = None)
werkzeug.serving.WSGIRequestHandler.execute?4()
werkzeug.serving.WSGIRequestHandler.handle?4()
werkzeug.serving.WSGIRequestHandler.handle_one_request?4()
werkzeug.serving.WSGIRequestHandler.initiate_shutdown?4()
werkzeug.serving.WSGIRequestHandler.log?4(type: str, message: str, *args: t.Any)
werkzeug.serving.WSGIRequestHandler.log_error?4(format: str, *args: t.Any)
werkzeug.serving.WSGIRequestHandler.log_message?4(format: str, *args: t.Any)
werkzeug.serving.WSGIRequestHandler.log_request?4(code: t.Union[int, str] = "-", size: t.Union[int, str] = "-")
werkzeug.serving.WSGIRequestHandler.make_environ?4()
werkzeug.serving.WSGIRequestHandler.port_integer?4()
werkzeug.serving.WSGIRequestHandler.run_wsgi?4()
werkzeug.serving.WSGIRequestHandler.send_response?4(code: int, message: t.Optional[str] = None)
werkzeug.serving.WSGIRequestHandler.server_version?4()
werkzeug.serving.WSGIRequestHandler.shutdown_server?4()
werkzeug.serving.WSGIRequestHandler.start_response?4(headers, exc_info=None)
werkzeug.serving.WSGIRequestHandler.version_string?4()
werkzeug.serving.WSGIRequestHandler.write?4()
werkzeug.serving._SslDummy._log_add_style?8
werkzeug.serving._TSSLContextArg?8
werkzeug.serving._ansi_style?5(value: str, *styles: str)
werkzeug.serving._log_add_style?8
werkzeug.serving.can_fork?7
werkzeug.serving.can_open_by_fd?7
werkzeug.serving.generate_adhoc_ssl_context?4()
werkzeug.serving.generate_adhoc_ssl_pair?4(cn: t.Optional[str] = None, )
werkzeug.serving.get_interface_ip?4(family: socket.AddressFamily)
werkzeug.serving.get_sockaddr?4(host: str, port: int, family: socket.AddressFamily)
werkzeug.serving.inner?4()
werkzeug.serving.is_running_from_reloader?4()
werkzeug.serving.is_ssl_error?4(error: t.Optional[Exception] = None)
werkzeug.serving.load_ssl_context?4(cert_file: str, pkey_file: t.Optional[str] = None, protocol: t.Optional[int] = None)
werkzeug.serving.log_startup?4(sock: socket.socket)
werkzeug.serving.main?4()
werkzeug.serving.make_server?4(host: str, port: int, app: "WSGIApplication", threaded: bool = False, processes: int = 1, request_handler: t.Optional[t.Type[WSGIRequestHandler]] = None, passthrough_errors: bool = False, ssl_context: t.Optional[_TSSLContextArg] = None, fd: t.Optional[int] = None, )
werkzeug.serving.make_ssl_devcert?4(base_path: str, host: t.Optional[str] = None, cn: t.Optional[str] = None)
werkzeug.serving.run_simple?4(hostname: str, port: int, application: "WSGIApplication", use_reloader: bool = False, use_debugger: bool = False, use_evalex: bool = True, extra_files: t.Optional[t.Iterable[str]] = None, exclude_patterns: t.Optional[t.Iterable[str]] = None, reloader_interval: int = 1, reloader_type: str = "auto", threaded: bool = False, processes: int = 1, request_handler: t.Optional[t.Type[WSGIRequestHandler]] = None, static_files: t.Optional[t.Dict[str, t.Union[str, t.Tuple[str, str]]]] = None, passthrough_errors: bool = False, ssl_context: t.Optional[_TSSLContextArg] = None, )
werkzeug.serving.run_with_reloader?4(*args: t.Any, **kwargs: t.Any)
werkzeug.serving.select_address_family?4(host: str, port: int)
werkzeug.test.Client.delete?4(*args: t.Any, **kw: t.Any)
werkzeug.test.Client.delete_cookie?4(server_name: str, key: str, path: str = "/", domain: t.Optional[str] = None, secure: bool = False, httponly: bool = False, samesite: t.Optional[str] = None, )
werkzeug.test.Client.get?4(*args: t.Any, **kw: t.Any)
werkzeug.test.Client.head?4(*args: t.Any, **kw: t.Any)
werkzeug.test.Client.open?4(*args: t.Any, as_tuple: bool = False, buffered: bool = False, follow_redirects: bool = False, **kwargs: t.Any, )
werkzeug.test.Client.options?4(*args: t.Any, **kw: t.Any)
werkzeug.test.Client.patch?4(*args: t.Any, **kw: t.Any)
werkzeug.test.Client.post?4(*args: t.Any, **kw: t.Any)
werkzeug.test.Client.put?4(*args: t.Any, **kw: t.Any)
werkzeug.test.Client.resolve_redirect?4(response: "TestResponse", buffered: bool = False)
werkzeug.test.Client.run_wsgi_app?4(environ: "WSGIEnvironment", buffered: bool = False)
werkzeug.test.Client.set_cookie?4(server_name: str, key: str, value: str = "", max_age: t.Optional[t.Union[timedelta, int]] = None, expires: t.Optional[t.Union[str, datetime, int, float]] = None, path: str = "/", domain: t.Optional[str] = None, secure: bool = False, httponly: bool = False, samesite: t.Optional[str] = None, charset: str = "utf-8", )
werkzeug.test.Client.trace?4(*args: t.Any, **kw: t.Any)
werkzeug.test.Client?1(application: "WSGIApplication", response_wrapper: t.Optional[t.Type["Response"]] = None, use_cookies: bool = True, allow_subdomain_redirects: bool = False, )
werkzeug.test.EnvironBuilder._add_file_from_data?5(key: str, value: t.Union[
            t.BinaryIO, t.Tuple[t.BinaryIO, str], t.Tuple[t.BinaryIO, str, str]
        ], )
werkzeug.test.EnvironBuilder._get_form?5(name: str, storage: t.Type[_TAnyMultiDict])
werkzeug.test.EnvironBuilder._make_base_url?5(host: str, script_root: str)
werkzeug.test.EnvironBuilder._path_encode?5()
werkzeug.test.EnvironBuilder._set_form?5(name: str, value: MultiDict)
werkzeug.test.EnvironBuilder.args?4(value: t.Optional[MultiDict])
werkzeug.test.EnvironBuilder.base_url?4(value: t.Optional[str])
werkzeug.test.EnvironBuilder.close?4()
werkzeug.test.EnvironBuilder.content_length?4(value: t.Optional[int])
werkzeug.test.EnvironBuilder.content_type?4(value: t.Optional[str])
werkzeug.test.EnvironBuilder.files?4(value: FileMultiDict)
werkzeug.test.EnvironBuilder.form?4(value: MultiDict)
werkzeug.test.EnvironBuilder.from_environ?4(environ: "WSGIEnvironment", **kwargs: t.Any)
werkzeug.test.EnvironBuilder.get_environ?4()
werkzeug.test.EnvironBuilder.get_request?4(cls: t.Optional[t.Type[Request]] = None)
werkzeug.test.EnvironBuilder.input_stream?4(value: t.Optional[t.BinaryIO])
werkzeug.test.EnvironBuilder.json_dumps?7
werkzeug.test.EnvironBuilder.mimetype?4(value: str)
werkzeug.test.EnvironBuilder.mimetype_params?4()
werkzeug.test.EnvironBuilder.on_update?4(str])
werkzeug.test.EnvironBuilder.query_string?4(value: t.Optional[str])
werkzeug.test.EnvironBuilder.request_class?7
werkzeug.test.EnvironBuilder.server_name?4()
werkzeug.test.EnvironBuilder.server_port?4()
werkzeug.test.EnvironBuilder.server_protocol?7
werkzeug.test.EnvironBuilder.wsgi_version?7
werkzeug.test.EnvironBuilder?1(path: str = "/", base_url: t.Optional[str] = None, query_string: t.Optional[t.Union[t.Mapping[str, str], str]] = None, method: str = "GET", input_stream: t.Optional[t.BinaryIO] = None, content_type: t.Optional[str] = None, content_length: t.Optional[int] = None, errors_stream: t.Optional[t.TextIO] = None, multithread: bool = False, multiprocess: bool = False, run_once: bool = False, headers: t.Optional[t.Union[Headers, t.Iterable[t.Tuple[str, str]]]] = None, data: t.Optional[t.Union[t.BinaryIO, str, bytes, t.Mapping[str, t.Any]]] = None, environ_base: t.Optional[t.Mapping[str, t.Any]] = None, environ_overrides: t.Optional[t.Mapping[str, t.Any]] = None, charset: str = "utf-8", mimetype: t.Optional[str] = None, json: t.Optional[t.Mapping[str, t.Any]] = None, auth: t.Optional[t.Union[Authorization, t.Tuple[str, str]]] = None, )
werkzeug.test.TestResponse?1(response: t.Iterable[bytes], status: str, headers: Headers, request: Request, history: t.Tuple["TestResponse"] = (), **kwargs: t.Any, )
werkzeug.test._TAnyMultiDict?8
werkzeug.test._TestCookieHeaders.get_all?4(name: str, default: t.Optional[t.Iterable[str]] = None)
werkzeug.test._TestCookieHeaders.getheaders?4(name: str)
werkzeug.test._TestCookieHeaders?2(headers: t.Union[Headers, t.List[t.Tuple[str, str]]])
werkzeug.test._TestCookieJar.extract_wsgi?4(environ: "WSGIEnvironment", headers: t.Union[Headers, t.List[t.Tuple[str, str]]], )
werkzeug.test._TestCookieJar.inject_wsgi?4(environ: "WSGIEnvironment")
werkzeug.test._TestCookieResponse.info?4()
werkzeug.test._TestCookieResponse?2(headers: t.Union[Headers, t.List[t.Tuple[str, str]]])
werkzeug.test._iter_data?5(data: t.Mapping[str, t.Any])
werkzeug.test.create_environ?4(*args: t.Any, **kwargs: t.Any)
werkzeug.test.encode_multipart?4(values: t.Mapping[str, t.Any], boundary: t.Optional[str] = None, charset: str = "utf-8", )
werkzeug.test.run_wsgi_app?4(app: "WSGIApplication", environ: "WSGIEnvironment", buffered: bool = False)
werkzeug.test.start_response?4(status, headers, exc_info=None)
werkzeug.test.stream_encode_multipart?4(data: t.Mapping[str, t.Any], use_tempfile: bool = True, threshold: int = 1024 * 500, boundary: t.Optional[str] = None, charset: str = "utf-8", )
werkzeug.test.write_binary?4(s: bytes)
werkzeug.testapp.TEMPLATE?7
werkzeug.testapp.iter_sys_path?4()
werkzeug.testapp.logo?7
werkzeug.testapp.render_testapp?4(req: Request)
werkzeug.testapp.strip?4(x: str)
werkzeug.testapp.test_app?4(environ: "WSGIEnvironment", start_response: "StartResponse")
werkzeug.urls.BaseURL._split_auth?5()
werkzeug.urls.BaseURL._split_host?5()
werkzeug.urls.BaseURL._split_netloc?5()
werkzeug.urls.BaseURL.ascii_host?4()
werkzeug.urls.BaseURL.auth?4()
werkzeug.urls.BaseURL.decode_netloc?4()
werkzeug.urls.BaseURL.decode_query?4(*args: t.Any, **kwargs: t.Any)
werkzeug.urls.BaseURL.encode_netloc?4()
werkzeug.urls.BaseURL.get_file_location?4(pathformat: t.Optional[str] = None)
werkzeug.urls.BaseURL.host?4()
werkzeug.urls.BaseURL.join?4(*args: t.Any, **kwargs: t.Any)
werkzeug.urls.BaseURL.password?4()
werkzeug.urls.BaseURL.port?4()
werkzeug.urls.BaseURL.raw_password?4()
werkzeug.urls.BaseURL.raw_username?4()
werkzeug.urls.BaseURL.replace?4(**kwargs: t.Any)
werkzeug.urls.BaseURL.to_iri_tuple?4()
werkzeug.urls.BaseURL.to_uri_tuple?4()
werkzeug.urls.BaseURL.to_url?4()
werkzeug.urls.BaseURL.username?4()
werkzeug.urls.BytesURL._at?8
werkzeug.urls.BytesURL._colon?8
werkzeug.urls.BytesURL._lbracket?8
werkzeug.urls.BytesURL._rbracket?8
werkzeug.urls.BytesURL.decode?4(charset: str = "utf-8", errors: str = "replace")
werkzeug.urls.BytesURL.encode_netloc?4()
werkzeug.urls.Href?1(base="./", charset="utf-8", sort=False, key=None)
werkzeug.urls.URL._at?8
werkzeug.urls.URL._colon?8
werkzeug.urls.URL._lbracket?8
werkzeug.urls.URL._rbracket?8
werkzeug.urls.URL.encode?4(charset: str = "utf-8", errors: str = "replace")
werkzeug.urls._always_safe?8
werkzeug.urls._bytetohex?8
werkzeug.urls._codec_error_url_quote?5(e: UnicodeError)
werkzeug.urls._fast_quote_plus?8
werkzeug.urls._fast_url_quote?8
werkzeug.urls._fast_url_quote_plus?5(string: bytes)
werkzeug.urls._hexdigits?8
werkzeug.urls._hextobyte?8
werkzeug.urls._make_fast_url_quote?5(charset: str = "utf-8", errors: str = "strict", safe: t.Union[str, bytes] = "/:", unsafe: t.Union[str, bytes] = "", )
werkzeug.urls._scheme_re?8
werkzeug.urls._to_iri_unsafe?8
werkzeug.urls._to_uri_safe?8
werkzeug.urls._unquote_to_bytes?5(string: t.Union[str, bytes], unsafe: t.Union[str, bytes] = "")
werkzeug.urls._url_decode_impl?5(pair_iter: t.Iterable[t.AnyStr], charset: str, include_empty: bool, errors: str)
werkzeug.urls._url_encode_impl?5(obj: t.Union[t.Mapping[str, str], t.Iterable[t.Tuple[str, str]]], charset: str, sort: bool, key: t.Optional[t.Callable[[t.Tuple[str, str]], t.Any]], )
werkzeug.urls._url_unquote_legacy?5(value: str, unsafe: str = "")
werkzeug.urls.iri_to_uri?4(iri: t.Union[str, t.Tuple[str, str, str, str, str]], charset: str = "utf-8", errors: str = "strict", safe_conversion: bool = False, )
werkzeug.urls.quote?4(string: bytes)
werkzeug.urls.uri_to_iri?4(uri: t.Union[str, t.Tuple[str, str, str, str, str]], charset: str = "utf-8", errors: str = "werkzeug.url_quote", )
werkzeug.urls.url_decode?4(s: t.AnyStr, charset: str = "utf-8", decode_keys: None = None, include_empty: bool = True, errors: str = "replace", separator: str = "&", cls: t.Optional[t.Type["ds.MultiDict"]] = None, )
werkzeug.urls.url_decode_stream?4(stream: t.BinaryIO, charset: str = "utf-8", decode_keys: None = None, include_empty: bool = True, errors: str = "replace", separator: bytes = b"&", cls: t.Optional[t.Type["ds.MultiDict"]] = None, limit: t.Optional[int] = None, return_iterator: bool = False, )
werkzeug.urls.url_encode?4(obj: t.Union[t.Mapping[str, str], t.Iterable[t.Tuple[str, str]]], charset: str = "utf-8", encode_keys: None = None, sort: bool = False, key: t.Optional[t.Callable[[t.Tuple[str, str]], t.Any]] = None, separator: str = "&", )
werkzeug.urls.url_encode_stream?4(obj: t.Union[t.Mapping[str, str], t.Iterable[t.Tuple[str, str]]], stream: t.Optional[t.TextIO] = None, charset: str = "utf-8", encode_keys: None = None, sort: bool = False, key: t.Optional[t.Callable[[t.Tuple[str, str]], t.Any]] = None, separator: str = "&", )
werkzeug.urls.url_fix?4(s: str, charset: str = "utf-8")
werkzeug.urls.url_join?4(base: t.Union[str, t.Tuple[str, str, str, str, str]], url: t.Union[str, t.Tuple[str, str, str, str, str]], allow_fragments: bool = True, )
werkzeug.urls.url_parse?4(url: str, scheme: t.Optional[str] = None, allow_fragments: bool = True)
werkzeug.urls.url_quote?4(string: t.Union[str, bytes], charset: str = "utf-8", errors: str = "strict", safe: t.Union[str, bytes] = "/:", unsafe: t.Union[str, bytes] = "", )
werkzeug.urls.url_quote_plus?4(string: str, charset: str = "utf-8", errors: str = "strict", safe: str = "")
werkzeug.urls.url_unparse?4(components: t.Tuple[str, str, str, str, str])
werkzeug.urls.url_unquote?4(s: t.Union[str, bytes], charset: str = "utf-8", errors: str = "replace", unsafe: str = "", )
werkzeug.urls.url_unquote_plus?4(s: t.Union[str, bytes], charset: str = "utf-8", errors: str = "replace")
werkzeug.user_agent.UserAgent.to_header?4()
werkzeug.user_agent.UserAgent?1(string: str)
werkzeug.useragents.UserAgent?1(environ_or_string: "t.Union[str, WSGIEnvironment]")
werkzeug.useragents.UserAgentParser?1()
werkzeug.useragents._UserAgent._parser?8
werkzeug.useragents._UserAgent.browser?4()
werkzeug.useragents._UserAgent.language?4()
werkzeug.useragents._UserAgent.platform?4()
werkzeug.useragents._UserAgent.version?4()
werkzeug.useragents._UserAgent?2(string: str)
werkzeug.useragents._UserAgentParser._browser_version_re?8
werkzeug.useragents._UserAgentParser._language_re?8
werkzeug.useragents._UserAgentParser?2()
werkzeug.useragents._deprecated_property?2(fget: t.Callable[["_UserAgent"], t.Any])
werkzeug.utils.ArgumentValidationError?1(missing=None, extra=None, extra_positional=None)
werkzeug.utils.HTMLBuilder._boolean_attributes?8
werkzeug.utils.HTMLBuilder._c_like_cdata?8
werkzeug.utils.HTMLBuilder._empty_elements?8
werkzeug.utils.HTMLBuilder._entities?8
werkzeug.utils.HTMLBuilder._entity_re?8
werkzeug.utils.HTMLBuilder._plaintext_elements?8
werkzeug.utils.HTMLBuilder.proxy?4(**arguments)
werkzeug.utils.HTMLBuilder?1(dialect)
werkzeug.utils.ImportStringError?1(import_name: str, exception: BaseException)
werkzeug.utils._T?8
werkzeug.utils._charset_mimetypes?8
werkzeug.utils._entity_re?8
werkzeug.utils._filename_ascii_strip_re?8
werkzeug.utils._windows_device_files?8
werkzeug.utils.append_slash_redirect?4(environ: "WSGIEnvironment", code: int = 301)
werkzeug.utils.bind_arguments?4(func, args, kwargs)
werkzeug.utils.cached_property?1(fget: t.Callable[[t.Any], _T], name: t.Optional[str] = None, doc: t.Optional[str] = None, )
werkzeug.utils.detect_utf_encoding?4(data: bytes)
werkzeug.utils.environ_property.lookup?4(obj: "Request")
werkzeug.utils.environ_property.read_only?7
werkzeug.utils.escape?4(s: t.Any)
werkzeug.utils.find_modules?4(import_path: str, include_packages: bool = False, recursive: bool = False)
werkzeug.utils.format_string?4(string: str, context: t.Mapping[str, t.Any])
werkzeug.utils.get_content_type?4(mimetype: str, charset: str)
werkzeug.utils.header_property.lookup?4(obj: t.Union["Request", "Response"])
werkzeug.utils.html?7
werkzeug.utils.import_string?4(import_name: str, silent: bool = False)
werkzeug.utils.invalidate_cached_property?4(obj: object, name: str)
werkzeug.utils.redirect?4(location: str, code: int = 302, Response: t.Optional[t.Type["Response"]] = None)
werkzeug.utils.secure_filename?4(filename: str)
werkzeug.utils.send_file?4(path_or_file: t.Union[os.PathLike, str, t.BinaryIO], environ: "WSGIEnvironment", mimetype: t.Optional[str] = None, as_attachment: bool = False, download_name: t.Optional[str] = None, conditional: bool = True, etag: t.Union[bool, str] = True, last_modified: t.Optional[t.Union[datetime, int, float]] = None, max_age: t.Optional[
        t.Union[int, t.Callable[[t.Optional[str]], t.Optional[int]]]
    ] = None, use_x_sendfile: bool = False, response_class: t.Optional[t.Type["Response"]] = None, _root_path: t.Optional[t.Union[os.PathLike, str]] = None, )
werkzeug.utils.send_from_directory?4(directory: t.Union[os.PathLike, str], path: t.Union[os.PathLike, str], environ: "WSGIEnvironment", **kwargs: t.Any, )
werkzeug.utils.unescape?4(s: str)
werkzeug.utils.validate_arguments?4(func, args, kwargs, drop_extra=True)
werkzeug.utils.xhtml?7
werkzeug.wrappers.accept.AcceptMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.auth.AuthorizationMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.auth.WWWAuthenticateMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.base_request.BaseRequest?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.base_response.BaseResponse?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.common_descriptors.CommonRequestDescriptorsMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.common_descriptors.CommonResponseDescriptorsMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.cors.CORSRequestMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.cors.CORSResponseMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.etag.ETagRequestMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.etag.ETagResponseMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.json.JSONMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.request.PlainRequest?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.request.Request._get_file_stream?5(total_content_length: t.Optional[int], content_type: t.Optional[str], filename: t.Optional[str] = None, content_length: t.Optional[int] = None, )
werkzeug.wrappers.request.Request._get_stream_for_parsing?5()
werkzeug.wrappers.request.Request._load_form_data?5()
werkzeug.wrappers.request.Request.application?4()
werkzeug.wrappers.request.Request.close?4()
werkzeug.wrappers.request.Request.data?4()
werkzeug.wrappers.request.Request.files?4()
werkzeug.wrappers.request.Request.form?4()
werkzeug.wrappers.request.Request.from_values?4(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.request.Request.get_data?4(cache: bool = True, as_text: bool = False, parse_form_data: bool = False)
werkzeug.wrappers.request.Request.get_json?4(force: bool = False, silent: bool = False, cache: bool = True)
werkzeug.wrappers.request.Request.input_stream?7
werkzeug.wrappers.request.Request.is_multiprocess?7
werkzeug.wrappers.request.Request.is_multithread?7
werkzeug.wrappers.request.Request.is_run_once?7
werkzeug.wrappers.request.Request.json?4()
werkzeug.wrappers.request.Request.json_module?7
werkzeug.wrappers.request.Request.make_form_data_parser?4()
werkzeug.wrappers.request.Request.on_json_loading_failed?4(e: ValueError)
werkzeug.wrappers.request.Request.remote_user?7
werkzeug.wrappers.request.Request.script_root?4()
werkzeug.wrappers.request.Request.stream?4()
werkzeug.wrappers.request.Request.url_root?4()
werkzeug.wrappers.request.Request.values?4()
werkzeug.wrappers.request.Request.want_form_data_parsed?4()
werkzeug.wrappers.request.Request?1(environ: "WSGIEnvironment", populate_request: bool = True, shallow: bool = False, )
werkzeug.wrappers.request.StreamOnlyMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.response.Response._ensure_sequence?5(mutable: bool = False)
werkzeug.wrappers.response.Response._is_range_request_processable?5(environ: "WSGIEnvironment")
werkzeug.wrappers.response.Response._process_range_request?5(environ: "WSGIEnvironment", complete_length: t.Optional[int] = None, accept_ranges: t.Optional[t.Union[bool, str]] = None, )
werkzeug.wrappers.response.Response._wrap_range_response?5(start: int, length: int)
werkzeug.wrappers.response.Response.add_etag?4(overwrite: bool = False, weak: bool = False)
werkzeug.wrappers.response.Response.autocorrect_location_header?7
werkzeug.wrappers.response.Response.automatically_set_content_length?7
werkzeug.wrappers.response.Response.calculate_content_length?4()
werkzeug.wrappers.response.Response.call_on_close?4(func: t.Callable[[], t.Any])
werkzeug.wrappers.response.Response.close?4()
werkzeug.wrappers.response.Response.data?7
werkzeug.wrappers.response.Response.force_type?4(response: "Response", environ: t.Optional["WSGIEnvironment"] = None)
werkzeug.wrappers.response.Response.freeze?4(no_etag: None = None)
werkzeug.wrappers.response.Response.from_app?4(app: "WSGIApplication", environ: "WSGIEnvironment", buffered: bool = False)
werkzeug.wrappers.response.Response.get_app_iter?4(environ: "WSGIEnvironment")
werkzeug.wrappers.response.Response.get_data?4(as_text: bool = False)
werkzeug.wrappers.response.Response.get_json?4(force: bool = False, silent: bool = False)
werkzeug.wrappers.response.Response.get_wsgi_headers?4(environ: "WSGIEnvironment")
werkzeug.wrappers.response.Response.get_wsgi_response?4(environ: "WSGIEnvironment")
werkzeug.wrappers.response.Response.implicit_sequence_conversion?7
werkzeug.wrappers.response.Response.is_sequence?4()
werkzeug.wrappers.response.Response.is_streamed?4()
werkzeug.wrappers.response.Response.iter_encoded?4()
werkzeug.wrappers.response.Response.json?4()
werkzeug.wrappers.response.Response.json_module?7
werkzeug.wrappers.response.Response.make_conditional?4(request_or_environ: "WSGIEnvironment", accept_ranges: t.Union[bool, str] = False, complete_length: t.Optional[int] = None, )
werkzeug.wrappers.response.Response.make_sequence?4()
werkzeug.wrappers.response.Response.set_data?4(value: t.Union[bytes, str])
werkzeug.wrappers.response.Response.stream?4()
werkzeug.wrappers.response.Response?1(response: t.Optional[
            t.Union[t.Iterable[bytes], bytes, t.Iterable[str], str]
        ] = None, status: t.Optional[t.Union[int, str, HTTPStatus]] = None, headers: t.Optional[
            t.Union[
                t.Mapping[str, t.Union[str, int, t.Iterable[t.Union[str, int]]]], t.Iterable[t.Tuple[str, t.Union[str, int]]], ]
        ] = None, mimetype: t.Optional[str] = None, content_type: t.Optional[str] = None, direct_passthrough: bool = False, )
werkzeug.wrappers.response.ResponseStream.close?4()
werkzeug.wrappers.response.ResponseStream.encoding?4()
werkzeug.wrappers.response.ResponseStream.flush?4()
werkzeug.wrappers.response.ResponseStream.isatty?4()
werkzeug.wrappers.response.ResponseStream.mode?7
werkzeug.wrappers.response.ResponseStream.tell?4()
werkzeug.wrappers.response.ResponseStream.write?4(value: bytes)
werkzeug.wrappers.response.ResponseStream.writelines?4(seq: t.Iterable[bytes])
werkzeug.wrappers.response.ResponseStream?1(response: Response)
werkzeug.wrappers.response.ResponseStreamMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wrappers.response._clean_accept_ranges?5(accept_ranges: t.Union[bool, str])
werkzeug.wrappers.response._iter_encoded?5(iterable: t.Iterable[t.Union[str, bytes]], charset: str)
werkzeug.wrappers.response._warn_if_string?5(iterable: t.Iterable)
werkzeug.wrappers.user_agent.UserAgentMixin?1(*args: t.Any, **kwargs: t.Any)
werkzeug.wsgi.ClosingIterator.close?4()
werkzeug.wsgi.ClosingIterator?1(iterable: t.Iterable[bytes], callbacks: t.Optional[
            t.Union[t.Callable[[], None], t.Iterable[t.Callable[[], None]]]
        ] = None, )
werkzeug.wsgi.FileWrapper.close?4()
werkzeug.wsgi.FileWrapper.seek?4(*args: t.Any)
werkzeug.wsgi.FileWrapper.seekable?4()
werkzeug.wsgi.FileWrapper.tell?4()
werkzeug.wsgi.FileWrapper?1(file: t.BinaryIO, buffer_size: int = 8192)
werkzeug.wsgi.LimitedStream.exhaust?4(chunk_size: int = 1024 * 64)
werkzeug.wsgi.LimitedStream.is_exhausted?4()
werkzeug.wsgi.LimitedStream.on_disconnect?4()
werkzeug.wsgi.LimitedStream.on_exhausted?4()
werkzeug.wsgi.LimitedStream.read?4(size: t.Optional[int] = None)
werkzeug.wsgi.LimitedStream.readable?4()
werkzeug.wsgi.LimitedStream.readline?4(size: t.Optional[int] = None)
werkzeug.wsgi.LimitedStream.readlines?4(size: t.Optional[int] = None)
werkzeug.wsgi.LimitedStream.tell?4()
werkzeug.wsgi.LimitedStream?1(stream: t.BinaryIO, limit: int)
werkzeug.wsgi._RangeWrapper._first_iteration?5()
werkzeug.wsgi._RangeWrapper._next?5()
werkzeug.wsgi._RangeWrapper._next_chunk?5()
werkzeug.wsgi._RangeWrapper.close?4()
werkzeug.wsgi._RangeWrapper?2(iterable: t.Union[t.Iterable[bytes], t.BinaryIO], start_byte: int = 0, byte_range: t.Optional[int] = None, )
werkzeug.wsgi._get_server?5(environ: "WSGIEnvironment", )
werkzeug.wsgi._iter_basic_lines?5()
werkzeug.wsgi._make_chunk_iter?5(stream: t.Union[t.Iterable[bytes], t.BinaryIO], limit: t.Optional[int], buffer_size: int, )
werkzeug.wsgi._normalize_netloc?5(scheme: str, netloc: str)
werkzeug.wsgi.extract_path_info?4(environ_or_baseurl: t.Union[str, "WSGIEnvironment"], path_or_url: t.Union[str, _URLTuple], charset: str = "utf-8", errors: str = "werkzeug.url_quote", collapse_http_schemes: bool = True, )
werkzeug.wsgi.get_content_length?4(environ: "WSGIEnvironment")
werkzeug.wsgi.get_current_url?4(environ: "WSGIEnvironment", root_only: bool = False, strip_querystring: bool = False, host_only: bool = False, trusted_hosts: t.Optional[t.Iterable[str]] = None, )
werkzeug.wsgi.get_host?4(environ: "WSGIEnvironment", trusted_hosts: t.Optional[t.Iterable[str]] = None)
werkzeug.wsgi.get_input_stream?4(environ: "WSGIEnvironment", safe_fallback: bool = True)
werkzeug.wsgi.get_path_info?4(environ: "WSGIEnvironment", charset: str = "utf-8", errors: str = "replace")
werkzeug.wsgi.get_query_string?4(environ: "WSGIEnvironment")
werkzeug.wsgi.get_script_name?4(environ: "WSGIEnvironment", charset: str = "utf-8", errors: str = "replace")
werkzeug.wsgi.make_chunk_iter?4(stream: t.Union[t.Iterable[bytes], t.BinaryIO], separator: bytes, limit: t.Optional[int] = None, buffer_size: int = 10 * 1024, cap_at_buffer: bool = False, )
werkzeug.wsgi.make_line_iter?4(stream: t.Union[t.Iterable[bytes], t.BinaryIO], limit: t.Optional[int] = None, buffer_size: int = 10 * 1024, cap_at_buffer: bool = False, )
werkzeug.wsgi.peek_path_info?4(environ: "WSGIEnvironment", charset: str = "utf-8", errors: str = "replace")
werkzeug.wsgi.pop_path_info?4(environ: "WSGIEnvironment", charset: str = "utf-8", errors: str = "replace")
werkzeug.wsgi.responder?4(f: t.Callable[..., "WSGIApplication"])
werkzeug.wsgi.wrap_file?4(environ: "WSGIEnvironment", file: t.BinaryIO, buffer_size: int = 8192)