doc_content stringlengths 1 386k | doc_id stringlengths 5 188 |
|---|---|
call_on_close(func)
Adds a function to the internal list of functions that should be called as part of closing down the response. Since 0.7 this function also returns the function that was passed so that this can be used as a decorator. Changelog New in version 0.6. Parameters
func (Callable[[], Any]) – Return ... | flask.api.index#flask.Response.call_on_close |
close()
Close the wrapped response if possible. You can also use the object in a with statement which will automatically close it. Changelog New in version 0.9: Can now be used in a with statement. Return type
None | flask.api.index#flask.Response.close |
content_encoding
The Content-Encoding entity-header field is used as a modifier to the media-type. When present, its value indicates what additional content codings have been applied to the entity-body, and thus what decoding mechanisms must be applied in order to obtain the media-type referenced by the Content-Type ... | flask.api.index#flask.Response.content_encoding |
content_length
The Content-Length entity-header field indicates the size of the entity-body, in decimal number of OCTETs, sent to the recipient or, in the case of the HEAD method, the size of the entity-body that would have been sent had the request been a GET. | flask.api.index#flask.Response.content_length |
content_location
The Content-Location entity-header field MAY be used to supply the resource location for the entity enclosed in the message when that entity is accessible from a location separate from the requested resource’s URI. | flask.api.index#flask.Response.content_location |
content_md5
The Content-MD5 entity-header field, as defined in RFC 1864, is an MD5 digest of the entity-body for the purpose of providing an end-to-end message integrity check (MIC) of the entity-body. (Note: a MIC is good for detecting accidental modification of the entity-body in transit, but is not proof against m... | flask.api.index#flask.Response.content_md5 |
content_security_policy
The Content-Security-Policy header adds an additional layer of security to help detect and mitigate certain types of attacks. | flask.api.index#flask.Response.content_security_policy |
content_security_policy_report_only
The Content-Security-Policy-Report-Only header adds a csp policy that is not enforced but is reported thereby helping detect certain types of attacks. | flask.api.index#flask.Response.content_security_policy_report_only |
content_type
The Content-Type entity-header field indicates the media type of the entity-body sent to the recipient or, in the case of the HEAD method, the media type that would have been sent had the request been a GET. | flask.api.index#flask.Response.content_type |
cross_origin_embedder_policy
Prevents a document from loading any cross-origin resources that do not explicitly grant the document permission. Values must be a member of the werkzeug.http.COEP enum. | flask.api.index#flask.Response.cross_origin_embedder_policy |
cross_origin_opener_policy
Allows control over sharing of browsing context group with cross-origin documents. Values must be a member of the werkzeug.http.COOP enum. | flask.api.index#flask.Response.cross_origin_opener_policy |
date
The Date general-header field represents the date and time at which the message was originated, having the same semantics as orig-date in RFC 822. Changed in version 2.0: The datetime object is timezone-aware. | flask.api.index#flask.Response.date |
delete_cookie(key, path='/', domain=None, secure=False, httponly=False, samesite=None)
Delete a cookie. Fails silently if key doesn’t exist. Parameters
key (str) – the key (name) of the cookie to be deleted.
path (str) – if the cookie that should be deleted was limited to a path, the path has to be defined here.... | flask.api.index#flask.Response.delete_cookie |
direct_passthrough
Pass the response body directly through as the WSGI iterable. This can be used when the body is a binary file or other iterator of bytes, to skip some unnecessary checks. Use send_file() instead of setting this manually. | flask.api.index#flask.Response.direct_passthrough |
expires
The Expires entity-header field gives the date/time after which the response is considered stale. A stale cache entry may not normally be returned by a cache. Changed in version 2.0: The datetime object is timezone-aware. | flask.api.index#flask.Response.expires |
classmethod force_type(response, environ=None)
Enforce that the WSGI response is a response object of the current type. Werkzeug will use the Response internally in many situations like the exceptions. If you call get_response() on an exception you will get back a regular Response object, even if you are using a cust... | flask.api.index#flask.Response.force_type |
freeze(no_etag=None)
Make the response object ready to be pickled. Does the following: Buffer the response into a list, ignoring implicity_sequence_conversion and direct_passthrough. Set the Content-Length header. Generate an ETag header if one is not already set. Changed in version 2.0: An ETag header is added, t... | flask.api.index#flask.Response.freeze |
classmethod from_app(app, environ, buffered=False)
Create a new response object from an application output. This works best if you pass it an application that returns a generator all the time. Sometimes applications may use the write() callable returned by the start_response function. This tries to resolve such edge ... | flask.api.index#flask.Response.from_app |
get_app_iter(environ)
Returns the application iterator for the given environ. Depending on the request method and the current status code the return value might be an empty response rather than the one from the response. If the request method is HEAD or the status code is in a range where the HTTP specification requi... | flask.api.index#flask.Response.get_app_iter |
get_data(as_text=False)
The string representation of the response body. Whenever you call this property the response iterable is encoded and flattened. This can lead to unwanted behavior if you stream big data. This behavior can be disabled by setting implicit_sequence_conversion to False. If as_text is set to True t... | flask.api.index#flask.Response.get_data |
get_etag()
Return a tuple in the form (etag, is_weak). If there is no ETag the return value is (None, None). Return type
Union[Tuple[str, bool], Tuple[None, None]] | flask.api.index#flask.Response.get_etag |
get_json(force=False, silent=False)
Parse data as JSON. Useful during testing. If the mimetype does not indicate JSON (application/json, see is_json()), this returns None. Unlike Request.get_json(), the result is not cached. Parameters
force (bool) – Ignore the mimetype and always try to parse JSON.
silent (bool... | flask.api.index#flask.Response.get_json |
get_wsgi_headers(environ)
This is automatically called right before the response is started and returns headers modified for the given environment. It returns a copy of the headers from the response with some modifications applied if necessary. For example the location header (if present) is joined with the root URL ... | flask.api.index#flask.Response.get_wsgi_headers |
get_wsgi_response(environ)
Returns the final WSGI response as tuple. The first item in the tuple is the application iterator, the second the status and the third the list of headers. The response returned is created specially for the given environment. For example if the request method in the WSGI environment is 'HEA... | flask.api.index#flask.Response.get_wsgi_response |
iter_encoded()
Iter the response encoded with the encoding of the response. If the response object is invoked as WSGI application the return value of this method is used as application iterator unless direct_passthrough was activated. Return type
Iterator[bytes] | flask.api.index#flask.Response.iter_encoded |
last_modified
The Last-Modified entity-header field indicates the date and time at which the origin server believes the variant was last modified. Changed in version 2.0: The datetime object is timezone-aware. | flask.api.index#flask.Response.last_modified |
location
The Location response-header field is used to redirect the recipient to a location other than the Request-URI for completion of the request or identification of a new resource. | flask.api.index#flask.Response.location |
make_conditional(request_or_environ, accept_ranges=False, complete_length=None)
Make the response conditional to the request. This method works best if an etag was defined for the response already. The add_etag method can be used to do that. If called without etag just the date header is set. This does nothing if the... | flask.api.index#flask.Response.make_conditional |
make_sequence()
Converts the response iterator in a list. By default this happens automatically if required. If implicit_sequence_conversion is disabled, this method is not automatically called and some properties might raise exceptions. This also encodes all the items. Changelog New in version 0.6. Return type
N... | flask.api.index#flask.Response.make_sequence |
set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=False, httponly=False, samesite=None)
Sets a cookie. A warning is raised if the size of the cookie header exceeds max_cookie_size, but the header will still be set. Parameters
key (str) – the key (name) of the cookie to be set.
v... | flask.api.index#flask.Response.set_cookie |
set_data(value)
Sets a new string as response. The value must be a string or bytes. If a string is set it’s encoded to the charset of the response (utf-8 by default). Changelog New in version 0.9. Parameters
value (Union[bytes, str]) – Return type
None | flask.api.index#flask.Response.set_data |
set_etag(etag, weak=False)
Set the etag, and override the old one if there was one. Parameters
etag (str) –
weak (bool) – Return type
None | flask.api.index#flask.Response.set_etag |
flask.safe_join(directory, *pathnames)
Safely join zero or more untrusted path components to a base directory to avoid escaping the base directory. Parameters
directory (str) – The trusted base directory.
pathnames (str) – The untrusted path components relative to the base directory. Returns
A safe path, othe... | flask.api.index#flask.safe_join |
class flask.cli.ScriptInfo(app_import_path=None, create_app=None, set_debug_flag=True)
Helper object to deal with Flask applications. This is usually not necessary to interface with as it’s used internally in the dispatching to click. In future versions of Flask this object will most likely play a bigger role. Typica... | flask.api.index#flask.cli.ScriptInfo |
app_import_path
Optionally the import path for the Flask application. | flask.api.index#flask.cli.ScriptInfo.app_import_path |
create_app
Optionally a function that is passed the script info to create the instance of the application. | flask.api.index#flask.cli.ScriptInfo.create_app |
data
A dictionary with arbitrary data that can be associated with this script info. | flask.api.index#flask.cli.ScriptInfo.data |
load_app()
Loads the Flask app (if not yet loaded) and returns it. Calling this multiple times will just result in the already loaded app to be returned. | flask.api.index#flask.cli.ScriptInfo.load_app |
SECRET_KEY
A secret key that will be used for securely signing the session cookie and can be used for any other security related needs by extensions or your application. It should be a long random bytes or str. For example, copy the output of this to your config: $ python -c 'import os; print(os.urandom(16))'
b'_5#y2... | flask.config.index#SECRET_KEY |
class flask.sessions.SecureCookieSession(initial=None)
Base class for sessions based on signed cookies. This session backend will set the modified and accessed attributes. It cannot reliably track whether a session is new (vs. empty), so new remains hard coded to False. Parameters
initial (Any) – Return type
Non... | flask.api.index#flask.sessions.SecureCookieSession |
accessed = False
header, which allows caching proxies to cache different pages for different users. | flask.api.index#flask.sessions.SecureCookieSession.accessed |
get(key, default=None)
Return the value for key if key is in the dictionary, else default. Parameters
key (str) –
default (Optional[Any]) – Return type
Any | flask.api.index#flask.sessions.SecureCookieSession.get |
modified = False
When data is changed, this is set to True. Only the session dictionary itself is tracked; if the session contains mutable data (for example a nested dict) then this must be set to True manually when modifying that data. The session cookie will only be written to the response if this is True. | flask.api.index#flask.sessions.SecureCookieSession.modified |
setdefault(key, default=None)
Insert key with a value of default if key is not in the dictionary. Return the value for key if key is in the dictionary, else default. Parameters
key (str) –
default (Optional[Any]) – Return type
Any | flask.api.index#flask.sessions.SecureCookieSession.setdefault |
class flask.sessions.SecureCookieSessionInterface
The default session interface that stores sessions in signed cookies through the itsdangerous module.
static digest_method()
the hash function to use for the signature. The default is sha1
key_derivation = 'hmac'
the name of the itsdangerous supported key de... | flask.api.index#flask.sessions.SecureCookieSessionInterface |
static digest_method()
the hash function to use for the signature. The default is sha1 | flask.api.index#flask.sessions.SecureCookieSessionInterface.digest_method |
key_derivation = 'hmac'
the name of the itsdangerous supported key derivation. The default is hmac. | flask.api.index#flask.sessions.SecureCookieSessionInterface.key_derivation |
open_session(app, request)
This method has to be implemented and must either return None in case the loading failed because of a configuration error or an instance of a session object which implements a dictionary like interface + the methods and attributes on SessionMixin. Parameters
app (Flask) –
request (Req... | flask.api.index#flask.sessions.SecureCookieSessionInterface.open_session |
salt = 'cookie-session'
the salt that should be applied on top of the secret key for the signing of cookie based sessions. | flask.api.index#flask.sessions.SecureCookieSessionInterface.salt |
save_session(app, session, response)
This is called for actual sessions returned by open_session() at the end of the request. This is still called during a request context so if you absolutely need access to the request you can do that. Parameters
app (Flask) –
session (flask.sessions.SessionMixin) –
response... | flask.api.index#flask.sessions.SecureCookieSessionInterface.save_session |
serializer = <flask.json.tag.TaggedJSONSerializer object>
A python serializer for the payload. The default is a compact JSON derived serializer with support for some extra Python types such as datetime objects or tuples. | flask.api.index#flask.sessions.SecureCookieSessionInterface.serializer |
session_class
alias of flask.sessions.SecureCookieSession | flask.api.index#flask.sessions.SecureCookieSessionInterface.session_class |
flask.send_file(path_or_file, mimetype=None, as_attachment=False, download_name=None, attachment_filename=None, conditional=True, etag=True, add_etags=None, last_modified=None, max_age=None, cache_timeout=None)
Send the contents of a file to the client. The first argument can be a file path or a file-like object. Pat... | flask.api.index#flask.send_file |
SEND_FILE_MAX_AGE_DEFAULT
When serving files, set the cache control max age to this number of seconds. Can be a datetime.timedelta or an int. Override this value on a per-file basis using get_send_file_max_age() on the application or blueprint. If None, send_file tells the browser to use conditional requests will be ... | flask.config.index#SEND_FILE_MAX_AGE_DEFAULT |
flask.send_from_directory(directory, path, filename=None, **kwargs)
Send a file from within a directory using send_file(). @app.route("/uploads/<path:name>")
def download_file(name):
return send_from_directory(
app.config['UPLOAD_FOLDER'], name, as_attachment=True
)
This is a secure way to serve file... | flask.api.index#flask.send_from_directory |
SERVER_NAME
Inform the application what host and port it is bound to. Required for subdomain route matching support. If set, will be used for the session cookie domain if SESSION_COOKIE_DOMAIN is not set. Modern web browsers will not allow setting cookies for domains without a dot. To use a domain locally, add any na... | flask.config.index#SERVER_NAME |
class flask.session
The session object works pretty much like an ordinary dict, with the difference that it keeps track of modifications. This is a proxy. See Notes On Proxies for more information. The following attributes are interesting:
new
True if the session is new, False otherwise.
modified
True if th... | flask.api.index#flask.session |
modified
True if the session object detected a modification. Be advised that modifications on mutable structures are not picked up automatically, in that situation you have to explicitly set the attribute to True yourself. Here an example: # this change is not picked up because a mutable object (here
# a list) is cha... | flask.api.index#flask.session.modified |
new
True if the session is new, False otherwise. | flask.api.index#flask.session.new |
permanent
If set to True the session lives for permanent_session_lifetime seconds. The default is 31 days. If set to False (which is the default) the session will be deleted when the user closes the browser. | flask.api.index#flask.session.permanent |
class flask.sessions.SessionInterface
The basic interface you have to implement in order to replace the default session interface which uses werkzeug’s securecookie implementation. The only methods you have to implement are open_session() and save_session(), the others have useful defaults which you don’t need to cha... | flask.api.index#flask.sessions.SessionInterface |
get_cookie_domain(app)
Returns the domain that should be set for the session cookie. Uses SESSION_COOKIE_DOMAIN if it is configured, otherwise falls back to detecting the domain based on SERVER_NAME. Once detected (or if not set at all), SESSION_COOKIE_DOMAIN is updated to avoid re-running the logic. Parameters
app... | flask.api.index#flask.sessions.SessionInterface.get_cookie_domain |
get_cookie_httponly(app)
Returns True if the session cookie should be httponly. This currently just returns the value of the SESSION_COOKIE_HTTPONLY config var. Parameters
app (Flask) – Return type
bool | flask.api.index#flask.sessions.SessionInterface.get_cookie_httponly |
get_cookie_name(app)
Returns the name of the session cookie. Uses app.session_cookie_name which is set to SESSION_COOKIE_NAME Parameters
app (Flask) – Return type
str | flask.api.index#flask.sessions.SessionInterface.get_cookie_name |
get_cookie_path(app)
Returns the path for which the cookie should be valid. The default implementation uses the value from the SESSION_COOKIE_PATH config var if it’s set, and falls back to APPLICATION_ROOT or uses / if it’s None. Parameters
app (Flask) – Return type
str | flask.api.index#flask.sessions.SessionInterface.get_cookie_path |
get_cookie_samesite(app)
Return 'Strict' or 'Lax' if the cookie should use the SameSite attribute. This currently just returns the value of the SESSION_COOKIE_SAMESITE setting. Parameters
app (Flask) – Return type
str | flask.api.index#flask.sessions.SessionInterface.get_cookie_samesite |
get_cookie_secure(app)
Returns True if the cookie should be secure. This currently just returns the value of the SESSION_COOKIE_SECURE setting. Parameters
app (Flask) – Return type
bool | flask.api.index#flask.sessions.SessionInterface.get_cookie_secure |
get_expiration_time(app, session)
A helper method that returns an expiration date for the session or None if the session is linked to the browser session. The default implementation returns now + the permanent session lifetime configured on the application. Parameters
app (Flask) –
session (flask.sessions.Sessi... | flask.api.index#flask.sessions.SessionInterface.get_expiration_time |
is_null_session(obj)
Checks if a given object is a null session. Null sessions are not asked to be saved. This checks if the object is an instance of null_session_class by default. Parameters
obj (object) – Return type
bool | flask.api.index#flask.sessions.SessionInterface.is_null_session |
make_null_session(app)
Creates a null session which acts as a replacement object if the real session support could not be loaded due to a configuration error. This mainly aids the user experience because the job of the null session is to still support lookup without complaining but modifications are answered with a h... | flask.api.index#flask.sessions.SessionInterface.make_null_session |
null_session_class
make_null_session() will look here for the class that should be created when a null session is requested. Likewise the is_null_session() method will perform a typecheck against this type. alias of flask.sessions.NullSession | flask.api.index#flask.sessions.SessionInterface.null_session_class |
open_session(app, request)
This method has to be implemented and must either return None in case the loading failed because of a configuration error or an instance of a session object which implements a dictionary like interface + the methods and attributes on SessionMixin. Parameters
app (Flask) –
request (Req... | flask.api.index#flask.sessions.SessionInterface.open_session |
pickle_based = False
A flag that indicates if the session interface is pickle based. This can be used by Flask extensions to make a decision in regards to how to deal with the session object. Changelog New in version 0.10. | flask.api.index#flask.sessions.SessionInterface.pickle_based |
save_session(app, session, response)
This is called for actual sessions returned by open_session() at the end of the request. This is still called during a request context so if you absolutely need access to the request you can do that. Parameters
app (Flask) –
session (flask.sessions.SessionMixin) –
response... | flask.api.index#flask.sessions.SessionInterface.save_session |
should_set_cookie(app, session)
Used by session backends to determine if a Set-Cookie header should be set for this session cookie for this response. If the session has been modified, the cookie is set. If the session is permanent and the SESSION_REFRESH_EACH_REQUEST config is true, the cookie is always set. This che... | flask.api.index#flask.sessions.SessionInterface.should_set_cookie |
class flask.sessions.SessionMixin
Expands a basic dictionary with session attributes.
accessed = True
Some implementations can detect when session data is read or written and set this when that happens. The mixin default is hard coded to True.
modified = True
Some implementations can detect changes to the s... | flask.api.index#flask.sessions.SessionMixin |
accessed = True
Some implementations can detect when session data is read or written and set this when that happens. The mixin default is hard coded to True. | flask.api.index#flask.sessions.SessionMixin.accessed |
modified = True
Some implementations can detect changes to the session and set this when that happens. The mixin default is hard coded to True. | flask.api.index#flask.sessions.SessionMixin.modified |
SESSION_COOKIE_DOMAIN
The domain match rule that the session cookie will be valid for. If not set, the cookie will be valid for all subdomains of SERVER_NAME. If False, the cookie’s domain will not be set. Default: None | flask.config.index#SESSION_COOKIE_DOMAIN |
SESSION_COOKIE_HTTPONLY
Browsers will not allow JavaScript access to cookies marked as “HTTP only” for security. Default: True | flask.config.index#SESSION_COOKIE_HTTPONLY |
SESSION_COOKIE_NAME
The name of the session cookie. Can be changed in case you already have a cookie with the same name. Default: 'session' | flask.config.index#SESSION_COOKIE_NAME |
SESSION_COOKIE_PATH
The path that the session cookie will be valid for. If not set, the cookie will be valid underneath APPLICATION_ROOT or / if that is not set. Default: None | flask.config.index#SESSION_COOKIE_PATH |
SESSION_COOKIE_SAMESITE
Restrict how cookies are sent with requests from external sites. Can be set to 'Lax' (recommended) or 'Strict'. See Set-Cookie options. Default: None Changelog New in version 1.0. | flask.config.index#SESSION_COOKIE_SAMESITE |
SESSION_COOKIE_SECURE
Browsers will only send cookies with requests over HTTPS if the cookie is marked “secure”. The application must be served over HTTPS for this to make sense. Default: False | flask.config.index#SESSION_COOKIE_SECURE |
SESSION_REFRESH_EACH_REQUEST
Control whether the cookie is sent with every response when session.permanent is true. Sending the cookie every time (the default) can more reliably keep the session from expiring, but uses more bandwidth. Non-permanent sessions are not affected. Default: True | flask.config.index#SESSION_REFRESH_EACH_REQUEST |
Signals Changelog New in version 0.6. Starting with Flask 0.6, there is integrated support for signalling in Flask. This support is provided by the excellent blinker library and will gracefully fall back if it is not available. What are signals? Signals help you decouple applications by sending notifications when act... | flask.signals.index |
flask.stream_with_context(generator_or_function)
Request contexts disappear when the response is started on the server. This is done for efficiency reasons and to make it less likely to encounter memory leaks with badly written WSGI middlewares. The downside is that if you are using streamed responses, the generator ... | flask.api.index#flask.stream_with_context |
class flask.json.tag.TaggedJSONSerializer
Serializer that uses a tag system to compactly represent objects that are not JSON types. Passed as the intermediate serializer to itsdangerous.Serializer. The following extra types are supported: dict tuple bytes Markup UUID datetime Return type
None
default_tags = [... | flask.api.index#flask.json.tag.TaggedJSONSerializer |
default_tags = [<class 'flask.json.tag.TagDict'>, <class 'flask.json.tag.PassDict'>, <class 'flask.json.tag.TagTuple'>, <class 'flask.json.tag.PassList'>, <class 'flask.json.tag.TagBytes'>, <class 'flask.json.tag.TagMarkup'>, <class 'flask.json.tag.TagUUID'>, <class 'flask.json.tag.TagDateTime'>]
Tag classes to bind ... | flask.api.index#flask.json.tag.TaggedJSONSerializer.default_tags |
dumps(value)
Tag the value and dump it to a compact JSON string. Parameters
value (Any) – Return type
str | flask.api.index#flask.json.tag.TaggedJSONSerializer.dumps |
loads(value)
Load data from a JSON string and deserialized any tagged objects. Parameters
value (str) – Return type
Any | flask.api.index#flask.json.tag.TaggedJSONSerializer.loads |
register(tag_class, force=False, index=None)
Register a new tag with this serializer. Parameters
tag_class (Type[flask.json.tag.JSONTag]) – tag class to register. Will be instantiated with this serializer instance.
force (bool) – overwrite an existing tag. If false (default), a KeyError is raised.
index (Option... | flask.api.index#flask.json.tag.TaggedJSONSerializer.register |
tag(value)
Convert a value to a tagged representation if necessary. Parameters
value (Any) – Return type
Dict[str, Any] | flask.api.index#flask.json.tag.TaggedJSONSerializer.tag |
untag(value)
Convert a tagged representation back to the original type. Parameters
value (Dict[str, Any]) – Return type
Any | flask.api.index#flask.json.tag.TaggedJSONSerializer.untag |
Templates Flask leverages Jinja2 as its template engine. You are obviously free to use a different template engine, but you still have to install Jinja2 to run Flask itself. This requirement is necessary to enable rich extensions. An extension can depend on Jinja2 being present. This section only gives a very quick int... | flask.templating.index |
TEMPLATES_AUTO_RELOAD
Reload templates when they are changed. If not set, it will be enabled in debug mode. Default: None | flask.config.index#TEMPLATES_AUTO_RELOAD |
TESTING
Enable testing mode. Exceptions are propagated rather than handled by the the app’s error handlers. Extensions may also change their behavior to facilitate easier testing. You should enable this in your own tests. Default: False | flask.config.index#TESTING |
TRAP_BAD_REQUEST_ERRORS
Trying to access a key that doesn’t exist from request dicts like args and form will return a 400 Bad Request error page. Enable this to treat the error as an unhandled exception instead so that you get the interactive debugger. This is a more specific version of TRAP_HTTP_EXCEPTIONS. If unset... | flask.config.index#TRAP_BAD_REQUEST_ERRORS |
TRAP_HTTP_EXCEPTIONS
If there is no handler for an HTTPException-type exception, re-raise it to be handled by the interactive debugger instead of returning it as a simple error response. Default: False | flask.config.index#TRAP_HTTP_EXCEPTIONS |
flask.url_for(endpoint, **values)
Generates a URL to the given endpoint with the method provided. Variable arguments that are unknown to the target endpoint are appended to the generated URL as query arguments. If the value of a query argument is None, the whole pair is skipped. In case blueprints are active you can ... | flask.api.index#flask.url_for |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.