Mercurial Repositories > Flask Project / file comparison

comparison: ProjectFlask/APIs/werkzeug-2.0.1.api

ProjectFlask/APIs/werkzeug-2.0.1.api

branch
eric7
changeset 64
0ee58185b8df
equal deleted inserted replaced
63:7c05cbc8b3e5 64:0ee58185b8df
1 werkzeug._internal._ColorStreamHandler?2()
2 werkzeug._internal._DictAccessorProperty.lookup?4(instance: t.Any)
3 werkzeug._internal._DictAccessorProperty.read_only?7
4 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, )
5 werkzeug._internal._TAccessorValue?8
6 werkzeug._internal._check_str_tuple?5(value: t.Tuple[t.AnyStr, ...])
7 werkzeug._internal._cookie_parse_impl?5(b: bytes)
8 werkzeug._internal._cookie_quote?5(b: bytes)
9 werkzeug._internal._cookie_quoting_map?8
10 werkzeug._internal._cookie_re?8
11 werkzeug._internal._cookie_unquote?5(b: bytes)
12 werkzeug._internal._decode_idna?5(domain: t.Union[str, bytes])
13 werkzeug._internal._default_encoding?8
14 werkzeug._internal._dt_as_utc?5(dt: None)
15 werkzeug._internal._dt_as_utc?5(dt: datetime)
16 werkzeug._internal._dt_as_utc?5(dt: t.Optional[datetime])
17 werkzeug._internal._easteregg?5(app: t.Optional["WSGIApplication"] = None)
18 werkzeug._internal._encode_idna?5(domain: str)
19 werkzeug._internal._epoch_ord?8
20 werkzeug._internal._get_environ?5(obj: t.Union["WSGIEnvironment", "Request"])
21 werkzeug._internal._has_level_handler?5(logger: logging.Logger)
22 werkzeug._internal._legal_cookie_chars?8
23 werkzeug._internal._legal_cookie_chars_re?8
24 werkzeug._internal._log?5(type: str, message: str, *args: t.Any, **kwargs: t.Any)
25 werkzeug._internal._make_cookie_domain?5(domain: None)
26 werkzeug._internal._make_cookie_domain?5(domain: str)
27 werkzeug._internal._make_cookie_domain?5(domain: t.Optional[str])
28 werkzeug._internal._make_encode_wrapper?5(reference: bytes)
29 werkzeug._internal._make_encode_wrapper?5(reference: str)
30 werkzeug._internal._make_encode_wrapper?5(reference: t.AnyStr)
31 werkzeug._internal._missing?8
32 werkzeug._internal._octal_re?8
33 werkzeug._internal._parse_signature?5(func)
34 werkzeug._internal._quote_re?8
35 werkzeug._internal._signature_cache?8
36 werkzeug._internal._to_bytes?5(x: t.Union[str, bytes], charset: str = _default_encoding, errors: str = "strict")
37 werkzeug._internal._to_str?5(x: None, charset: t.Optional[str] = ..., errors: str = ..., allow_none_charset: bool = ..., )
38 werkzeug._internal._to_str?5(x: t.Any, charset: t.Optional[str] = ..., errors: str = ..., allow_none_charset: bool = ..., )
39 werkzeug._internal._to_str?5(x: t.Optional[t.Any], charset: t.Optional[str] = _default_encoding, errors: str = "strict", allow_none_charset: bool = False, )
40 werkzeug._internal._wsgi_decoding_dance?5(s: str, charset: str = "utf-8", errors: str = "replace")
41 werkzeug._internal._wsgi_encoding_dance?5(s: str, charset: str = "utf-8", errors: str = "replace")
42 werkzeug._internal.bzzzzzzz?4(gyver: bytes)
43 werkzeug._internal.decode_part?4(part: bytes)
44 werkzeug._internal.easteregged?4(environ: "WSGIEnvironment", start_response: "StartResponse")
45 werkzeug._internal.injecting_start_response?4(status: str, headers: t.List[t.Tuple[str, str]], exc_info: t.Any = None)
46 werkzeug._internal.parse?4(args, kwargs)
47 werkzeug._reloader.EventHandler.ignore_patterns?7
48 werkzeug._reloader.EventHandler.on_any_event?4(event)
49 werkzeug._reloader.EventHandler.patterns?7
50 werkzeug._reloader.EventHandler.reloader_name?7
51 werkzeug._reloader.ReloaderLoop.log_reload?4(filename: str)
52 werkzeug._reloader.ReloaderLoop.name?7
53 werkzeug._reloader.ReloaderLoop.restart_with_reloader?4()
54 werkzeug._reloader.ReloaderLoop.run?4()
55 werkzeug._reloader.ReloaderLoop.run_step?4()
56 werkzeug._reloader.ReloaderLoop.trigger_reload?4(filename: str)
57 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, )
58 werkzeug._reloader.StatReloaderLoop.name?7
59 werkzeug._reloader.StatReloaderLoop.run_step?4()
60 werkzeug._reloader.WatchdogReloaderLoop.run?4()
61 werkzeug._reloader.WatchdogReloaderLoop.run_step?4()
62 werkzeug._reloader.WatchdogReloaderLoop.trigger_reload?4(filename: str)
63 werkzeug._reloader.WatchdogReloaderLoop?1(*args: t.Any, **kwargs: t.Any)
64 werkzeug._reloader._find_common_roots?5(paths: t.Iterable[str])
65 werkzeug._reloader._find_stat_paths?5(extra_files: t.Set[str], exclude_patterns: t.Set[str])
66 werkzeug._reloader._find_watchdog_paths?5(extra_files: t.Set[str], exclude_patterns: t.Set[str])
67 werkzeug._reloader._get_args_for_reloading?5()
68 werkzeug._reloader._ignore_prefixes?8
69 werkzeug._reloader._iter_module_paths?5()
70 werkzeug._reloader._remove_by_pattern?5(paths: t.Set[str], exclude_patterns: t.Set[str])
71 werkzeug._reloader._walk?5(node: t.Mapping[str, dict], path: t.Tuple[str, ...])
72 werkzeug._reloader.ensure_echo_on?4()
73 werkzeug._reloader.prefix?7
74 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", )
75 werkzeug.datastructures.Accept._best_single_match?5(match)
76 werkzeug.datastructures.Accept._specificity?5(value)
77 werkzeug.datastructures.Accept._value_matches?5(value, item)
78 werkzeug.datastructures.Accept.best?4()
79 werkzeug.datastructures.Accept.best_match?4(matches, default=None)
80 werkzeug.datastructures.Accept.find?4(key)
81 werkzeug.datastructures.Accept.index?4(key)
82 werkzeug.datastructures.Accept.quality?4(key)
83 werkzeug.datastructures.Accept.to_header?4()
84 werkzeug.datastructures.Accept.values?4()
85 werkzeug.datastructures.Accept?1(values=())
86 werkzeug.datastructures.Authorization.cnonce?4()
87 werkzeug.datastructures.Authorization.nc?4()
88 werkzeug.datastructures.Authorization.nonce?4()
89 werkzeug.datastructures.Authorization.opaque?4()
90 werkzeug.datastructures.Authorization.password?4()
91 werkzeug.datastructures.Authorization.qop?4()
92 werkzeug.datastructures.Authorization.realm?4()
93 werkzeug.datastructures.Authorization.response?4()
94 werkzeug.datastructures.Authorization.to_header?4()
95 werkzeug.datastructures.Authorization.uri?4()
96 werkzeug.datastructures.Authorization.username?4()
97 werkzeug.datastructures.Authorization?1(auth_type, data=None)
98 werkzeug.datastructures.CallbackDict?1(initial=None, on_update=None)
99 werkzeug.datastructures.CharsetAccept._normalize?5()
100 werkzeug.datastructures.CharsetAccept._value_matches?5(value, item)
101 werkzeug.datastructures.CombinedMultiDict._keys_impl?5()
102 werkzeug.datastructures.CombinedMultiDict.copy?4()
103 werkzeug.datastructures.CombinedMultiDict.fromkeys?4(keys, value=None)
104 werkzeug.datastructures.CombinedMultiDict.get?4(key, default=None, type=None)
105 werkzeug.datastructures.CombinedMultiDict.getlist?4(key, type=None)
106 werkzeug.datastructures.CombinedMultiDict.has_key?4(key)
107 werkzeug.datastructures.CombinedMultiDict.items?4(multi=False)
108 werkzeug.datastructures.CombinedMultiDict.keys?4()
109 werkzeug.datastructures.CombinedMultiDict.lists?4()
110 werkzeug.datastructures.CombinedMultiDict.listvalues?4()
111 werkzeug.datastructures.CombinedMultiDict.to_dict?4(flat=True)
112 werkzeug.datastructures.CombinedMultiDict.values?4()
113 werkzeug.datastructures.CombinedMultiDict?1(dicts=None)
114 werkzeug.datastructures.ContentRange.length?7
115 werkzeug.datastructures.ContentRange.set?4(start, stop, length=None, units="bytes")
116 werkzeug.datastructures.ContentRange.start?7
117 werkzeug.datastructures.ContentRange.stop?7
118 werkzeug.datastructures.ContentRange.to_header?4()
119 werkzeug.datastructures.ContentRange.units?7
120 werkzeug.datastructures.ContentRange.unset?4()
121 werkzeug.datastructures.ContentRange?1(units, start, stop, length=None, on_update=None)
122 werkzeug.datastructures.ContentSecurityPolicy._del_value?5(key)
123 werkzeug.datastructures.ContentSecurityPolicy._get_value?5(key)
124 werkzeug.datastructures.ContentSecurityPolicy._set_value?5(key, value)
125 werkzeug.datastructures.ContentSecurityPolicy.base_uri?7
126 werkzeug.datastructures.ContentSecurityPolicy.child_src?7
127 werkzeug.datastructures.ContentSecurityPolicy.connect_src?7
128 werkzeug.datastructures.ContentSecurityPolicy.default_src?7
129 werkzeug.datastructures.ContentSecurityPolicy.font_src?7
130 werkzeug.datastructures.ContentSecurityPolicy.form_action?7
131 werkzeug.datastructures.ContentSecurityPolicy.frame_ancestors?7
132 werkzeug.datastructures.ContentSecurityPolicy.frame_src?7
133 werkzeug.datastructures.ContentSecurityPolicy.img_src?7
134 werkzeug.datastructures.ContentSecurityPolicy.manifest_src?7
135 werkzeug.datastructures.ContentSecurityPolicy.media_src?7
136 werkzeug.datastructures.ContentSecurityPolicy.navigate_to?7
137 werkzeug.datastructures.ContentSecurityPolicy.object_src?7
138 werkzeug.datastructures.ContentSecurityPolicy.plugin_types?7
139 werkzeug.datastructures.ContentSecurityPolicy.prefetch_src?7
140 werkzeug.datastructures.ContentSecurityPolicy.report_to?7
141 werkzeug.datastructures.ContentSecurityPolicy.report_uri?7
142 werkzeug.datastructures.ContentSecurityPolicy.sandbox?7
143 werkzeug.datastructures.ContentSecurityPolicy.script_src?7
144 werkzeug.datastructures.ContentSecurityPolicy.script_src_attr?7
145 werkzeug.datastructures.ContentSecurityPolicy.script_src_elem?7
146 werkzeug.datastructures.ContentSecurityPolicy.style_src?7
147 werkzeug.datastructures.ContentSecurityPolicy.style_src_attr?7
148 werkzeug.datastructures.ContentSecurityPolicy.style_src_elem?7
149 werkzeug.datastructures.ContentSecurityPolicy.to_header?4()
150 werkzeug.datastructures.ContentSecurityPolicy.worker_src?7
151 werkzeug.datastructures.ContentSecurityPolicy?1(values=(), on_update=None)
152 werkzeug.datastructures.ETags.as_set?4(include_weak=False)
153 werkzeug.datastructures.ETags.contains?4(etag)
154 werkzeug.datastructures.ETags.contains_raw?4(etag)
155 werkzeug.datastructures.ETags.contains_weak?4(etag)
156 werkzeug.datastructures.ETags.is_strong?4(etag)
157 werkzeug.datastructures.ETags.is_weak?4(etag)
158 werkzeug.datastructures.ETags.to_header?4()
159 werkzeug.datastructures.ETags?1(strong_etags=None, weak_etags=None, star_tag=False)
160 werkzeug.datastructures.EnvironHeaders.copy?4()
161 werkzeug.datastructures.EnvironHeaders?1(environ)
162 werkzeug.datastructures.FileMultiDict.add_file?4(name, file, filename=None, content_type=None)
163 werkzeug.datastructures.FileStorage._parse_content_type?5()
164 werkzeug.datastructures.FileStorage.close?4()
165 werkzeug.datastructures.FileStorage.content_length?4()
166 werkzeug.datastructures.FileStorage.content_type?4()
167 werkzeug.datastructures.FileStorage.mimetype?4()
168 werkzeug.datastructures.FileStorage.mimetype_params?4()
169 werkzeug.datastructures.FileStorage.save?4(dst, buffer_size=16384)
170 werkzeug.datastructures.FileStorage?1(stream=None, filename=None, name=None, content_type=None, content_length=None, headers=None, )
171 werkzeug.datastructures.HeaderSet.add?4(header)
172 werkzeug.datastructures.HeaderSet.as_set?4(preserve_casing=False)
173 werkzeug.datastructures.HeaderSet.clear?4()
174 werkzeug.datastructures.HeaderSet.discard?4(header)
175 werkzeug.datastructures.HeaderSet.find?4(header)
176 werkzeug.datastructures.HeaderSet.index?4(header)
177 werkzeug.datastructures.HeaderSet.remove?4(header)
178 werkzeug.datastructures.HeaderSet.to_header?4()
179 werkzeug.datastructures.HeaderSet.update?4(iterable)
180 werkzeug.datastructures.HeaderSet?1(headers=None, on_update=None)
181 werkzeug.datastructures.Headers._validate_value?5(value)
182 werkzeug.datastructures.Headers.add?4(_key, _value, **kw)
183 werkzeug.datastructures.Headers.add_header?4(_key, _value, **_kw)
184 werkzeug.datastructures.Headers.clear?4()
185 werkzeug.datastructures.Headers.copy?4()
186 werkzeug.datastructures.Headers.extend?4(*args, **kwargs)
187 werkzeug.datastructures.Headers.get?4(key, default=None, type=None, as_bytes=False)
188 werkzeug.datastructures.Headers.get_all?4(name)
189 werkzeug.datastructures.Headers.getlist?4(key, type=None, as_bytes=False)
190 werkzeug.datastructures.Headers.has_key?4(key)
191 werkzeug.datastructures.Headers.items?4(lower=False)
192 werkzeug.datastructures.Headers.keys?4(lower=False)
193 werkzeug.datastructures.Headers.lowered?4()
194 werkzeug.datastructures.Headers.pop?4(key=None, default=_missing)
195 werkzeug.datastructures.Headers.popitem?4()
196 werkzeug.datastructures.Headers.remove?4(key)
197 werkzeug.datastructures.Headers.set?4(_key, _value, **kw)
198 werkzeug.datastructures.Headers.setdefault?4(key, default)
199 werkzeug.datastructures.Headers.setlist?4(key, values)
200 werkzeug.datastructures.Headers.setlistdefault?4(key, default)
201 werkzeug.datastructures.Headers.to_wsgi_list?4()
202 werkzeug.datastructures.Headers.update?4(*args, **kwargs)
203 werkzeug.datastructures.Headers.values?4()
204 werkzeug.datastructures.Headers?1(defaults=None)
205 werkzeug.datastructures.IfRange.to_header?4()
206 werkzeug.datastructures.IfRange?1(etag=None, date=None)
207 werkzeug.datastructures.ImmutableDict.copy?4()
208 werkzeug.datastructures.ImmutableDictMixin._hash_cache?8
209 werkzeug.datastructures.ImmutableDictMixin._iter_hashitems?5()
210 werkzeug.datastructures.ImmutableDictMixin.clear?4()
211 werkzeug.datastructures.ImmutableDictMixin.fromkeys?4(keys, value=None)
212 werkzeug.datastructures.ImmutableDictMixin.pop?4(key, default=None)
213 werkzeug.datastructures.ImmutableDictMixin.popitem?4()
214 werkzeug.datastructures.ImmutableDictMixin.setdefault?4(key, default=None)
215 werkzeug.datastructures.ImmutableDictMixin.update?4(*args, **kwargs)
216 werkzeug.datastructures.ImmutableHeadersMixin.add?4(_key, _value, **kw)
217 werkzeug.datastructures.ImmutableHeadersMixin.add_header?4(_key, _value, **_kw)
218 werkzeug.datastructures.ImmutableHeadersMixin.extend?4(*args, **kwargs)
219 werkzeug.datastructures.ImmutableHeadersMixin.insert?4(pos, value)
220 werkzeug.datastructures.ImmutableHeadersMixin.pop?4(key=None, default=_missing)
221 werkzeug.datastructures.ImmutableHeadersMixin.popitem?4()
222 werkzeug.datastructures.ImmutableHeadersMixin.remove?4(key)
223 werkzeug.datastructures.ImmutableHeadersMixin.set?4(_key, _value, **kw)
224 werkzeug.datastructures.ImmutableHeadersMixin.setdefault?4(key, default)
225 werkzeug.datastructures.ImmutableHeadersMixin.setlist?4(key, values)
226 werkzeug.datastructures.ImmutableHeadersMixin.setlistdefault?4(key, default)
227 werkzeug.datastructures.ImmutableHeadersMixin.update?4(*args, **kwargs)
228 werkzeug.datastructures.ImmutableListMixin._hash_cache?8
229 werkzeug.datastructures.ImmutableListMixin.append?4(item)
230 werkzeug.datastructures.ImmutableListMixin.extend?4(iterable)
231 werkzeug.datastructures.ImmutableListMixin.insert?4(pos, value)
232 werkzeug.datastructures.ImmutableListMixin.pop?4(index=-1)
233 werkzeug.datastructures.ImmutableListMixin.remove?4(item)
234 werkzeug.datastructures.ImmutableListMixin.reverse?4()
235 werkzeug.datastructures.ImmutableListMixin.sort?4(key=None, reverse=False)
236 werkzeug.datastructures.ImmutableMultiDict.copy?4()
237 werkzeug.datastructures.ImmutableMultiDictMixin._iter_hashitems?5()
238 werkzeug.datastructures.ImmutableMultiDictMixin.add?4(key, value)
239 werkzeug.datastructures.ImmutableMultiDictMixin.popitemlist?4()
240 werkzeug.datastructures.ImmutableMultiDictMixin.poplist?4(key)
241 werkzeug.datastructures.ImmutableMultiDictMixin.setlist?4(key, new_list)
242 werkzeug.datastructures.ImmutableMultiDictMixin.setlistdefault?4(key, default_list=None)
243 werkzeug.datastructures.ImmutableOrderedMultiDict._iter_hashitems?5()
244 werkzeug.datastructures.ImmutableOrderedMultiDict.copy?4()
245 werkzeug.datastructures.ImmutableTypeConversionDict.copy?4()
246 werkzeug.datastructures.LanguageAccept._value_matches?5(value, item)
247 werkzeug.datastructures.LanguageAccept.best_match?4(matches, default=None)
248 werkzeug.datastructures.MIMEAccept._specificity?5(value)
249 werkzeug.datastructures.MIMEAccept._value_matches?5(value, item)
250 werkzeug.datastructures.MIMEAccept.accept_html?4()
251 werkzeug.datastructures.MIMEAccept.accept_json?4()
252 werkzeug.datastructures.MIMEAccept.accept_xhtml?4()
253 werkzeug.datastructures.MultiDict.add?4(key, value)
254 werkzeug.datastructures.MultiDict.copy?4()
255 werkzeug.datastructures.MultiDict.deepcopy?4(memo=None)
256 werkzeug.datastructures.MultiDict.getlist?4(key, type=None)
257 werkzeug.datastructures.MultiDict.items?4(multi=False)
258 werkzeug.datastructures.MultiDict.lists?4()
259 werkzeug.datastructures.MultiDict.listvalues?4()
260 werkzeug.datastructures.MultiDict.pop?4(key, default=_missing)
261 werkzeug.datastructures.MultiDict.popitem?4()
262 werkzeug.datastructures.MultiDict.popitemlist?4()
263 werkzeug.datastructures.MultiDict.poplist?4(key)
264 werkzeug.datastructures.MultiDict.setdefault?4(key, default=None)
265 werkzeug.datastructures.MultiDict.setlist?4(key, new_list)
266 werkzeug.datastructures.MultiDict.setlistdefault?4(key, default_list=None)
267 werkzeug.datastructures.MultiDict.to_dict?4(flat=True)
268 werkzeug.datastructures.MultiDict.update?4(mapping)
269 werkzeug.datastructures.MultiDict.values?4()
270 werkzeug.datastructures.MultiDict?1(mapping=None)
271 werkzeug.datastructures.OrderedMultiDict.add?4(key, value)
272 werkzeug.datastructures.OrderedMultiDict.getlist?4(key, type=None)
273 werkzeug.datastructures.OrderedMultiDict.items?4(multi=False)
274 werkzeug.datastructures.OrderedMultiDict.keys?4()
275 werkzeug.datastructures.OrderedMultiDict.lists?4()
276 werkzeug.datastructures.OrderedMultiDict.listvalues?4()
277 werkzeug.datastructures.OrderedMultiDict.pop?4(key, default=_missing)
278 werkzeug.datastructures.OrderedMultiDict.popitem?4()
279 werkzeug.datastructures.OrderedMultiDict.popitemlist?4()
280 werkzeug.datastructures.OrderedMultiDict.poplist?4(key)
281 werkzeug.datastructures.OrderedMultiDict.setlist?4(key, new_list)
282 werkzeug.datastructures.OrderedMultiDict.setlistdefault?4(key, default_list=None)
283 werkzeug.datastructures.OrderedMultiDict.update?4(mapping)
284 werkzeug.datastructures.OrderedMultiDict.values?4()
285 werkzeug.datastructures.OrderedMultiDict?1(mapping=None)
286 werkzeug.datastructures.Range.make_content_range?4(length)
287 werkzeug.datastructures.Range.range_for_length?4(length)
288 werkzeug.datastructures.Range.to_content_range_header?4(length)
289 werkzeug.datastructures.Range.to_header?4()
290 werkzeug.datastructures.Range?1(units, ranges)
291 werkzeug.datastructures.RequestCacheControl.max_stale?7
292 werkzeug.datastructures.RequestCacheControl.min_fresh?7
293 werkzeug.datastructures.RequestCacheControl.only_if_cached?7
294 werkzeug.datastructures.ResponseCacheControl.immutable?7
295 werkzeug.datastructures.ResponseCacheControl.must_revalidate?7
296 werkzeug.datastructures.ResponseCacheControl.private?7
297 werkzeug.datastructures.ResponseCacheControl.proxy_revalidate?7
298 werkzeug.datastructures.ResponseCacheControl.public?7
299 werkzeug.datastructures.ResponseCacheControl.s_maxage?7
300 werkzeug.datastructures.TypeConversionDict.get?4(key, default=None, type=None)
301 werkzeug.datastructures.UpdateDictMixin.clear?7
302 werkzeug.datastructures.UpdateDictMixin.on_update?7
303 werkzeug.datastructures.UpdateDictMixin.pop?4(key, default=_missing)
304 werkzeug.datastructures.UpdateDictMixin.popitem?7
305 werkzeug.datastructures.UpdateDictMixin.setdefault?4(key, default=None)
306 werkzeug.datastructures.UpdateDictMixin.update?7
307 werkzeug.datastructures.WWWAuthenticate._require_quoting?8
308 werkzeug.datastructures.WWWAuthenticate.algorithm?7
309 werkzeug.datastructures.WWWAuthenticate.auth_property?7
310 werkzeug.datastructures.WWWAuthenticate.domain?7
311 werkzeug.datastructures.WWWAuthenticate.nonce?7
312 werkzeug.datastructures.WWWAuthenticate.opaque?7
313 werkzeug.datastructures.WWWAuthenticate.qop?7
314 werkzeug.datastructures.WWWAuthenticate.realm?7
315 werkzeug.datastructures.WWWAuthenticate.set_basic?4(realm="authentication required")
316 werkzeug.datastructures.WWWAuthenticate.set_digest?4(realm, nonce, qop=("auth", ), opaque=None, algorithm=None, stale=False)
317 werkzeug.datastructures.WWWAuthenticate.stale?4(value)
318 werkzeug.datastructures.WWWAuthenticate.to_header?4()
319 werkzeug.datastructures.WWWAuthenticate.type?7
320 werkzeug.datastructures.WWWAuthenticate?1(auth_type=None, values=None, on_update=None)
321 werkzeug.datastructures._CacheControl._del_cache_value?5(key)
322 werkzeug.datastructures._CacheControl._get_cache_value?5(key, empty, type)
323 werkzeug.datastructures._CacheControl._set_cache_value?5(key, value, type)
324 werkzeug.datastructures._CacheControl.cache_property?7
325 werkzeug.datastructures._CacheControl.max_age?7
326 werkzeug.datastructures._CacheControl.no_cache?7
327 werkzeug.datastructures._CacheControl.no_store?7
328 werkzeug.datastructures._CacheControl.no_transform?7
329 werkzeug.datastructures._CacheControl.to_header?4()
330 werkzeug.datastructures._CacheControl?2(values=(), on_update=None)
331 werkzeug.datastructures._callback_property?5(name)
332 werkzeug.datastructures._calls_update?5(name)
333 werkzeug.datastructures._locale_delim_re?8
334 werkzeug.datastructures._mime_split_re?8
335 werkzeug.datastructures._normalize_lang?5(value)
336 werkzeug.datastructures._normalize_mime?5(value)
337 werkzeug.datastructures._omd_bucket.unlink?4(omd)
338 werkzeug.datastructures._omd_bucket?2(omd, key, value)
339 werkzeug.datastructures._options_header_vkw?5(value, kw)
340 werkzeug.datastructures._set_property?5(name, doc=None)
341 werkzeug.datastructures._set_value?5(self, value)
342 werkzeug.datastructures._unicodify_header_value?5(value)
343 werkzeug.datastructures.auth_property?4(name, doc=None)
344 werkzeug.datastructures.cache_control_property?4(key, empty, type)
345 werkzeug.datastructures.cache_property?4(key, empty, type)
346 werkzeug.datastructures.csp_property?4(key)
347 werkzeug.datastructures.fget?4(self)
348 werkzeug.datastructures.fset?4(self, value)
349 werkzeug.datastructures.is_immutable?4(self)
350 werkzeug.datastructures.iter_multi_items?4(mapping)
351 werkzeug.datastructures.on_update?4(header_set)
352 werkzeug.datastructures.oncall?4(self, *args, **kw)
353 werkzeug.debug.DebuggedApplication._fail_pin_auth?5()
354 werkzeug.debug.DebuggedApplication.check_pin_trust?4(environ: "WSGIEnvironment")
355 werkzeug.debug.DebuggedApplication.debug_application?4(environ: "WSGIEnvironment", start_response: "StartResponse")
356 werkzeug.debug.DebuggedApplication.display_console?4(request: Request)
357 werkzeug.debug.DebuggedApplication.execute_command?4(request: Request, command: str, frame: t.Union[Frame, _ConsoleFrame])
358 werkzeug.debug.DebuggedApplication.get_resource?4(request: Request, filename: str)
359 werkzeug.debug.DebuggedApplication.log_pin_request?4()
360 werkzeug.debug.DebuggedApplication.pin?4(value: str)
361 werkzeug.debug.DebuggedApplication.pin_auth?4(request: Request)
362 werkzeug.debug.DebuggedApplication.pin_cookie_name?4()
363 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, )
364 werkzeug.debug.PIN_TIME?7
365 werkzeug.debug._ConsoleFrame?2(namespace: t.Dict[str, t.Any])
366 werkzeug.debug._generate?5()
367 werkzeug.debug.console.Console.eval?4(code: str)
368 werkzeug.debug.console.Console?1(globals: t.Optional[t.Dict[str, t.Any]] = None, locals: t.Optional[t.Dict[str, t.Any]] = None, )
369 werkzeug.debug.console.HTMLStringO._write?5(x: str)
370 werkzeug.debug.console.HTMLStringO.close?4()
371 werkzeug.debug.console.HTMLStringO.flush?4()
372 werkzeug.debug.console.HTMLStringO.isatty?4()
373 werkzeug.debug.console.HTMLStringO.readline?4()
374 werkzeug.debug.console.HTMLStringO.reset?4()
375 werkzeug.debug.console.HTMLStringO.seek?4(n: int, mode: int = 0)
376 werkzeug.debug.console.HTMLStringO.write?4(x: str)
377 werkzeug.debug.console.HTMLStringO.writelines?4(x: t.Iterable[str])
378 werkzeug.debug.console.HTMLStringO?1()
379 werkzeug.debug.console.ThreadedStream.displayhook?4()
380 werkzeug.debug.console.ThreadedStream.fetch?4()
381 werkzeug.debug.console.ThreadedStream.push?4()
382 werkzeug.debug.console._ConsoleLoader.get_source_by_code?4(code: CodeType)
383 werkzeug.debug.console._ConsoleLoader.register?4(code: CodeType, source: str)
384 werkzeug.debug.console._ConsoleLoader?2()
385 werkzeug.debug.console._InteractiveConsole.compile?4(filename: str, symbol: str)
386 werkzeug.debug.console._InteractiveConsole.runcode?4(code: CodeType)
387 werkzeug.debug.console._InteractiveConsole.runsource?4(source: str, **kwargs: t.Any)
388 werkzeug.debug.console._InteractiveConsole.showsyntaxerror?4(filename: t.Optional[str] = None)
389 werkzeug.debug.console._InteractiveConsole.showtraceback?4()
390 werkzeug.debug.console._InteractiveConsole.write?4(data: str)
391 werkzeug.debug.console._InteractiveConsole?2(globals: t.Dict[str, t.Any], locals: t.Dict[str, t.Any])
392 werkzeug.debug.console._displayhook?8
393 werkzeug.debug.console._local?8
394 werkzeug.debug.get_machine_id?4()
395 werkzeug.debug.get_pin_and_cookie_name?4(app: "WSGIApplication", )
396 werkzeug.debug.hash_pin?4(pin: str)
397 werkzeug.debug.repr.DebugReprGenerator.deque_repr?7
398 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, )
399 werkzeug.debug.repr.DebugReprGenerator.dispatch_repr?4(obj: t.Any, recursive: bool)
400 werkzeug.debug.repr.DebugReprGenerator.dump_locals?4(d: t.Dict[str, t.Any])
401 werkzeug.debug.repr.DebugReprGenerator.dump_object?4(obj: object)
402 werkzeug.debug.repr.DebugReprGenerator.fallback_repr?4()
403 werkzeug.debug.repr.DebugReprGenerator.frozenset_repr?7
404 werkzeug.debug.repr.DebugReprGenerator.list_repr?7
405 werkzeug.debug.repr.DebugReprGenerator.object_repr?4(obj: t.Optional[t.Union[t.Type[dict], t.Callable, t.Type[list]]])
406 werkzeug.debug.repr.DebugReprGenerator.regex_repr?4(obj: t.Pattern)
407 werkzeug.debug.repr.DebugReprGenerator.render_object_dump?4(items: t.List[t.Tuple[str, str]], title: str, repr: t.Optional[str] = None)
408 werkzeug.debug.repr.DebugReprGenerator.repr?4(obj: object)
409 werkzeug.debug.repr.DebugReprGenerator.set_repr?7
410 werkzeug.debug.repr.DebugReprGenerator.string_repr?4(obj: t.Union[str, bytes], limit: int = 70)
411 werkzeug.debug.repr.DebugReprGenerator.tuple_repr?7
412 werkzeug.debug.repr.DebugReprGenerator?1()
413 werkzeug.debug.repr.HELP_HTML?7
414 werkzeug.debug.repr.OBJECT_DUMP_HTML?7
415 werkzeug.debug.repr.RegexType?7
416 werkzeug.debug.repr._add_subclass_info?5(inner: str, obj: object, base: t.Union[t.Type, t.Tuple[t.Type, ...]])
417 werkzeug.debug.repr._paragraph_re?8
418 werkzeug.debug.repr._sequence_repr_maker?5(left: str, right: str, base: t.Type, limit: int = 8)
419 werkzeug.debug.repr.debug_repr?4(obj: object)
420 werkzeug.debug.repr.dump?4(obj: object = missing)
421 werkzeug.debug.repr.helper?7
422 werkzeug.debug.repr.missing?7
423 werkzeug.debug.repr.proxy?4(self: "DebugReprGenerator", obj: t.Iterable, recursive: bool)
424 werkzeug.debug.tbtools.CONSOLE_HTML?7
425 werkzeug.debug.tbtools.FOOTER?7
426 werkzeug.debug.tbtools.FRAME_HTML?7
427 werkzeug.debug.tbtools.Frame.console?4()
428 werkzeug.debug.tbtools.Frame.current_line?4()
429 werkzeug.debug.tbtools.Frame.eval?4(code: t.Union[str, CodeType], mode: str = "single")
430 werkzeug.debug.tbtools.Frame.get_annotated_lines?4()
431 werkzeug.debug.tbtools.Frame.get_context_lines?4(context: int = 5)
432 werkzeug.debug.tbtools.Frame.id?4()
433 werkzeug.debug.tbtools.Frame.is_library?4()
434 werkzeug.debug.tbtools.Frame.render?4(mark_lib: bool = True)
435 werkzeug.debug.tbtools.Frame.render_line?4(cls: str)
436 werkzeug.debug.tbtools.Frame.render_line_context?4()
437 werkzeug.debug.tbtools.Frame.render_text?4()
438 werkzeug.debug.tbtools.Frame.sourcelines?4()
439 werkzeug.debug.tbtools.Frame?1(exc_type: t.Type[BaseException], exc_value: BaseException, tb: TracebackType, )
440 werkzeug.debug.tbtools.Group.exception?4()
441 werkzeug.debug.tbtools.Group.filter_hidden_frames?4()
442 werkzeug.debug.tbtools.Group.render?4(mark_lib: bool = True)
443 werkzeug.debug.tbtools.Group.render_text?4()
444 werkzeug.debug.tbtools.Group?1(exc_type: t.Type[BaseException], exc_value: BaseException, tb: TracebackType, )
445 werkzeug.debug.tbtools.HEADER?7
446 werkzeug.debug.tbtools.Line.classes?4()
447 werkzeug.debug.tbtools.Line.render?4()
448 werkzeug.debug.tbtools.Line?1(lineno: int, code: str)
449 werkzeug.debug.tbtools.PAGE_HTML?7
450 werkzeug.debug.tbtools.SOURCE_LINE_HTML?7
451 werkzeug.debug.tbtools.SUMMARY_HTML?7
452 werkzeug.debug.tbtools.Traceback.exception?4()
453 werkzeug.debug.tbtools.Traceback.filter_hidden_frames?4()
454 werkzeug.debug.tbtools.Traceback.id?4()
455 werkzeug.debug.tbtools.Traceback.is_syntax_error?4()
456 werkzeug.debug.tbtools.Traceback.log?4(logfile: t.Optional[t.TextIO] = None)
457 werkzeug.debug.tbtools.Traceback.plaintext?4()
458 werkzeug.debug.tbtools.Traceback.render_full?4(evalex: bool = False, secret: t.Optional[str] = None, evalex_trusted: bool = True, )
459 werkzeug.debug.tbtools.Traceback.render_summary?4(include_title: bool = True)
460 werkzeug.debug.tbtools.Traceback?1(exc_type: t.Type[BaseException], exc_value: BaseException, tb: TracebackType, )
461 werkzeug.debug.tbtools._coding_re?8
462 werkzeug.debug.tbtools._funcdef_re?8
463 werkzeug.debug.tbtools._line_re?8
464 werkzeug.debug.tbtools.get_current_traceback?4(ignore_system_exceptions: bool = False, show_hidden_frames: bool = False, skip: int = 0, )
465 werkzeug.debug.tbtools.render_console_html?4(secret: str, evalex_trusted: bool = True)
466 werkzeug.exceptions.Aborter?1(mapping: t.Optional[t.Dict[int, t.Type[HTTPException]]] = None, extra: t.Optional[t.Dict[int, t.Type[HTTPException]]] = None, )
467 werkzeug.exceptions.BadGateway.code?7
468 werkzeug.exceptions.BadGateway.description?7
469 werkzeug.exceptions.BadRequest.code?7
470 werkzeug.exceptions.BadRequest.description?7
471 werkzeug.exceptions.BadRequestKeyError._description?8
472 werkzeug.exceptions.BadRequestKeyError.description?4(value: str)
473 werkzeug.exceptions.BadRequestKeyError.show_exception?7
474 werkzeug.exceptions.BadRequestKeyError?1(arg: t.Optional[str] = None, *args: t.Any, **kwargs: t.Any)
475 werkzeug.exceptions.Conflict.code?7
476 werkzeug.exceptions.Conflict.description?7
477 werkzeug.exceptions.ExpectationFailed.code?7
478 werkzeug.exceptions.ExpectationFailed.description?7
479 werkzeug.exceptions.FailedDependency.code?7
480 werkzeug.exceptions.FailedDependency.description?7
481 werkzeug.exceptions.Forbidden.code?7
482 werkzeug.exceptions.Forbidden.description?7
483 werkzeug.exceptions.GatewayTimeout.code?7
484 werkzeug.exceptions.GatewayTimeout.description?7
485 werkzeug.exceptions.Gone.code?7
486 werkzeug.exceptions.Gone.description?7
487 werkzeug.exceptions.HTTPException.get_body?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
488 werkzeug.exceptions.HTTPException.get_description?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
489 werkzeug.exceptions.HTTPException.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
490 werkzeug.exceptions.HTTPException.get_response?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
491 werkzeug.exceptions.HTTPException.name?4()
492 werkzeug.exceptions.HTTPException.wrap?4(exception: t.Type[BaseException], name: t.Optional[str] = None)
493 werkzeug.exceptions.HTTPException?1(description: t.Optional[str] = None, response: t.Optional["Response"] = None, )
494 werkzeug.exceptions.HTTPVersionNotSupported.code?7
495 werkzeug.exceptions.HTTPVersionNotSupported.description?7
496 werkzeug.exceptions.ImATeapot.code?7
497 werkzeug.exceptions.ImATeapot.description?7
498 werkzeug.exceptions.InternalServerError.code?7
499 werkzeug.exceptions.InternalServerError.description?7
500 werkzeug.exceptions.InternalServerError?1(description: t.Optional[str] = None, response: t.Optional["Response"] = None, original_exception: t.Optional[BaseException] = None, )
501 werkzeug.exceptions.LengthRequired.code?7
502 werkzeug.exceptions.LengthRequired.description?7
503 werkzeug.exceptions.Locked.code?7
504 werkzeug.exceptions.Locked.description?7
505 werkzeug.exceptions.MethodNotAllowed.code?7
506 werkzeug.exceptions.MethodNotAllowed.description?7
507 werkzeug.exceptions.MethodNotAllowed.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
508 werkzeug.exceptions.MethodNotAllowed?1(valid_methods: t.Optional[t.Iterable[str]] = None, description: t.Optional[str] = None, response: t.Optional["Response"] = None, )
509 werkzeug.exceptions.NotAcceptable.code?7
510 werkzeug.exceptions.NotAcceptable.description?7
511 werkzeug.exceptions.NotFound.code?7
512 werkzeug.exceptions.NotFound.description?7
513 werkzeug.exceptions.NotImplemented.code?7
514 werkzeug.exceptions.NotImplemented.description?7
515 werkzeug.exceptions.PreconditionFailed.code?7
516 werkzeug.exceptions.PreconditionFailed.description?7
517 werkzeug.exceptions.PreconditionRequired.code?7
518 werkzeug.exceptions.PreconditionRequired.description?7
519 werkzeug.exceptions.RequestEntityTooLarge.code?7
520 werkzeug.exceptions.RequestEntityTooLarge.description?7
521 werkzeug.exceptions.RequestHeaderFieldsTooLarge.code?7
522 werkzeug.exceptions.RequestHeaderFieldsTooLarge.description?7
523 werkzeug.exceptions.RequestTimeout.code?7
524 werkzeug.exceptions.RequestTimeout.description?7
525 werkzeug.exceptions.RequestURITooLarge.code?7
526 werkzeug.exceptions.RequestURITooLarge.description?7
527 werkzeug.exceptions.RequestedRangeNotSatisfiable.code?7
528 werkzeug.exceptions.RequestedRangeNotSatisfiable.description?7
529 werkzeug.exceptions.RequestedRangeNotSatisfiable.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
530 werkzeug.exceptions.RequestedRangeNotSatisfiable?1(length: t.Optional[int] = None, units: str = "bytes", description: t.Optional[str] = None, response: t.Optional["Response"] = None, )
531 werkzeug.exceptions.ServiceUnavailable.code?7
532 werkzeug.exceptions.ServiceUnavailable.description?7
533 werkzeug.exceptions.TooManyRequests.code?7
534 werkzeug.exceptions.TooManyRequests.description?7
535 werkzeug.exceptions.Unauthorized.code?7
536 werkzeug.exceptions.Unauthorized.description?7
537 werkzeug.exceptions.Unauthorized.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
538 werkzeug.exceptions.Unauthorized?1(description: t.Optional[str] = None, response: t.Optional["Response"] = None, www_authenticate: t.Optional[
539 t.Union["WWWAuthenticate", t.Iterable["WWWAuthenticate"]]
540 ] = None, )
541 werkzeug.exceptions.UnavailableForLegalReasons.code?7
542 werkzeug.exceptions.UnavailableForLegalReasons.description?7
543 werkzeug.exceptions.UnprocessableEntity.code?7
544 werkzeug.exceptions.UnprocessableEntity.description?7
545 werkzeug.exceptions.UnsupportedMediaType.code?7
546 werkzeug.exceptions.UnsupportedMediaType.description?7
547 werkzeug.exceptions._RetryAfter.get_headers?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
548 werkzeug.exceptions._RetryAfter?2(description: t.Optional[str] = None, response: t.Optional["Response"] = None, retry_after: t.Optional[t.Union[datetime, int]] = None, )
549 werkzeug.exceptions._find_exceptions?5()
550 werkzeug.exceptions.abort?4(status: t.Union[int, "Response"], *args: t.Any, **kwargs: t.Any)
551 werkzeug.exceptions.newcls._description?8
552 werkzeug.exceptions.newcls.description?4(value: str)
553 werkzeug.exceptions.newcls.show_exception?7
554 werkzeug.exceptions.newcls?1(arg: t.Optional[t.Any] = None, *args: t.Any, **kwargs: t.Any)
555 werkzeug.filesystem._is_ascii_encoding?5(encoding: t.Optional[str])
556 werkzeug.filesystem._warned_about_filesystem_encoding?8
557 werkzeug.filesystem.get_filesystem_encoding?4()
558 werkzeug.filesystem.has_likely_buggy_unicode_filesystem?7
559 werkzeug.formparser.F?7
560 werkzeug.formparser.FormDataParser._parse_multipart?5(stream: t.BinaryIO, mimetype: str, content_length: t.Optional[int], options: t.Dict[str, str], )
561 werkzeug.formparser.FormDataParser._parse_urlencoded?5(stream: t.BinaryIO, mimetype: str, content_length: t.Optional[int], options: t.Dict[str, str], )
562 werkzeug.formparser.FormDataParser.get_parse_func?4(mimetype: str, options: t.Dict[str, str])
563 werkzeug.formparser.FormDataParser.parse?4(stream: t.BinaryIO, mimetype: str, content_length: t.Optional[int], options: t.Optional[t.Dict[str, str]] = None, )
564 werkzeug.formparser.FormDataParser.parse_from_environ?4(environ: "WSGIEnvironment")
565 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, )
566 werkzeug.formparser.MultiPartParser.fail?4(message: str)
567 werkzeug.formparser.MultiPartParser.get_part_charset?4(headers: Headers)
568 werkzeug.formparser.MultiPartParser.parse?4(stream: t.BinaryIO, boundary: bytes, content_length: t.Optional[int])
569 werkzeug.formparser.MultiPartParser.start_file_streaming?4(event: File, total_content_length: t.Optional[int])
570 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, )
571 werkzeug.formparser._exhaust?5(stream: t.BinaryIO)
572 werkzeug.formparser._line_parse?5(line: str)
573 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, )
574 werkzeug.formparser.exhaust_stream?4(f: F)
575 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, )
576 werkzeug.formparser.parse_multipart_headers?4(iterable: t.Iterable[bytes])
577 werkzeug.formparser.wrapper?4(self, stream, *args, **kwargs)
578 werkzeug.http.COEP.REQUIRE_CORP?7
579 werkzeug.http.COEP.UNSAFE_NONE?7
580 werkzeug.http.COOP.SAME_ORIGIN?7
581 werkzeug.http.COOP.SAME_ORIGIN_ALLOW_POPUPS?7
582 werkzeug.http.COOP.UNSAFE_NONE?7
583 werkzeug.http.HTTP_STATUS_CODES?7
584 werkzeug.http._TAnyAccept?8
585 werkzeug.http._TAnyCC?8
586 werkzeug.http._TAnyCSP?8
587 werkzeug.http._accept_re?8
588 werkzeug.http._entity_headers?8
589 werkzeug.http._etag_re?8
590 werkzeug.http._hop_by_hop_headers?8
591 werkzeug.http._option_header_piece_re?8
592 werkzeug.http._option_header_start_mime_type?8
593 werkzeug.http._parse_pairs?5()
594 werkzeug.http._t_cc_update?8
595 werkzeug.http._t_csp_update?8
596 werkzeug.http._token_chars?8
597 werkzeug.http.cookie_date?4(expires: t.Optional[t.Union[datetime, date, int, float, struct_time]] = None)
598 werkzeug.http.dump_age?4(age: t.Optional[t.Union[timedelta, int]] = None)
599 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, )
600 werkzeug.http.dump_csp_header?4(header: "ds.ContentSecurityPolicy")
601 werkzeug.http.dump_header?4(iterable: t.Union[t.Dict[str, t.Union[str, int]], t.Iterable[str]], allow_token: bool = True, )
602 werkzeug.http.dump_options_header?4(header: t.Optional[str], options: t.Mapping[str, t.Optional[t.Union[str, int]]])
603 werkzeug.http.generate_etag?4(data: bytes)
604 werkzeug.http.http_date?4(timestamp: t.Optional[t.Union[datetime, date, int, float, struct_time]] = None)
605 werkzeug.http.is_byte_range_valid?4(start: t.Optional[int], stop: t.Optional[int], length: t.Optional[int])
606 werkzeug.http.is_entity_header?4(header: str)
607 werkzeug.http.is_hop_by_hop_header?4(header: str)
608 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, )
609 werkzeug.http.parse_accept_header?4(value: t.Optional[str])
610 werkzeug.http.parse_accept_header?4(value: t.Optional[str], cls: t.Optional[t.Type[_TAnyAccept]] = None)
611 werkzeug.http.parse_accept_header?4(value: t.Optional[str], cls: t.Type[_TAnyAccept])
612 werkzeug.http.parse_age?4(value: t.Optional[str] = None)
613 werkzeug.http.parse_authorization_header?4(value: t.Optional[str], )
614 werkzeug.http.parse_cache_control_header?4(value: t.Optional[str], on_update: _t_cc_update = None, cls: t.Optional[t.Type[_TAnyCC]] = None, )
615 werkzeug.http.parse_cache_control_header?4(value: t.Optional[str], on_update: _t_cc_update, cls: None = None)
616 werkzeug.http.parse_cache_control_header?4(value: t.Optional[str], on_update: _t_cc_update, cls: t.Type[_TAnyCC])
617 werkzeug.http.parse_content_range_header?4(value: t.Optional[str], on_update: t.Optional[t.Callable[["ds.ContentRange"], None]] = None, )
618 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, )
619 werkzeug.http.parse_csp_header?4(value: t.Optional[str], on_update: _t_csp_update = None, cls: t.Optional[t.Type[_TAnyCSP]] = None, )
620 werkzeug.http.parse_csp_header?4(value: t.Optional[str], on_update: _t_csp_update, cls: None = None)
621 werkzeug.http.parse_csp_header?4(value: t.Optional[str], on_update: _t_csp_update, cls: t.Type[_TAnyCSP])
622 werkzeug.http.parse_date?4(value: t.Optional[str])
623 werkzeug.http.parse_dict_header?4(value: str, cls: t.Type[dict] = dict)
624 werkzeug.http.parse_etags?4(value: t.Optional[str])
625 werkzeug.http.parse_if_range_header?4(value: t.Optional[str])
626 werkzeug.http.parse_list_header?4(value: str)
627 werkzeug.http.parse_options_header?4(value: t.Optional[str], multiple: "te.Literal[False]" = False)
628 werkzeug.http.parse_options_header?4(value: t.Optional[str], multiple: "te.Literal[True]")
629 werkzeug.http.parse_options_header?4(value: t.Optional[str], multiple: bool = False)
630 werkzeug.http.parse_range_header?4(value: t.Optional[str], make_inclusive: bool = True)
631 werkzeug.http.parse_set_header?4(value: t.Optional[str], on_update: t.Optional[t.Callable[["ds.HeaderSet"], None]] = None, )
632 werkzeug.http.parse_www_authenticate_header?4(value: t.Optional[str], on_update: t.Optional[t.Callable[["ds.WWWAuthenticate"], None]] = None, )
633 werkzeug.http.quote_etag?4(etag: str, weak: bool = False)
634 werkzeug.http.quote_header_value?4(value: t.Union[str, int], extra_chars: str = "", allow_token: bool = True)
635 werkzeug.http.remove_entity_headers?4(headers: t.Union["ds.Headers", t.List[t.Tuple[str, str]]], allowed: t.Iterable[str] = ("expires", "content-location"), )
636 werkzeug.http.remove_hop_by_hop_headers?4(headers: t.Union["ds.Headers", t.List[t.Tuple[str, str]]])
637 werkzeug.http.unquote_etag?4(etag: t.Optional[str], )
638 werkzeug.http.unquote_header_value?4(value: str, is_filename: bool = False)
639 werkzeug.local.ContextVar.get?4(default: t.Dict[str, t.Any])
640 werkzeug.local.ContextVar.set?4(value: t.Dict[str, t.Any])
641 werkzeug.local.ContextVar?1(_name: str)
642 werkzeug.local.F?7
643 werkzeug.local.Local?1()
644 werkzeug.local.LocalManager.application?4(start_response: "StartResponse")
645 werkzeug.local.LocalManager.cleanup?4()
646 werkzeug.local.LocalManager.get_ident?4()
647 werkzeug.local.LocalManager.ident_func?4(func: t.Callable[[], int])
648 werkzeug.local.LocalManager.make_middleware?4(app: "WSGIApplication")
649 werkzeug.local.LocalManager.middleware?4(func: "WSGIApplication")
650 werkzeug.local.LocalManager?1(locals: t.Optional[t.Iterable[t.Union[Local, LocalStack]]] = None, ident_func: None = None, )
651 werkzeug.local.LocalProxy._get_current_object?5()
652 werkzeug.local.LocalProxy?1(local: t.Union["Local", t.Callable[[], t.Any]], name: t.Optional[str] = None, )
653 werkzeug.local.LocalStack._lookup?5()
654 werkzeug.local.LocalStack.pop?4()
655 werkzeug.local.LocalStack.push?4(obj: t.Any)
656 werkzeug.local.LocalStack.top?4()
657 werkzeug.local.LocalStack?1()
658 werkzeug.local._CannotUseContextVar.greenlet_patched?7
659 werkzeug.local._ProxyIOp.bind_f?4(obj: t.Any)
660 werkzeug.local._ProxyIOp.i_op?4(other: t.Any)
661 werkzeug.local._ProxyIOp?2(f: t.Optional[t.Callable] = None, fallback: t.Optional[t.Callable] = None)
662 werkzeug.local._ProxyLookup.bind_f?4(obj: t.Any)
663 werkzeug.local._ProxyLookup?2(f: t.Optional[t.Callable] = None, fallback: t.Optional[t.Callable] = None, class_value: t.Optional[t.Any] = None, )
664 werkzeug.local._l_to_r_op?5(op: F)
665 werkzeug.local.get_ident?4()
666 werkzeug.local.r_op?4(obj: t.Any, other: t.Any)
667 werkzeug.local.release_local?4(local: t.Union["Local", "LocalStack"])
668 werkzeug.middleware.dispatcher.DispatcherMiddleware?1(app: "WSGIApplication", mounts: t.Optional[t.Dict[str, "WSGIApplication"]] = None, )
669 werkzeug.middleware.http_proxy.ProxyMiddleware._set_defaults?5(t.Any])
670 werkzeug.middleware.http_proxy.ProxyMiddleware.application?4(start_response: "StartResponse")
671 werkzeug.middleware.http_proxy.ProxyMiddleware.proxy_to?4(opts: t.Dict[str, t.Any], path: str, prefix: str)
672 werkzeug.middleware.http_proxy.ProxyMiddleware.read?4()
673 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, )
674 werkzeug.middleware.lint.ErrorStream.close?4()
675 werkzeug.middleware.lint.ErrorStream.flush?4()
676 werkzeug.middleware.lint.ErrorStream.write?4(s: str)
677 werkzeug.middleware.lint.ErrorStream.writelines?4(seq: t.Iterable[str])
678 werkzeug.middleware.lint.ErrorStream?1(stream: t.TextIO)
679 werkzeug.middleware.lint.GuardedIterator.close?4()
680 werkzeug.middleware.lint.GuardedIterator?1(iterator: t.Iterable[bytes], headers_set: t.Tuple[int, Headers], chunks: t.List[int], )
681 werkzeug.middleware.lint.GuardedWrite?1(write: t.Callable[[bytes], None], chunks: t.List[int])
682 werkzeug.middleware.lint.InputStream.close?4()
683 werkzeug.middleware.lint.InputStream.read?4(*args: t.Any)
684 werkzeug.middleware.lint.InputStream.readline?4(*args: t.Any)
685 werkzeug.middleware.lint.InputStream?1(stream: t.BinaryIO)
686 werkzeug.middleware.lint.LintMiddleware.check_environ?4(environ: "WSGIEnvironment")
687 werkzeug.middleware.lint.LintMiddleware.check_headers?4(headers: Headers)
688 werkzeug.middleware.lint.LintMiddleware.check_iterator?4(app_iter: t.Iterable[bytes])
689 werkzeug.middleware.lint.LintMiddleware.check_start_response?4(status: str, headers: t.List[t.Tuple[str, str]], exc_info: t.Optional[
690 t.Tuple[t.Type[BaseException], BaseException, TracebackType]
691 ], )
692 werkzeug.middleware.lint.LintMiddleware.checking_start_response?4(**kwargs: t.Any)
693 werkzeug.middleware.lint.LintMiddleware?1(app: "WSGIApplication")
694 werkzeug.middleware.lint.check_type?4(context: str, obj: object, need: t.Type = str)
695 werkzeug.middleware.profiler.ProfilerMiddleware.catching_start_response?4(headers, exc_info=None)
696 werkzeug.middleware.profiler.ProfilerMiddleware.runapp?4()
697 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", )
698 werkzeug.middleware.proxy_fix.ProxyFix._get_real_value?5(trusted: int, value: t.Optional[str])
699 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, )
700 werkzeug.middleware.shared_data.SharedDataMiddleware._opener?5(filename: str)
701 werkzeug.middleware.shared_data.SharedDataMiddleware.generate_etag?4(mtime: datetime, file_size: int, real_filename: str)
702 werkzeug.middleware.shared_data.SharedDataMiddleware.get_directory_loader?4(directory: str)
703 werkzeug.middleware.shared_data.SharedDataMiddleware.get_file_loader?4(filename: str)
704 werkzeug.middleware.shared_data.SharedDataMiddleware.get_package_loader?4(package: str, package_path: str)
705 werkzeug.middleware.shared_data.SharedDataMiddleware.is_allowed?4(filename: str)
706 werkzeug.middleware.shared_data.SharedDataMiddleware.loader?4()
707 werkzeug.middleware.shared_data.SharedDataMiddleware?1(app: "WSGIApplication", exports: t.Union[
708 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", )
709 werkzeug.middleware.shared_data._TLoader?8
710 werkzeug.middleware.shared_data._TOpener?8
711 werkzeug.routing.AnyConverter?1(map: "Map", *items: str)
712 werkzeug.routing.BaseConverter.regex?7
713 werkzeug.routing.BaseConverter.to_python?4(value: str)
714 werkzeug.routing.BaseConverter.to_url?4(value: t.Any)
715 werkzeug.routing.BaseConverter.weight?7
716 werkzeug.routing.BaseConverter?1(map: "Map", *args: t.Any, **kwargs: t.Any)
717 werkzeug.routing.BuildError._score_rule?5()
718 werkzeug.routing.BuildError.closest_rule?4(adapter: t.Optional["MapAdapter"])
719 werkzeug.routing.BuildError.suggested?4()
720 werkzeug.routing.BuildError?1(endpoint: str, values: t.Mapping[str, t.Any], method: t.Optional[str], adapter: t.Optional["MapAdapter"] = None, )
721 werkzeug.routing.EndpointPrefix.get_rules?4(map: "Map")
722 werkzeug.routing.EndpointPrefix?1(prefix: str, rules: t.Iterable["Rule"])
723 werkzeug.routing.FloatConverter.num_convert?7
724 werkzeug.routing.FloatConverter.regex?7
725 werkzeug.routing.FloatConverter?1(map: "Map", min: t.Optional[float] = None, max: t.Optional[float] = None, signed: bool = False, )
726 werkzeug.routing.IntegerConverter.regex?7
727 werkzeug.routing.Map._get_wsgi_string?5()
728 werkzeug.routing.Map.add?4(rulefactory: RuleFactory)
729 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, )
730 werkzeug.routing.Map.bind_to_environ?4(environ: "WSGIEnvironment", server_name: t.Optional[str] = None, subdomain: t.Optional[str] = None, )
731 werkzeug.routing.Map.default_converters?7
732 werkzeug.routing.Map.is_endpoint_expecting?4(endpoint: str, *arguments: str)
733 werkzeug.routing.Map.iter_rules?4(endpoint: t.Optional[str] = None)
734 werkzeug.routing.Map.lock_class?7
735 werkzeug.routing.Map.update?4()
736 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, )
737 werkzeug.routing.MapAdapter._handle_match?5()
738 werkzeug.routing.MapAdapter._partial_build?5(endpoint: str, values: t.Mapping[str, t.Any], method: t.Optional[str], append_unknown: bool, )
739 werkzeug.routing.MapAdapter.allowed_methods?4(path_info: t.Optional[str] = None)
740 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, )
741 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, )
742 werkzeug.routing.MapAdapter.encode_query_args?4(query_args: t.Union[t.Mapping[str, t.Any], str])
743 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], )
744 werkzeug.routing.MapAdapter.get_host?4(domain_part: t.Optional[str])
745 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], )
746 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, )
747 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, )
748 werkzeug.routing.MapAdapter.test?4(path_info: t.Optional[str] = None, method: t.Optional[str] = None)
749 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, )
750 werkzeug.routing.NumberConverter.signed_regex?4()
751 werkzeug.routing.NumberConverter.to_python?4(value: str)
752 werkzeug.routing.NumberConverter.to_url?4(value: t.Any)
753 werkzeug.routing.NumberConverter.weight?7
754 werkzeug.routing.NumberConverter?1(map: "Map", fixed_digits: int = 0, min: t.Optional[int] = None, max: t.Optional[int] = None, signed: bool = False, )
755 werkzeug.routing.PathConverter.regex?7
756 werkzeug.routing.PathConverter.weight?7
757 werkzeug.routing.RequestAliasRedirect?1(matched_values: t.Mapping[str, t.Any])
758 werkzeug.routing.RequestPath?1(path_info: str)
759 werkzeug.routing.RequestRedirect.code?7
760 werkzeug.routing.RequestRedirect.get_response?4(environ: t.Optional["WSGIEnvironment"] = None, scope: t.Optional[dict] = None, )
761 werkzeug.routing.RequestRedirect?1(new_url: str)
762 werkzeug.routing.Rule._build_regex?5()
763 werkzeug.routing.Rule._compile_builder?5(append_unknown: bool = True)
764 werkzeug.routing.Rule._convert?5()
765 werkzeug.routing.Rule._encode_query_vars?5(query_vars: t.Mapping[str, t.Any])
766 werkzeug.routing.Rule._get_func_code?5(name: str)
767 werkzeug.routing.Rule._join?5()
768 werkzeug.routing.Rule._parts?5(str]])
769 werkzeug.routing.Rule.bind?4(map: "Map", rebind: bool = False)
770 werkzeug.routing.Rule.build?4(values: t.Mapping[str, t.Any], append_unknown: bool = True)
771 werkzeug.routing.Rule.build_compare_key?4()
772 werkzeug.routing.Rule.compile?4()
773 werkzeug.routing.Rule.empty?4()
774 werkzeug.routing.Rule.get_converter?4(variable_name: str, converter_name: str, args: t.Tuple, kwargs: t.Mapping[str, t.Any], )
775 werkzeug.routing.Rule.get_empty_kwargs?4()
776 werkzeug.routing.Rule.get_rules?4(map: "Map")
777 werkzeug.routing.Rule.match?4(path: str, method: t.Optional[str] = None)
778 werkzeug.routing.Rule.match_compare_key?4()
779 werkzeug.routing.Rule.provides_defaults_for?4(rule: "Rule")
780 werkzeug.routing.Rule.refresh?4()
781 werkzeug.routing.Rule.suitable_for?4(values: t.Mapping[str, t.Any], method: t.Optional[str] = None)
782 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, )
783 werkzeug.routing.RuleFactory.get_rules?4(map: "Map")
784 werkzeug.routing.RuleTemplate?1(rules: t.Iterable["Rule"])
785 werkzeug.routing.RuleTemplateFactory.get_rules?4(map: "Map")
786 werkzeug.routing.RuleTemplateFactory?1(rules: t.Iterable["Rule"], context: t.Dict[str, t.Any])
787 werkzeug.routing.Subdomain.get_rules?4(map: "Map")
788 werkzeug.routing.Subdomain?1(subdomain: str, rules: t.Iterable["Rule"])
789 werkzeug.routing.Submount.get_rules?4(map: "Map")
790 werkzeug.routing.Submount?1(path: str, rules: t.Iterable["Rule"])
791 werkzeug.routing.UUIDConverter.regex?7
792 werkzeug.routing.UUIDConverter.to_python?4(value: str)
793 werkzeug.routing.UUIDConverter.to_url?4(value: uuid.UUID)
794 werkzeug.routing.UnicodeConverter?1(map: "Map", minlength: int = 1, maxlength: t.Optional[int] = None, length: t.Optional[int] = None, )
795 werkzeug.routing._CALL_CONVERTER_CODE_FMT?8
796 werkzeug.routing._IF_KWARGS_URL_ENCODE_AST?8
797 werkzeug.routing._IF_KWARGS_URL_ENCODE_CODE?8
798 werkzeug.routing._PYTHON_CONSTANTS?8
799 werkzeug.routing._URL_ENCODE_AST_NAMES?8
800 werkzeug.routing._converter_args_re?8
801 werkzeug.routing._prefix_names?5(src: str)
802 werkzeug.routing._pythonize?5(value: str)
803 werkzeug.routing._rule_re?8
804 werkzeug.routing._simple_rule_re?8
805 werkzeug.routing.parse_converter_args?4(argstr: str)
806 werkzeug.routing.parse_rule?4(rule: str)
807 werkzeug.sansio.multipart.BLANK_LINE_RE?7
808 werkzeug.sansio.multipart.HEADER_CONTINUATION_RE?7
809 werkzeug.sansio.multipart.LINE_BREAK?7
810 werkzeug.sansio.multipart.LINE_BREAK_RE?7
811 werkzeug.sansio.multipart.MultipartDecoder._parse_headers?5(data: bytes)
812 werkzeug.sansio.multipart.MultipartDecoder.last_newline?4()
813 werkzeug.sansio.multipart.MultipartDecoder.next_event?4()
814 werkzeug.sansio.multipart.MultipartDecoder.receive_data?4(data: Optional[bytes])
815 werkzeug.sansio.multipart.MultipartDecoder?1(boundary: bytes, max_form_memory_size: Optional[int] = None, )
816 werkzeug.sansio.multipart.MultipartEncoder.send_event?4(event: Event)
817 werkzeug.sansio.multipart.MultipartEncoder?1(boundary: bytes)
818 werkzeug.sansio.multipart.NEED_DATA?7
819 werkzeug.sansio.multipart.State.COMPLETE?7
820 werkzeug.sansio.multipart.State.DATA?7
821 werkzeug.sansio.multipart.State.EPILOGUE?7
822 werkzeug.sansio.multipart.State.PART?7
823 werkzeug.sansio.multipart.State.PREAMBLE?7
824 werkzeug.sansio.request.Request._parse_content_type?5()
825 werkzeug.sansio.request.Request.accept_charsets?4()
826 werkzeug.sansio.request.Request.accept_encodings?4()
827 werkzeug.sansio.request.Request.accept_languages?4()
828 werkzeug.sansio.request.Request.accept_mimetypes?4()
829 werkzeug.sansio.request.Request.access_control_request_headers?7
830 werkzeug.sansio.request.Request.access_control_request_method?7
831 werkzeug.sansio.request.Request.access_route?4()
832 werkzeug.sansio.request.Request.args?4()
833 werkzeug.sansio.request.Request.authorization?4()
834 werkzeug.sansio.request.Request.base_url?4()
835 werkzeug.sansio.request.Request.cache_control?4()
836 werkzeug.sansio.request.Request.charset?7
837 werkzeug.sansio.request.Request.content_encoding?7
838 werkzeug.sansio.request.Request.content_length?4()
839 werkzeug.sansio.request.Request.content_md5?7
840 werkzeug.sansio.request.Request.content_type?7
841 werkzeug.sansio.request.Request.cookies?4()
842 werkzeug.sansio.request.Request.date?7
843 werkzeug.sansio.request.Request.encoding_errors?7
844 werkzeug.sansio.request.Request.full_path?4()
845 werkzeug.sansio.request.Request.host?4()
846 werkzeug.sansio.request.Request.host_url?4()
847 werkzeug.sansio.request.Request.if_match?4()
848 werkzeug.sansio.request.Request.if_modified_since?4()
849 werkzeug.sansio.request.Request.if_none_match?4()
850 werkzeug.sansio.request.Request.if_range?4()
851 werkzeug.sansio.request.Request.if_unmodified_since?4()
852 werkzeug.sansio.request.Request.is_json?4()
853 werkzeug.sansio.request.Request.is_secure?4()
854 werkzeug.sansio.request.Request.max_forwards?7
855 werkzeug.sansio.request.Request.mimetype?4()
856 werkzeug.sansio.request.Request.mimetype_params?4()
857 werkzeug.sansio.request.Request.origin?7
858 werkzeug.sansio.request.Request.pragma?4()
859 werkzeug.sansio.request.Request.range?4()
860 werkzeug.sansio.request.Request.referrer?7
861 werkzeug.sansio.request.Request.root_url?4()
862 werkzeug.sansio.request.Request.url?4()
863 werkzeug.sansio.request.Request.url_charset?4()
864 werkzeug.sansio.request.Request.user_agent?4()
865 werkzeug.sansio.request.Request.user_agent_class?7
866 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], )
867 werkzeug.sansio.response.Response._clean_status?5(value: t.Union[str, int, HTTPStatus])
868 werkzeug.sansio.response.Response.accept_ranges?7
869 werkzeug.sansio.response.Response.access_control_allow_credentials?4(value: t.Optional[bool])
870 werkzeug.sansio.response.Response.access_control_allow_headers?7
871 werkzeug.sansio.response.Response.access_control_allow_methods?7
872 werkzeug.sansio.response.Response.access_control_allow_origin?7
873 werkzeug.sansio.response.Response.access_control_expose_headers?7
874 werkzeug.sansio.response.Response.access_control_max_age?7
875 werkzeug.sansio.response.Response.age?7
876 werkzeug.sansio.response.Response.allow?7
877 werkzeug.sansio.response.Response.cache_control?4()
878 werkzeug.sansio.response.Response.charset?7
879 werkzeug.sansio.response.Response.content_encoding?7
880 werkzeug.sansio.response.Response.content_language?7
881 werkzeug.sansio.response.Response.content_length?7
882 werkzeug.sansio.response.Response.content_location?7
883 werkzeug.sansio.response.Response.content_md5?7
884 werkzeug.sansio.response.Response.content_range?4(value: t.Optional[t.Union[ContentRange, str]])
885 werkzeug.sansio.response.Response.content_security_policy?7
886 werkzeug.sansio.response.Response.content_security_policy_report_only?7
887 werkzeug.sansio.response.Response.content_type?7
888 werkzeug.sansio.response.Response.cross_origin_embedder_policy?7
889 werkzeug.sansio.response.Response.cross_origin_opener_policy?7
890 werkzeug.sansio.response.Response.date?7
891 werkzeug.sansio.response.Response.default_mimetype?7
892 werkzeug.sansio.response.Response.default_status?7
893 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, )
894 werkzeug.sansio.response.Response.expires?7
895 werkzeug.sansio.response.Response.get_etag?4()
896 werkzeug.sansio.response.Response.is_json?4()
897 werkzeug.sansio.response.Response.last_modified?7
898 werkzeug.sansio.response.Response.location?7
899 werkzeug.sansio.response.Response.max_cookie_size?7
900 werkzeug.sansio.response.Response.mimetype?4(value: str)
901 werkzeug.sansio.response.Response.mimetype_params?4()
902 werkzeug.sansio.response.Response.on_update?4()
903 werkzeug.sansio.response.Response.retry_after?4(value: t.Optional[t.Union[datetime, int, str]])
904 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, )
905 werkzeug.sansio.response.Response.set_etag?4(etag: str, weak: bool = False)
906 werkzeug.sansio.response.Response.status?4(value: t.Union[str, int, HTTPStatus])
907 werkzeug.sansio.response.Response.status_code?4(code: int)
908 werkzeug.sansio.response.Response.vary?7
909 werkzeug.sansio.response.Response.www_authenticate?4()
910 werkzeug.sansio.response.Response?1(status: t.Optional[t.Union[int, str, HTTPStatus]] = None, headers: t.Optional[
911 t.Union[
912 t.Mapping[str, t.Union[str, int, t.Iterable[t.Union[str, int]]]], t.Iterable[t.Tuple[str, t.Union[str, int]]], ]
913 ] = None, mimetype: t.Optional[str] = None, content_type: t.Optional[str] = None, )
914 werkzeug.sansio.response._set_property?5(name: str, doc: t.Optional[str] = None)
915 werkzeug.sansio.response.fget?4(self: "Response")
916 werkzeug.sansio.response.fset?4(self: "Response", value: t.Optional[
917 t.Union[str, t.Dict[str, t.Union[str, int]], t.Iterable[str]]
918 ], )
919 werkzeug.sansio.response.on_update?4(header_set: HeaderSet)
920 werkzeug.sansio.utils._normalize?5(hostname: str)
921 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, )
922 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, )
923 werkzeug.sansio.utils.host_is_trusted?4(hostname: str, trusted_list: t.Iterable[str])
924 werkzeug.security.DEFAULT_PBKDF2_ITERATIONS?7
925 werkzeug.security.SALT_CHARS?7
926 werkzeug.security._hash_internal?5(method: str, salt: str, password: str)
927 werkzeug.security.check_password_hash?4(pwhash: str, password: str)
928 werkzeug.security.gen_salt?4(length: int)
929 werkzeug.security.generate_password_hash?4(password: str, method: str = "pbkdf2:sha256", salt_length: int = 16)
930 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, )
931 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, )
932 werkzeug.security.safe_join?4(directory: str, *pathnames: str)
933 werkzeug.security.safe_str_cmp?4(a: str, b: str)
934 werkzeug.serving.BaseWSGIServer.handle_error?4(request: t.Any, client_address: t.Tuple[str, int])
935 werkzeug.serving.BaseWSGIServer.log?4(type: str, message: str, *args: t.Any)
936 werkzeug.serving.BaseWSGIServer.multiprocess?7
937 werkzeug.serving.BaseWSGIServer.multithread?7
938 werkzeug.serving.BaseWSGIServer.request_queue_size?7
939 werkzeug.serving.BaseWSGIServer.serve_forever?4(poll_interval: float = 0.5)
940 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, )
941 werkzeug.serving.DechunkedInput.read_chunk_len?4()
942 werkzeug.serving.DechunkedInput.readable?4()
943 werkzeug.serving.DechunkedInput.readinto?4(buf: bytearray)
944 werkzeug.serving.DechunkedInput?1(rfile: t.BinaryIO)
945 werkzeug.serving.ForkingWSGIServer.multiprocess?7
946 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, )
947 werkzeug.serving.LISTEN_QUEUE?7
948 werkzeug.serving.ThreadedWSGIServer.daemon_threads?7
949 werkzeug.serving.ThreadedWSGIServer.multithread?7
950 werkzeug.serving.WSGIRequestHandler.address_string?4()
951 werkzeug.serving.WSGIRequestHandler.connection_dropped?4(error: BaseException, environ: t.Optional["WSGIEnvironment"] = None)
952 werkzeug.serving.WSGIRequestHandler.execute?4()
953 werkzeug.serving.WSGIRequestHandler.handle?4()
954 werkzeug.serving.WSGIRequestHandler.handle_one_request?4()
955 werkzeug.serving.WSGIRequestHandler.initiate_shutdown?4()
956 werkzeug.serving.WSGIRequestHandler.log?4(type: str, message: str, *args: t.Any)
957 werkzeug.serving.WSGIRequestHandler.log_error?4(format: str, *args: t.Any)
958 werkzeug.serving.WSGIRequestHandler.log_message?4(format: str, *args: t.Any)
959 werkzeug.serving.WSGIRequestHandler.log_request?4(code: t.Union[int, str] = "-", size: t.Union[int, str] = "-")
960 werkzeug.serving.WSGIRequestHandler.make_environ?4()
961 werkzeug.serving.WSGIRequestHandler.port_integer?4()
962 werkzeug.serving.WSGIRequestHandler.run_wsgi?4()
963 werkzeug.serving.WSGIRequestHandler.send_response?4(code: int, message: t.Optional[str] = None)
964 werkzeug.serving.WSGIRequestHandler.server_version?4()
965 werkzeug.serving.WSGIRequestHandler.shutdown_server?4()
966 werkzeug.serving.WSGIRequestHandler.start_response?4(headers, exc_info=None)
967 werkzeug.serving.WSGIRequestHandler.version_string?4()
968 werkzeug.serving.WSGIRequestHandler.write?4()
969 werkzeug.serving._SslDummy._log_add_style?8
970 werkzeug.serving._TSSLContextArg?8
971 werkzeug.serving._ansi_style?5(value: str, *styles: str)
972 werkzeug.serving._log_add_style?8
973 werkzeug.serving.can_fork?7
974 werkzeug.serving.can_open_by_fd?7
975 werkzeug.serving.generate_adhoc_ssl_context?4()
976 werkzeug.serving.generate_adhoc_ssl_pair?4(cn: t.Optional[str] = None, )
977 werkzeug.serving.get_interface_ip?4(family: socket.AddressFamily)
978 werkzeug.serving.get_sockaddr?4(host: str, port: int, family: socket.AddressFamily)
979 werkzeug.serving.inner?4()
980 werkzeug.serving.is_running_from_reloader?4()
981 werkzeug.serving.is_ssl_error?4(error: t.Optional[Exception] = None)
982 werkzeug.serving.load_ssl_context?4(cert_file: str, pkey_file: t.Optional[str] = None, protocol: t.Optional[int] = None)
983 werkzeug.serving.log_startup?4(sock: socket.socket)
984 werkzeug.serving.main?4()
985 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, )
986 werkzeug.serving.make_ssl_devcert?4(base_path: str, host: t.Optional[str] = None, cn: t.Optional[str] = None)
987 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, )
988 werkzeug.serving.run_with_reloader?4(*args: t.Any, **kwargs: t.Any)
989 werkzeug.serving.select_address_family?4(host: str, port: int)
990 werkzeug.test.Client.delete?4(*args: t.Any, **kw: t.Any)
991 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, )
992 werkzeug.test.Client.get?4(*args: t.Any, **kw: t.Any)
993 werkzeug.test.Client.head?4(*args: t.Any, **kw: t.Any)
994 werkzeug.test.Client.open?4(*args: t.Any, as_tuple: bool = False, buffered: bool = False, follow_redirects: bool = False, **kwargs: t.Any, )
995 werkzeug.test.Client.options?4(*args: t.Any, **kw: t.Any)
996 werkzeug.test.Client.patch?4(*args: t.Any, **kw: t.Any)
997 werkzeug.test.Client.post?4(*args: t.Any, **kw: t.Any)
998 werkzeug.test.Client.put?4(*args: t.Any, **kw: t.Any)
999 werkzeug.test.Client.resolve_redirect?4(response: "TestResponse", buffered: bool = False)
1000 werkzeug.test.Client.run_wsgi_app?4(environ: "WSGIEnvironment", buffered: bool = False)
1001 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", )
1002 werkzeug.test.Client.trace?4(*args: t.Any, **kw: t.Any)
1003 werkzeug.test.Client?1(application: "WSGIApplication", response_wrapper: t.Optional[t.Type["Response"]] = None, use_cookies: bool = True, allow_subdomain_redirects: bool = False, )
1004 werkzeug.test.EnvironBuilder._add_file_from_data?5(key: str, value: t.Union[
1005 t.BinaryIO, t.Tuple[t.BinaryIO, str], t.Tuple[t.BinaryIO, str, str]
1006 ], )
1007 werkzeug.test.EnvironBuilder._get_form?5(name: str, storage: t.Type[_TAnyMultiDict])
1008 werkzeug.test.EnvironBuilder._make_base_url?5(host: str, script_root: str)
1009 werkzeug.test.EnvironBuilder._path_encode?5()
1010 werkzeug.test.EnvironBuilder._set_form?5(name: str, value: MultiDict)
1011 werkzeug.test.EnvironBuilder.args?4(value: t.Optional[MultiDict])
1012 werkzeug.test.EnvironBuilder.base_url?4(value: t.Optional[str])
1013 werkzeug.test.EnvironBuilder.close?4()
1014 werkzeug.test.EnvironBuilder.content_length?4(value: t.Optional[int])
1015 werkzeug.test.EnvironBuilder.content_type?4(value: t.Optional[str])
1016 werkzeug.test.EnvironBuilder.files?4(value: FileMultiDict)
1017 werkzeug.test.EnvironBuilder.form?4(value: MultiDict)
1018 werkzeug.test.EnvironBuilder.from_environ?4(environ: "WSGIEnvironment", **kwargs: t.Any)
1019 werkzeug.test.EnvironBuilder.get_environ?4()
1020 werkzeug.test.EnvironBuilder.get_request?4(cls: t.Optional[t.Type[Request]] = None)
1021 werkzeug.test.EnvironBuilder.input_stream?4(value: t.Optional[t.BinaryIO])
1022 werkzeug.test.EnvironBuilder.json_dumps?7
1023 werkzeug.test.EnvironBuilder.mimetype?4(value: str)
1024 werkzeug.test.EnvironBuilder.mimetype_params?4()
1025 werkzeug.test.EnvironBuilder.on_update?4(str])
1026 werkzeug.test.EnvironBuilder.query_string?4(value: t.Optional[str])
1027 werkzeug.test.EnvironBuilder.request_class?7
1028 werkzeug.test.EnvironBuilder.server_name?4()
1029 werkzeug.test.EnvironBuilder.server_port?4()
1030 werkzeug.test.EnvironBuilder.server_protocol?7
1031 werkzeug.test.EnvironBuilder.wsgi_version?7
1032 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, )
1033 werkzeug.test.TestResponse?1(response: t.Iterable[bytes], status: str, headers: Headers, request: Request, history: t.Tuple["TestResponse"] = (), **kwargs: t.Any, )
1034 werkzeug.test._TAnyMultiDict?8
1035 werkzeug.test._TestCookieHeaders.get_all?4(name: str, default: t.Optional[t.Iterable[str]] = None)
1036 werkzeug.test._TestCookieHeaders.getheaders?4(name: str)
1037 werkzeug.test._TestCookieHeaders?2(headers: t.Union[Headers, t.List[t.Tuple[str, str]]])
1038 werkzeug.test._TestCookieJar.extract_wsgi?4(environ: "WSGIEnvironment", headers: t.Union[Headers, t.List[t.Tuple[str, str]]], )
1039 werkzeug.test._TestCookieJar.inject_wsgi?4(environ: "WSGIEnvironment")
1040 werkzeug.test._TestCookieResponse.info?4()
1041 werkzeug.test._TestCookieResponse?2(headers: t.Union[Headers, t.List[t.Tuple[str, str]]])
1042 werkzeug.test._iter_data?5(data: t.Mapping[str, t.Any])
1043 werkzeug.test.create_environ?4(*args: t.Any, **kwargs: t.Any)
1044 werkzeug.test.encode_multipart?4(values: t.Mapping[str, t.Any], boundary: t.Optional[str] = None, charset: str = "utf-8", )
1045 werkzeug.test.run_wsgi_app?4(app: "WSGIApplication", environ: "WSGIEnvironment", buffered: bool = False)
1046 werkzeug.test.start_response?4(status, headers, exc_info=None)
1047 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", )
1048 werkzeug.test.write_binary?4(s: bytes)
1049 werkzeug.testapp.TEMPLATE?7
1050 werkzeug.testapp.iter_sys_path?4()
1051 werkzeug.testapp.logo?7
1052 werkzeug.testapp.render_testapp?4(req: Request)
1053 werkzeug.testapp.strip?4(x: str)
1054 werkzeug.testapp.test_app?4(environ: "WSGIEnvironment", start_response: "StartResponse")
1055 werkzeug.urls.BaseURL._split_auth?5()
1056 werkzeug.urls.BaseURL._split_host?5()
1057 werkzeug.urls.BaseURL._split_netloc?5()
1058 werkzeug.urls.BaseURL.ascii_host?4()
1059 werkzeug.urls.BaseURL.auth?4()
1060 werkzeug.urls.BaseURL.decode_netloc?4()
1061 werkzeug.urls.BaseURL.decode_query?4(*args: t.Any, **kwargs: t.Any)
1062 werkzeug.urls.BaseURL.encode_netloc?4()
1063 werkzeug.urls.BaseURL.get_file_location?4(pathformat: t.Optional[str] = None)
1064 werkzeug.urls.BaseURL.host?4()
1065 werkzeug.urls.BaseURL.join?4(*args: t.Any, **kwargs: t.Any)
1066 werkzeug.urls.BaseURL.password?4()
1067 werkzeug.urls.BaseURL.port?4()
1068 werkzeug.urls.BaseURL.raw_password?4()
1069 werkzeug.urls.BaseURL.raw_username?4()
1070 werkzeug.urls.BaseURL.replace?4(**kwargs: t.Any)
1071 werkzeug.urls.BaseURL.to_iri_tuple?4()
1072 werkzeug.urls.BaseURL.to_uri_tuple?4()
1073 werkzeug.urls.BaseURL.to_url?4()
1074 werkzeug.urls.BaseURL.username?4()
1075 werkzeug.urls.BytesURL._at?8
1076 werkzeug.urls.BytesURL._colon?8
1077 werkzeug.urls.BytesURL._lbracket?8
1078 werkzeug.urls.BytesURL._rbracket?8
1079 werkzeug.urls.BytesURL.decode?4(charset: str = "utf-8", errors: str = "replace")
1080 werkzeug.urls.BytesURL.encode_netloc?4()
1081 werkzeug.urls.Href?1(base="./", charset="utf-8", sort=False, key=None)
1082 werkzeug.urls.URL._at?8
1083 werkzeug.urls.URL._colon?8
1084 werkzeug.urls.URL._lbracket?8
1085 werkzeug.urls.URL._rbracket?8
1086 werkzeug.urls.URL.encode?4(charset: str = "utf-8", errors: str = "replace")
1087 werkzeug.urls._always_safe?8
1088 werkzeug.urls._bytetohex?8
1089 werkzeug.urls._codec_error_url_quote?5(e: UnicodeError)
1090 werkzeug.urls._fast_quote_plus?8
1091 werkzeug.urls._fast_url_quote?8
1092 werkzeug.urls._fast_url_quote_plus?5(string: bytes)
1093 werkzeug.urls._hexdigits?8
1094 werkzeug.urls._hextobyte?8
1095 werkzeug.urls._make_fast_url_quote?5(charset: str = "utf-8", errors: str = "strict", safe: t.Union[str, bytes] = "/:", unsafe: t.Union[str, bytes] = "", )
1096 werkzeug.urls._scheme_re?8
1097 werkzeug.urls._to_iri_unsafe?8
1098 werkzeug.urls._to_uri_safe?8
1099 werkzeug.urls._unquote_to_bytes?5(string: t.Union[str, bytes], unsafe: t.Union[str, bytes] = "")
1100 werkzeug.urls._url_decode_impl?5(pair_iter: t.Iterable[t.AnyStr], charset: str, include_empty: bool, errors: str)
1101 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]], )
1102 werkzeug.urls._url_unquote_legacy?5(value: str, unsafe: str = "")
1103 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, )
1104 werkzeug.urls.quote?4(string: bytes)
1105 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", )
1106 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, )
1107 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, )
1108 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 = "&", )
1109 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 = "&", )
1110 werkzeug.urls.url_fix?4(s: str, charset: str = "utf-8")
1111 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, )
1112 werkzeug.urls.url_parse?4(url: str, scheme: t.Optional[str] = None, allow_fragments: bool = True)
1113 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] = "", )
1114 werkzeug.urls.url_quote_plus?4(string: str, charset: str = "utf-8", errors: str = "strict", safe: str = "")
1115 werkzeug.urls.url_unparse?4(components: t.Tuple[str, str, str, str, str])
1116 werkzeug.urls.url_unquote?4(s: t.Union[str, bytes], charset: str = "utf-8", errors: str = "replace", unsafe: str = "", )
1117 werkzeug.urls.url_unquote_plus?4(s: t.Union[str, bytes], charset: str = "utf-8", errors: str = "replace")
1118 werkzeug.user_agent.UserAgent.to_header?4()
1119 werkzeug.user_agent.UserAgent?1(string: str)
1120 werkzeug.useragents.UserAgent?1(environ_or_string: "t.Union[str, WSGIEnvironment]")
1121 werkzeug.useragents.UserAgentParser?1()
1122 werkzeug.useragents._UserAgent._parser?8
1123 werkzeug.useragents._UserAgent.browser?4()
1124 werkzeug.useragents._UserAgent.language?4()
1125 werkzeug.useragents._UserAgent.platform?4()
1126 werkzeug.useragents._UserAgent.version?4()
1127 werkzeug.useragents._UserAgent?2(string: str)
1128 werkzeug.useragents._UserAgentParser._browser_version_re?8
1129 werkzeug.useragents._UserAgentParser._language_re?8
1130 werkzeug.useragents._UserAgentParser?2()
1131 werkzeug.useragents._deprecated_property?2(fget: t.Callable[["_UserAgent"], t.Any])
1132 werkzeug.utils.ArgumentValidationError?1(missing=None, extra=None, extra_positional=None)
1133 werkzeug.utils.HTMLBuilder._boolean_attributes?8
1134 werkzeug.utils.HTMLBuilder._c_like_cdata?8
1135 werkzeug.utils.HTMLBuilder._empty_elements?8
1136 werkzeug.utils.HTMLBuilder._entities?8
1137 werkzeug.utils.HTMLBuilder._entity_re?8
1138 werkzeug.utils.HTMLBuilder._plaintext_elements?8
1139 werkzeug.utils.HTMLBuilder.proxy?4(**arguments)
1140 werkzeug.utils.HTMLBuilder?1(dialect)
1141 werkzeug.utils.ImportStringError?1(import_name: str, exception: BaseException)
1142 werkzeug.utils._T?8
1143 werkzeug.utils._charset_mimetypes?8
1144 werkzeug.utils._entity_re?8
1145 werkzeug.utils._filename_ascii_strip_re?8
1146 werkzeug.utils._windows_device_files?8
1147 werkzeug.utils.append_slash_redirect?4(environ: "WSGIEnvironment", code: int = 301)
1148 werkzeug.utils.bind_arguments?4(func, args, kwargs)
1149 werkzeug.utils.cached_property?1(fget: t.Callable[[t.Any], _T], name: t.Optional[str] = None, doc: t.Optional[str] = None, )
1150 werkzeug.utils.detect_utf_encoding?4(data: bytes)
1151 werkzeug.utils.environ_property.lookup?4(obj: "Request")
1152 werkzeug.utils.environ_property.read_only?7
1153 werkzeug.utils.escape?4(s: t.Any)
1154 werkzeug.utils.find_modules?4(import_path: str, include_packages: bool = False, recursive: bool = False)
1155 werkzeug.utils.format_string?4(string: str, context: t.Mapping[str, t.Any])
1156 werkzeug.utils.get_content_type?4(mimetype: str, charset: str)
1157 werkzeug.utils.header_property.lookup?4(obj: t.Union["Request", "Response"])
1158 werkzeug.utils.html?7
1159 werkzeug.utils.import_string?4(import_name: str, silent: bool = False)
1160 werkzeug.utils.invalidate_cached_property?4(obj: object, name: str)
1161 werkzeug.utils.redirect?4(location: str, code: int = 302, Response: t.Optional[t.Type["Response"]] = None)
1162 werkzeug.utils.secure_filename?4(filename: str)
1163 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[
1164 t.Union[int, t.Callable[[t.Optional[str]], t.Optional[int]]]
1165 ] = None, use_x_sendfile: bool = False, response_class: t.Optional[t.Type["Response"]] = None, _root_path: t.Optional[t.Union[os.PathLike, str]] = None, )
1166 werkzeug.utils.send_from_directory?4(directory: t.Union[os.PathLike, str], path: t.Union[os.PathLike, str], environ: "WSGIEnvironment", **kwargs: t.Any, )
1167 werkzeug.utils.unescape?4(s: str)
1168 werkzeug.utils.validate_arguments?4(func, args, kwargs, drop_extra=True)
1169 werkzeug.utils.xhtml?7
1170 werkzeug.wrappers.accept.AcceptMixin?1(*args: t.Any, **kwargs: t.Any)
1171 werkzeug.wrappers.auth.AuthorizationMixin?1(*args: t.Any, **kwargs: t.Any)
1172 werkzeug.wrappers.auth.WWWAuthenticateMixin?1(*args: t.Any, **kwargs: t.Any)
1173 werkzeug.wrappers.base_request.BaseRequest?1(*args: t.Any, **kwargs: t.Any)
1174 werkzeug.wrappers.base_response.BaseResponse?1(*args: t.Any, **kwargs: t.Any)
1175 werkzeug.wrappers.common_descriptors.CommonRequestDescriptorsMixin?1(*args: t.Any, **kwargs: t.Any)
1176 werkzeug.wrappers.common_descriptors.CommonResponseDescriptorsMixin?1(*args: t.Any, **kwargs: t.Any)
1177 werkzeug.wrappers.cors.CORSRequestMixin?1(*args: t.Any, **kwargs: t.Any)
1178 werkzeug.wrappers.cors.CORSResponseMixin?1(*args: t.Any, **kwargs: t.Any)
1179 werkzeug.wrappers.etag.ETagRequestMixin?1(*args: t.Any, **kwargs: t.Any)
1180 werkzeug.wrappers.etag.ETagResponseMixin?1(*args: t.Any, **kwargs: t.Any)
1181 werkzeug.wrappers.json.JSONMixin?1(*args: t.Any, **kwargs: t.Any)
1182 werkzeug.wrappers.request.PlainRequest?1(*args: t.Any, **kwargs: t.Any)
1183 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, )
1184 werkzeug.wrappers.request.Request._get_stream_for_parsing?5()
1185 werkzeug.wrappers.request.Request._load_form_data?5()
1186 werkzeug.wrappers.request.Request.application?4()
1187 werkzeug.wrappers.request.Request.close?4()
1188 werkzeug.wrappers.request.Request.data?4()
1189 werkzeug.wrappers.request.Request.files?4()
1190 werkzeug.wrappers.request.Request.form?4()
1191 werkzeug.wrappers.request.Request.from_values?4(*args: t.Any, **kwargs: t.Any)
1192 werkzeug.wrappers.request.Request.get_data?4(cache: bool = True, as_text: bool = False, parse_form_data: bool = False)
1193 werkzeug.wrappers.request.Request.get_json?4(force: bool = False, silent: bool = False, cache: bool = True)
1194 werkzeug.wrappers.request.Request.input_stream?7
1195 werkzeug.wrappers.request.Request.is_multiprocess?7
1196 werkzeug.wrappers.request.Request.is_multithread?7
1197 werkzeug.wrappers.request.Request.is_run_once?7
1198 werkzeug.wrappers.request.Request.json?4()
1199 werkzeug.wrappers.request.Request.json_module?7
1200 werkzeug.wrappers.request.Request.make_form_data_parser?4()
1201 werkzeug.wrappers.request.Request.on_json_loading_failed?4(e: ValueError)
1202 werkzeug.wrappers.request.Request.remote_user?7
1203 werkzeug.wrappers.request.Request.script_root?4()
1204 werkzeug.wrappers.request.Request.stream?4()
1205 werkzeug.wrappers.request.Request.url_root?4()
1206 werkzeug.wrappers.request.Request.values?4()
1207 werkzeug.wrappers.request.Request.want_form_data_parsed?4()
1208 werkzeug.wrappers.request.Request?1(environ: "WSGIEnvironment", populate_request: bool = True, shallow: bool = False, )
1209 werkzeug.wrappers.request.StreamOnlyMixin?1(*args: t.Any, **kwargs: t.Any)
1210 werkzeug.wrappers.response.Response._ensure_sequence?5(mutable: bool = False)
1211 werkzeug.wrappers.response.Response._is_range_request_processable?5(environ: "WSGIEnvironment")
1212 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, )
1213 werkzeug.wrappers.response.Response._wrap_range_response?5(start: int, length: int)
1214 werkzeug.wrappers.response.Response.add_etag?4(overwrite: bool = False, weak: bool = False)
1215 werkzeug.wrappers.response.Response.autocorrect_location_header?7
1216 werkzeug.wrappers.response.Response.automatically_set_content_length?7
1217 werkzeug.wrappers.response.Response.calculate_content_length?4()
1218 werkzeug.wrappers.response.Response.call_on_close?4(func: t.Callable[[], t.Any])
1219 werkzeug.wrappers.response.Response.close?4()
1220 werkzeug.wrappers.response.Response.data?7
1221 werkzeug.wrappers.response.Response.force_type?4(response: "Response", environ: t.Optional["WSGIEnvironment"] = None)
1222 werkzeug.wrappers.response.Response.freeze?4(no_etag: None = None)
1223 werkzeug.wrappers.response.Response.from_app?4(app: "WSGIApplication", environ: "WSGIEnvironment", buffered: bool = False)
1224 werkzeug.wrappers.response.Response.get_app_iter?4(environ: "WSGIEnvironment")
1225 werkzeug.wrappers.response.Response.get_data?4(as_text: bool = False)
1226 werkzeug.wrappers.response.Response.get_json?4(force: bool = False, silent: bool = False)
1227 werkzeug.wrappers.response.Response.get_wsgi_headers?4(environ: "WSGIEnvironment")
1228 werkzeug.wrappers.response.Response.get_wsgi_response?4(environ: "WSGIEnvironment")
1229 werkzeug.wrappers.response.Response.implicit_sequence_conversion?7
1230 werkzeug.wrappers.response.Response.is_sequence?4()
1231 werkzeug.wrappers.response.Response.is_streamed?4()
1232 werkzeug.wrappers.response.Response.iter_encoded?4()
1233 werkzeug.wrappers.response.Response.json?4()
1234 werkzeug.wrappers.response.Response.json_module?7
1235 werkzeug.wrappers.response.Response.make_conditional?4(request_or_environ: "WSGIEnvironment", accept_ranges: t.Union[bool, str] = False, complete_length: t.Optional[int] = None, )
1236 werkzeug.wrappers.response.Response.make_sequence?4()
1237 werkzeug.wrappers.response.Response.set_data?4(value: t.Union[bytes, str])
1238 werkzeug.wrappers.response.Response.stream?4()
1239 werkzeug.wrappers.response.Response?1(response: t.Optional[
1240 t.Union[t.Iterable[bytes], bytes, t.Iterable[str], str]
1241 ] = None, status: t.Optional[t.Union[int, str, HTTPStatus]] = None, headers: t.Optional[
1242 t.Union[
1243 t.Mapping[str, t.Union[str, int, t.Iterable[t.Union[str, int]]]], t.Iterable[t.Tuple[str, t.Union[str, int]]], ]
1244 ] = None, mimetype: t.Optional[str] = None, content_type: t.Optional[str] = None, direct_passthrough: bool = False, )
1245 werkzeug.wrappers.response.ResponseStream.close?4()
1246 werkzeug.wrappers.response.ResponseStream.encoding?4()
1247 werkzeug.wrappers.response.ResponseStream.flush?4()
1248 werkzeug.wrappers.response.ResponseStream.isatty?4()
1249 werkzeug.wrappers.response.ResponseStream.mode?7
1250 werkzeug.wrappers.response.ResponseStream.tell?4()
1251 werkzeug.wrappers.response.ResponseStream.write?4(value: bytes)
1252 werkzeug.wrappers.response.ResponseStream.writelines?4(seq: t.Iterable[bytes])
1253 werkzeug.wrappers.response.ResponseStream?1(response: Response)
1254 werkzeug.wrappers.response.ResponseStreamMixin?1(*args: t.Any, **kwargs: t.Any)
1255 werkzeug.wrappers.response._clean_accept_ranges?5(accept_ranges: t.Union[bool, str])
1256 werkzeug.wrappers.response._iter_encoded?5(iterable: t.Iterable[t.Union[str, bytes]], charset: str)
1257 werkzeug.wrappers.response._warn_if_string?5(iterable: t.Iterable)
1258 werkzeug.wrappers.user_agent.UserAgentMixin?1(*args: t.Any, **kwargs: t.Any)
1259 werkzeug.wsgi.ClosingIterator.close?4()
1260 werkzeug.wsgi.ClosingIterator?1(iterable: t.Iterable[bytes], callbacks: t.Optional[
1261 t.Union[t.Callable[[], None], t.Iterable[t.Callable[[], None]]]
1262 ] = None, )
1263 werkzeug.wsgi.FileWrapper.close?4()
1264 werkzeug.wsgi.FileWrapper.seek?4(*args: t.Any)
1265 werkzeug.wsgi.FileWrapper.seekable?4()
1266 werkzeug.wsgi.FileWrapper.tell?4()
1267 werkzeug.wsgi.FileWrapper?1(file: t.BinaryIO, buffer_size: int = 8192)
1268 werkzeug.wsgi.LimitedStream.exhaust?4(chunk_size: int = 1024 * 64)
1269 werkzeug.wsgi.LimitedStream.is_exhausted?4()
1270 werkzeug.wsgi.LimitedStream.on_disconnect?4()
1271 werkzeug.wsgi.LimitedStream.on_exhausted?4()
1272 werkzeug.wsgi.LimitedStream.read?4(size: t.Optional[int] = None)
1273 werkzeug.wsgi.LimitedStream.readable?4()
1274 werkzeug.wsgi.LimitedStream.readline?4(size: t.Optional[int] = None)
1275 werkzeug.wsgi.LimitedStream.readlines?4(size: t.Optional[int] = None)
1276 werkzeug.wsgi.LimitedStream.tell?4()
1277 werkzeug.wsgi.LimitedStream?1(stream: t.BinaryIO, limit: int)
1278 werkzeug.wsgi._RangeWrapper._first_iteration?5()
1279 werkzeug.wsgi._RangeWrapper._next?5()
1280 werkzeug.wsgi._RangeWrapper._next_chunk?5()
1281 werkzeug.wsgi._RangeWrapper.close?4()
1282 werkzeug.wsgi._RangeWrapper?2(iterable: t.Union[t.Iterable[bytes], t.BinaryIO], start_byte: int = 0, byte_range: t.Optional[int] = None, )
1283 werkzeug.wsgi._get_server?5(environ: "WSGIEnvironment", )
1284 werkzeug.wsgi._iter_basic_lines?5()
1285 werkzeug.wsgi._make_chunk_iter?5(stream: t.Union[t.Iterable[bytes], t.BinaryIO], limit: t.Optional[int], buffer_size: int, )
1286 werkzeug.wsgi._normalize_netloc?5(scheme: str, netloc: str)
1287 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, )
1288 werkzeug.wsgi.get_content_length?4(environ: "WSGIEnvironment")
1289 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, )
1290 werkzeug.wsgi.get_host?4(environ: "WSGIEnvironment", trusted_hosts: t.Optional[t.Iterable[str]] = None)
1291 werkzeug.wsgi.get_input_stream?4(environ: "WSGIEnvironment", safe_fallback: bool = True)
1292 werkzeug.wsgi.get_path_info?4(environ: "WSGIEnvironment", charset: str = "utf-8", errors: str = "replace")
1293 werkzeug.wsgi.get_query_string?4(environ: "WSGIEnvironment")
1294 werkzeug.wsgi.get_script_name?4(environ: "WSGIEnvironment", charset: str = "utf-8", errors: str = "replace")
1295 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, )
1296 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, )
1297 werkzeug.wsgi.peek_path_info?4(environ: "WSGIEnvironment", charset: str = "utf-8", errors: str = "replace")
1298 werkzeug.wsgi.pop_path_info?4(environ: "WSGIEnvironment", charset: str = "utf-8", errors: str = "replace")
1299 werkzeug.wsgi.responder?4(f: t.Callable[..., "WSGIApplication"])
1300 werkzeug.wsgi.wrap_file?4(environ: "WSGIEnvironment", file: t.BinaryIO, buffer_size: int = 8192)

Mercurial Repository: Flask Project

eric ide

mercurial