repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens listlengths 20 707 | docstring stringlengths 3 17.3k | docstring_tokens listlengths 3 222 | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1 value | idx int64 0 252k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
pgjones/quart | quart/app.py | Quart.teardown_websocket | def teardown_websocket(self, func: Callable, name: AppOrBlueprintKey=None) -> Callable:
"""Add a teardown websocket function.
This is designed to be used as a decorator. An example usage,
.. code-block:: python
@app.teardown_websocket
def func():
...
Arguments:
func: The teardown websocket function itself.
name: Optional blueprint key name.
"""
handler = ensure_coroutine(func)
self.teardown_websocket_funcs[name].append(handler)
return func | python | def teardown_websocket(self, func: Callable, name: AppOrBlueprintKey=None) -> Callable:
"""Add a teardown websocket function.
This is designed to be used as a decorator. An example usage,
.. code-block:: python
@app.teardown_websocket
def func():
...
Arguments:
func: The teardown websocket function itself.
name: Optional blueprint key name.
"""
handler = ensure_coroutine(func)
self.teardown_websocket_funcs[name].append(handler)
return func | [
"def",
"teardown_websocket",
"(",
"self",
",",
"func",
":",
"Callable",
",",
"name",
":",
"AppOrBlueprintKey",
"=",
"None",
")",
"->",
"Callable",
":",
"handler",
"=",
"ensure_coroutine",
"(",
"func",
")",
"self",
".",
"teardown_websocket_funcs",
"[",
"name",
... | Add a teardown websocket function.
This is designed to be used as a decorator. An example usage,
.. code-block:: python
@app.teardown_websocket
def func():
...
Arguments:
func: The teardown websocket function itself.
name: Optional blueprint key name. | [
"Add",
"a",
"teardown",
"websocket",
"function",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1164-L1181 | train | 226,600 |
pgjones/quart | quart/app.py | Quart.register_blueprint | def register_blueprint(self, blueprint: Blueprint, url_prefix: Optional[str]=None) -> None:
"""Register a blueprint on the app.
This results in the blueprint's routes, error handlers
etc... being added to the app.
Arguments:
blueprint: The blueprint to register.
url_prefix: Optional prefix to apply to all paths.
"""
first_registration = False
if blueprint.name in self.blueprints and self.blueprints[blueprint.name] is not blueprint:
raise RuntimeError(
f"Blueprint name '{blueprint.name}' "
f"is already registered by {self.blueprints[blueprint.name]}. "
"Blueprints must have unique names",
)
else:
self.blueprints[blueprint.name] = blueprint
first_registration = True
blueprint.register(self, first_registration, url_prefix=url_prefix) | python | def register_blueprint(self, blueprint: Blueprint, url_prefix: Optional[str]=None) -> None:
"""Register a blueprint on the app.
This results in the blueprint's routes, error handlers
etc... being added to the app.
Arguments:
blueprint: The blueprint to register.
url_prefix: Optional prefix to apply to all paths.
"""
first_registration = False
if blueprint.name in self.blueprints and self.blueprints[blueprint.name] is not blueprint:
raise RuntimeError(
f"Blueprint name '{blueprint.name}' "
f"is already registered by {self.blueprints[blueprint.name]}. "
"Blueprints must have unique names",
)
else:
self.blueprints[blueprint.name] = blueprint
first_registration = True
blueprint.register(self, first_registration, url_prefix=url_prefix) | [
"def",
"register_blueprint",
"(",
"self",
",",
"blueprint",
":",
"Blueprint",
",",
"url_prefix",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
")",
"->",
"None",
":",
"first_registration",
"=",
"False",
"if",
"blueprint",
".",
"name",
"in",
"self",
".",
... | Register a blueprint on the app.
This results in the blueprint's routes, error handlers
etc... being added to the app.
Arguments:
blueprint: The blueprint to register.
url_prefix: Optional prefix to apply to all paths. | [
"Register",
"a",
"blueprint",
"on",
"the",
"app",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1202-L1222 | train | 226,601 |
pgjones/quart | quart/app.py | Quart.open_session | async def open_session(self, request: BaseRequestWebsocket) -> Session:
"""Open and return a Session using the request."""
return await ensure_coroutine(self.session_interface.open_session)(self, request) | python | async def open_session(self, request: BaseRequestWebsocket) -> Session:
"""Open and return a Session using the request."""
return await ensure_coroutine(self.session_interface.open_session)(self, request) | [
"async",
"def",
"open_session",
"(",
"self",
",",
"request",
":",
"BaseRequestWebsocket",
")",
"->",
"Session",
":",
"return",
"await",
"ensure_coroutine",
"(",
"self",
".",
"session_interface",
".",
"open_session",
")",
"(",
"self",
",",
"request",
")"
] | Open and return a Session using the request. | [
"Open",
"and",
"return",
"a",
"Session",
"using",
"the",
"request",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1228-L1230 | train | 226,602 |
pgjones/quart | quart/app.py | Quart.save_session | async def save_session(self, session: Session, response: Response) -> None:
"""Saves the session to the response."""
await ensure_coroutine(self.session_interface.save_session)(self, session, response) | python | async def save_session(self, session: Session, response: Response) -> None:
"""Saves the session to the response."""
await ensure_coroutine(self.session_interface.save_session)(self, session, response) | [
"async",
"def",
"save_session",
"(",
"self",
",",
"session",
":",
"Session",
",",
"response",
":",
"Response",
")",
"->",
"None",
":",
"await",
"ensure_coroutine",
"(",
"self",
".",
"session_interface",
".",
"save_session",
")",
"(",
"self",
",",
"session",
... | Saves the session to the response. | [
"Saves",
"the",
"session",
"to",
"the",
"response",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1236-L1238 | train | 226,603 |
pgjones/quart | quart/app.py | Quart.do_teardown_request | async def do_teardown_request(
self,
exc: Optional[BaseException],
request_context: Optional[RequestContext]=None,
) -> None:
"""Teardown the request, calling the teardown functions.
Arguments:
exc: Any exception not handled that has caused the request
to teardown.
request_context: The request context, optional as Flask
omits this argument.
"""
request_ = (request_context or _request_ctx_stack.top).request
functions = self.teardown_request_funcs[None]
blueprint = request_.blueprint
if blueprint is not None:
functions = chain(functions, self.teardown_request_funcs[blueprint]) # type: ignore
for function in functions:
await function(exc=exc)
await request_tearing_down.send(self, exc=exc) | python | async def do_teardown_request(
self,
exc: Optional[BaseException],
request_context: Optional[RequestContext]=None,
) -> None:
"""Teardown the request, calling the teardown functions.
Arguments:
exc: Any exception not handled that has caused the request
to teardown.
request_context: The request context, optional as Flask
omits this argument.
"""
request_ = (request_context or _request_ctx_stack.top).request
functions = self.teardown_request_funcs[None]
blueprint = request_.blueprint
if blueprint is not None:
functions = chain(functions, self.teardown_request_funcs[blueprint]) # type: ignore
for function in functions:
await function(exc=exc)
await request_tearing_down.send(self, exc=exc) | [
"async",
"def",
"do_teardown_request",
"(",
"self",
",",
"exc",
":",
"Optional",
"[",
"BaseException",
"]",
",",
"request_context",
":",
"Optional",
"[",
"RequestContext",
"]",
"=",
"None",
",",
")",
"->",
"None",
":",
"request_",
"=",
"(",
"request_context"... | Teardown the request, calling the teardown functions.
Arguments:
exc: Any exception not handled that has caused the request
to teardown.
request_context: The request context, optional as Flask
omits this argument. | [
"Teardown",
"the",
"request",
"calling",
"the",
"teardown",
"functions",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1240-L1261 | train | 226,604 |
pgjones/quart | quart/app.py | Quart.do_teardown_websocket | async def do_teardown_websocket(
self,
exc: Optional[BaseException],
websocket_context: Optional[WebsocketContext]=None,
) -> None:
"""Teardown the websocket, calling the teardown functions.
Arguments:
exc: Any exception not handled that has caused the websocket
to teardown.
websocket_context: The websocket context, optional as Flask
omits this argument.
"""
websocket_ = (websocket_context or _websocket_ctx_stack.top).websocket
functions = self.teardown_websocket_funcs[None]
blueprint = websocket_.blueprint
if blueprint is not None:
functions = chain(functions, self.teardown_websocket_funcs[blueprint]) # type: ignore
for function in functions:
await function(exc=exc)
await websocket_tearing_down.send(self, exc=exc) | python | async def do_teardown_websocket(
self,
exc: Optional[BaseException],
websocket_context: Optional[WebsocketContext]=None,
) -> None:
"""Teardown the websocket, calling the teardown functions.
Arguments:
exc: Any exception not handled that has caused the websocket
to teardown.
websocket_context: The websocket context, optional as Flask
omits this argument.
"""
websocket_ = (websocket_context or _websocket_ctx_stack.top).websocket
functions = self.teardown_websocket_funcs[None]
blueprint = websocket_.blueprint
if blueprint is not None:
functions = chain(functions, self.teardown_websocket_funcs[blueprint]) # type: ignore
for function in functions:
await function(exc=exc)
await websocket_tearing_down.send(self, exc=exc) | [
"async",
"def",
"do_teardown_websocket",
"(",
"self",
",",
"exc",
":",
"Optional",
"[",
"BaseException",
"]",
",",
"websocket_context",
":",
"Optional",
"[",
"WebsocketContext",
"]",
"=",
"None",
",",
")",
"->",
"None",
":",
"websocket_",
"=",
"(",
"websocke... | Teardown the websocket, calling the teardown functions.
Arguments:
exc: Any exception not handled that has caused the websocket
to teardown.
websocket_context: The websocket context, optional as Flask
omits this argument. | [
"Teardown",
"the",
"websocket",
"calling",
"the",
"teardown",
"functions",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1263-L1284 | train | 226,605 |
pgjones/quart | quart/app.py | Quart.run | def run(
self,
host: str='127.0.0.1',
port: int=5000,
debug: Optional[bool]=None,
use_reloader: bool=True,
loop: Optional[asyncio.AbstractEventLoop]=None,
ca_certs: Optional[str]=None,
certfile: Optional[str]=None,
keyfile: Optional[str]=None,
**kwargs: Any,
) -> None:
"""Run this application.
This is best used for development only, see Hypercorn for
production servers.
Arguments:
host: Hostname to listen on. By default this is loopback
only, use 0.0.0.0 to have the server listen externally.
port: Port number to listen on.
debug: If set enable (or disable) debug mode and debug output.
use_reloader: Automatically reload on code changes.
loop: Asyncio loop to create the server in, if None, take default one.
If specified it is the caller's responsibility to close and cleanup the
loop.
ca_certs: Path to the SSL CA certificate file.
certfile: Path to the SSL certificate file.
keyfile: Path to the SSL key file.
"""
if kwargs:
warnings.warn(
f"Additional arguments, {','.join(kwargs.keys())}, are not supported.\n"
"They may be supported by Hypercorn, which is the ASGI server Quart "
"uses by default. This method is meant for development and debugging."
)
config = HyperConfig()
config.access_log_format = "%(h)s %(r)s %(s)s %(b)s %(D)s"
config.access_logger = create_serving_logger() # type: ignore
config.bind = [f"{host}:{port}"]
config.ca_certs = ca_certs
config.certfile = certfile
if debug is not None:
self.debug = debug
config.error_logger = config.access_logger # type: ignore
config.keyfile = keyfile
config.use_reloader = use_reloader
scheme = 'https' if config.ssl_enabled else 'http'
print("Running on {}://{} (CTRL + C to quit)".format(scheme, config.bind[0])) # noqa: T001
if loop is not None:
loop.set_debug(debug or False)
loop.run_until_complete(serve(self, config))
else:
asyncio.run(serve(self, config), debug=config.debug) | python | def run(
self,
host: str='127.0.0.1',
port: int=5000,
debug: Optional[bool]=None,
use_reloader: bool=True,
loop: Optional[asyncio.AbstractEventLoop]=None,
ca_certs: Optional[str]=None,
certfile: Optional[str]=None,
keyfile: Optional[str]=None,
**kwargs: Any,
) -> None:
"""Run this application.
This is best used for development only, see Hypercorn for
production servers.
Arguments:
host: Hostname to listen on. By default this is loopback
only, use 0.0.0.0 to have the server listen externally.
port: Port number to listen on.
debug: If set enable (or disable) debug mode and debug output.
use_reloader: Automatically reload on code changes.
loop: Asyncio loop to create the server in, if None, take default one.
If specified it is the caller's responsibility to close and cleanup the
loop.
ca_certs: Path to the SSL CA certificate file.
certfile: Path to the SSL certificate file.
keyfile: Path to the SSL key file.
"""
if kwargs:
warnings.warn(
f"Additional arguments, {','.join(kwargs.keys())}, are not supported.\n"
"They may be supported by Hypercorn, which is the ASGI server Quart "
"uses by default. This method is meant for development and debugging."
)
config = HyperConfig()
config.access_log_format = "%(h)s %(r)s %(s)s %(b)s %(D)s"
config.access_logger = create_serving_logger() # type: ignore
config.bind = [f"{host}:{port}"]
config.ca_certs = ca_certs
config.certfile = certfile
if debug is not None:
self.debug = debug
config.error_logger = config.access_logger # type: ignore
config.keyfile = keyfile
config.use_reloader = use_reloader
scheme = 'https' if config.ssl_enabled else 'http'
print("Running on {}://{} (CTRL + C to quit)".format(scheme, config.bind[0])) # noqa: T001
if loop is not None:
loop.set_debug(debug or False)
loop.run_until_complete(serve(self, config))
else:
asyncio.run(serve(self, config), debug=config.debug) | [
"def",
"run",
"(",
"self",
",",
"host",
":",
"str",
"=",
"'127.0.0.1'",
",",
"port",
":",
"int",
"=",
"5000",
",",
"debug",
":",
"Optional",
"[",
"bool",
"]",
"=",
"None",
",",
"use_reloader",
":",
"bool",
"=",
"True",
",",
"loop",
":",
"Optional",... | Run this application.
This is best used for development only, see Hypercorn for
production servers.
Arguments:
host: Hostname to listen on. By default this is loopback
only, use 0.0.0.0 to have the server listen externally.
port: Port number to listen on.
debug: If set enable (or disable) debug mode and debug output.
use_reloader: Automatically reload on code changes.
loop: Asyncio loop to create the server in, if None, take default one.
If specified it is the caller's responsibility to close and cleanup the
loop.
ca_certs: Path to the SSL CA certificate file.
certfile: Path to the SSL certificate file.
keyfile: Path to the SSL key file. | [
"Run",
"this",
"application",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1336-L1393 | train | 226,606 |
pgjones/quart | quart/app.py | Quart.try_trigger_before_first_request_functions | async def try_trigger_before_first_request_functions(self) -> None:
"""Trigger the before first request methods."""
if self._got_first_request:
return
# Reverse the teardown functions, so as to match the expected usage
self.teardown_appcontext_funcs = list(reversed(self.teardown_appcontext_funcs))
for key, value in self.teardown_request_funcs.items():
self.teardown_request_funcs[key] = list(reversed(value))
for key, value in self.teardown_websocket_funcs.items():
self.teardown_websocket_funcs[key] = list(reversed(value))
async with self._first_request_lock:
if self._got_first_request:
return
for function in self.before_first_request_funcs:
await function()
self._got_first_request = True | python | async def try_trigger_before_first_request_functions(self) -> None:
"""Trigger the before first request methods."""
if self._got_first_request:
return
# Reverse the teardown functions, so as to match the expected usage
self.teardown_appcontext_funcs = list(reversed(self.teardown_appcontext_funcs))
for key, value in self.teardown_request_funcs.items():
self.teardown_request_funcs[key] = list(reversed(value))
for key, value in self.teardown_websocket_funcs.items():
self.teardown_websocket_funcs[key] = list(reversed(value))
async with self._first_request_lock:
if self._got_first_request:
return
for function in self.before_first_request_funcs:
await function()
self._got_first_request = True | [
"async",
"def",
"try_trigger_before_first_request_functions",
"(",
"self",
")",
"->",
"None",
":",
"if",
"self",
".",
"_got_first_request",
":",
"return",
"# Reverse the teardown functions, so as to match the expected usage",
"self",
".",
"teardown_appcontext_funcs",
"=",
"li... | Trigger the before first request methods. | [
"Trigger",
"the",
"before",
"first",
"request",
"methods",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1437-L1454 | train | 226,607 |
pgjones/quart | quart/app.py | Quart.make_default_options_response | async def make_default_options_response(self) -> Response:
"""This is the default route function for OPTIONS requests."""
methods = _request_ctx_stack.top.url_adapter.allowed_methods()
return self.response_class('', headers={'Allow': ', '.join(methods)}) | python | async def make_default_options_response(self) -> Response:
"""This is the default route function for OPTIONS requests."""
methods = _request_ctx_stack.top.url_adapter.allowed_methods()
return self.response_class('', headers={'Allow': ', '.join(methods)}) | [
"async",
"def",
"make_default_options_response",
"(",
"self",
")",
"->",
"Response",
":",
"methods",
"=",
"_request_ctx_stack",
".",
"top",
".",
"url_adapter",
".",
"allowed_methods",
"(",
")",
"return",
"self",
".",
"response_class",
"(",
"''",
",",
"headers",
... | This is the default route function for OPTIONS requests. | [
"This",
"is",
"the",
"default",
"route",
"function",
"for",
"OPTIONS",
"requests",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1456-L1459 | train | 226,608 |
pgjones/quart | quart/app.py | Quart.make_response | async def make_response(self, result: ResponseReturnValue) -> Response:
"""Make a Response from the result of the route handler.
The result itself can either be:
- A Response object (or subclass).
- A tuple of a ResponseValue and a header dictionary.
- A tuple of a ResponseValue, status code and a header dictionary.
A ResponseValue is either a Response object (or subclass) or a str.
"""
status_or_headers = None
headers = None
status = None
if isinstance(result, tuple):
value, status_or_headers, headers = result + (None,) * (3 - len(result))
else:
value = result
if value is None:
raise TypeError('The response value returned by the view function cannot be None')
if isinstance(status_or_headers, (dict, list)):
headers = status_or_headers
status = None
elif status_or_headers is not None:
status = status_or_headers
if not isinstance(value, Response):
response = self.response_class( # type: ignore
value, timeout=self.config['RESPONSE_TIMEOUT'],
)
else:
response = value
if status is not None:
response.status_code = status # type: ignore
if headers is not None:
response.headers.update(headers) # type: ignore
return response | python | async def make_response(self, result: ResponseReturnValue) -> Response:
"""Make a Response from the result of the route handler.
The result itself can either be:
- A Response object (or subclass).
- A tuple of a ResponseValue and a header dictionary.
- A tuple of a ResponseValue, status code and a header dictionary.
A ResponseValue is either a Response object (or subclass) or a str.
"""
status_or_headers = None
headers = None
status = None
if isinstance(result, tuple):
value, status_or_headers, headers = result + (None,) * (3 - len(result))
else:
value = result
if value is None:
raise TypeError('The response value returned by the view function cannot be None')
if isinstance(status_or_headers, (dict, list)):
headers = status_or_headers
status = None
elif status_or_headers is not None:
status = status_or_headers
if not isinstance(value, Response):
response = self.response_class( # type: ignore
value, timeout=self.config['RESPONSE_TIMEOUT'],
)
else:
response = value
if status is not None:
response.status_code = status # type: ignore
if headers is not None:
response.headers.update(headers) # type: ignore
return response | [
"async",
"def",
"make_response",
"(",
"self",
",",
"result",
":",
"ResponseReturnValue",
")",
"->",
"Response",
":",
"status_or_headers",
"=",
"None",
"headers",
"=",
"None",
"status",
"=",
"None",
"if",
"isinstance",
"(",
"result",
",",
"tuple",
")",
":",
... | Make a Response from the result of the route handler.
The result itself can either be:
- A Response object (or subclass).
- A tuple of a ResponseValue and a header dictionary.
- A tuple of a ResponseValue, status code and a header dictionary.
A ResponseValue is either a Response object (or subclass) or a str. | [
"Make",
"a",
"Response",
"from",
"the",
"result",
"of",
"the",
"route",
"handler",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1461-L1501 | train | 226,609 |
pgjones/quart | quart/app.py | Quart.full_dispatch_request | async def full_dispatch_request(
self, request_context: Optional[RequestContext]=None,
) -> Response:
"""Adds pre and post processing to the request dispatching.
Arguments:
request_context: The request context, optional as Flask
omits this argument.
"""
await self.try_trigger_before_first_request_functions()
await request_started.send(self)
try:
result = await self.preprocess_request(request_context)
if result is None:
result = await self.dispatch_request(request_context)
except Exception as error:
result = await self.handle_user_exception(error)
return await self.finalize_request(result, request_context) | python | async def full_dispatch_request(
self, request_context: Optional[RequestContext]=None,
) -> Response:
"""Adds pre and post processing to the request dispatching.
Arguments:
request_context: The request context, optional as Flask
omits this argument.
"""
await self.try_trigger_before_first_request_functions()
await request_started.send(self)
try:
result = await self.preprocess_request(request_context)
if result is None:
result = await self.dispatch_request(request_context)
except Exception as error:
result = await self.handle_user_exception(error)
return await self.finalize_request(result, request_context) | [
"async",
"def",
"full_dispatch_request",
"(",
"self",
",",
"request_context",
":",
"Optional",
"[",
"RequestContext",
"]",
"=",
"None",
",",
")",
"->",
"Response",
":",
"await",
"self",
".",
"try_trigger_before_first_request_functions",
"(",
")",
"await",
"request... | Adds pre and post processing to the request dispatching.
Arguments:
request_context: The request context, optional as Flask
omits this argument. | [
"Adds",
"pre",
"and",
"post",
"processing",
"to",
"the",
"request",
"dispatching",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1512-L1529 | train | 226,610 |
pgjones/quart | quart/app.py | Quart.preprocess_request | async def preprocess_request(
self, request_context: Optional[RequestContext]=None,
) -> Optional[ResponseReturnValue]:
"""Preprocess the request i.e. call before_request functions.
Arguments:
request_context: The request context, optional as Flask
omits this argument.
"""
request_ = (request_context or _request_ctx_stack.top).request
blueprint = request_.blueprint
processors = self.url_value_preprocessors[None]
if blueprint is not None:
processors = chain(processors, self.url_value_preprocessors[blueprint]) # type: ignore
for processor in processors:
processor(request.endpoint, request.view_args)
functions = self.before_request_funcs[None]
if blueprint is not None:
functions = chain(functions, self.before_request_funcs[blueprint]) # type: ignore
for function in functions:
result = await function()
if result is not None:
return result
return None | python | async def preprocess_request(
self, request_context: Optional[RequestContext]=None,
) -> Optional[ResponseReturnValue]:
"""Preprocess the request i.e. call before_request functions.
Arguments:
request_context: The request context, optional as Flask
omits this argument.
"""
request_ = (request_context or _request_ctx_stack.top).request
blueprint = request_.blueprint
processors = self.url_value_preprocessors[None]
if blueprint is not None:
processors = chain(processors, self.url_value_preprocessors[blueprint]) # type: ignore
for processor in processors:
processor(request.endpoint, request.view_args)
functions = self.before_request_funcs[None]
if blueprint is not None:
functions = chain(functions, self.before_request_funcs[blueprint]) # type: ignore
for function in functions:
result = await function()
if result is not None:
return result
return None | [
"async",
"def",
"preprocess_request",
"(",
"self",
",",
"request_context",
":",
"Optional",
"[",
"RequestContext",
"]",
"=",
"None",
",",
")",
"->",
"Optional",
"[",
"ResponseReturnValue",
"]",
":",
"request_",
"=",
"(",
"request_context",
"or",
"_request_ctx_st... | Preprocess the request i.e. call before_request functions.
Arguments:
request_context: The request context, optional as Flask
omits this argument. | [
"Preprocess",
"the",
"request",
"i",
".",
"e",
".",
"call",
"before_request",
"functions",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1531-L1555 | train | 226,611 |
pgjones/quart | quart/app.py | Quart.dispatch_request | async def dispatch_request(
self, request_context: Optional[RequestContext]=None,
) -> ResponseReturnValue:
"""Dispatch the request to the view function.
Arguments:
request_context: The request context, optional as Flask
omits this argument.
"""
request_ = (request_context or _request_ctx_stack.top).request
if request_.routing_exception is not None:
raise request_.routing_exception
if request_.method == 'OPTIONS' and request_.url_rule.provide_automatic_options:
return await self.make_default_options_response()
handler = self.view_functions[request_.url_rule.endpoint]
return await handler(**request_.view_args) | python | async def dispatch_request(
self, request_context: Optional[RequestContext]=None,
) -> ResponseReturnValue:
"""Dispatch the request to the view function.
Arguments:
request_context: The request context, optional as Flask
omits this argument.
"""
request_ = (request_context or _request_ctx_stack.top).request
if request_.routing_exception is not None:
raise request_.routing_exception
if request_.method == 'OPTIONS' and request_.url_rule.provide_automatic_options:
return await self.make_default_options_response()
handler = self.view_functions[request_.url_rule.endpoint]
return await handler(**request_.view_args) | [
"async",
"def",
"dispatch_request",
"(",
"self",
",",
"request_context",
":",
"Optional",
"[",
"RequestContext",
"]",
"=",
"None",
",",
")",
"->",
"ResponseReturnValue",
":",
"request_",
"=",
"(",
"request_context",
"or",
"_request_ctx_stack",
".",
"top",
")",
... | Dispatch the request to the view function.
Arguments:
request_context: The request context, optional as Flask
omits this argument. | [
"Dispatch",
"the",
"request",
"to",
"the",
"view",
"function",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1557-L1574 | train | 226,612 |
pgjones/quart | quart/app.py | Quart.process_response | async def process_response(
self,
response: Response,
request_context: Optional[RequestContext]=None,
) -> Response:
"""Postprocess the request acting on the response.
Arguments:
response: The response after the request is finalized.
request_context: The request context, optional as Flask
omits this argument.
"""
request_ = (request_context or _request_ctx_stack.top).request
functions = (request_context or _request_ctx_stack.top)._after_request_functions
blueprint = request_.blueprint
if blueprint is not None:
functions = chain(functions, self.after_request_funcs[blueprint])
functions = chain(functions, self.after_request_funcs[None])
for function in functions:
response = await function(response)
session_ = (request_context or _request_ctx_stack.top).session
if not self.session_interface.is_null_session(session_):
await self.save_session(session_, response)
return response | python | async def process_response(
self,
response: Response,
request_context: Optional[RequestContext]=None,
) -> Response:
"""Postprocess the request acting on the response.
Arguments:
response: The response after the request is finalized.
request_context: The request context, optional as Flask
omits this argument.
"""
request_ = (request_context or _request_ctx_stack.top).request
functions = (request_context or _request_ctx_stack.top)._after_request_functions
blueprint = request_.blueprint
if blueprint is not None:
functions = chain(functions, self.after_request_funcs[blueprint])
functions = chain(functions, self.after_request_funcs[None])
for function in functions:
response = await function(response)
session_ = (request_context or _request_ctx_stack.top).session
if not self.session_interface.is_null_session(session_):
await self.save_session(session_, response)
return response | [
"async",
"def",
"process_response",
"(",
"self",
",",
"response",
":",
"Response",
",",
"request_context",
":",
"Optional",
"[",
"RequestContext",
"]",
"=",
"None",
",",
")",
"->",
"Response",
":",
"request_",
"=",
"(",
"request_context",
"or",
"_request_ctx_s... | Postprocess the request acting on the response.
Arguments:
response: The response after the request is finalized.
request_context: The request context, optional as Flask
omits this argument. | [
"Postprocess",
"the",
"request",
"acting",
"on",
"the",
"response",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1599-L1624 | train | 226,613 |
pgjones/quart | quart/app.py | Quart.full_dispatch_websocket | async def full_dispatch_websocket(
self, websocket_context: Optional[WebsocketContext]=None,
) -> Optional[Response]:
"""Adds pre and post processing to the websocket dispatching.
Arguments:
websocket_context: The websocket context, optional to match
the Flask convention.
"""
await self.try_trigger_before_first_request_functions()
await websocket_started.send(self)
try:
result = await self.preprocess_websocket(websocket_context)
if result is None:
result = await self.dispatch_websocket(websocket_context)
except Exception as error:
result = await self.handle_user_exception(error)
return await self.finalize_websocket(result, websocket_context) | python | async def full_dispatch_websocket(
self, websocket_context: Optional[WebsocketContext]=None,
) -> Optional[Response]:
"""Adds pre and post processing to the websocket dispatching.
Arguments:
websocket_context: The websocket context, optional to match
the Flask convention.
"""
await self.try_trigger_before_first_request_functions()
await websocket_started.send(self)
try:
result = await self.preprocess_websocket(websocket_context)
if result is None:
result = await self.dispatch_websocket(websocket_context)
except Exception as error:
result = await self.handle_user_exception(error)
return await self.finalize_websocket(result, websocket_context) | [
"async",
"def",
"full_dispatch_websocket",
"(",
"self",
",",
"websocket_context",
":",
"Optional",
"[",
"WebsocketContext",
"]",
"=",
"None",
",",
")",
"->",
"Optional",
"[",
"Response",
"]",
":",
"await",
"self",
".",
"try_trigger_before_first_request_functions",
... | Adds pre and post processing to the websocket dispatching.
Arguments:
websocket_context: The websocket context, optional to match
the Flask convention. | [
"Adds",
"pre",
"and",
"post",
"processing",
"to",
"the",
"websocket",
"dispatching",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1635-L1652 | train | 226,614 |
pgjones/quart | quart/app.py | Quart.preprocess_websocket | async def preprocess_websocket(
self, websocket_context: Optional[WebsocketContext]=None,
) -> Optional[ResponseReturnValue]:
"""Preprocess the websocket i.e. call before_websocket functions.
Arguments:
websocket_context: The websocket context, optional as Flask
omits this argument.
"""
websocket_ = (websocket_context or _websocket_ctx_stack.top).websocket
blueprint = websocket_.blueprint
processors = self.url_value_preprocessors[None]
if blueprint is not None:
processors = chain(processors, self.url_value_preprocessors[blueprint]) # type: ignore
for processor in processors:
processor(websocket_.endpoint, websocket_.view_args)
functions = self.before_websocket_funcs[None]
if blueprint is not None:
functions = chain(functions, self.before_websocket_funcs[blueprint]) # type: ignore
for function in functions:
result = await function()
if result is not None:
return result
return None | python | async def preprocess_websocket(
self, websocket_context: Optional[WebsocketContext]=None,
) -> Optional[ResponseReturnValue]:
"""Preprocess the websocket i.e. call before_websocket functions.
Arguments:
websocket_context: The websocket context, optional as Flask
omits this argument.
"""
websocket_ = (websocket_context or _websocket_ctx_stack.top).websocket
blueprint = websocket_.blueprint
processors = self.url_value_preprocessors[None]
if blueprint is not None:
processors = chain(processors, self.url_value_preprocessors[blueprint]) # type: ignore
for processor in processors:
processor(websocket_.endpoint, websocket_.view_args)
functions = self.before_websocket_funcs[None]
if blueprint is not None:
functions = chain(functions, self.before_websocket_funcs[blueprint]) # type: ignore
for function in functions:
result = await function()
if result is not None:
return result
return None | [
"async",
"def",
"preprocess_websocket",
"(",
"self",
",",
"websocket_context",
":",
"Optional",
"[",
"WebsocketContext",
"]",
"=",
"None",
",",
")",
"->",
"Optional",
"[",
"ResponseReturnValue",
"]",
":",
"websocket_",
"=",
"(",
"websocket_context",
"or",
"_webs... | Preprocess the websocket i.e. call before_websocket functions.
Arguments:
websocket_context: The websocket context, optional as Flask
omits this argument. | [
"Preprocess",
"the",
"websocket",
"i",
".",
"e",
".",
"call",
"before_websocket",
"functions",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1654-L1678 | train | 226,615 |
pgjones/quart | quart/app.py | Quart.dispatch_websocket | async def dispatch_websocket(
self, websocket_context: Optional[WebsocketContext]=None,
) -> None:
"""Dispatch the websocket to the view function.
Arguments:
websocket_context: The websocket context, optional to match
the Flask convention.
"""
websocket_ = (websocket_context or _websocket_ctx_stack.top).websocket
if websocket_.routing_exception is not None:
raise websocket_.routing_exception
handler = self.view_functions[websocket_.url_rule.endpoint]
return await handler(**websocket_.view_args) | python | async def dispatch_websocket(
self, websocket_context: Optional[WebsocketContext]=None,
) -> None:
"""Dispatch the websocket to the view function.
Arguments:
websocket_context: The websocket context, optional to match
the Flask convention.
"""
websocket_ = (websocket_context or _websocket_ctx_stack.top).websocket
if websocket_.routing_exception is not None:
raise websocket_.routing_exception
handler = self.view_functions[websocket_.url_rule.endpoint]
return await handler(**websocket_.view_args) | [
"async",
"def",
"dispatch_websocket",
"(",
"self",
",",
"websocket_context",
":",
"Optional",
"[",
"WebsocketContext",
"]",
"=",
"None",
",",
")",
"->",
"None",
":",
"websocket_",
"=",
"(",
"websocket_context",
"or",
"_websocket_ctx_stack",
".",
"top",
")",
".... | Dispatch the websocket to the view function.
Arguments:
websocket_context: The websocket context, optional to match
the Flask convention. | [
"Dispatch",
"the",
"websocket",
"to",
"the",
"view",
"function",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1680-L1694 | train | 226,616 |
pgjones/quart | quart/app.py | Quart.postprocess_websocket | async def postprocess_websocket(
self,
response: Optional[Response],
websocket_context: Optional[WebsocketContext]=None,
) -> Response:
"""Postprocess the websocket acting on the response.
Arguments:
response: The response after the websocket is finalized.
webcoket_context: The websocket context, optional as Flask
omits this argument.
"""
websocket_ = (websocket_context or _websocket_ctx_stack.top).websocket
functions = (websocket_context or _websocket_ctx_stack.top)._after_websocket_functions
blueprint = websocket_.blueprint
if blueprint is not None:
functions = chain(functions, self.after_websocket_funcs[blueprint])
functions = chain(functions, self.after_websocket_funcs[None])
for function in functions:
response = await function(response)
session_ = (websocket_context or _request_ctx_stack.top).session
if not self.session_interface.is_null_session(session_):
if response is None and isinstance(session_, SecureCookieSession) and session_.modified:
self.logger.exception(
"Secure Cookie Session modified during websocket handling. "
"These modifications will be lost as a cookie cannot be set."
)
else:
await self.save_session(session_, response)
return response | python | async def postprocess_websocket(
self,
response: Optional[Response],
websocket_context: Optional[WebsocketContext]=None,
) -> Response:
"""Postprocess the websocket acting on the response.
Arguments:
response: The response after the websocket is finalized.
webcoket_context: The websocket context, optional as Flask
omits this argument.
"""
websocket_ = (websocket_context or _websocket_ctx_stack.top).websocket
functions = (websocket_context or _websocket_ctx_stack.top)._after_websocket_functions
blueprint = websocket_.blueprint
if blueprint is not None:
functions = chain(functions, self.after_websocket_funcs[blueprint])
functions = chain(functions, self.after_websocket_funcs[None])
for function in functions:
response = await function(response)
session_ = (websocket_context or _request_ctx_stack.top).session
if not self.session_interface.is_null_session(session_):
if response is None and isinstance(session_, SecureCookieSession) and session_.modified:
self.logger.exception(
"Secure Cookie Session modified during websocket handling. "
"These modifications will be lost as a cookie cannot be set."
)
else:
await self.save_session(session_, response)
return response | [
"async",
"def",
"postprocess_websocket",
"(",
"self",
",",
"response",
":",
"Optional",
"[",
"Response",
"]",
",",
"websocket_context",
":",
"Optional",
"[",
"WebsocketContext",
"]",
"=",
"None",
",",
")",
"->",
"Response",
":",
"websocket_",
"=",
"(",
"webs... | Postprocess the websocket acting on the response.
Arguments:
response: The response after the websocket is finalized.
webcoket_context: The websocket context, optional as Flask
omits this argument. | [
"Postprocess",
"the",
"websocket",
"acting",
"on",
"the",
"response",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/app.py#L1722-L1753 | train | 226,617 |
pgjones/quart | quart/ctx.py | after_this_request | def after_this_request(func: Callable) -> Callable:
"""Schedule the func to be called after the current request.
This is useful in situations whereby you want an after request
function for a specific route or circumstance only, for example,
.. code-block:: python
def index():
@after_this_request
def set_cookie(response):
response.set_cookie('special', 'value')
return response
...
"""
_request_ctx_stack.top._after_request_functions.append(func)
return func | python | def after_this_request(func: Callable) -> Callable:
"""Schedule the func to be called after the current request.
This is useful in situations whereby you want an after request
function for a specific route or circumstance only, for example,
.. code-block:: python
def index():
@after_this_request
def set_cookie(response):
response.set_cookie('special', 'value')
return response
...
"""
_request_ctx_stack.top._after_request_functions.append(func)
return func | [
"def",
"after_this_request",
"(",
"func",
":",
"Callable",
")",
"->",
"Callable",
":",
"_request_ctx_stack",
".",
"top",
".",
"_after_request_functions",
".",
"append",
"(",
"func",
")",
"return",
"func"
] | Schedule the func to be called after the current request.
This is useful in situations whereby you want an after request
function for a specific route or circumstance only, for example,
.. code-block:: python
def index():
@after_this_request
def set_cookie(response):
response.set_cookie('special', 'value')
return response
... | [
"Schedule",
"the",
"func",
"to",
"be",
"called",
"after",
"the",
"current",
"request",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L183-L200 | train | 226,618 |
pgjones/quart | quart/ctx.py | after_this_websocket | def after_this_websocket(func: Callable) -> Callable:
"""Schedule the func to be called after the current websocket.
This is useful in situations whereby you want an after websocket
function for a specific route or circumstance only, for example,
.. note::
The response is an optional argument, and will only be
passed if the websocket was not active (i.e. there was an
error).
.. code-block:: python
def index():
@after_this_websocket
def set_cookie(response: Optional[Response]):
response.set_cookie('special', 'value')
return response
...
"""
_websocket_ctx_stack.top._after_websocket_functions.append(func)
return func | python | def after_this_websocket(func: Callable) -> Callable:
"""Schedule the func to be called after the current websocket.
This is useful in situations whereby you want an after websocket
function for a specific route or circumstance only, for example,
.. note::
The response is an optional argument, and will only be
passed if the websocket was not active (i.e. there was an
error).
.. code-block:: python
def index():
@after_this_websocket
def set_cookie(response: Optional[Response]):
response.set_cookie('special', 'value')
return response
...
"""
_websocket_ctx_stack.top._after_websocket_functions.append(func)
return func | [
"def",
"after_this_websocket",
"(",
"func",
":",
"Callable",
")",
"->",
"Callable",
":",
"_websocket_ctx_stack",
".",
"top",
".",
"_after_websocket_functions",
".",
"append",
"(",
"func",
")",
"return",
"func"
] | Schedule the func to be called after the current websocket.
This is useful in situations whereby you want an after websocket
function for a specific route or circumstance only, for example,
.. note::
The response is an optional argument, and will only be
passed if the websocket was not active (i.e. there was an
error).
.. code-block:: python
def index():
@after_this_websocket
def set_cookie(response: Optional[Response]):
response.set_cookie('special', 'value')
return response
... | [
"Schedule",
"the",
"func",
"to",
"be",
"called",
"after",
"the",
"current",
"websocket",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L203-L226 | train | 226,619 |
pgjones/quart | quart/ctx.py | copy_current_app_context | def copy_current_app_context(func: Callable) -> Callable:
"""Share the current app context with the function decorated.
The app context is local per task and hence will not be available
in any other task. This decorator can be used to make the context
available,
.. code-block:: python
@copy_current_app_context
async def within_context() -> None:
name = current_app.name
...
"""
if not has_app_context():
raise RuntimeError('Attempt to copy app context outside of a app context')
app_context = _app_ctx_stack.top.copy()
@wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> Any:
async with app_context:
return await func(*args, **kwargs)
return wrapper | python | def copy_current_app_context(func: Callable) -> Callable:
"""Share the current app context with the function decorated.
The app context is local per task and hence will not be available
in any other task. This decorator can be used to make the context
available,
.. code-block:: python
@copy_current_app_context
async def within_context() -> None:
name = current_app.name
...
"""
if not has_app_context():
raise RuntimeError('Attempt to copy app context outside of a app context')
app_context = _app_ctx_stack.top.copy()
@wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> Any:
async with app_context:
return await func(*args, **kwargs)
return wrapper | [
"def",
"copy_current_app_context",
"(",
"func",
":",
"Callable",
")",
"->",
"Callable",
":",
"if",
"not",
"has_app_context",
"(",
")",
":",
"raise",
"RuntimeError",
"(",
"'Attempt to copy app context outside of a app context'",
")",
"app_context",
"=",
"_app_ctx_stack",... | Share the current app context with the function decorated.
The app context is local per task and hence will not be available
in any other task. This decorator can be used to make the context
available,
.. code-block:: python
@copy_current_app_context
async def within_context() -> None:
name = current_app.name
... | [
"Share",
"the",
"current",
"app",
"context",
"with",
"the",
"function",
"decorated",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L229-L253 | train | 226,620 |
pgjones/quart | quart/ctx.py | copy_current_request_context | def copy_current_request_context(func: Callable) -> Callable:
"""Share the current request context with the function decorated.
The request context is local per task and hence will not be
available in any other task. This decorator can be used to make
the context available,
.. code-block:: python
@copy_current_request_context
async def within_context() -> None:
method = request.method
...
"""
if not has_request_context():
raise RuntimeError('Attempt to copy request context outside of a request context')
request_context = _request_ctx_stack.top.copy()
@wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> Any:
async with request_context:
return await func(*args, **kwargs)
return wrapper | python | def copy_current_request_context(func: Callable) -> Callable:
"""Share the current request context with the function decorated.
The request context is local per task and hence will not be
available in any other task. This decorator can be used to make
the context available,
.. code-block:: python
@copy_current_request_context
async def within_context() -> None:
method = request.method
...
"""
if not has_request_context():
raise RuntimeError('Attempt to copy request context outside of a request context')
request_context = _request_ctx_stack.top.copy()
@wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> Any:
async with request_context:
return await func(*args, **kwargs)
return wrapper | [
"def",
"copy_current_request_context",
"(",
"func",
":",
"Callable",
")",
"->",
"Callable",
":",
"if",
"not",
"has_request_context",
"(",
")",
":",
"raise",
"RuntimeError",
"(",
"'Attempt to copy request context outside of a request context'",
")",
"request_context",
"=",... | Share the current request context with the function decorated.
The request context is local per task and hence will not be
available in any other task. This decorator can be used to make
the context available,
.. code-block:: python
@copy_current_request_context
async def within_context() -> None:
method = request.method
... | [
"Share",
"the",
"current",
"request",
"context",
"with",
"the",
"function",
"decorated",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L256-L280 | train | 226,621 |
pgjones/quart | quart/ctx.py | copy_current_websocket_context | def copy_current_websocket_context(func: Callable) -> Callable:
"""Share the current websocket context with the function decorated.
The websocket context is local per task and hence will not be
available in any other task. This decorator can be used to make
the context available,
.. code-block:: python
@copy_current_websocket_context
async def within_context() -> None:
method = websocket.method
...
"""
if not has_websocket_context():
raise RuntimeError('Attempt to copy websocket context outside of a websocket context')
websocket_context = _websocket_ctx_stack.top.copy()
@wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> Any:
async with websocket_context:
return await func(*args, **kwargs)
return wrapper | python | def copy_current_websocket_context(func: Callable) -> Callable:
"""Share the current websocket context with the function decorated.
The websocket context is local per task and hence will not be
available in any other task. This decorator can be used to make
the context available,
.. code-block:: python
@copy_current_websocket_context
async def within_context() -> None:
method = websocket.method
...
"""
if not has_websocket_context():
raise RuntimeError('Attempt to copy websocket context outside of a websocket context')
websocket_context = _websocket_ctx_stack.top.copy()
@wraps(func)
async def wrapper(*args: Any, **kwargs: Any) -> Any:
async with websocket_context:
return await func(*args, **kwargs)
return wrapper | [
"def",
"copy_current_websocket_context",
"(",
"func",
":",
"Callable",
")",
"->",
"Callable",
":",
"if",
"not",
"has_websocket_context",
"(",
")",
":",
"raise",
"RuntimeError",
"(",
"'Attempt to copy websocket context outside of a websocket context'",
")",
"websocket_contex... | Share the current websocket context with the function decorated.
The websocket context is local per task and hence will not be
available in any other task. This decorator can be used to make
the context available,
.. code-block:: python
@copy_current_websocket_context
async def within_context() -> None:
method = websocket.method
... | [
"Share",
"the",
"current",
"websocket",
"context",
"with",
"the",
"function",
"decorated",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L283-L307 | train | 226,622 |
pgjones/quart | quart/ctx.py | _BaseRequestWebsocketContext.match_request | def match_request(self) -> None:
"""Match the request against the adapter.
Override this method to configure request matching, it should
set the request url_rule and view_args and optionally a
routing_exception.
"""
try:
self.request_websocket.url_rule, self.request_websocket.view_args = self.url_adapter.match() # noqa
except (NotFound, MethodNotAllowed, RedirectRequired) as error:
self.request_websocket.routing_exception = error | python | def match_request(self) -> None:
"""Match the request against the adapter.
Override this method to configure request matching, it should
set the request url_rule and view_args and optionally a
routing_exception.
"""
try:
self.request_websocket.url_rule, self.request_websocket.view_args = self.url_adapter.match() # noqa
except (NotFound, MethodNotAllowed, RedirectRequired) as error:
self.request_websocket.routing_exception = error | [
"def",
"match_request",
"(",
"self",
")",
"->",
"None",
":",
"try",
":",
"self",
".",
"request_websocket",
".",
"url_rule",
",",
"self",
".",
"request_websocket",
".",
"view_args",
"=",
"self",
".",
"url_adapter",
".",
"match",
"(",
")",
"# noqa",
"except"... | Match the request against the adapter.
Override this method to configure request matching, it should
set the request url_rule and view_args and optionally a
routing_exception. | [
"Match",
"the",
"request",
"against",
"the",
"adapter",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L37-L47 | train | 226,623 |
pgjones/quart | quart/ctx.py | _AppCtxGlobals.get | def get(self, name: str, default: Optional[Any]=None) -> Any:
"""Get a named attribute of this instance, or return the default."""
return self.__dict__.get(name, default) | python | def get(self, name: str, default: Optional[Any]=None) -> Any:
"""Get a named attribute of this instance, or return the default."""
return self.__dict__.get(name, default) | [
"def",
"get",
"(",
"self",
",",
"name",
":",
"str",
",",
"default",
":",
"Optional",
"[",
"Any",
"]",
"=",
"None",
")",
"->",
"Any",
":",
"return",
"self",
".",
"__dict__",
".",
"get",
"(",
"name",
",",
"default",
")"
] | Get a named attribute of this instance, or return the default. | [
"Get",
"a",
"named",
"attribute",
"of",
"this",
"instance",
"or",
"return",
"the",
"default",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L364-L366 | train | 226,624 |
pgjones/quart | quart/ctx.py | _AppCtxGlobals.pop | def pop(self, name: str, default: Any=_sentinel) -> Any:
"""Pop, get and remove the named attribute of this instance."""
if default is _sentinel:
return self.__dict__.pop(name)
else:
return self.__dict__.pop(name, default) | python | def pop(self, name: str, default: Any=_sentinel) -> Any:
"""Pop, get and remove the named attribute of this instance."""
if default is _sentinel:
return self.__dict__.pop(name)
else:
return self.__dict__.pop(name, default) | [
"def",
"pop",
"(",
"self",
",",
"name",
":",
"str",
",",
"default",
":",
"Any",
"=",
"_sentinel",
")",
"->",
"Any",
":",
"if",
"default",
"is",
"_sentinel",
":",
"return",
"self",
".",
"__dict__",
".",
"pop",
"(",
"name",
")",
"else",
":",
"return"... | Pop, get and remove the named attribute of this instance. | [
"Pop",
"get",
"and",
"remove",
"the",
"named",
"attribute",
"of",
"this",
"instance",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L368-L373 | train | 226,625 |
pgjones/quart | quart/ctx.py | _AppCtxGlobals.setdefault | def setdefault(self, name: str, default: Any=None) -> Any:
"""Set an attribute with a default value."""
return self.__dict__.setdefault(name, default) | python | def setdefault(self, name: str, default: Any=None) -> Any:
"""Set an attribute with a default value."""
return self.__dict__.setdefault(name, default) | [
"def",
"setdefault",
"(",
"self",
",",
"name",
":",
"str",
",",
"default",
":",
"Any",
"=",
"None",
")",
"->",
"Any",
":",
"return",
"self",
".",
"__dict__",
".",
"setdefault",
"(",
"name",
",",
"default",
")"
] | Set an attribute with a default value. | [
"Set",
"an",
"attribute",
"with",
"a",
"default",
"value",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/ctx.py#L375-L377 | train | 226,626 |
pgjones/quart | quart/sessions.py | SessionInterface.get_cookie_domain | def get_cookie_domain(self, app: 'Quart') -> Optional[str]:
"""Helper method to return the Cookie Domain for the App."""
if app.config['SESSION_COOKIE_DOMAIN'] is not None:
return app.config['SESSION_COOKIE_DOMAIN']
elif app.config['SERVER_NAME'] is not None:
return '.' + app.config['SERVER_NAME'].rsplit(':', 1)[0]
else:
return None | python | def get_cookie_domain(self, app: 'Quart') -> Optional[str]:
"""Helper method to return the Cookie Domain for the App."""
if app.config['SESSION_COOKIE_DOMAIN'] is not None:
return app.config['SESSION_COOKIE_DOMAIN']
elif app.config['SERVER_NAME'] is not None:
return '.' + app.config['SERVER_NAME'].rsplit(':', 1)[0]
else:
return None | [
"def",
"get_cookie_domain",
"(",
"self",
",",
"app",
":",
"'Quart'",
")",
"->",
"Optional",
"[",
"str",
"]",
":",
"if",
"app",
".",
"config",
"[",
"'SESSION_COOKIE_DOMAIN'",
"]",
"is",
"not",
"None",
":",
"return",
"app",
".",
"config",
"[",
"'SESSION_CO... | Helper method to return the Cookie Domain for the App. | [
"Helper",
"method",
"to",
"return",
"the",
"Cookie",
"Domain",
"for",
"the",
"App",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/sessions.py#L129-L136 | train | 226,627 |
pgjones/quart | quart/sessions.py | SessionInterface.get_expiration_time | def get_expiration_time(self, app: 'Quart', session: SessionMixin) -> Optional[datetime]:
"""Helper method to return the Session expiration time.
If the session is not 'permanent' it will expire as and when
the browser stops accessing the app.
"""
if session.permanent:
return datetime.utcnow() + app.permanent_session_lifetime
else:
return None | python | def get_expiration_time(self, app: 'Quart', session: SessionMixin) -> Optional[datetime]:
"""Helper method to return the Session expiration time.
If the session is not 'permanent' it will expire as and when
the browser stops accessing the app.
"""
if session.permanent:
return datetime.utcnow() + app.permanent_session_lifetime
else:
return None | [
"def",
"get_expiration_time",
"(",
"self",
",",
"app",
":",
"'Quart'",
",",
"session",
":",
"SessionMixin",
")",
"->",
"Optional",
"[",
"datetime",
"]",
":",
"if",
"session",
".",
"permanent",
":",
"return",
"datetime",
".",
"utcnow",
"(",
")",
"+",
"app... | Helper method to return the Session expiration time.
If the session is not 'permanent' it will expire as and when
the browser stops accessing the app. | [
"Helper",
"method",
"to",
"return",
"the",
"Session",
"expiration",
"time",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/sessions.py#L150-L159 | train | 226,628 |
pgjones/quart | quart/sessions.py | SessionInterface.should_set_cookie | def should_set_cookie(self, app: 'Quart', session: SessionMixin) -> bool:
"""Helper method to return if the Set Cookie header should be present.
This triggers if the session is marked as modified or the app
is configured to always refresh the cookie.
"""
if session.modified:
return True
save_each = app.config['SESSION_REFRESH_EACH_REQUEST']
return save_each and session.permanent | python | def should_set_cookie(self, app: 'Quart', session: SessionMixin) -> bool:
"""Helper method to return if the Set Cookie header should be present.
This triggers if the session is marked as modified or the app
is configured to always refresh the cookie.
"""
if session.modified:
return True
save_each = app.config['SESSION_REFRESH_EACH_REQUEST']
return save_each and session.permanent | [
"def",
"should_set_cookie",
"(",
"self",
",",
"app",
":",
"'Quart'",
",",
"session",
":",
"SessionMixin",
")",
"->",
"bool",
":",
"if",
"session",
".",
"modified",
":",
"return",
"True",
"save_each",
"=",
"app",
".",
"config",
"[",
"'SESSION_REFRESH_EACH_REQ... | Helper method to return if the Set Cookie header should be present.
This triggers if the session is marked as modified or the app
is configured to always refresh the cookie. | [
"Helper",
"method",
"to",
"return",
"if",
"the",
"Set",
"Cookie",
"header",
"should",
"be",
"present",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/sessions.py#L161-L170 | train | 226,629 |
pgjones/quart | quart/sessions.py | SecureCookieSessionInterface.get_signing_serializer | def get_signing_serializer(self, app: 'Quart') -> Optional[URLSafeTimedSerializer]:
"""Return a serializer for the session that also signs data.
This will return None if the app is not configured for secrets.
"""
if not app.secret_key:
return None
options = {
'key_derivation': self.key_derivation,
'digest_method': self.digest_method,
}
return URLSafeTimedSerializer(
app.secret_key, salt=self.salt, serializer=self.serializer, signer_kwargs=options,
) | python | def get_signing_serializer(self, app: 'Quart') -> Optional[URLSafeTimedSerializer]:
"""Return a serializer for the session that also signs data.
This will return None if the app is not configured for secrets.
"""
if not app.secret_key:
return None
options = {
'key_derivation': self.key_derivation,
'digest_method': self.digest_method,
}
return URLSafeTimedSerializer(
app.secret_key, salt=self.salt, serializer=self.serializer, signer_kwargs=options,
) | [
"def",
"get_signing_serializer",
"(",
"self",
",",
"app",
":",
"'Quart'",
")",
"->",
"Optional",
"[",
"URLSafeTimedSerializer",
"]",
":",
"if",
"not",
"app",
".",
"secret_key",
":",
"return",
"None",
"options",
"=",
"{",
"'key_derivation'",
":",
"self",
".",... | Return a serializer for the session that also signs data.
This will return None if the app is not configured for secrets. | [
"Return",
"a",
"serializer",
"for",
"the",
"session",
"that",
"also",
"signs",
"data",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/sessions.py#L204-L218 | train | 226,630 |
pgjones/quart | quart/sessions.py | SecureCookieSessionInterface.open_session | async def open_session(
self,
app: 'Quart',
request: BaseRequestWebsocket,
) -> Optional[SecureCookieSession]:
"""Open a secure cookie based session.
This will return None if a signing serializer is not availabe,
usually if the config SECRET_KEY is not set.
"""
signer = self.get_signing_serializer(app)
if signer is None:
return None
cookie = request.cookies.get(app.session_cookie_name)
if cookie is None:
return self.session_class()
try:
data = signer.loads(
cookie, max_age=app.permanent_session_lifetime.total_seconds(),
)
return self.session_class(**data)
except BadSignature:
return self.session_class() | python | async def open_session(
self,
app: 'Quart',
request: BaseRequestWebsocket,
) -> Optional[SecureCookieSession]:
"""Open a secure cookie based session.
This will return None if a signing serializer is not availabe,
usually if the config SECRET_KEY is not set.
"""
signer = self.get_signing_serializer(app)
if signer is None:
return None
cookie = request.cookies.get(app.session_cookie_name)
if cookie is None:
return self.session_class()
try:
data = signer.loads(
cookie, max_age=app.permanent_session_lifetime.total_seconds(),
)
return self.session_class(**data)
except BadSignature:
return self.session_class() | [
"async",
"def",
"open_session",
"(",
"self",
",",
"app",
":",
"'Quart'",
",",
"request",
":",
"BaseRequestWebsocket",
",",
")",
"->",
"Optional",
"[",
"SecureCookieSession",
"]",
":",
"signer",
"=",
"self",
".",
"get_signing_serializer",
"(",
"app",
")",
"if... | Open a secure cookie based session.
This will return None if a signing serializer is not availabe,
usually if the config SECRET_KEY is not set. | [
"Open",
"a",
"secure",
"cookie",
"based",
"session",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/sessions.py#L220-L243 | train | 226,631 |
pgjones/quart | quart/sessions.py | SecureCookieSessionInterface.save_session | async def save_session( # type: ignore
self, app: 'Quart', session: SecureCookieSession, response: Response,
) -> None:
"""Saves the session to the response in a secure cookie."""
domain = self.get_cookie_domain(app)
path = self.get_cookie_path(app)
if not session:
if session.modified:
response.delete_cookie(app.session_cookie_name, domain=domain, path=path)
return
if session.accessed:
response.vary.add('Cookie')
if not self.should_set_cookie(app, session):
return
data = self.get_signing_serializer(app).dumps(dict(session))
response.set_cookie(
app.session_cookie_name,
data,
expires=self.get_expiration_time(app, session),
httponly=self.get_cookie_httponly(app),
domain=domain,
path=path,
secure=self.get_cookie_secure(app),
) | python | async def save_session( # type: ignore
self, app: 'Quart', session: SecureCookieSession, response: Response,
) -> None:
"""Saves the session to the response in a secure cookie."""
domain = self.get_cookie_domain(app)
path = self.get_cookie_path(app)
if not session:
if session.modified:
response.delete_cookie(app.session_cookie_name, domain=domain, path=path)
return
if session.accessed:
response.vary.add('Cookie')
if not self.should_set_cookie(app, session):
return
data = self.get_signing_serializer(app).dumps(dict(session))
response.set_cookie(
app.session_cookie_name,
data,
expires=self.get_expiration_time(app, session),
httponly=self.get_cookie_httponly(app),
domain=domain,
path=path,
secure=self.get_cookie_secure(app),
) | [
"async",
"def",
"save_session",
"(",
"# type: ignore",
"self",
",",
"app",
":",
"'Quart'",
",",
"session",
":",
"SecureCookieSession",
",",
"response",
":",
"Response",
",",
")",
"->",
"None",
":",
"domain",
"=",
"self",
".",
"get_cookie_domain",
"(",
"app",... | Saves the session to the response in a secure cookie. | [
"Saves",
"the",
"session",
"to",
"the",
"response",
"in",
"a",
"secure",
"cookie",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/sessions.py#L245-L271 | train | 226,632 |
pgjones/quart | quart/wrappers/response.py | Response.get_data | async def get_data(self, raw: bool=True) -> AnyStr:
"""Return the body data."""
if self.implicit_sequence_conversion:
self.response = self.data_body_class(await self.response.convert_to_sequence())
result = b'' if raw else ''
async with self.response as body: # type: ignore
async for data in body:
if raw:
result += data
else:
result += data.decode(self.charset)
return result | python | async def get_data(self, raw: bool=True) -> AnyStr:
"""Return the body data."""
if self.implicit_sequence_conversion:
self.response = self.data_body_class(await self.response.convert_to_sequence())
result = b'' if raw else ''
async with self.response as body: # type: ignore
async for data in body:
if raw:
result += data
else:
result += data.decode(self.charset)
return result | [
"async",
"def",
"get_data",
"(",
"self",
",",
"raw",
":",
"bool",
"=",
"True",
")",
"->",
"AnyStr",
":",
"if",
"self",
".",
"implicit_sequence_conversion",
":",
"self",
".",
"response",
"=",
"self",
".",
"data_body_class",
"(",
"await",
"self",
".",
"res... | Return the body data. | [
"Return",
"the",
"body",
"data",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/response.py#L272-L283 | train | 226,633 |
pgjones/quart | quart/wrappers/response.py | Response.set_data | def set_data(self, data: AnyStr) -> None:
"""Set the response data.
This will encode using the :attr:`charset`.
"""
if isinstance(data, str):
bytes_data = data.encode(self.charset)
else:
bytes_data = data
self.response = self.data_body_class(bytes_data)
if self.automatically_set_content_length:
self.content_length = len(bytes_data) | python | def set_data(self, data: AnyStr) -> None:
"""Set the response data.
This will encode using the :attr:`charset`.
"""
if isinstance(data, str):
bytes_data = data.encode(self.charset)
else:
bytes_data = data
self.response = self.data_body_class(bytes_data)
if self.automatically_set_content_length:
self.content_length = len(bytes_data) | [
"def",
"set_data",
"(",
"self",
",",
"data",
":",
"AnyStr",
")",
"->",
"None",
":",
"if",
"isinstance",
"(",
"data",
",",
"str",
")",
":",
"bytes_data",
"=",
"data",
".",
"encode",
"(",
"self",
".",
"charset",
")",
"else",
":",
"bytes_data",
"=",
"... | Set the response data.
This will encode using the :attr:`charset`. | [
"Set",
"the",
"response",
"data",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/response.py#L285-L296 | train | 226,634 |
pgjones/quart | quart/wrappers/response.py | Response.make_conditional | async def make_conditional(
self,
request_range: Range,
max_partial_size: Optional[int]=None,
) -> None:
"""Make the response conditional to the
Arguments:
request_range: The range as requested by the request.
max_partial_size: The maximum length the server is willing
to serve in a single response. Defaults to unlimited.
"""
self.accept_ranges = "bytes" # Advertise this ability
if len(request_range.ranges) == 0: # Not a conditional request
return
if request_range.units != "bytes" or len(request_range.ranges) > 1:
from ..exceptions import RequestRangeNotSatisfiable
raise RequestRangeNotSatisfiable()
begin, end = request_range.ranges[0]
try:
complete_length = await self.response.make_conditional( # type: ignore
begin, end, max_partial_size,
)
except AttributeError:
self.response = self.data_body_class(await self.response.convert_to_sequence())
return await self.make_conditional(request_range, max_partial_size)
else:
self.content_length = self.response.end - self.response.begin # type: ignore
if self.content_length != complete_length:
self.content_range = ContentRange(
request_range.units,
self.response.begin, self.response.end - 1, # type: ignore
complete_length,
)
self.status_code = 206 | python | async def make_conditional(
self,
request_range: Range,
max_partial_size: Optional[int]=None,
) -> None:
"""Make the response conditional to the
Arguments:
request_range: The range as requested by the request.
max_partial_size: The maximum length the server is willing
to serve in a single response. Defaults to unlimited.
"""
self.accept_ranges = "bytes" # Advertise this ability
if len(request_range.ranges) == 0: # Not a conditional request
return
if request_range.units != "bytes" or len(request_range.ranges) > 1:
from ..exceptions import RequestRangeNotSatisfiable
raise RequestRangeNotSatisfiable()
begin, end = request_range.ranges[0]
try:
complete_length = await self.response.make_conditional( # type: ignore
begin, end, max_partial_size,
)
except AttributeError:
self.response = self.data_body_class(await self.response.convert_to_sequence())
return await self.make_conditional(request_range, max_partial_size)
else:
self.content_length = self.response.end - self.response.begin # type: ignore
if self.content_length != complete_length:
self.content_range = ContentRange(
request_range.units,
self.response.begin, self.response.end - 1, # type: ignore
complete_length,
)
self.status_code = 206 | [
"async",
"def",
"make_conditional",
"(",
"self",
",",
"request_range",
":",
"Range",
",",
"max_partial_size",
":",
"Optional",
"[",
"int",
"]",
"=",
"None",
",",
")",
"->",
"None",
":",
"self",
".",
"accept_ranges",
"=",
"\"bytes\"",
"# Advertise this ability"... | Make the response conditional to the
Arguments:
request_range: The range as requested by the request.
max_partial_size: The maximum length the server is willing
to serve in a single response. Defaults to unlimited. | [
"Make",
"the",
"response",
"conditional",
"to",
"the"
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/response.py#L298-L335 | train | 226,635 |
pgjones/quart | quart/wrappers/response.py | Response.set_cookie | def set_cookie( # type: ignore
self,
key: str,
value: AnyStr='',
max_age: Optional[Union[int, timedelta]]=None,
expires: Optional[datetime]=None,
path: str='/',
domain: Optional[str]=None,
secure: bool=False,
httponly: bool=False,
) -> None:
"""Set a cookie in the response headers.
The arguments are the standard cookie morsels and this is a
wrapper around the stdlib SimpleCookie code.
"""
if isinstance(value, bytes):
value = value.decode() # type: ignore
cookie = create_cookie(key, value, max_age, expires, path, domain, secure, httponly) # type: ignore # noqa: E501
self.headers.add('Set-Cookie', cookie.output(header='')) | python | def set_cookie( # type: ignore
self,
key: str,
value: AnyStr='',
max_age: Optional[Union[int, timedelta]]=None,
expires: Optional[datetime]=None,
path: str='/',
domain: Optional[str]=None,
secure: bool=False,
httponly: bool=False,
) -> None:
"""Set a cookie in the response headers.
The arguments are the standard cookie morsels and this is a
wrapper around the stdlib SimpleCookie code.
"""
if isinstance(value, bytes):
value = value.decode() # type: ignore
cookie = create_cookie(key, value, max_age, expires, path, domain, secure, httponly) # type: ignore # noqa: E501
self.headers.add('Set-Cookie', cookie.output(header='')) | [
"def",
"set_cookie",
"(",
"# type: ignore",
"self",
",",
"key",
":",
"str",
",",
"value",
":",
"AnyStr",
"=",
"''",
",",
"max_age",
":",
"Optional",
"[",
"Union",
"[",
"int",
",",
"timedelta",
"]",
"]",
"=",
"None",
",",
"expires",
":",
"Optional",
"... | Set a cookie in the response headers.
The arguments are the standard cookie morsels and this is a
wrapper around the stdlib SimpleCookie code. | [
"Set",
"a",
"cookie",
"in",
"the",
"response",
"headers",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/response.py#L341-L360 | train | 226,636 |
pgjones/quart | quart/routing.py | Rule.match | def match(self, path: str) -> Tuple[Optional[Dict[str, Any]], bool]:
"""Check if the path matches this Rule.
If it does it returns a dict of matched and converted values,
otherwise None is returned.
"""
match = self._pattern.match(path)
if match is not None:
# If the route is a branch (not leaf) and the path is
# missing a trailing slash then it needs one to be
# considered a match in the strict slashes mode.
needs_slash = (
self.strict_slashes and not self.is_leaf and match.groupdict()['__slash__'] != '/'
)
try:
converted_varaibles = {
name: self._converters[name].to_python(value)
for name, value in match.groupdict().items()
if name != '__slash__'
}
except ValidationError: # Doesn't meet conversion rules, no match
return None, False
else:
return {**self.defaults, **converted_varaibles}, needs_slash
else:
return None, False | python | def match(self, path: str) -> Tuple[Optional[Dict[str, Any]], bool]:
"""Check if the path matches this Rule.
If it does it returns a dict of matched and converted values,
otherwise None is returned.
"""
match = self._pattern.match(path)
if match is not None:
# If the route is a branch (not leaf) and the path is
# missing a trailing slash then it needs one to be
# considered a match in the strict slashes mode.
needs_slash = (
self.strict_slashes and not self.is_leaf and match.groupdict()['__slash__'] != '/'
)
try:
converted_varaibles = {
name: self._converters[name].to_python(value)
for name, value in match.groupdict().items()
if name != '__slash__'
}
except ValidationError: # Doesn't meet conversion rules, no match
return None, False
else:
return {**self.defaults, **converted_varaibles}, needs_slash
else:
return None, False | [
"def",
"match",
"(",
"self",
",",
"path",
":",
"str",
")",
"->",
"Tuple",
"[",
"Optional",
"[",
"Dict",
"[",
"str",
",",
"Any",
"]",
"]",
",",
"bool",
"]",
":",
"match",
"=",
"self",
".",
"_pattern",
".",
"match",
"(",
"path",
")",
"if",
"match... | Check if the path matches this Rule.
If it does it returns a dict of matched and converted values,
otherwise None is returned. | [
"Check",
"if",
"the",
"path",
"matches",
"this",
"Rule",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/routing.py#L335-L360 | train | 226,637 |
pgjones/quart | quart/routing.py | Rule.provides_defaults_for | def provides_defaults_for(self, rule: 'Rule', **values: Any) -> bool:
"""Returns true if this rule provides defaults for the argument and values."""
defaults_match = all(
values[key] == self.defaults[key] for key in self.defaults if key in values # noqa: S101, E501
)
return self != rule and bool(self.defaults) and defaults_match | python | def provides_defaults_for(self, rule: 'Rule', **values: Any) -> bool:
"""Returns true if this rule provides defaults for the argument and values."""
defaults_match = all(
values[key] == self.defaults[key] for key in self.defaults if key in values # noqa: S101, E501
)
return self != rule and bool(self.defaults) and defaults_match | [
"def",
"provides_defaults_for",
"(",
"self",
",",
"rule",
":",
"'Rule'",
",",
"*",
"*",
"values",
":",
"Any",
")",
"->",
"bool",
":",
"defaults_match",
"=",
"all",
"(",
"values",
"[",
"key",
"]",
"==",
"self",
".",
"defaults",
"[",
"key",
"]",
"for",... | Returns true if this rule provides defaults for the argument and values. | [
"Returns",
"true",
"if",
"this",
"rule",
"provides",
"defaults",
"for",
"the",
"argument",
"and",
"values",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/routing.py#L362-L367 | train | 226,638 |
pgjones/quart | quart/routing.py | Rule.build | def build(self, **values: Any) -> str:
"""Build this rule into a path using the values given."""
converted_values = {
key: self._converters[key].to_url(value)
for key, value in values.items()
if key in self._converters
}
result = self._builder.format(**converted_values).split('|', 1)[1]
query_string = urlencode(
{
key: value
for key, value in values.items()
if key not in self._converters and key not in self.defaults
},
doseq=True,
)
if query_string:
result = "{}?{}".format(result, query_string)
return result | python | def build(self, **values: Any) -> str:
"""Build this rule into a path using the values given."""
converted_values = {
key: self._converters[key].to_url(value)
for key, value in values.items()
if key in self._converters
}
result = self._builder.format(**converted_values).split('|', 1)[1]
query_string = urlencode(
{
key: value
for key, value in values.items()
if key not in self._converters and key not in self.defaults
},
doseq=True,
)
if query_string:
result = "{}?{}".format(result, query_string)
return result | [
"def",
"build",
"(",
"self",
",",
"*",
"*",
"values",
":",
"Any",
")",
"->",
"str",
":",
"converted_values",
"=",
"{",
"key",
":",
"self",
".",
"_converters",
"[",
"key",
"]",
".",
"to_url",
"(",
"value",
")",
"for",
"key",
",",
"value",
"in",
"v... | Build this rule into a path using the values given. | [
"Build",
"this",
"rule",
"into",
"a",
"path",
"using",
"the",
"values",
"given",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/routing.py#L369-L387 | train | 226,639 |
pgjones/quart | quart/routing.py | Rule.buildable | def buildable(self, values: Optional[dict]=None, method: Optional[str]=None) -> bool:
"""Return True if this rule can build with the values and method."""
if method is not None and method not in self.methods:
return False
defaults_match = all(
values[key] == self.defaults[key] for key in self.defaults if key in values # noqa: S101, E501
)
return defaults_match and set(values.keys()) >= set(self._converters.keys()) | python | def buildable(self, values: Optional[dict]=None, method: Optional[str]=None) -> bool:
"""Return True if this rule can build with the values and method."""
if method is not None and method not in self.methods:
return False
defaults_match = all(
values[key] == self.defaults[key] for key in self.defaults if key in values # noqa: S101, E501
)
return defaults_match and set(values.keys()) >= set(self._converters.keys()) | [
"def",
"buildable",
"(",
"self",
",",
"values",
":",
"Optional",
"[",
"dict",
"]",
"=",
"None",
",",
"method",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
")",
"->",
"bool",
":",
"if",
"method",
"is",
"not",
"None",
"and",
"method",
"not",
"in",... | Return True if this rule can build with the values and method. | [
"Return",
"True",
"if",
"this",
"rule",
"can",
"build",
"with",
"the",
"values",
"and",
"method",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/routing.py#L389-L396 | train | 226,640 |
pgjones/quart | quart/routing.py | Rule.bind | def bind(self, map: Map) -> None:
"""Bind the Rule to a Map and compile it."""
if self.map is not None:
raise RuntimeError(f"{self!r} is already bound to {self.map!r}")
self.map = map
pattern = ''
builder = ''
full_rule = "{}\\|{}".format(self.host or '', self.rule)
for part in _parse_rule(full_rule):
if isinstance(part, VariablePart):
converter = self.map.converters[part.converter](
*part.arguments[0], **part.arguments[1],
)
pattern += f"(?P<{part.name}>{converter.regex})"
self._converters[part.name] = converter
builder += '{' + part.name + '}'
self._weights.append(WeightedPart(True, converter.weight))
else:
builder += part
pattern += part
self._weights.append(WeightedPart(False, -len(part)))
if not self.is_leaf or not self.strict_slashes:
# Pattern should match with or without a trailing slash
pattern = f"{pattern.rstrip('/')}(?<!/)(?P<__slash__>/?)$"
else:
pattern = f"{pattern}$"
self._pattern = re.compile(pattern)
self._builder = builder | python | def bind(self, map: Map) -> None:
"""Bind the Rule to a Map and compile it."""
if self.map is not None:
raise RuntimeError(f"{self!r} is already bound to {self.map!r}")
self.map = map
pattern = ''
builder = ''
full_rule = "{}\\|{}".format(self.host or '', self.rule)
for part in _parse_rule(full_rule):
if isinstance(part, VariablePart):
converter = self.map.converters[part.converter](
*part.arguments[0], **part.arguments[1],
)
pattern += f"(?P<{part.name}>{converter.regex})"
self._converters[part.name] = converter
builder += '{' + part.name + '}'
self._weights.append(WeightedPart(True, converter.weight))
else:
builder += part
pattern += part
self._weights.append(WeightedPart(False, -len(part)))
if not self.is_leaf or not self.strict_slashes:
# Pattern should match with or without a trailing slash
pattern = f"{pattern.rstrip('/')}(?<!/)(?P<__slash__>/?)$"
else:
pattern = f"{pattern}$"
self._pattern = re.compile(pattern)
self._builder = builder | [
"def",
"bind",
"(",
"self",
",",
"map",
":",
"Map",
")",
"->",
"None",
":",
"if",
"self",
".",
"map",
"is",
"not",
"None",
":",
"raise",
"RuntimeError",
"(",
"f\"{self!r} is already bound to {self.map!r}\"",
")",
"self",
".",
"map",
"=",
"map",
"pattern",
... | Bind the Rule to a Map and compile it. | [
"Bind",
"the",
"Rule",
"to",
"a",
"Map",
"and",
"compile",
"it",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/routing.py#L398-L427 | train | 226,641 |
pgjones/quart | quart/routing.py | Rule.match_key | def match_key(self) -> Tuple[bool, bool, int, List[WeightedPart]]:
"""A Key to sort the rules by weight for matching.
The key leads to ordering:
- By first order by defaults as they are simple rules without
conversions.
- Then on the complexity of the rule, i.e. does it have any
converted parts. This is as simple rules are quick to match
or reject.
- Then by the number of parts, with more complex (more parts)
first.
- Finally by the weights themselves. Note that weights are also
sub keyed by converter first then weight second.
"""
if self.map is None:
raise RuntimeError(f"{self!r} is not bound to a Map")
complex_rule = any(weight.converter for weight in self._weights)
return (not bool(self.defaults), complex_rule, -len(self._weights), self._weights) | python | def match_key(self) -> Tuple[bool, bool, int, List[WeightedPart]]:
"""A Key to sort the rules by weight for matching.
The key leads to ordering:
- By first order by defaults as they are simple rules without
conversions.
- Then on the complexity of the rule, i.e. does it have any
converted parts. This is as simple rules are quick to match
or reject.
- Then by the number of parts, with more complex (more parts)
first.
- Finally by the weights themselves. Note that weights are also
sub keyed by converter first then weight second.
"""
if self.map is None:
raise RuntimeError(f"{self!r} is not bound to a Map")
complex_rule = any(weight.converter for weight in self._weights)
return (not bool(self.defaults), complex_rule, -len(self._weights), self._weights) | [
"def",
"match_key",
"(",
"self",
")",
"->",
"Tuple",
"[",
"bool",
",",
"bool",
",",
"int",
",",
"List",
"[",
"WeightedPart",
"]",
"]",
":",
"if",
"self",
".",
"map",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"f\"{self!r} is not bound to a Map\"",
... | A Key to sort the rules by weight for matching.
The key leads to ordering:
- By first order by defaults as they are simple rules without
conversions.
- Then on the complexity of the rule, i.e. does it have any
converted parts. This is as simple rules are quick to match
or reject.
- Then by the number of parts, with more complex (more parts)
first.
- Finally by the weights themselves. Note that weights are also
sub keyed by converter first then weight second. | [
"A",
"Key",
"to",
"sort",
"the",
"rules",
"by",
"weight",
"for",
"matching",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/routing.py#L430-L448 | train | 226,642 |
pgjones/quart | quart/routing.py | Rule.build_key | def build_key(self) -> Tuple[bool, int]:
"""A Key to sort the rules by weight for building.
The key leads to ordering:
- By routes with defaults first, as these must be evaulated
for building before ones without.
- Then the more complex routes (most converted parts).
"""
if self.map is None:
raise RuntimeError(f"{self!r} is not bound to a Map")
return (not bool(self.defaults), -sum(1 for weight in self._weights if weight.converter)) | python | def build_key(self) -> Tuple[bool, int]:
"""A Key to sort the rules by weight for building.
The key leads to ordering:
- By routes with defaults first, as these must be evaulated
for building before ones without.
- Then the more complex routes (most converted parts).
"""
if self.map is None:
raise RuntimeError(f"{self!r} is not bound to a Map")
return (not bool(self.defaults), -sum(1 for weight in self._weights if weight.converter)) | [
"def",
"build_key",
"(",
"self",
")",
"->",
"Tuple",
"[",
"bool",
",",
"int",
"]",
":",
"if",
"self",
".",
"map",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"f\"{self!r} is not bound to a Map\"",
")",
"return",
"(",
"not",
"bool",
"(",
"self",
".",... | A Key to sort the rules by weight for building.
The key leads to ordering:
- By routes with defaults first, as these must be evaulated
for building before ones without.
- Then the more complex routes (most converted parts). | [
"A",
"Key",
"to",
"sort",
"the",
"rules",
"by",
"weight",
"for",
"building",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/routing.py#L451-L462 | train | 226,643 |
pgjones/quart | examples/http2_push/http2_push.py | get_tile | def get_tile(tile_number):
"""
Returns a crop of `img` based on a sequence number `tile_number`.
:param int tile_number: Number of the tile between 0 and `max_tiles`^2.
:raises TileOutOfBoundsError: When `tile_number` exceeds `max_tiles`^2
:rtype PIL.Image:
"""
tile_number = int(tile_number)
max_tiles = app.max_tiles
if tile_number > max_tiles * max_tiles:
raise TileOutOfBoundsError('Requested an out of bounds tile')
tile_size = Point(
app.img.size[0] // max_tiles, app.img.size[1] // max_tiles)
tile_coords = Point(
tile_number % max_tiles, tile_number // max_tiles)
crop_box = (
tile_coords.x * tile_size.x,
tile_coords.y * tile_size.y,
tile_coords.x * tile_size.x + tile_size.x,
tile_coords.y * tile_size.y + tile_size.y,
)
return app.img.crop(crop_box) | python | def get_tile(tile_number):
"""
Returns a crop of `img` based on a sequence number `tile_number`.
:param int tile_number: Number of the tile between 0 and `max_tiles`^2.
:raises TileOutOfBoundsError: When `tile_number` exceeds `max_tiles`^2
:rtype PIL.Image:
"""
tile_number = int(tile_number)
max_tiles = app.max_tiles
if tile_number > max_tiles * max_tiles:
raise TileOutOfBoundsError('Requested an out of bounds tile')
tile_size = Point(
app.img.size[0] // max_tiles, app.img.size[1] // max_tiles)
tile_coords = Point(
tile_number % max_tiles, tile_number // max_tiles)
crop_box = (
tile_coords.x * tile_size.x,
tile_coords.y * tile_size.y,
tile_coords.x * tile_size.x + tile_size.x,
tile_coords.y * tile_size.y + tile_size.y,
)
return app.img.crop(crop_box) | [
"def",
"get_tile",
"(",
"tile_number",
")",
":",
"tile_number",
"=",
"int",
"(",
"tile_number",
")",
"max_tiles",
"=",
"app",
".",
"max_tiles",
"if",
"tile_number",
">",
"max_tiles",
"*",
"max_tiles",
":",
"raise",
"TileOutOfBoundsError",
"(",
"'Requested an out... | Returns a crop of `img` based on a sequence number `tile_number`.
:param int tile_number: Number of the tile between 0 and `max_tiles`^2.
:raises TileOutOfBoundsError: When `tile_number` exceeds `max_tiles`^2
:rtype PIL.Image: | [
"Returns",
"a",
"crop",
"of",
"img",
"based",
"on",
"a",
"sequence",
"number",
"tile_number",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/examples/http2_push/http2_push.py#L21-L44 | train | 226,644 |
pgjones/quart | examples/http2_push/http2_push.py | tile | async def tile(tile_number):
"""
Handles GET requests for a tile number.
:param int tile_number: Number of the tile between 0 and `max_tiles`^2.
:raises HTTPError: 404 if tile exceeds `max_tiles`^2.
"""
try:
tile = get_tile(tile_number)
except TileOutOfBoundsError:
abort(404)
buf = BytesIO(tile.tobytes())
tile.save(buf, 'JPEG')
content = buf.getvalue()
response = await make_response(content)
response.headers['Content-Type'] = 'image/jpg'
response.headers['Accept-Ranges'] = 'bytes'
response.headers['Content-Length'] = str(len(content))
return response | python | async def tile(tile_number):
"""
Handles GET requests for a tile number.
:param int tile_number: Number of the tile between 0 and `max_tiles`^2.
:raises HTTPError: 404 if tile exceeds `max_tiles`^2.
"""
try:
tile = get_tile(tile_number)
except TileOutOfBoundsError:
abort(404)
buf = BytesIO(tile.tobytes())
tile.save(buf, 'JPEG')
content = buf.getvalue()
response = await make_response(content)
response.headers['Content-Type'] = 'image/jpg'
response.headers['Accept-Ranges'] = 'bytes'
response.headers['Content-Length'] = str(len(content))
return response | [
"async",
"def",
"tile",
"(",
"tile_number",
")",
":",
"try",
":",
"tile",
"=",
"get_tile",
"(",
"tile_number",
")",
"except",
"TileOutOfBoundsError",
":",
"abort",
"(",
"404",
")",
"buf",
"=",
"BytesIO",
"(",
"tile",
".",
"tobytes",
"(",
")",
")",
"til... | Handles GET requests for a tile number.
:param int tile_number: Number of the tile between 0 and `max_tiles`^2.
:raises HTTPError: 404 if tile exceeds `max_tiles`^2. | [
"Handles",
"GET",
"requests",
"for",
"a",
"tile",
"number",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/examples/http2_push/http2_push.py#L66-L86 | train | 226,645 |
pgjones/quart | quart/wrappers/_base.py | JSONMixin.is_json | def is_json(self) -> bool:
"""Returns True if the content_type is json like."""
content_type = self.mimetype
if content_type == 'application/json' or (
content_type.startswith('application/') and content_type.endswith('+json')
):
return True
else:
return False | python | def is_json(self) -> bool:
"""Returns True if the content_type is json like."""
content_type = self.mimetype
if content_type == 'application/json' or (
content_type.startswith('application/') and content_type.endswith('+json')
):
return True
else:
return False | [
"def",
"is_json",
"(",
"self",
")",
"->",
"bool",
":",
"content_type",
"=",
"self",
".",
"mimetype",
"if",
"content_type",
"==",
"'application/json'",
"or",
"(",
"content_type",
".",
"startswith",
"(",
"'application/'",
")",
"and",
"content_type",
".",
"endswi... | Returns True if the content_type is json like. | [
"Returns",
"True",
"if",
"the",
"content_type",
"is",
"json",
"like",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/_base.py#L40-L48 | train | 226,646 |
pgjones/quart | quart/wrappers/_base.py | JSONMixin.get_json | async def get_json(
self, force: bool=False, silent: bool=False, cache: bool=True,
) -> Any:
"""Parses the body data as JSON and returns it.
Arguments:
force: Force JSON parsing even if the mimetype is not JSON.
silent: Do not trigger error handling if parsing fails, without
this the :meth:`on_json_loading_failed` will be called on
error.
cache: Cache the parsed JSON on this request object.
"""
if cache and self._cached_json is not sentinel:
return self._cached_json
if not (force or self.is_json):
return None
data = await self._load_json_data()
try:
result = loads(data)
except ValueError as error:
if silent:
result = None
else:
self.on_json_loading_failed(error)
if cache:
self._cached_json = result
return result | python | async def get_json(
self, force: bool=False, silent: bool=False, cache: bool=True,
) -> Any:
"""Parses the body data as JSON and returns it.
Arguments:
force: Force JSON parsing even if the mimetype is not JSON.
silent: Do not trigger error handling if parsing fails, without
this the :meth:`on_json_loading_failed` will be called on
error.
cache: Cache the parsed JSON on this request object.
"""
if cache and self._cached_json is not sentinel:
return self._cached_json
if not (force or self.is_json):
return None
data = await self._load_json_data()
try:
result = loads(data)
except ValueError as error:
if silent:
result = None
else:
self.on_json_loading_failed(error)
if cache:
self._cached_json = result
return result | [
"async",
"def",
"get_json",
"(",
"self",
",",
"force",
":",
"bool",
"=",
"False",
",",
"silent",
":",
"bool",
"=",
"False",
",",
"cache",
":",
"bool",
"=",
"True",
",",
")",
"->",
"Any",
":",
"if",
"cache",
"and",
"self",
".",
"_cached_json",
"is",... | Parses the body data as JSON and returns it.
Arguments:
force: Force JSON parsing even if the mimetype is not JSON.
silent: Do not trigger error handling if parsing fails, without
this the :meth:`on_json_loading_failed` will be called on
error.
cache: Cache the parsed JSON on this request object. | [
"Parses",
"the",
"body",
"data",
"as",
"JSON",
"and",
"returns",
"it",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/_base.py#L54-L82 | train | 226,647 |
pgjones/quart | quart/wrappers/_base.py | _BaseRequestResponse.mimetype | def mimetype(self, value: str) -> None:
"""Set the mimetype to the value."""
if (
value.startswith('text/') or value == 'application/xml' or
(value.startswith('application/') and value.endswith('+xml'))
):
mimetype = f"{value}; charset={self.charset}"
else:
mimetype = value
self.headers['Content-Type'] = mimetype | python | def mimetype(self, value: str) -> None:
"""Set the mimetype to the value."""
if (
value.startswith('text/') or value == 'application/xml' or
(value.startswith('application/') and value.endswith('+xml'))
):
mimetype = f"{value}; charset={self.charset}"
else:
mimetype = value
self.headers['Content-Type'] = mimetype | [
"def",
"mimetype",
"(",
"self",
",",
"value",
":",
"str",
")",
"->",
"None",
":",
"if",
"(",
"value",
".",
"startswith",
"(",
"'text/'",
")",
"or",
"value",
"==",
"'application/xml'",
"or",
"(",
"value",
".",
"startswith",
"(",
"'application/'",
")",
"... | Set the mimetype to the value. | [
"Set",
"the",
"mimetype",
"to",
"the",
"value",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/_base.py#L117-L126 | train | 226,648 |
pgjones/quart | quart/wrappers/_base.py | BaseRequestWebsocket.blueprint | def blueprint(self) -> Optional[str]:
"""Returns the blueprint the matched endpoint belongs to.
This can be None if the request has not been matched or the
endpoint is not in a blueprint.
"""
if self.endpoint is not None and '.' in self.endpoint:
return self.endpoint.rsplit('.', 1)[0]
else:
return None | python | def blueprint(self) -> Optional[str]:
"""Returns the blueprint the matched endpoint belongs to.
This can be None if the request has not been matched or the
endpoint is not in a blueprint.
"""
if self.endpoint is not None and '.' in self.endpoint:
return self.endpoint.rsplit('.', 1)[0]
else:
return None | [
"def",
"blueprint",
"(",
"self",
")",
"->",
"Optional",
"[",
"str",
"]",
":",
"if",
"self",
".",
"endpoint",
"is",
"not",
"None",
"and",
"'.'",
"in",
"self",
".",
"endpoint",
":",
"return",
"self",
".",
"endpoint",
".",
"rsplit",
"(",
"'.'",
",",
"... | Returns the blueprint the matched endpoint belongs to.
This can be None if the request has not been matched or the
endpoint is not in a blueprint. | [
"Returns",
"the",
"blueprint",
"the",
"matched",
"endpoint",
"belongs",
"to",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/_base.py#L195-L204 | train | 226,649 |
pgjones/quart | quart/wrappers/_base.py | BaseRequestWebsocket.base_url | def base_url(self) -> str:
"""Returns the base url without query string or fragments."""
return urlunparse(ParseResult(self.scheme, self.host, self.path, '', '', '')) | python | def base_url(self) -> str:
"""Returns the base url without query string or fragments."""
return urlunparse(ParseResult(self.scheme, self.host, self.path, '', '', '')) | [
"def",
"base_url",
"(",
"self",
")",
"->",
"str",
":",
"return",
"urlunparse",
"(",
"ParseResult",
"(",
"self",
".",
"scheme",
",",
"self",
".",
"host",
",",
"self",
".",
"path",
",",
"''",
",",
"''",
",",
"''",
")",
")"
] | Returns the base url without query string or fragments. | [
"Returns",
"the",
"base",
"url",
"without",
"query",
"string",
"or",
"fragments",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/_base.py#L266-L268 | train | 226,650 |
pgjones/quart | quart/wrappers/_base.py | BaseRequestWebsocket.url | def url(self) -> str:
"""Returns the full url requested."""
return urlunparse(
ParseResult(
self.scheme, self.host, self.path, '', self.query_string.decode('ascii'), '',
),
) | python | def url(self) -> str:
"""Returns the full url requested."""
return urlunparse(
ParseResult(
self.scheme, self.host, self.path, '', self.query_string.decode('ascii'), '',
),
) | [
"def",
"url",
"(",
"self",
")",
"->",
"str",
":",
"return",
"urlunparse",
"(",
"ParseResult",
"(",
"self",
".",
"scheme",
",",
"self",
".",
"host",
",",
"self",
".",
"path",
",",
"''",
",",
"self",
".",
"query_string",
".",
"decode",
"(",
"'ascii'",
... | Returns the full url requested. | [
"Returns",
"the",
"full",
"url",
"requested",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/_base.py#L286-L292 | train | 226,651 |
pgjones/quart | quart/wrappers/_base.py | BaseRequestWebsocket.cookies | def cookies(self) -> Dict[str, str]:
"""The parsed cookies attached to this request."""
cookies = SimpleCookie()
cookies.load(self.headers.get('Cookie', ''))
return {key: cookie.value for key, cookie in cookies.items()} | python | def cookies(self) -> Dict[str, str]:
"""The parsed cookies attached to this request."""
cookies = SimpleCookie()
cookies.load(self.headers.get('Cookie', ''))
return {key: cookie.value for key, cookie in cookies.items()} | [
"def",
"cookies",
"(",
"self",
")",
"->",
"Dict",
"[",
"str",
",",
"str",
"]",
":",
"cookies",
"=",
"SimpleCookie",
"(",
")",
"cookies",
".",
"load",
"(",
"self",
".",
"headers",
".",
"get",
"(",
"'Cookie'",
",",
"''",
")",
")",
"return",
"{",
"k... | The parsed cookies attached to this request. | [
"The",
"parsed",
"cookies",
"attached",
"to",
"this",
"request",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/wrappers/_base.py#L307-L311 | train | 226,652 |
pgjones/quart | quart/config.py | Config.from_envvar | def from_envvar(self, variable_name: str, silent: bool=False) -> None:
"""Load the configuration from a location specified in the environment.
This will load a cfg file using :meth:`from_pyfile` from the
location specified in the environment, for example the two blocks
below are equivalent.
.. code-block:: python
app.config.from_envvar('CONFIG')
.. code-block:: python
filename = os.environ['CONFIG']
app.config.from_pyfile(filename)
"""
value = os.environ.get(variable_name)
if value is None and not silent:
raise RuntimeError(
f"Environment variable {variable_name} is not present, cannot load config",
)
return self.from_pyfile(value) | python | def from_envvar(self, variable_name: str, silent: bool=False) -> None:
"""Load the configuration from a location specified in the environment.
This will load a cfg file using :meth:`from_pyfile` from the
location specified in the environment, for example the two blocks
below are equivalent.
.. code-block:: python
app.config.from_envvar('CONFIG')
.. code-block:: python
filename = os.environ['CONFIG']
app.config.from_pyfile(filename)
"""
value = os.environ.get(variable_name)
if value is None and not silent:
raise RuntimeError(
f"Environment variable {variable_name} is not present, cannot load config",
)
return self.from_pyfile(value) | [
"def",
"from_envvar",
"(",
"self",
",",
"variable_name",
":",
"str",
",",
"silent",
":",
"bool",
"=",
"False",
")",
"->",
"None",
":",
"value",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"variable_name",
")",
"if",
"value",
"is",
"None",
"and",
"not... | Load the configuration from a location specified in the environment.
This will load a cfg file using :meth:`from_pyfile` from the
location specified in the environment, for example the two blocks
below are equivalent.
.. code-block:: python
app.config.from_envvar('CONFIG')
.. code-block:: python
filename = os.environ['CONFIG']
app.config.from_pyfile(filename) | [
"Load",
"the",
"configuration",
"from",
"a",
"location",
"specified",
"in",
"the",
"environment",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/config.py#L88-L109 | train | 226,653 |
pgjones/quart | quart/config.py | Config.from_pyfile | def from_pyfile(self, filename: str, silent: bool=False) -> None:
"""Load the configuration from a Python cfg or py file.
See Python's ConfigParser docs for details on the cfg format.
It is a common practice to load the defaults from the source
using the :meth:`from_object` and then override with a cfg or
py file, for example
.. code-block:: python
app.config.from_object('config_module')
app.config.from_pyfile('production.cfg')
Arguments:
filename: The filename which when appended to
:attr:`root_path` gives the path to the file
"""
file_path = self.root_path / filename
try:
spec = importlib.util.spec_from_file_location("module.name", file_path) # type: ignore
if spec is None: # Likely passed a cfg file
parser = ConfigParser()
parser.optionxform = str # type: ignore # Prevents lowercasing of keys
with open(file_path) as file_:
config_str = '[section]\n' + file_.read()
parser.read_string(config_str)
self.from_mapping(parser['section'])
else:
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module) # type: ignore
self.from_object(module)
except (FileNotFoundError, IsADirectoryError):
if not silent:
raise | python | def from_pyfile(self, filename: str, silent: bool=False) -> None:
"""Load the configuration from a Python cfg or py file.
See Python's ConfigParser docs for details on the cfg format.
It is a common practice to load the defaults from the source
using the :meth:`from_object` and then override with a cfg or
py file, for example
.. code-block:: python
app.config.from_object('config_module')
app.config.from_pyfile('production.cfg')
Arguments:
filename: The filename which when appended to
:attr:`root_path` gives the path to the file
"""
file_path = self.root_path / filename
try:
spec = importlib.util.spec_from_file_location("module.name", file_path) # type: ignore
if spec is None: # Likely passed a cfg file
parser = ConfigParser()
parser.optionxform = str # type: ignore # Prevents lowercasing of keys
with open(file_path) as file_:
config_str = '[section]\n' + file_.read()
parser.read_string(config_str)
self.from_mapping(parser['section'])
else:
module = importlib.util.module_from_spec(spec)
spec.loader.exec_module(module) # type: ignore
self.from_object(module)
except (FileNotFoundError, IsADirectoryError):
if not silent:
raise | [
"def",
"from_pyfile",
"(",
"self",
",",
"filename",
":",
"str",
",",
"silent",
":",
"bool",
"=",
"False",
")",
"->",
"None",
":",
"file_path",
"=",
"self",
".",
"root_path",
"/",
"filename",
"try",
":",
"spec",
"=",
"importlib",
".",
"util",
".",
"sp... | Load the configuration from a Python cfg or py file.
See Python's ConfigParser docs for details on the cfg format.
It is a common practice to load the defaults from the source
using the :meth:`from_object` and then override with a cfg or
py file, for example
.. code-block:: python
app.config.from_object('config_module')
app.config.from_pyfile('production.cfg')
Arguments:
filename: The filename which when appended to
:attr:`root_path` gives the path to the file | [
"Load",
"the",
"configuration",
"from",
"a",
"Python",
"cfg",
"or",
"py",
"file",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/config.py#L111-L145 | train | 226,654 |
pgjones/quart | quart/config.py | Config.from_object | def from_object(self, instance: Union[object, str]) -> None:
"""Load the configuration from a Python object.
This can be used to reference modules or objects within
modules for example,
.. code-block:: python
app.config.from_object('module')
app.config.from_object('module.instance')
from module import instance
app.config.from_object(instance)
are valid.
Arguments:
instance: Either a str referencing a python object or the
object itself.
"""
if isinstance(instance, str):
try:
path, config = instance.rsplit('.', 1)
except ValueError:
path = instance
instance = importlib.import_module(path)
else:
module = importlib.import_module(path)
instance = getattr(module, config)
for key in dir(instance):
if key.isupper():
self[key] = getattr(instance, key) | python | def from_object(self, instance: Union[object, str]) -> None:
"""Load the configuration from a Python object.
This can be used to reference modules or objects within
modules for example,
.. code-block:: python
app.config.from_object('module')
app.config.from_object('module.instance')
from module import instance
app.config.from_object(instance)
are valid.
Arguments:
instance: Either a str referencing a python object or the
object itself.
"""
if isinstance(instance, str):
try:
path, config = instance.rsplit('.', 1)
except ValueError:
path = instance
instance = importlib.import_module(path)
else:
module = importlib.import_module(path)
instance = getattr(module, config)
for key in dir(instance):
if key.isupper():
self[key] = getattr(instance, key) | [
"def",
"from_object",
"(",
"self",
",",
"instance",
":",
"Union",
"[",
"object",
",",
"str",
"]",
")",
"->",
"None",
":",
"if",
"isinstance",
"(",
"instance",
",",
"str",
")",
":",
"try",
":",
"path",
",",
"config",
"=",
"instance",
".",
"rsplit",
... | Load the configuration from a Python object.
This can be used to reference modules or objects within
modules for example,
.. code-block:: python
app.config.from_object('module')
app.config.from_object('module.instance')
from module import instance
app.config.from_object(instance)
are valid.
Arguments:
instance: Either a str referencing a python object or the
object itself. | [
"Load",
"the",
"configuration",
"from",
"a",
"Python",
"object",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/config.py#L147-L179 | train | 226,655 |
pgjones/quart | quart/config.py | Config.from_json | def from_json(self, filename: str, silent: bool=False) -> None:
"""Load the configuration values from a JSON formatted file.
This allows configuration to be loaded as so
.. code-block:: python
app.config.from_json('config.json')
Arguments:
filename: The filename which when appended to
:attr:`root_path` gives the path to the file.
silent: If True any errors will fail silently.
"""
file_path = self.root_path / filename
try:
with open(file_path) as file_:
data = json.loads(file_.read())
except (FileNotFoundError, IsADirectoryError):
if not silent:
raise
else:
self.from_mapping(data) | python | def from_json(self, filename: str, silent: bool=False) -> None:
"""Load the configuration values from a JSON formatted file.
This allows configuration to be loaded as so
.. code-block:: python
app.config.from_json('config.json')
Arguments:
filename: The filename which when appended to
:attr:`root_path` gives the path to the file.
silent: If True any errors will fail silently.
"""
file_path = self.root_path / filename
try:
with open(file_path) as file_:
data = json.loads(file_.read())
except (FileNotFoundError, IsADirectoryError):
if not silent:
raise
else:
self.from_mapping(data) | [
"def",
"from_json",
"(",
"self",
",",
"filename",
":",
"str",
",",
"silent",
":",
"bool",
"=",
"False",
")",
"->",
"None",
":",
"file_path",
"=",
"self",
".",
"root_path",
"/",
"filename",
"try",
":",
"with",
"open",
"(",
"file_path",
")",
"as",
"fil... | Load the configuration values from a JSON formatted file.
This allows configuration to be loaded as so
.. code-block:: python
app.config.from_json('config.json')
Arguments:
filename: The filename which when appended to
:attr:`root_path` gives the path to the file.
silent: If True any errors will fail silently. | [
"Load",
"the",
"configuration",
"values",
"from",
"a",
"JSON",
"formatted",
"file",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/config.py#L181-L203 | train | 226,656 |
pgjones/quart | quart/config.py | Config.from_mapping | def from_mapping(self, mapping: Optional[Mapping[str, Any]]=None, **kwargs: Any) -> None:
"""Load the configuration values from a mapping.
This allows either a mapping to be directly passed or as
keyword arguments, for example,
.. code-block:: python
config = {'FOO': 'bar'}
app.config.from_mapping(config)
app.config.form_mapping(FOO='bar')
Arguments:
mapping: Optionally a mapping object.
kwargs: Optionally a collection of keyword arguments to
form a mapping.
"""
mappings: Dict[str, Any] = {}
if mapping is not None:
mappings.update(mapping)
mappings.update(kwargs)
for key, value in mappings.items():
if key.isupper():
self[key] = value | python | def from_mapping(self, mapping: Optional[Mapping[str, Any]]=None, **kwargs: Any) -> None:
"""Load the configuration values from a mapping.
This allows either a mapping to be directly passed or as
keyword arguments, for example,
.. code-block:: python
config = {'FOO': 'bar'}
app.config.from_mapping(config)
app.config.form_mapping(FOO='bar')
Arguments:
mapping: Optionally a mapping object.
kwargs: Optionally a collection of keyword arguments to
form a mapping.
"""
mappings: Dict[str, Any] = {}
if mapping is not None:
mappings.update(mapping)
mappings.update(kwargs)
for key, value in mappings.items():
if key.isupper():
self[key] = value | [
"def",
"from_mapping",
"(",
"self",
",",
"mapping",
":",
"Optional",
"[",
"Mapping",
"[",
"str",
",",
"Any",
"]",
"]",
"=",
"None",
",",
"*",
"*",
"kwargs",
":",
"Any",
")",
"->",
"None",
":",
"mappings",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",... | Load the configuration values from a mapping.
This allows either a mapping to be directly passed or as
keyword arguments, for example,
.. code-block:: python
config = {'FOO': 'bar'}
app.config.from_mapping(config)
app.config.form_mapping(FOO='bar')
Arguments:
mapping: Optionally a mapping object.
kwargs: Optionally a collection of keyword arguments to
form a mapping. | [
"Load",
"the",
"configuration",
"values",
"from",
"a",
"mapping",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/config.py#L205-L228 | train | 226,657 |
pgjones/quart | quart/config.py | Config.get_namespace | def get_namespace(
self,
namespace: str,
lowercase: bool=True,
trim_namespace: bool=True,
) -> Dict[str, Any]:
"""Return a dictionary of keys within a namespace.
A namespace is considered to be a key prefix, for example the
keys ``FOO_A, FOO_BAR, FOO_B`` are all within the ``FOO``
namespace. This method would return a dictionary with these
keys and values present.
.. code-block:: python
config = {'FOO_A': 'a', 'FOO_BAR': 'bar', 'BAR': False}
app.config.from_mapping(config)
assert app.config.get_namespace('FOO_') == {'a': 'a', 'bar': 'bar'}
Arguments:
namespace: The namespace itself (should be uppercase).
lowercase: Lowercase the keys in the returned dictionary.
trim_namespace: Remove the namespace from the returned
keys.
"""
config = {}
for key, value in self.items():
if key.startswith(namespace):
if trim_namespace:
new_key = key[len(namespace):]
else:
new_key = key
if lowercase:
new_key = new_key.lower()
config[new_key] = value
return config | python | def get_namespace(
self,
namespace: str,
lowercase: bool=True,
trim_namespace: bool=True,
) -> Dict[str, Any]:
"""Return a dictionary of keys within a namespace.
A namespace is considered to be a key prefix, for example the
keys ``FOO_A, FOO_BAR, FOO_B`` are all within the ``FOO``
namespace. This method would return a dictionary with these
keys and values present.
.. code-block:: python
config = {'FOO_A': 'a', 'FOO_BAR': 'bar', 'BAR': False}
app.config.from_mapping(config)
assert app.config.get_namespace('FOO_') == {'a': 'a', 'bar': 'bar'}
Arguments:
namespace: The namespace itself (should be uppercase).
lowercase: Lowercase the keys in the returned dictionary.
trim_namespace: Remove the namespace from the returned
keys.
"""
config = {}
for key, value in self.items():
if key.startswith(namespace):
if trim_namespace:
new_key = key[len(namespace):]
else:
new_key = key
if lowercase:
new_key = new_key.lower()
config[new_key] = value
return config | [
"def",
"get_namespace",
"(",
"self",
",",
"namespace",
":",
"str",
",",
"lowercase",
":",
"bool",
"=",
"True",
",",
"trim_namespace",
":",
"bool",
"=",
"True",
",",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"config",
"=",
"{",
"}",
"for"... | Return a dictionary of keys within a namespace.
A namespace is considered to be a key prefix, for example the
keys ``FOO_A, FOO_BAR, FOO_B`` are all within the ``FOO``
namespace. This method would return a dictionary with these
keys and values present.
.. code-block:: python
config = {'FOO_A': 'a', 'FOO_BAR': 'bar', 'BAR': False}
app.config.from_mapping(config)
assert app.config.get_namespace('FOO_') == {'a': 'a', 'bar': 'bar'}
Arguments:
namespace: The namespace itself (should be uppercase).
lowercase: Lowercase the keys in the returned dictionary.
trim_namespace: Remove the namespace from the returned
keys. | [
"Return",
"a",
"dictionary",
"of",
"keys",
"within",
"a",
"namespace",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/config.py#L230-L265 | train | 226,658 |
pgjones/quart | quart/helpers.py | make_response | async def make_response(*args: Any) -> Response:
"""Create a response, a simple wrapper function.
This is most useful when you want to alter a Response before
returning it, for example
.. code-block:: python
response = make_response(render_template('index.html'))
response.headers['X-Header'] = 'Something'
"""
if not args:
return current_app.response_class()
if len(args) == 1:
args = args[0]
return await current_app.make_response(args) | python | async def make_response(*args: Any) -> Response:
"""Create a response, a simple wrapper function.
This is most useful when you want to alter a Response before
returning it, for example
.. code-block:: python
response = make_response(render_template('index.html'))
response.headers['X-Header'] = 'Something'
"""
if not args:
return current_app.response_class()
if len(args) == 1:
args = args[0]
return await current_app.make_response(args) | [
"async",
"def",
"make_response",
"(",
"*",
"args",
":",
"Any",
")",
"->",
"Response",
":",
"if",
"not",
"args",
":",
"return",
"current_app",
".",
"response_class",
"(",
")",
"if",
"len",
"(",
"args",
")",
"==",
"1",
":",
"args",
"=",
"args",
"[",
... | Create a response, a simple wrapper function.
This is most useful when you want to alter a Response before
returning it, for example
.. code-block:: python
response = make_response(render_template('index.html'))
response.headers['X-Header'] = 'Something' | [
"Create",
"a",
"response",
"a",
"simple",
"wrapper",
"function",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/helpers.py#L38-L55 | train | 226,659 |
pgjones/quart | quart/helpers.py | get_flashed_messages | def get_flashed_messages(
with_categories: bool=False,
category_filter: List[str]=[],
) -> Union[List[str], List[Tuple[str, str]]]:
"""Retrieve the flashed messages stored in the session.
This is mostly useful in templates where it is exposed as a global
function, for example
.. code-block:: html+jinja
<ul>
{% for message in get_flashed_messages() %}
<li>{{ message }}</li>
{% endfor %}
</ul>
Note that caution is required for usage of ``category_filter`` as
all messages will be popped, but only those matching the filter
returned. See :func:`~quart.helpers.flash` for message creation.
"""
flashes = session.pop('_flashes') if '_flashes' in session else []
if category_filter:
flashes = [flash for flash in flashes if flash[0] in category_filter]
if not with_categories:
flashes = [flash[1] for flash in flashes]
return flashes | python | def get_flashed_messages(
with_categories: bool=False,
category_filter: List[str]=[],
) -> Union[List[str], List[Tuple[str, str]]]:
"""Retrieve the flashed messages stored in the session.
This is mostly useful in templates where it is exposed as a global
function, for example
.. code-block:: html+jinja
<ul>
{% for message in get_flashed_messages() %}
<li>{{ message }}</li>
{% endfor %}
</ul>
Note that caution is required for usage of ``category_filter`` as
all messages will be popped, but only those matching the filter
returned. See :func:`~quart.helpers.flash` for message creation.
"""
flashes = session.pop('_flashes') if '_flashes' in session else []
if category_filter:
flashes = [flash for flash in flashes if flash[0] in category_filter]
if not with_categories:
flashes = [flash[1] for flash in flashes]
return flashes | [
"def",
"get_flashed_messages",
"(",
"with_categories",
":",
"bool",
"=",
"False",
",",
"category_filter",
":",
"List",
"[",
"str",
"]",
"=",
"[",
"]",
",",
")",
"->",
"Union",
"[",
"List",
"[",
"str",
"]",
",",
"List",
"[",
"Tuple",
"[",
"str",
",",
... | Retrieve the flashed messages stored in the session.
This is mostly useful in templates where it is exposed as a global
function, for example
.. code-block:: html+jinja
<ul>
{% for message in get_flashed_messages() %}
<li>{{ message }}</li>
{% endfor %}
</ul>
Note that caution is required for usage of ``category_filter`` as
all messages will be popped, but only those matching the filter
returned. See :func:`~quart.helpers.flash` for message creation. | [
"Retrieve",
"the",
"flashed",
"messages",
"stored",
"in",
"the",
"session",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/helpers.py#L95-L121 | train | 226,660 |
pgjones/quart | quart/helpers.py | url_for | def url_for(
endpoint: str,
*,
_anchor: Optional[str]=None,
_external: Optional[bool]=None,
_method: Optional[str]=None,
_scheme: Optional[str]=None,
**values: Any,
) -> str:
"""Return the url for a specific endpoint.
This is most useful in templates and redirects to create a URL
that can be used in the browser.
Arguments:
endpoint: The endpoint to build a url for, if prefixed with
``.`` it targets endpoint's in the current blueprint.
_anchor: Additional anchor text to append (i.e. #text).
_external: Return an absolute url for external (to app) usage.
_method: The method to consider alongside the endpoint.
_scheme: A specific scheme to use.
values: The values to build into the URL, as specified in
the endpoint rule.
"""
app_context = _app_ctx_stack.top
request_context = _request_ctx_stack.top
if request_context is not None:
url_adapter = request_context.url_adapter
if endpoint.startswith('.'):
if request.blueprint is not None:
endpoint = request.blueprint + endpoint
else:
endpoint = endpoint[1:]
if _external is None:
_external = False
elif app_context is not None:
url_adapter = app_context.url_adapter
if _external is None:
_external = True
else:
raise RuntimeError('Cannot create a url outside of an application context')
if url_adapter is None:
raise RuntimeError(
'Unable to create a url adapter, try setting the the SERVER_NAME config variable.'
)
if _scheme is not None and not _external:
raise ValueError('External must be True for scheme usage')
app_context.app.inject_url_defaults(endpoint, values)
try:
url = url_adapter.build(
endpoint, values, method=_method, scheme=_scheme, external=_external,
)
except BuildError as error:
return app_context.app.handle_url_build_error(error, endpoint, values)
if _anchor is not None:
quoted_anchor = quote(_anchor)
url = f"{url}#{quoted_anchor}"
return url | python | def url_for(
endpoint: str,
*,
_anchor: Optional[str]=None,
_external: Optional[bool]=None,
_method: Optional[str]=None,
_scheme: Optional[str]=None,
**values: Any,
) -> str:
"""Return the url for a specific endpoint.
This is most useful in templates and redirects to create a URL
that can be used in the browser.
Arguments:
endpoint: The endpoint to build a url for, if prefixed with
``.`` it targets endpoint's in the current blueprint.
_anchor: Additional anchor text to append (i.e. #text).
_external: Return an absolute url for external (to app) usage.
_method: The method to consider alongside the endpoint.
_scheme: A specific scheme to use.
values: The values to build into the URL, as specified in
the endpoint rule.
"""
app_context = _app_ctx_stack.top
request_context = _request_ctx_stack.top
if request_context is not None:
url_adapter = request_context.url_adapter
if endpoint.startswith('.'):
if request.blueprint is not None:
endpoint = request.blueprint + endpoint
else:
endpoint = endpoint[1:]
if _external is None:
_external = False
elif app_context is not None:
url_adapter = app_context.url_adapter
if _external is None:
_external = True
else:
raise RuntimeError('Cannot create a url outside of an application context')
if url_adapter is None:
raise RuntimeError(
'Unable to create a url adapter, try setting the the SERVER_NAME config variable.'
)
if _scheme is not None and not _external:
raise ValueError('External must be True for scheme usage')
app_context.app.inject_url_defaults(endpoint, values)
try:
url = url_adapter.build(
endpoint, values, method=_method, scheme=_scheme, external=_external,
)
except BuildError as error:
return app_context.app.handle_url_build_error(error, endpoint, values)
if _anchor is not None:
quoted_anchor = quote(_anchor)
url = f"{url}#{quoted_anchor}"
return url | [
"def",
"url_for",
"(",
"endpoint",
":",
"str",
",",
"*",
",",
"_anchor",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
",",
"_external",
":",
"Optional",
"[",
"bool",
"]",
"=",
"None",
",",
"_method",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",... | Return the url for a specific endpoint.
This is most useful in templates and redirects to create a URL
that can be used in the browser.
Arguments:
endpoint: The endpoint to build a url for, if prefixed with
``.`` it targets endpoint's in the current blueprint.
_anchor: Additional anchor text to append (i.e. #text).
_external: Return an absolute url for external (to app) usage.
_method: The method to consider alongside the endpoint.
_scheme: A specific scheme to use.
values: The values to build into the URL, as specified in
the endpoint rule. | [
"Return",
"the",
"url",
"for",
"a",
"specific",
"endpoint",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/helpers.py#L137-L198 | train | 226,661 |
pgjones/quart | quart/helpers.py | stream_with_context | def stream_with_context(func: Callable) -> Callable:
"""Share the current request context with a generator.
This allows the request context to be accessed within a streaming
generator, for example,
.. code-block:: python
@app.route('/')
def index() -> AsyncGenerator[bytes, None]:
@stream_with_context
async def generator() -> bytes:
yield request.method.encode()
yield b' '
yield request.path.encode()
return generator()
"""
request_context = _request_ctx_stack.top.copy()
@wraps(func)
async def generator(*args: Any, **kwargs: Any) -> Any:
async with request_context:
async for data in func(*args, **kwargs):
yield data
return generator | python | def stream_with_context(func: Callable) -> Callable:
"""Share the current request context with a generator.
This allows the request context to be accessed within a streaming
generator, for example,
.. code-block:: python
@app.route('/')
def index() -> AsyncGenerator[bytes, None]:
@stream_with_context
async def generator() -> bytes:
yield request.method.encode()
yield b' '
yield request.path.encode()
return generator()
"""
request_context = _request_ctx_stack.top.copy()
@wraps(func)
async def generator(*args: Any, **kwargs: Any) -> Any:
async with request_context:
async for data in func(*args, **kwargs):
yield data
return generator | [
"def",
"stream_with_context",
"(",
"func",
":",
"Callable",
")",
"->",
"Callable",
":",
"request_context",
"=",
"_request_ctx_stack",
".",
"top",
".",
"copy",
"(",
")",
"@",
"wraps",
"(",
"func",
")",
"async",
"def",
"generator",
"(",
"*",
"args",
":",
"... | Share the current request context with a generator.
This allows the request context to be accessed within a streaming
generator, for example,
.. code-block:: python
@app.route('/')
def index() -> AsyncGenerator[bytes, None]:
@stream_with_context
async def generator() -> bytes:
yield request.method.encode()
yield b' '
yield request.path.encode()
return generator() | [
"Share",
"the",
"current",
"request",
"context",
"with",
"a",
"generator",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/helpers.py#L201-L227 | train | 226,662 |
pgjones/quart | quart/static.py | safe_join | def safe_join(directory: FilePath, *paths: FilePath) -> Path:
"""Safely join the paths to the known directory to return a full path.
Raises:
NotFound: if the full path does not share a commonprefix with
the directory.
"""
try:
safe_path = file_path_to_path(directory).resolve(strict=True)
full_path = file_path_to_path(directory, *paths).resolve(strict=True)
except FileNotFoundError:
raise NotFound()
try:
full_path.relative_to(safe_path)
except ValueError:
raise NotFound()
return full_path | python | def safe_join(directory: FilePath, *paths: FilePath) -> Path:
"""Safely join the paths to the known directory to return a full path.
Raises:
NotFound: if the full path does not share a commonprefix with
the directory.
"""
try:
safe_path = file_path_to_path(directory).resolve(strict=True)
full_path = file_path_to_path(directory, *paths).resolve(strict=True)
except FileNotFoundError:
raise NotFound()
try:
full_path.relative_to(safe_path)
except ValueError:
raise NotFound()
return full_path | [
"def",
"safe_join",
"(",
"directory",
":",
"FilePath",
",",
"*",
"paths",
":",
"FilePath",
")",
"->",
"Path",
":",
"try",
":",
"safe_path",
"=",
"file_path_to_path",
"(",
"directory",
")",
".",
"resolve",
"(",
"strict",
"=",
"True",
")",
"full_path",
"="... | Safely join the paths to the known directory to return a full path.
Raises:
NotFound: if the full path does not share a commonprefix with
the directory. | [
"Safely",
"join",
"the",
"paths",
"to",
"the",
"known",
"directory",
"to",
"return",
"a",
"full",
"path",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/static.py#L117-L133 | train | 226,663 |
pgjones/quart | quart/static.py | send_from_directory | async def send_from_directory(
directory: FilePath,
file_name: str,
*,
mimetype: Optional[str]=None,
as_attachment: bool=False,
attachment_filename: Optional[str]=None,
add_etags: bool=True,
cache_timeout: Optional[int]=None,
conditional: bool=True,
last_modified: Optional[datetime]=None,
) -> Response:
"""Send a file from a given directory.
Arguments:
directory: Directory that when combined with file_name gives
the file path.
file_name: File name that when combined with directory gives
the file path.
See :func:`send_file` for the other arguments.
"""
file_path = safe_join(directory, file_name)
if not file_path.is_file():
raise NotFound()
return await send_file(
file_path,
mimetype=mimetype,
as_attachment=as_attachment,
attachment_filename=attachment_filename,
add_etags=add_etags,
cache_timeout=cache_timeout,
conditional=conditional,
last_modified=last_modified,
) | python | async def send_from_directory(
directory: FilePath,
file_name: str,
*,
mimetype: Optional[str]=None,
as_attachment: bool=False,
attachment_filename: Optional[str]=None,
add_etags: bool=True,
cache_timeout: Optional[int]=None,
conditional: bool=True,
last_modified: Optional[datetime]=None,
) -> Response:
"""Send a file from a given directory.
Arguments:
directory: Directory that when combined with file_name gives
the file path.
file_name: File name that when combined with directory gives
the file path.
See :func:`send_file` for the other arguments.
"""
file_path = safe_join(directory, file_name)
if not file_path.is_file():
raise NotFound()
return await send_file(
file_path,
mimetype=mimetype,
as_attachment=as_attachment,
attachment_filename=attachment_filename,
add_etags=add_etags,
cache_timeout=cache_timeout,
conditional=conditional,
last_modified=last_modified,
) | [
"async",
"def",
"send_from_directory",
"(",
"directory",
":",
"FilePath",
",",
"file_name",
":",
"str",
",",
"*",
",",
"mimetype",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
",",
"as_attachment",
":",
"bool",
"=",
"False",
",",
"attachment_filename",
"... | Send a file from a given directory.
Arguments:
directory: Directory that when combined with file_name gives
the file path.
file_name: File name that when combined with directory gives
the file path.
See :func:`send_file` for the other arguments. | [
"Send",
"a",
"file",
"from",
"a",
"given",
"directory",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/static.py#L136-L169 | train | 226,664 |
pgjones/quart | quart/static.py | send_file | async def send_file(
filename: FilePath,
mimetype: Optional[str]=None,
as_attachment: bool=False,
attachment_filename: Optional[str]=None,
add_etags: bool=True,
cache_timeout: Optional[int]=None,
conditional: bool=False,
last_modified: Optional[datetime]=None,
) -> Response:
"""Return a Reponse to send the filename given.
Arguments:
filename: The filename (path) to send, remember to use
:func:`safe_join`.
mimetype: Mimetype to use, by default it will be guessed or
revert to the DEFAULT_MIMETYPE.
as_attachment: If true use the attachment filename in a
Content-Disposition attachment header.
attachment_filename: Name for the filename, if it differs
add_etags: Set etags based on the filename, size and
modification time.
last_modified: Used to override the last modified value.
cache_timeout: Time in seconds for the response to be cached.
"""
file_path = file_path_to_path(filename)
if attachment_filename is None:
attachment_filename = file_path.name
if mimetype is None:
mimetype = mimetypes.guess_type(attachment_filename)[0] or DEFAULT_MIMETYPE
file_body = current_app.response_class.file_body_class(file_path)
response = current_app.response_class(file_body, mimetype=mimetype)
if as_attachment:
response.headers.add('Content-Disposition', 'attachment', filename=attachment_filename)
if last_modified is not None:
response.last_modified = last_modified
else:
response.last_modified = datetime.fromtimestamp(file_path.stat().st_mtime)
response.cache_control.public = True
cache_timeout = cache_timeout or current_app.get_send_file_max_age(file_path)
if cache_timeout is not None:
response.cache_control.max_age = cache_timeout
response.expires = datetime.utcnow() + timedelta(seconds=cache_timeout)
if add_etags:
response.set_etag(
'{}-{}-{}'.format(
file_path.stat().st_mtime, file_path.stat().st_size,
adler32(bytes(file_path)),
),
)
if conditional:
await response.make_conditional(request.range)
return response | python | async def send_file(
filename: FilePath,
mimetype: Optional[str]=None,
as_attachment: bool=False,
attachment_filename: Optional[str]=None,
add_etags: bool=True,
cache_timeout: Optional[int]=None,
conditional: bool=False,
last_modified: Optional[datetime]=None,
) -> Response:
"""Return a Reponse to send the filename given.
Arguments:
filename: The filename (path) to send, remember to use
:func:`safe_join`.
mimetype: Mimetype to use, by default it will be guessed or
revert to the DEFAULT_MIMETYPE.
as_attachment: If true use the attachment filename in a
Content-Disposition attachment header.
attachment_filename: Name for the filename, if it differs
add_etags: Set etags based on the filename, size and
modification time.
last_modified: Used to override the last modified value.
cache_timeout: Time in seconds for the response to be cached.
"""
file_path = file_path_to_path(filename)
if attachment_filename is None:
attachment_filename = file_path.name
if mimetype is None:
mimetype = mimetypes.guess_type(attachment_filename)[0] or DEFAULT_MIMETYPE
file_body = current_app.response_class.file_body_class(file_path)
response = current_app.response_class(file_body, mimetype=mimetype)
if as_attachment:
response.headers.add('Content-Disposition', 'attachment', filename=attachment_filename)
if last_modified is not None:
response.last_modified = last_modified
else:
response.last_modified = datetime.fromtimestamp(file_path.stat().st_mtime)
response.cache_control.public = True
cache_timeout = cache_timeout or current_app.get_send_file_max_age(file_path)
if cache_timeout is not None:
response.cache_control.max_age = cache_timeout
response.expires = datetime.utcnow() + timedelta(seconds=cache_timeout)
if add_etags:
response.set_etag(
'{}-{}-{}'.format(
file_path.stat().st_mtime, file_path.stat().st_size,
adler32(bytes(file_path)),
),
)
if conditional:
await response.make_conditional(request.range)
return response | [
"async",
"def",
"send_file",
"(",
"filename",
":",
"FilePath",
",",
"mimetype",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
",",
"as_attachment",
":",
"bool",
"=",
"False",
",",
"attachment_filename",
":",
"Optional",
"[",
"str",
"]",
"=",
"None",
","... | Return a Reponse to send the filename given.
Arguments:
filename: The filename (path) to send, remember to use
:func:`safe_join`.
mimetype: Mimetype to use, by default it will be guessed or
revert to the DEFAULT_MIMETYPE.
as_attachment: If true use the attachment filename in a
Content-Disposition attachment header.
attachment_filename: Name for the filename, if it differs
add_etags: Set etags based on the filename, size and
modification time.
last_modified: Used to override the last modified value.
cache_timeout: Time in seconds for the response to be cached. | [
"Return",
"a",
"Reponse",
"to",
"send",
"the",
"filename",
"given",
"."
] | 7cb2d3bd98e8746025764f2b933abc12041fa175 | https://github.com/pgjones/quart/blob/7cb2d3bd98e8746025764f2b933abc12041fa175/quart/static.py#L172-L230 | train | 226,665 |
manrajgrover/halo | halo/halo.py | Halo._render_frame | def _render_frame(self):
"""Renders the frame on the line after clearing it.
"""
frame = self.frame()
output = '\r{0}'.format(frame)
self.clear()
try:
self._stream.write(output)
except UnicodeEncodeError:
self._stream.write(encode_utf_8_text(output)) | python | def _render_frame(self):
"""Renders the frame on the line after clearing it.
"""
frame = self.frame()
output = '\r{0}'.format(frame)
self.clear()
try:
self._stream.write(output)
except UnicodeEncodeError:
self._stream.write(encode_utf_8_text(output)) | [
"def",
"_render_frame",
"(",
"self",
")",
":",
"frame",
"=",
"self",
".",
"frame",
"(",
")",
"output",
"=",
"'\\r{0}'",
".",
"format",
"(",
"frame",
")",
"self",
".",
"clear",
"(",
")",
"try",
":",
"self",
".",
"_stream",
".",
"write",
"(",
"output... | Renders the frame on the line after clearing it. | [
"Renders",
"the",
"frame",
"on",
"the",
"line",
"after",
"clearing",
"it",
"."
] | 0ac5149dea965b27b09f0776df9095ebf013fb4d | https://github.com/manrajgrover/halo/blob/0ac5149dea965b27b09f0776df9095ebf013fb4d/halo/halo.py#L336-L345 | train | 226,666 |
manrajgrover/halo | halo/_utils.py | get_environment | def get_environment():
"""Get the environment in which halo is running
Returns
-------
str
Environment name
"""
try:
from IPython import get_ipython
except ImportError:
return 'terminal'
try:
shell = get_ipython().__class__.__name__
if shell == 'ZMQInteractiveShell': # Jupyter notebook or qtconsole
return 'jupyter'
elif shell == 'TerminalInteractiveShell': # Terminal running IPython
return 'ipython'
else:
return 'terminal' # Other type (?)
except NameError:
return 'terminal' | python | def get_environment():
"""Get the environment in which halo is running
Returns
-------
str
Environment name
"""
try:
from IPython import get_ipython
except ImportError:
return 'terminal'
try:
shell = get_ipython().__class__.__name__
if shell == 'ZMQInteractiveShell': # Jupyter notebook or qtconsole
return 'jupyter'
elif shell == 'TerminalInteractiveShell': # Terminal running IPython
return 'ipython'
else:
return 'terminal' # Other type (?)
except NameError:
return 'terminal' | [
"def",
"get_environment",
"(",
")",
":",
"try",
":",
"from",
"IPython",
"import",
"get_ipython",
"except",
"ImportError",
":",
"return",
"'terminal'",
"try",
":",
"shell",
"=",
"get_ipython",
"(",
")",
".",
"__class__",
".",
"__name__",
"if",
"shell",
"==",
... | Get the environment in which halo is running
Returns
-------
str
Environment name | [
"Get",
"the",
"environment",
"in",
"which",
"halo",
"is",
"running"
] | 0ac5149dea965b27b09f0776df9095ebf013fb4d | https://github.com/manrajgrover/halo/blob/0ac5149dea965b27b09f0776df9095ebf013fb4d/halo/_utils.py#L35-L59 | train | 226,667 |
manrajgrover/halo | halo/_utils.py | is_text_type | def is_text_type(text):
"""Check if given parameter is a string or not
Parameters
----------
text : *
Parameter to be checked for text type
Returns
-------
bool
Whether parameter is a string or not
"""
if isinstance(text, six.text_type) or isinstance(text, six.string_types):
return True
return False | python | def is_text_type(text):
"""Check if given parameter is a string or not
Parameters
----------
text : *
Parameter to be checked for text type
Returns
-------
bool
Whether parameter is a string or not
"""
if isinstance(text, six.text_type) or isinstance(text, six.string_types):
return True
return False | [
"def",
"is_text_type",
"(",
"text",
")",
":",
"if",
"isinstance",
"(",
"text",
",",
"six",
".",
"text_type",
")",
"or",
"isinstance",
"(",
"text",
",",
"six",
".",
"string_types",
")",
":",
"return",
"True",
"return",
"False"
] | Check if given parameter is a string or not
Parameters
----------
text : *
Parameter to be checked for text type
Returns
-------
bool
Whether parameter is a string or not | [
"Check",
"if",
"given",
"parameter",
"is",
"a",
"string",
"or",
"not"
] | 0ac5149dea965b27b09f0776df9095ebf013fb4d | https://github.com/manrajgrover/halo/blob/0ac5149dea965b27b09f0776df9095ebf013fb4d/halo/_utils.py#L80-L96 | train | 226,668 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | find_stateless_by_name | def find_stateless_by_name(name):
'''
Find stateless app given its name
First search the Django ORM, and if not found then look the app up in a local registry.
If the app does not have an ORM entry then a StatelessApp model instance is created.
'''
try:
dsa_app = StatelessApp.objects.get(app_name=name) # pylint: disable=no-member
return dsa_app.as_dash_app()
except: # pylint: disable=bare-except
pass
dash_app = get_stateless_by_name(name)
dsa_app = StatelessApp(app_name=name)
dsa_app.save()
return dash_app | python | def find_stateless_by_name(name):
'''
Find stateless app given its name
First search the Django ORM, and if not found then look the app up in a local registry.
If the app does not have an ORM entry then a StatelessApp model instance is created.
'''
try:
dsa_app = StatelessApp.objects.get(app_name=name) # pylint: disable=no-member
return dsa_app.as_dash_app()
except: # pylint: disable=bare-except
pass
dash_app = get_stateless_by_name(name)
dsa_app = StatelessApp(app_name=name)
dsa_app.save()
return dash_app | [
"def",
"find_stateless_by_name",
"(",
"name",
")",
":",
"try",
":",
"dsa_app",
"=",
"StatelessApp",
".",
"objects",
".",
"get",
"(",
"app_name",
"=",
"name",
")",
"# pylint: disable=no-member",
"return",
"dsa_app",
".",
"as_dash_app",
"(",
")",
"except",
":",
... | Find stateless app given its name
First search the Django ORM, and if not found then look the app up in a local registry.
If the app does not have an ORM entry then a StatelessApp model instance is created. | [
"Find",
"stateless",
"app",
"given",
"its",
"name"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L63-L79 | train | 226,669 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | StatelessApp.as_dash_app | def as_dash_app(self):
'''
Return a DjangoDash instance of the dash application
'''
dateless_dash_app = getattr(self, '_stateless_dash_app_instance', None)
if not dateless_dash_app:
dateless_dash_app = get_stateless_by_name(self.app_name)
setattr(self, '_stateless_dash_app_instance', dateless_dash_app)
return dateless_dash_app | python | def as_dash_app(self):
'''
Return a DjangoDash instance of the dash application
'''
dateless_dash_app = getattr(self, '_stateless_dash_app_instance', None)
if not dateless_dash_app:
dateless_dash_app = get_stateless_by_name(self.app_name)
setattr(self, '_stateless_dash_app_instance', dateless_dash_app)
return dateless_dash_app | [
"def",
"as_dash_app",
"(",
"self",
")",
":",
"dateless_dash_app",
"=",
"getattr",
"(",
"self",
",",
"'_stateless_dash_app_instance'",
",",
"None",
")",
"if",
"not",
"dateless_dash_app",
":",
"dateless_dash_app",
"=",
"get_stateless_by_name",
"(",
"self",
".",
"app... | Return a DjangoDash instance of the dash application | [
"Return",
"a",
"DjangoDash",
"instance",
"of",
"the",
"dash",
"application"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L53-L61 | train | 226,670 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | DashApp.handle_current_state | def handle_current_state(self):
'''
Check to see if the current hydrated state and the saved state are different.
If they are, then persist the current state in the database by saving the model instance.
'''
if getattr(self, '_current_state_hydrated_changed', False) and self.save_on_change:
new_base_state = json.dumps(getattr(self, '_current_state_hydrated', {}))
if new_base_state != self.base_state:
self.base_state = new_base_state
self.save() | python | def handle_current_state(self):
'''
Check to see if the current hydrated state and the saved state are different.
If they are, then persist the current state in the database by saving the model instance.
'''
if getattr(self, '_current_state_hydrated_changed', False) and self.save_on_change:
new_base_state = json.dumps(getattr(self, '_current_state_hydrated', {}))
if new_base_state != self.base_state:
self.base_state = new_base_state
self.save() | [
"def",
"handle_current_state",
"(",
"self",
")",
":",
"if",
"getattr",
"(",
"self",
",",
"'_current_state_hydrated_changed'",
",",
"False",
")",
"and",
"self",
".",
"save_on_change",
":",
"new_base_state",
"=",
"json",
".",
"dumps",
"(",
"getattr",
"(",
"self"... | Check to see if the current hydrated state and the saved state are different.
If they are, then persist the current state in the database by saving the model instance. | [
"Check",
"to",
"see",
"if",
"the",
"current",
"hydrated",
"state",
"and",
"the",
"saved",
"state",
"are",
"different",
"."
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L114-L124 | train | 226,671 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | DashApp.have_current_state_entry | def have_current_state_entry(self, wid, key):
'Return True if there is a cached current state for this app'
cscoll = self.current_state()
c_state = cscoll.get(wid, {})
return key in c_state | python | def have_current_state_entry(self, wid, key):
'Return True if there is a cached current state for this app'
cscoll = self.current_state()
c_state = cscoll.get(wid, {})
return key in c_state | [
"def",
"have_current_state_entry",
"(",
"self",
",",
"wid",
",",
"key",
")",
":",
"cscoll",
"=",
"self",
".",
"current_state",
"(",
")",
"c_state",
"=",
"cscoll",
".",
"get",
"(",
"wid",
",",
"{",
"}",
")",
"return",
"key",
"in",
"c_state"
] | Return True if there is a cached current state for this app | [
"Return",
"True",
"if",
"there",
"is",
"a",
"cached",
"current",
"state",
"for",
"this",
"app"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L126-L130 | train | 226,672 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | DashApp.current_state | def current_state(self):
'''
Return the current internal state of the model instance.
This is not necessarily the same as the persisted state
stored in the self.base_state variable.
'''
c_state = getattr(self, '_current_state_hydrated', None)
if not c_state:
c_state = json.loads(self.base_state)
setattr(self, '_current_state_hydrated', c_state)
setattr(self, '_current_state_hydrated_changed', False)
return c_state | python | def current_state(self):
'''
Return the current internal state of the model instance.
This is not necessarily the same as the persisted state
stored in the self.base_state variable.
'''
c_state = getattr(self, '_current_state_hydrated', None)
if not c_state:
c_state = json.loads(self.base_state)
setattr(self, '_current_state_hydrated', c_state)
setattr(self, '_current_state_hydrated_changed', False)
return c_state | [
"def",
"current_state",
"(",
"self",
")",
":",
"c_state",
"=",
"getattr",
"(",
"self",
",",
"'_current_state_hydrated'",
",",
"None",
")",
"if",
"not",
"c_state",
":",
"c_state",
"=",
"json",
".",
"loads",
"(",
"self",
".",
"base_state",
")",
"setattr",
... | Return the current internal state of the model instance.
This is not necessarily the same as the persisted state
stored in the self.base_state variable. | [
"Return",
"the",
"current",
"internal",
"state",
"of",
"the",
"model",
"instance",
"."
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L146-L158 | train | 226,673 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | DashApp.as_dash_instance | def as_dash_instance(self, cache_id=None):
'Return a dash application instance for this model instance'
dash_app = self.stateless_app.as_dash_app() # pylint: disable=no-member
base = self.current_state()
return dash_app.do_form_dash_instance(replacements=base,
specific_identifier=self.slug,
cache_id=cache_id) | python | def as_dash_instance(self, cache_id=None):
'Return a dash application instance for this model instance'
dash_app = self.stateless_app.as_dash_app() # pylint: disable=no-member
base = self.current_state()
return dash_app.do_form_dash_instance(replacements=base,
specific_identifier=self.slug,
cache_id=cache_id) | [
"def",
"as_dash_instance",
"(",
"self",
",",
"cache_id",
"=",
"None",
")",
":",
"dash_app",
"=",
"self",
".",
"stateless_app",
".",
"as_dash_app",
"(",
")",
"# pylint: disable=no-member",
"base",
"=",
"self",
".",
"current_state",
"(",
")",
"return",
"dash_app... | Return a dash application instance for this model instance | [
"Return",
"a",
"dash",
"application",
"instance",
"for",
"this",
"model",
"instance"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L160-L166 | train | 226,674 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | DashApp._get_base_state | def _get_base_state(self):
'''
Get the base state of the object, as defined by the app.layout code, as a python dict
'''
base_app_inst = self.stateless_app.as_dash_app().as_dash_instance() # pylint: disable=no-member
# Get base layout response, from a base object
base_resp = base_app_inst.locate_endpoint_function('dash-layout')()
base_obj = json.loads(base_resp.data.decode('utf-8'))
# Walk the base layout and find all values; insert into base state map
obj = {}
base_app_inst.walk_tree_and_extract(base_obj, obj)
return obj | python | def _get_base_state(self):
'''
Get the base state of the object, as defined by the app.layout code, as a python dict
'''
base_app_inst = self.stateless_app.as_dash_app().as_dash_instance() # pylint: disable=no-member
# Get base layout response, from a base object
base_resp = base_app_inst.locate_endpoint_function('dash-layout')()
base_obj = json.loads(base_resp.data.decode('utf-8'))
# Walk the base layout and find all values; insert into base state map
obj = {}
base_app_inst.walk_tree_and_extract(base_obj, obj)
return obj | [
"def",
"_get_base_state",
"(",
"self",
")",
":",
"base_app_inst",
"=",
"self",
".",
"stateless_app",
".",
"as_dash_app",
"(",
")",
".",
"as_dash_instance",
"(",
")",
"# pylint: disable=no-member",
"# Get base layout response, from a base object",
"base_resp",
"=",
"base... | Get the base state of the object, as defined by the app.layout code, as a python dict | [
"Get",
"the",
"base",
"state",
"of",
"the",
"object",
"as",
"defined",
"by",
"the",
"app",
".",
"layout",
"code",
"as",
"a",
"python",
"dict"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L168-L182 | train | 226,675 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | DashApp.populate_values | def populate_values(self):
'''
Add values from the underlying dash layout configuration
'''
obj = self._get_base_state()
self.base_state = json.dumps(obj) | python | def populate_values(self):
'''
Add values from the underlying dash layout configuration
'''
obj = self._get_base_state()
self.base_state = json.dumps(obj) | [
"def",
"populate_values",
"(",
"self",
")",
":",
"obj",
"=",
"self",
".",
"_get_base_state",
"(",
")",
"self",
".",
"base_state",
"=",
"json",
".",
"dumps",
"(",
"obj",
")"
] | Add values from the underlying dash layout configuration | [
"Add",
"values",
"from",
"the",
"underlying",
"dash",
"layout",
"configuration"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L184-L189 | train | 226,676 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/models.py | DashApp.locate_item | def locate_item(ident, stateless=False, cache_id=None):
'''Locate a dash application, given either the
slug of an instance or the name for a stateless app'''
if stateless:
dash_app = find_stateless_by_name(ident)
else:
dash_app = get_object_or_404(DashApp, slug=ident)
app = dash_app.as_dash_instance(cache_id=cache_id)
return dash_app, app | python | def locate_item(ident, stateless=False, cache_id=None):
'''Locate a dash application, given either the
slug of an instance or the name for a stateless app'''
if stateless:
dash_app = find_stateless_by_name(ident)
else:
dash_app = get_object_or_404(DashApp, slug=ident)
app = dash_app.as_dash_instance(cache_id=cache_id)
return dash_app, app | [
"def",
"locate_item",
"(",
"ident",
",",
"stateless",
"=",
"False",
",",
"cache_id",
"=",
"None",
")",
":",
"if",
"stateless",
":",
"dash_app",
"=",
"find_stateless_by_name",
"(",
"ident",
")",
"else",
":",
"dash_app",
"=",
"get_object_or_404",
"(",
"DashApp... | Locate a dash application, given either the
slug of an instance or the name for a stateless app | [
"Locate",
"a",
"dash",
"application",
"given",
"either",
"the",
"slug",
"of",
"an",
"instance",
"or",
"the",
"name",
"for",
"a",
"stateless",
"app"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/models.py#L192-L201 | train | 226,677 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/consumers.py | send_to_pipe_channel | def send_to_pipe_channel(channel_name,
label,
value):
'Send message through pipe to client component'
async_to_sync(async_send_to_pipe_channel)(channel_name=channel_name,
label=label,
value=value) | python | def send_to_pipe_channel(channel_name,
label,
value):
'Send message through pipe to client component'
async_to_sync(async_send_to_pipe_channel)(channel_name=channel_name,
label=label,
value=value) | [
"def",
"send_to_pipe_channel",
"(",
"channel_name",
",",
"label",
",",
"value",
")",
":",
"async_to_sync",
"(",
"async_send_to_pipe_channel",
")",
"(",
"channel_name",
"=",
"channel_name",
",",
"label",
"=",
"label",
",",
"value",
"=",
"value",
")"
] | Send message through pipe to client component | [
"Send",
"message",
"through",
"pipe",
"to",
"client",
"component"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/consumers.py#L35-L41 | train | 226,678 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/consumers.py | async_send_to_pipe_channel | async def async_send_to_pipe_channel(channel_name,
label,
value):
'Send message asynchronously through pipe to client component'
pcn = _form_pipe_channel_name(channel_name)
channel_layer = get_channel_layer()
await channel_layer.group_send(pcn,
{"type":"pipe.value",
"label":label,
"value":value}) | python | async def async_send_to_pipe_channel(channel_name,
label,
value):
'Send message asynchronously through pipe to client component'
pcn = _form_pipe_channel_name(channel_name)
channel_layer = get_channel_layer()
await channel_layer.group_send(pcn,
{"type":"pipe.value",
"label":label,
"value":value}) | [
"async",
"def",
"async_send_to_pipe_channel",
"(",
"channel_name",
",",
"label",
",",
"value",
")",
":",
"pcn",
"=",
"_form_pipe_channel_name",
"(",
"channel_name",
")",
"channel_layer",
"=",
"get_channel_layer",
"(",
")",
"await",
"channel_layer",
".",
"group_send"... | Send message asynchronously through pipe to client component | [
"Send",
"message",
"asynchronously",
"through",
"pipe",
"to",
"client",
"component"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/consumers.py#L43-L53 | train | 226,679 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/consumers.py | MessageConsumer.pipe_value | def pipe_value(self, message):
'Send a new value into the ws pipe'
jmsg = json.dumps(message)
self.send(jmsg) | python | def pipe_value(self, message):
'Send a new value into the ws pipe'
jmsg = json.dumps(message)
self.send(jmsg) | [
"def",
"pipe_value",
"(",
"self",
",",
"message",
")",
":",
"jmsg",
"=",
"json",
".",
"dumps",
"(",
"message",
")",
"self",
".",
"send",
"(",
"jmsg",
")"
] | Send a new value into the ws pipe | [
"Send",
"a",
"new",
"value",
"into",
"the",
"ws",
"pipe"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/consumers.py#L72-L75 | train | 226,680 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/consumers.py | MessageConsumer.update_pipe_channel | def update_pipe_channel(self, uid, channel_name, label): # pylint: disable=unused-argument
'''
Update this consumer to listen on channel_name for the js widget associated with uid
'''
pipe_group_name = _form_pipe_channel_name(channel_name)
if self.channel_layer:
current = self.channel_maps.get(uid, None)
if current != pipe_group_name:
if current:
async_to_sync(self.channel_layer.group_discard)(current, self.channel_name)
self.channel_maps[uid] = pipe_group_name
async_to_sync(self.channel_layer.group_add)(pipe_group_name, self.channel_name) | python | def update_pipe_channel(self, uid, channel_name, label): # pylint: disable=unused-argument
'''
Update this consumer to listen on channel_name for the js widget associated with uid
'''
pipe_group_name = _form_pipe_channel_name(channel_name)
if self.channel_layer:
current = self.channel_maps.get(uid, None)
if current != pipe_group_name:
if current:
async_to_sync(self.channel_layer.group_discard)(current, self.channel_name)
self.channel_maps[uid] = pipe_group_name
async_to_sync(self.channel_layer.group_add)(pipe_group_name, self.channel_name) | [
"def",
"update_pipe_channel",
"(",
"self",
",",
"uid",
",",
"channel_name",
",",
"label",
")",
":",
"# pylint: disable=unused-argument",
"pipe_group_name",
"=",
"_form_pipe_channel_name",
"(",
"channel_name",
")",
"if",
"self",
".",
"channel_layer",
":",
"current",
... | Update this consumer to listen on channel_name for the js widget associated with uid | [
"Update",
"this",
"consumer",
"to",
"listen",
"on",
"channel_name",
"for",
"the",
"js",
"widget",
"associated",
"with",
"uid"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/consumers.py#L77-L90 | train | 226,681 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/util.py | store_initial_arguments | def store_initial_arguments(request, initial_arguments=None):
'Store initial arguments, if any, and return a cache identifier'
if initial_arguments is None:
return None
# Generate a cache id
cache_id = "dpd-initial-args-%s" % str(uuid.uuid4()).replace('-', '')
# Store args in json form in cache
if initial_argument_location():
cache.set(cache_id, initial_arguments, cache_timeout_initial_arguments())
else:
request.session[cache_id] = initial_arguments
return cache_id | python | def store_initial_arguments(request, initial_arguments=None):
'Store initial arguments, if any, and return a cache identifier'
if initial_arguments is None:
return None
# Generate a cache id
cache_id = "dpd-initial-args-%s" % str(uuid.uuid4()).replace('-', '')
# Store args in json form in cache
if initial_argument_location():
cache.set(cache_id, initial_arguments, cache_timeout_initial_arguments())
else:
request.session[cache_id] = initial_arguments
return cache_id | [
"def",
"store_initial_arguments",
"(",
"request",
",",
"initial_arguments",
"=",
"None",
")",
":",
"if",
"initial_arguments",
"is",
"None",
":",
"return",
"None",
"# Generate a cache id",
"cache_id",
"=",
"\"dpd-initial-args-%s\"",
"%",
"str",
"(",
"uuid",
".",
"u... | Store initial arguments, if any, and return a cache identifier | [
"Store",
"initial",
"arguments",
"if",
"any",
"and",
"return",
"a",
"cache",
"identifier"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/util.py#L72-L87 | train | 226,682 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/util.py | get_initial_arguments | def get_initial_arguments(request, cache_id=None):
'Extract initial arguments for the dash app'
if cache_id is None:
return None
if initial_argument_location():
return cache.get(cache_id)
return request.session[cache_id] | python | def get_initial_arguments(request, cache_id=None):
'Extract initial arguments for the dash app'
if cache_id is None:
return None
if initial_argument_location():
return cache.get(cache_id)
return request.session[cache_id] | [
"def",
"get_initial_arguments",
"(",
"request",
",",
"cache_id",
"=",
"None",
")",
":",
"if",
"cache_id",
"is",
"None",
":",
"return",
"None",
"if",
"initial_argument_location",
"(",
")",
":",
"return",
"cache",
".",
"get",
"(",
"cache_id",
")",
"return",
... | Extract initial arguments for the dash app | [
"Extract",
"initial",
"arguments",
"for",
"the",
"dash",
"app"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/util.py#L89-L98 | train | 226,683 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/views.py | dependencies | def dependencies(request, ident, stateless=False, **kwargs):
'Return the dependencies'
_, app = DashApp.locate_item(ident, stateless)
with app.app_context():
view_func = app.locate_endpoint_function('dash-dependencies')
resp = view_func()
return HttpResponse(resp.data,
content_type=resp.mimetype) | python | def dependencies(request, ident, stateless=False, **kwargs):
'Return the dependencies'
_, app = DashApp.locate_item(ident, stateless)
with app.app_context():
view_func = app.locate_endpoint_function('dash-dependencies')
resp = view_func()
return HttpResponse(resp.data,
content_type=resp.mimetype) | [
"def",
"dependencies",
"(",
"request",
",",
"ident",
",",
"stateless",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"_",
",",
"app",
"=",
"DashApp",
".",
"locate_item",
"(",
"ident",
",",
"stateless",
")",
"with",
"app",
".",
"app_context",
"(",
... | Return the dependencies | [
"Return",
"the",
"dependencies"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/views.py#L39-L47 | train | 226,684 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/views.py | layout | def layout(request, ident, stateless=False, cache_id=None, **kwargs):
'Return the layout of the dash application'
_, app = DashApp.locate_item(ident, stateless)
view_func = app.locate_endpoint_function('dash-layout')
resp = view_func()
initial_arguments = get_initial_arguments(request, cache_id)
response_data, mimetype = app.augment_initial_layout(resp, initial_arguments)
return HttpResponse(response_data,
content_type=mimetype) | python | def layout(request, ident, stateless=False, cache_id=None, **kwargs):
'Return the layout of the dash application'
_, app = DashApp.locate_item(ident, stateless)
view_func = app.locate_endpoint_function('dash-layout')
resp = view_func()
initial_arguments = get_initial_arguments(request, cache_id)
response_data, mimetype = app.augment_initial_layout(resp, initial_arguments)
return HttpResponse(response_data,
content_type=mimetype) | [
"def",
"layout",
"(",
"request",
",",
"ident",
",",
"stateless",
"=",
"False",
",",
"cache_id",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"_",
",",
"app",
"=",
"DashApp",
".",
"locate_item",
"(",
"ident",
",",
"stateless",
")",
"view_func",
"="... | Return the layout of the dash application | [
"Return",
"the",
"layout",
"of",
"the",
"dash",
"application"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/views.py#L49-L60 | train | 226,685 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/views.py | update | def update(request, ident, stateless=False, **kwargs):
'Generate update json response'
dash_app, app = DashApp.locate_item(ident, stateless)
request_body = json.loads(request.body.decode('utf-8'))
if app.use_dash_dispatch():
# Force call through dash
view_func = app.locate_endpoint_function('dash-update-component')
import flask
with app.test_request_context():
# Fudge request object
# pylint: disable=protected-access
flask.request._cached_json = (request_body, flask.request._cached_json[True])
resp = view_func()
else:
# Use direct dispatch with extra arguments in the argMap
app_state = request.session.get("django_plotly_dash", dict())
arg_map = {'dash_app_id': ident,
'dash_app': dash_app,
'user': request.user,
'session_state': app_state}
resp = app.dispatch_with_args(request_body, arg_map)
request.session['django_plotly_dash'] = app_state
dash_app.handle_current_state()
# Special for ws-driven edge case
if str(resp) == 'EDGECASEEXIT':
return HttpResponse("")
# Change in returned value type
try:
rdata = resp.data
rtype = resp.mimetype
except:
rdata = resp
rtype = "application/json"
return HttpResponse(rdata,
content_type=rtype) | python | def update(request, ident, stateless=False, **kwargs):
'Generate update json response'
dash_app, app = DashApp.locate_item(ident, stateless)
request_body = json.loads(request.body.decode('utf-8'))
if app.use_dash_dispatch():
# Force call through dash
view_func = app.locate_endpoint_function('dash-update-component')
import flask
with app.test_request_context():
# Fudge request object
# pylint: disable=protected-access
flask.request._cached_json = (request_body, flask.request._cached_json[True])
resp = view_func()
else:
# Use direct dispatch with extra arguments in the argMap
app_state = request.session.get("django_plotly_dash", dict())
arg_map = {'dash_app_id': ident,
'dash_app': dash_app,
'user': request.user,
'session_state': app_state}
resp = app.dispatch_with_args(request_body, arg_map)
request.session['django_plotly_dash'] = app_state
dash_app.handle_current_state()
# Special for ws-driven edge case
if str(resp) == 'EDGECASEEXIT':
return HttpResponse("")
# Change in returned value type
try:
rdata = resp.data
rtype = resp.mimetype
except:
rdata = resp
rtype = "application/json"
return HttpResponse(rdata,
content_type=rtype) | [
"def",
"update",
"(",
"request",
",",
"ident",
",",
"stateless",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"dash_app",
",",
"app",
"=",
"DashApp",
".",
"locate_item",
"(",
"ident",
",",
"stateless",
")",
"request_body",
"=",
"json",
".",
"loads"... | Generate update json response | [
"Generate",
"update",
"json",
"response"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/views.py#L62-L102 | train | 226,686 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/views.py | main_view | def main_view(request, ident, stateless=False, cache_id=None, **kwargs):
'Main view for a dash app'
_, app = DashApp.locate_item(ident, stateless, cache_id=cache_id)
view_func = app.locate_endpoint_function()
resp = view_func()
return HttpResponse(resp) | python | def main_view(request, ident, stateless=False, cache_id=None, **kwargs):
'Main view for a dash app'
_, app = DashApp.locate_item(ident, stateless, cache_id=cache_id)
view_func = app.locate_endpoint_function()
resp = view_func()
return HttpResponse(resp) | [
"def",
"main_view",
"(",
"request",
",",
"ident",
",",
"stateless",
"=",
"False",
",",
"cache_id",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"_",
",",
"app",
"=",
"DashApp",
".",
"locate_item",
"(",
"ident",
",",
"stateless",
",",
"cache_id",
"... | Main view for a dash app | [
"Main",
"view",
"for",
"a",
"dash",
"app"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/views.py#L104-L110 | train | 226,687 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/views.py | app_assets | def app_assets(request, **kwargs):
'Return a local dash app asset, served up through the Django static framework'
get_params = request.GET.urlencode()
extra_part = ""
if get_params:
redone_url = "/static/dash/assets/%s?%s" %(extra_part, get_params)
else:
redone_url = "/static/dash/assets/%s" % extra_part
return HttpResponseRedirect(redirect_to=redone_url) | python | def app_assets(request, **kwargs):
'Return a local dash app asset, served up through the Django static framework'
get_params = request.GET.urlencode()
extra_part = ""
if get_params:
redone_url = "/static/dash/assets/%s?%s" %(extra_part, get_params)
else:
redone_url = "/static/dash/assets/%s" % extra_part
return HttpResponseRedirect(redirect_to=redone_url) | [
"def",
"app_assets",
"(",
"request",
",",
"*",
"*",
"kwargs",
")",
":",
"get_params",
"=",
"request",
".",
"GET",
".",
"urlencode",
"(",
")",
"extra_part",
"=",
"\"\"",
"if",
"get_params",
":",
"redone_url",
"=",
"\"/static/dash/assets/%s?%s\"",
"%",
"(",
... | Return a local dash app asset, served up through the Django static framework | [
"Return",
"a",
"local",
"dash",
"app",
"asset",
"served",
"up",
"through",
"the",
"Django",
"static",
"framework"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/views.py#L131-L140 | train | 226,688 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/views.py | add_to_session | def add_to_session(request, template_name="index.html", **kwargs):
'Add some info to a session in a place that django-plotly-dash can pass to a callback'
django_plotly_dash = request.session.get("django_plotly_dash", dict())
session_add_count = django_plotly_dash.get('add_counter', 0)
django_plotly_dash['add_counter'] = session_add_count + 1
request.session['django_plotly_dash'] = django_plotly_dash
return TemplateResponse(request, template_name, {}) | python | def add_to_session(request, template_name="index.html", **kwargs):
'Add some info to a session in a place that django-plotly-dash can pass to a callback'
django_plotly_dash = request.session.get("django_plotly_dash", dict())
session_add_count = django_plotly_dash.get('add_counter', 0)
django_plotly_dash['add_counter'] = session_add_count + 1
request.session['django_plotly_dash'] = django_plotly_dash
return TemplateResponse(request, template_name, {}) | [
"def",
"add_to_session",
"(",
"request",
",",
"template_name",
"=",
"\"index.html\"",
",",
"*",
"*",
"kwargs",
")",
":",
"django_plotly_dash",
"=",
"request",
".",
"session",
".",
"get",
"(",
"\"django_plotly_dash\"",
",",
"dict",
"(",
")",
")",
"session_add_c... | Add some info to a session in a place that django-plotly-dash can pass to a callback | [
"Add",
"some",
"info",
"to",
"a",
"session",
"in",
"a",
"place",
"that",
"django",
"-",
"plotly",
"-",
"dash",
"can",
"pass",
"to",
"a",
"callback"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/views.py#L145-L154 | train | 226,689 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/views.py | asset_redirection | def asset_redirection(request, path, ident=None, stateless=False, **kwargs):
'Redirect static assets for a component'
X, app = DashApp.locate_item(ident, stateless)
# Redirect to a location based on the import path of the module containing the DjangoDash app
static_path = X.get_asset_static_url(path)
return redirect(static_path) | python | def asset_redirection(request, path, ident=None, stateless=False, **kwargs):
'Redirect static assets for a component'
X, app = DashApp.locate_item(ident, stateless)
# Redirect to a location based on the import path of the module containing the DjangoDash app
static_path = X.get_asset_static_url(path)
return redirect(static_path) | [
"def",
"asset_redirection",
"(",
"request",
",",
"path",
",",
"ident",
"=",
"None",
",",
"stateless",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"X",
",",
"app",
"=",
"DashApp",
".",
"locate_item",
"(",
"ident",
",",
"stateless",
")",
"# Redirect... | Redirect static assets for a component | [
"Redirect",
"static",
"assets",
"for",
"a",
"component"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/views.py#L156-L164 | train | 226,690 |
GibbsConsulting/django-plotly-dash | demo/demo/views.py | dash_example_1_view | def dash_example_1_view(request, template_name="demo_six.html", **kwargs):
'Example view that inserts content into the dash context passed to the dash application'
context = {}
# create some context to send over to Dash:
dash_context = request.session.get("django_plotly_dash", dict())
dash_context['django_to_dash_context'] = "I am Dash receiving context from Django"
request.session['django_plotly_dash'] = dash_context
return render(request, template_name=template_name, context=context) | python | def dash_example_1_view(request, template_name="demo_six.html", **kwargs):
'Example view that inserts content into the dash context passed to the dash application'
context = {}
# create some context to send over to Dash:
dash_context = request.session.get("django_plotly_dash", dict())
dash_context['django_to_dash_context'] = "I am Dash receiving context from Django"
request.session['django_plotly_dash'] = dash_context
return render(request, template_name=template_name, context=context) | [
"def",
"dash_example_1_view",
"(",
"request",
",",
"template_name",
"=",
"\"demo_six.html\"",
",",
"*",
"*",
"kwargs",
")",
":",
"context",
"=",
"{",
"}",
"# create some context to send over to Dash:",
"dash_context",
"=",
"request",
".",
"session",
".",
"get",
"(... | Example view that inserts content into the dash context passed to the dash application | [
"Example",
"view",
"that",
"inserts",
"content",
"into",
"the",
"dash",
"context",
"passed",
"to",
"the",
"dash",
"application"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/demo/demo/views.py#L9-L19 | train | 226,691 |
GibbsConsulting/django-plotly-dash | demo/demo/views.py | session_state_view | def session_state_view(request, template_name, **kwargs):
'Example view that exhibits the use of sessions to store state'
session = request.session
demo_count = session.get('django_plotly_dash', {})
ind_use = demo_count.get('ind_use', 0)
ind_use += 1
demo_count['ind_use'] = ind_use
context = {'ind_use' : ind_use}
session['django_plotly_dash'] = demo_count
return render(request, template_name=template_name, context=context) | python | def session_state_view(request, template_name, **kwargs):
'Example view that exhibits the use of sessions to store state'
session = request.session
demo_count = session.get('django_plotly_dash', {})
ind_use = demo_count.get('ind_use', 0)
ind_use += 1
demo_count['ind_use'] = ind_use
context = {'ind_use' : ind_use}
session['django_plotly_dash'] = demo_count
return render(request, template_name=template_name, context=context) | [
"def",
"session_state_view",
"(",
"request",
",",
"template_name",
",",
"*",
"*",
"kwargs",
")",
":",
"session",
"=",
"request",
".",
"session",
"demo_count",
"=",
"session",
".",
"get",
"(",
"'django_plotly_dash'",
",",
"{",
"}",
")",
"ind_use",
"=",
"dem... | Example view that exhibits the use of sessions to store state | [
"Example",
"view",
"that",
"exhibits",
"the",
"use",
"of",
"sessions",
"to",
"store",
"state"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/demo/demo/views.py#L21-L36 | train | 226,692 |
GibbsConsulting/django-plotly-dash | django_plotly_dash/middleware.py | ContentCollector.adjust_response | def adjust_response(self, response):
'Locate placeholder magic strings and replace with content'
try:
c1 = self._replace(response.content,
self.header_placeholder,
self.embedded_holder.css)
response.content = self._replace(c1,
self.footer_placeholder,
"\n".join([self.embedded_holder.config,
self.embedded_holder.scripts]))
except AttributeError:
# Catch the "FileResponse instance has no `content` attribute" error when serving media files in the Django development server.
pass
return response | python | def adjust_response(self, response):
'Locate placeholder magic strings and replace with content'
try:
c1 = self._replace(response.content,
self.header_placeholder,
self.embedded_holder.css)
response.content = self._replace(c1,
self.footer_placeholder,
"\n".join([self.embedded_holder.config,
self.embedded_holder.scripts]))
except AttributeError:
# Catch the "FileResponse instance has no `content` attribute" error when serving media files in the Django development server.
pass
return response | [
"def",
"adjust_response",
"(",
"self",
",",
"response",
")",
":",
"try",
":",
"c1",
"=",
"self",
".",
"_replace",
"(",
"response",
".",
"content",
",",
"self",
".",
"header_placeholder",
",",
"self",
".",
"embedded_holder",
".",
"css",
")",
"response",
"... | Locate placeholder magic strings and replace with content | [
"Locate",
"placeholder",
"magic",
"strings",
"and",
"replace",
"with",
"content"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/django_plotly_dash/middleware.py#L65-L81 | train | 226,693 |
GibbsConsulting/django-plotly-dash | demo/demo/plotly_apps.py | callback_c | def callback_c(*args, **kwargs):
'Update the output following a change of the input selection'
#da = kwargs['dash_app']
session_state = kwargs['session_state']
calls_so_far = session_state.get('calls_so_far', 0)
session_state['calls_so_far'] = calls_so_far + 1
user_counts = session_state.get('user_counts', None)
user_name = str(kwargs['user'])
if user_counts is None:
user_counts = {user_name:1}
session_state['user_counts'] = user_counts
else:
user_counts[user_name] = user_counts.get(user_name, 0) + 1
return "Args are [%s] and kwargs are %s" %(",".join(args), str(kwargs)) | python | def callback_c(*args, **kwargs):
'Update the output following a change of the input selection'
#da = kwargs['dash_app']
session_state = kwargs['session_state']
calls_so_far = session_state.get('calls_so_far', 0)
session_state['calls_so_far'] = calls_so_far + 1
user_counts = session_state.get('user_counts', None)
user_name = str(kwargs['user'])
if user_counts is None:
user_counts = {user_name:1}
session_state['user_counts'] = user_counts
else:
user_counts[user_name] = user_counts.get(user_name, 0) + 1
return "Args are [%s] and kwargs are %s" %(",".join(args), str(kwargs)) | [
"def",
"callback_c",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"#da = kwargs['dash_app']",
"session_state",
"=",
"kwargs",
"[",
"'session_state'",
"]",
"calls_so_far",
"=",
"session_state",
".",
"get",
"(",
"'calls_so_far'",
",",
"0",
")",
"session_... | Update the output following a change of the input selection | [
"Update",
"the",
"output",
"following",
"a",
"change",
"of",
"the",
"input",
"selection"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/demo/demo/plotly_apps.py#L101-L118 | train | 226,694 |
GibbsConsulting/django-plotly-dash | demo/demo/plotly_apps.py | callback_liveIn_button_press | def callback_liveIn_button_press(red_clicks, blue_clicks, green_clicks,
rc_timestamp, bc_timestamp, gc_timestamp, **kwargs): # pylint: disable=unused-argument
'Input app button pressed, so do something interesting'
if not rc_timestamp:
rc_timestamp = 0
if not bc_timestamp:
bc_timestamp = 0
if not gc_timestamp:
gc_timestamp = 0
if (rc_timestamp + bc_timestamp + gc_timestamp) < 1:
change_col = None
timestamp = 0
else:
if rc_timestamp > bc_timestamp:
change_col = "red"
timestamp = rc_timestamp
else:
change_col = "blue"
timestamp = bc_timestamp
if gc_timestamp > timestamp:
timestamp = gc_timestamp
change_col = "green"
value = {'red_clicks':red_clicks,
'blue_clicks':blue_clicks,
'green_clicks':green_clicks,
'click_colour':change_col,
'click_timestamp':timestamp,
'user':str(kwargs.get('user', 'UNKNOWN'))}
send_to_pipe_channel(channel_name="live_button_counter",
label="named_counts",
value=value)
return "Number of local clicks so far is %s red and %s blue; last change is %s at %s" % (red_clicks,
blue_clicks,
change_col,
datetime.fromtimestamp(0.001*timestamp)) | python | def callback_liveIn_button_press(red_clicks, blue_clicks, green_clicks,
rc_timestamp, bc_timestamp, gc_timestamp, **kwargs): # pylint: disable=unused-argument
'Input app button pressed, so do something interesting'
if not rc_timestamp:
rc_timestamp = 0
if not bc_timestamp:
bc_timestamp = 0
if not gc_timestamp:
gc_timestamp = 0
if (rc_timestamp + bc_timestamp + gc_timestamp) < 1:
change_col = None
timestamp = 0
else:
if rc_timestamp > bc_timestamp:
change_col = "red"
timestamp = rc_timestamp
else:
change_col = "blue"
timestamp = bc_timestamp
if gc_timestamp > timestamp:
timestamp = gc_timestamp
change_col = "green"
value = {'red_clicks':red_clicks,
'blue_clicks':blue_clicks,
'green_clicks':green_clicks,
'click_colour':change_col,
'click_timestamp':timestamp,
'user':str(kwargs.get('user', 'UNKNOWN'))}
send_to_pipe_channel(channel_name="live_button_counter",
label="named_counts",
value=value)
return "Number of local clicks so far is %s red and %s blue; last change is %s at %s" % (red_clicks,
blue_clicks,
change_col,
datetime.fromtimestamp(0.001*timestamp)) | [
"def",
"callback_liveIn_button_press",
"(",
"red_clicks",
",",
"blue_clicks",
",",
"green_clicks",
",",
"rc_timestamp",
",",
"bc_timestamp",
",",
"gc_timestamp",
",",
"*",
"*",
"kwargs",
")",
":",
"# pylint: disable=unused-argument",
"if",
"not",
"rc_timestamp",
":",
... | Input app button pressed, so do something interesting | [
"Input",
"app",
"button",
"pressed",
"so",
"do",
"something",
"interesting"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/demo/demo/plotly_apps.py#L149-L188 | train | 226,695 |
GibbsConsulting/django-plotly-dash | demo/demo/plotly_apps.py | generate_liveOut_layout | def generate_liveOut_layout():
'Generate the layout per-app, generating each tine a new uuid for the state_uid argument'
return html.Div([
dpd.Pipe(id="named_count_pipe",
value=None,
label="named_counts",
channel_name="live_button_counter"),
html.Div(id="internal_state",
children="No state has been computed yet",
style={'display':'none'}),
dcc.Graph(id="timeseries_plot"),
dcc.Input(value=str(uuid.uuid4()),
id="state_uid",
style={'display':'none'},
)
]) | python | def generate_liveOut_layout():
'Generate the layout per-app, generating each tine a new uuid for the state_uid argument'
return html.Div([
dpd.Pipe(id="named_count_pipe",
value=None,
label="named_counts",
channel_name="live_button_counter"),
html.Div(id="internal_state",
children="No state has been computed yet",
style={'display':'none'}),
dcc.Graph(id="timeseries_plot"),
dcc.Input(value=str(uuid.uuid4()),
id="state_uid",
style={'display':'none'},
)
]) | [
"def",
"generate_liveOut_layout",
"(",
")",
":",
"return",
"html",
".",
"Div",
"(",
"[",
"dpd",
".",
"Pipe",
"(",
"id",
"=",
"\"named_count_pipe\"",
",",
"value",
"=",
"None",
",",
"label",
"=",
"\"named_counts\"",
",",
"channel_name",
"=",
"\"live_button_co... | Generate the layout per-app, generating each tine a new uuid for the state_uid argument | [
"Generate",
"the",
"layout",
"per",
"-",
"app",
"generating",
"each",
"tine",
"a",
"new",
"uuid",
"for",
"the",
"state_uid",
"argument"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/demo/demo/plotly_apps.py#L195-L210 | train | 226,696 |
GibbsConsulting/django-plotly-dash | demo/demo/plotly_apps.py | callback_liveOut_pipe_in | def callback_liveOut_pipe_in(named_count, state_uid, **kwargs):
'Handle something changing the value of the input pipe or the associated state uid'
cache_key = _get_cache_key(state_uid)
state = cache.get(cache_key)
# If nothing in cache, prepopulate
if not state:
state = {}
# Guard against missing input on startup
if not named_count:
named_count = {}
# extract incoming info from the message and update the internal state
user = named_count.get('user', None)
click_colour = named_count.get('click_colour', None)
click_timestamp = named_count.get('click_timestamp', 0)
if click_colour:
colour_set = state.get(click_colour, None)
if not colour_set:
colour_set = [(None, 0, 100) for i in range(5)]
_, last_ts, prev = colour_set[-1]
# Loop over all existing timestamps and find the latest one
if not click_timestamp or click_timestamp < 1:
click_timestamp = 0
for _, the_colour_set in state.items():
_, lts, _ = the_colour_set[-1]
if lts > click_timestamp:
click_timestamp = lts
click_timestamp = click_timestamp + 1000
if click_timestamp > last_ts:
colour_set.append((user, click_timestamp, prev * random.lognormvariate(0.0, 0.1)),)
colour_set = colour_set[-100:]
state[click_colour] = colour_set
cache.set(cache_key, state, 3600)
return "(%s,%s)" % (cache_key, click_timestamp) | python | def callback_liveOut_pipe_in(named_count, state_uid, **kwargs):
'Handle something changing the value of the input pipe or the associated state uid'
cache_key = _get_cache_key(state_uid)
state = cache.get(cache_key)
# If nothing in cache, prepopulate
if not state:
state = {}
# Guard against missing input on startup
if not named_count:
named_count = {}
# extract incoming info from the message and update the internal state
user = named_count.get('user', None)
click_colour = named_count.get('click_colour', None)
click_timestamp = named_count.get('click_timestamp', 0)
if click_colour:
colour_set = state.get(click_colour, None)
if not colour_set:
colour_set = [(None, 0, 100) for i in range(5)]
_, last_ts, prev = colour_set[-1]
# Loop over all existing timestamps and find the latest one
if not click_timestamp or click_timestamp < 1:
click_timestamp = 0
for _, the_colour_set in state.items():
_, lts, _ = the_colour_set[-1]
if lts > click_timestamp:
click_timestamp = lts
click_timestamp = click_timestamp + 1000
if click_timestamp > last_ts:
colour_set.append((user, click_timestamp, prev * random.lognormvariate(0.0, 0.1)),)
colour_set = colour_set[-100:]
state[click_colour] = colour_set
cache.set(cache_key, state, 3600)
return "(%s,%s)" % (cache_key, click_timestamp) | [
"def",
"callback_liveOut_pipe_in",
"(",
"named_count",
",",
"state_uid",
",",
"*",
"*",
"kwargs",
")",
":",
"cache_key",
"=",
"_get_cache_key",
"(",
"state_uid",
")",
"state",
"=",
"cache",
".",
"get",
"(",
"cache_key",
")",
"# If nothing in cache, prepopulate",
... | Handle something changing the value of the input pipe or the associated state uid | [
"Handle",
"something",
"changing",
"the",
"value",
"of",
"the",
"input",
"pipe",
"or",
"the",
"associated",
"state",
"uid"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/demo/demo/plotly_apps.py#L221-L266 | train | 226,697 |
GibbsConsulting/django-plotly-dash | demo/demo/plotly_apps.py | callback_show_timeseries | def callback_show_timeseries(internal_state_string, state_uid, **kwargs):
'Build a timeseries from the internal state'
cache_key = _get_cache_key(state_uid)
state = cache.get(cache_key)
# If nothing in cache, prepopulate
if not state:
state = {}
colour_series = {}
colors = {'red':'#FF0000',
'blue':'#0000FF',
'green':'#00FF00',
'yellow': '#FFFF00',
'cyan': '#00FFFF',
'magenta': '#FF00FF',
'black' : '#000000',
}
for colour, values in state.items():
timestamps = [datetime.fromtimestamp(int(0.001*ts)) for _, ts, _ in values if ts > 0]
#users = [user for user, ts, _ in values if ts > 0]
levels = [level for _, ts, level in values if ts > 0]
if colour in colors:
colour_series[colour] = pd.Series(levels, index=timestamps).groupby(level=0).first()
df = pd.DataFrame(colour_series).fillna(method="ffill").reset_index()[-25:]
traces = [go.Scatter(y=df[colour],
x=df['index'],
name=colour,
line=dict(color=colors.get(colour, '#000000')),
) for colour in colour_series]
return {'data':traces,
#'layout': go.Layout
} | python | def callback_show_timeseries(internal_state_string, state_uid, **kwargs):
'Build a timeseries from the internal state'
cache_key = _get_cache_key(state_uid)
state = cache.get(cache_key)
# If nothing in cache, prepopulate
if not state:
state = {}
colour_series = {}
colors = {'red':'#FF0000',
'blue':'#0000FF',
'green':'#00FF00',
'yellow': '#FFFF00',
'cyan': '#00FFFF',
'magenta': '#FF00FF',
'black' : '#000000',
}
for colour, values in state.items():
timestamps = [datetime.fromtimestamp(int(0.001*ts)) for _, ts, _ in values if ts > 0]
#users = [user for user, ts, _ in values if ts > 0]
levels = [level for _, ts, level in values if ts > 0]
if colour in colors:
colour_series[colour] = pd.Series(levels, index=timestamps).groupby(level=0).first()
df = pd.DataFrame(colour_series).fillna(method="ffill").reset_index()[-25:]
traces = [go.Scatter(y=df[colour],
x=df['index'],
name=colour,
line=dict(color=colors.get(colour, '#000000')),
) for colour in colour_series]
return {'data':traces,
#'layout': go.Layout
} | [
"def",
"callback_show_timeseries",
"(",
"internal_state_string",
",",
"state_uid",
",",
"*",
"*",
"kwargs",
")",
":",
"cache_key",
"=",
"_get_cache_key",
"(",
"state_uid",
")",
"state",
"=",
"cache",
".",
"get",
"(",
"cache_key",
")",
"# If nothing in cache, prepo... | Build a timeseries from the internal state | [
"Build",
"a",
"timeseries",
"from",
"the",
"internal",
"state"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/demo/demo/plotly_apps.py#L273-L311 | train | 226,698 |
GibbsConsulting/django-plotly-dash | demo/demo/bootstrap_app.py | session_demo_danger_callback | def session_demo_danger_callback(da_children, session_state=None, **kwargs):
'Update output based just on state'
if not session_state:
return "Session state not yet available"
return "Session state contains: " + str(session_state.get('bootstrap_demo_state', "NOTHING")) + " and the page render count is " + str(session_state.get("ind_use", "NOT SET")) | python | def session_demo_danger_callback(da_children, session_state=None, **kwargs):
'Update output based just on state'
if not session_state:
return "Session state not yet available"
return "Session state contains: " + str(session_state.get('bootstrap_demo_state', "NOTHING")) + " and the page render count is " + str(session_state.get("ind_use", "NOT SET")) | [
"def",
"session_demo_danger_callback",
"(",
"da_children",
",",
"session_state",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"session_state",
":",
"return",
"\"Session state not yet available\"",
"return",
"\"Session state contains: \"",
"+",
"str",
"... | Update output based just on state | [
"Update",
"output",
"based",
"just",
"on",
"state"
] | 773ed081fc2ea3cc7607590322a14686a7a79bc5 | https://github.com/GibbsConsulting/django-plotly-dash/blob/773ed081fc2ea3cc7607590322a14686a7a79bc5/demo/demo/bootstrap_app.py#L57-L62 | train | 226,699 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.