\n
\n {% if current_user == post.author %}\n Edit\n {% endif %}\n {{ post.title }}
\nby {{ post.author.username }} on {{ post.created.strftime('%Y-%m-%d') }}
\n {{ post.body }}
\n{{ post.body }}
\nLogged in user: {current_user.id}
\n \n \n'''\n\n\n@app.route('/login', methods=['GET', 'POST'])\ndef login():\n if request.method == 'GET':\n return '''\n\n \n \n \n'''\n else:\n login_user(User(request.form['username']))\n return redirect(request.args.get('next', '/'))\n\n\n@app.route('/logout', methods=['POST'])\ndef logout():\n logout_user()\n return redirect('/')\n" }, { "path": "examples/quotes-aiohttp/README.md", "content": "Quotes\n======\n\nReturns 10 famous quotes each time the page is refreshed. Quotes are obtained\nby sending concurrent HTTP requests to a Quotes API with the aiohttp\nasynchronous client.\n\nTo run this example, set `FLASK_APP=quotes.py` in your environment and then use\nthe standard `flask aiorun` command to start the server.\n" }, { "path": "examples/quotes-aiohttp/quotes.py", "content": "import asyncio\nimport aiohttp\nfrom aioflask import Flask, render_template_string\n\napp = Flask(__name__)\ntemplate = '''\n\n \n\"{{ quote.content }}\" — {{ quote.author }}
\n {% endfor %}\n \n'''\n\n\nasync def get_quote(session):\n response = await session.get('https://api.quotable.io/random')\n return await response.json()\n\n\n@app.route('/')\nasync def index():\n async with aiohttp.ClientSession() as session:\n tasks = [get_quote(session) for _ in range(10)]\n quotes = await asyncio.gather(*tasks)\n return await render_template_string(template, quotes=quotes)\n" }, { "path": "examples/quotes-requests/README.md", "content": "Quotes\n======\n\nReturns 10 famous quotes each time the page is refreshed. Quotes are obtained\nby sending concurrent HTTP requests to a Quotes API with the requests client.\n\nThis example shows how you can incorporate blocking code into your aioflask\napplication without blocking the asyncio loop. \n\nTo run this example, set `FLASK_APP=quotes.py` in your environment and then use\nthe standard `flask aiorun` command to start the server.\n" }, { "path": "examples/quotes-requests/quotes.py", "content": "import greenletio\n\n# import the application with blocking functions monkey patched\nwith greenletio.patch_blocking():\n from quotes_app import app\n" }, { "path": "examples/quotes-requests/quotes_app.py", "content": "import asyncio\nfrom aioflask import Flask, render_template_string\nfrom greenletio import async_\nimport requests\n\napp = Flask(__name__)\ntemplate = '''\n\n \n\"{{ quote.content }}\" — {{ quote.author }}
\n {% endfor %}\n \n'''\n\n\n# this is a blocking function that is converted to asynchronous with\n# greenletio's @async_ decorator. For this to work, all the low-level I/O\n# functions started from this function must be asynchronous, which can be\n# achieved with greenletio's monkey patching feature.\n@async_\ndef get_quote():\n response = requests.get('https://api.quotable.io/random')\n return response.json()\n\n\n@app.route('/')\nasync def index():\n tasks = [get_quote() for _ in range(10)]\n quotes = await asyncio.gather(*tasks)\n return await render_template_string(template, quotes=quotes)\n" }, { "path": "pyproject.toml", "content": "[build-system]\nrequires = [\n \"setuptools>=42\",\n \"wheel\"\n]\nbuild-backend = \"setuptools.build_meta\"\n" }, { "path": "setup.cfg", "content": "[metadata]\nname = aioflask\nversion = 0.4.1.dev0\nauthor = Miguel Grinberg\nauthor_email = miguel.grinberg@gmail.com\ndescription = Flask running on asyncio.\nlong_description = file: README.md\nlong_description_content_type = text/markdown\nurl = https://github.com/miguelgrinberg/aioflask\nproject_urls =\n Bug Tracker = https://github.com/miguelgrinberg/aioflask/issues\nclassifiers =\n Intended Audience :: Developers\n Programming Language :: Python :: 3\n License :: OSI Approved :: MIT License\n Operating System :: OS Independent\n\n[options]\nzip_safe = False\ninclude_package_data = True\npackage_dir =\n = src\npackages = find:\npython_requires = >=3.6\ninstall_requires =\n greenletio\n flask >= 2\n uvicorn\n\n[options.packages.find]\nwhere = src\n\n[options.entry_points]\nflask.commands = \n aiorun = aioflask.cli:run_command\n\n[options.extras_require]\ndocs =\n sphinx\n" }, { "path": "setup.py", "content": "import setuptools\n\nsetuptools.setup()\n" }, { "path": "src/aioflask/__init__.py", "content": "from flask import *\nfrom .app import Flask\nfrom .templating import render_template, render_template_string\nfrom .testing import FlaskClient\n" }, { "path": "src/aioflask/app.py", "content": "import asyncio\nfrom functools import wraps\nfrom inspect import iscoroutinefunction\nimport os\nfrom flask.app import *\nfrom flask.app import Flask as OriginalFlask\nfrom flask import cli\nfrom flask.globals import _app_ctx_stack, _request_ctx_stack\nfrom flask.helpers import get_debug_flag, get_env, get_load_dotenv\nfrom greenletio import await_\nimport uvicorn\nfrom .asgi import WsgiToAsgiInstance\nfrom .cli import show_server_banner, AppGroup\nfrom .ctx import AppContext, RequestContext\nfrom .testing import FlaskClient, FlaskCliRunner\n\n\nclass Flask(OriginalFlask):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.cli = AppGroup()\n self.jinja_options['enable_async'] = True\n self.test_client_class = FlaskClient\n self.test_cli_runner_class = FlaskCliRunner\n self.async_fixed = False\n\n def ensure_sync(self, func):\n if not iscoroutinefunction(func):\n return func\n\n def wrapped(*args, **kwargs):\n appctx = _app_ctx_stack.top\n reqctx = _request_ctx_stack.top\n\n async def _coro():\n # app context is push internally to avoid changing reference\n # counts and emitting duplicate signals\n _app_ctx_stack.push(appctx)\n if reqctx:\n _request_ctx_stack.push(reqctx)\n ret = await func(*args, **kwargs)\n if reqctx:\n _request_ctx_stack.pop()\n _app_ctx_stack.pop()\n return ret\n\n return await_(_coro())\n\n return wrapped\n\n def app_context(self):\n return AppContext(self)\n\n def request_context(self, environ):\n return RequestContext(self, environ)\n\n def _fix_async(self): # pragma: no cover\n self.async_fixed = True\n\n if os.environ.get('AIOFLASK_USE_DEBUGGER') == 'true':\n os.environ['WERKZEUG_RUN_MAIN'] = 'true'\n from werkzeug.debug import DebuggedApplication\n self.wsgi_app = DebuggedApplication(self.wsgi_app, evalex=True)\n\n async def asgi_app(self, scope, receive, send): # pragma: no cover\n if not self.async_fixed:\n self._fix_async()\n return await WsgiToAsgiInstance(self.wsgi_app)(scope, receive, send)\n\n async def __call__(self, scope, receive, send=None): # pragma: no cover\n if send is None:\n # we were called with two arguments, so this is likely a WSGI app\n raise RuntimeError('The WSGI interface is not supported by '\n 'aioflask, use an ASGI web server instead.')\n return await self.asgi_app(scope, receive, send)\n\n def run(self, host=None, port=None, debug=None, load_dotenv=True,\n **options):\n\n if get_load_dotenv(load_dotenv):\n cli.load_dotenv()\n\n # if set, let env vars override previous values\n if \"FLASK_ENV\" in os.environ:\n self.env = get_env()\n self.debug = get_debug_flag()\n elif \"FLASK_DEBUG\" in os.environ:\n self.debug = get_debug_flag()\n\n # debug passed to method overrides all other sources\n if debug is not None:\n self.debug = bool(debug)\n\n server_name = self.config.get(\"SERVER_NAME\")\n sn_host = sn_port = None\n\n if server_name:\n sn_host, _, sn_port = server_name.partition(\":\")\n\n if not host:\n if sn_host:\n host = sn_host\n else:\n host = \"127.0.0.1\"\n\n if port or port == 0:\n port = int(port)\n elif sn_port:\n port = int(sn_port)\n else:\n port = 5000\n\n options.setdefault(\"use_reloader\", self.debug)\n options.setdefault(\"use_debugger\", self.debug)\n options.setdefault(\"threaded\", True)\n options.setdefault(\"workers\", 1)\n\n certfile = None\n keyfile = None\n cert = options.get('ssl_context')\n if cert is not None and len(cert) == 2:\n certfile = cert[0]\n keyfile = cert[1]\n elif cert == 'adhoc':\n raise RuntimeError(\n 'Aad-hoc certificates are not supported by aioflask.')\n\n if debug:\n os.environ['FLASK_DEBUG'] = 'true'\n\n if options['use_debugger']:\n os.environ['AIOFLASK_USE_DEBUGGER'] = 'true'\n\n show_server_banner(self.env, self.debug, self.name, False)\n\n uvicorn.run(\n self.import_name + ':app',\n host=host,\n port=port,\n reload=options['use_reloader'],\n workers=options['workers'],\n log_level='debug' if self.debug else 'info',\n ssl_certfile=certfile,\n ssl_keyfile=keyfile,\n )\n" }, { "path": "src/aioflask/asgi.py", "content": "import sys\nfrom tempfile import SpooledTemporaryFile\nfrom greenletio import async_, await_\n\n\nclass wsgi_to_asgi: # pragma: no cover\n \"\"\"Wraps a WSGI application to make it into an ASGI application.\"\"\"\n\n def __init__(self, wsgi_application):\n self.wsgi_application = wsgi_application\n\n async def __call__(self, scope, receive, send):\n \"\"\"ASGI application instantiation point.\n\n We return a new WsgiToAsgiInstance here with the WSGI app\n and the scope, ready to respond when it is __call__ed.\n \"\"\"\n await WsgiToAsgiInstance(self.wsgi_application)(scope, receive, send)\n\n\nclass WsgiToAsgiInstance: # pragma: no cover\n \"\"\"Per-socket instance of a wrapped WSGI application\"\"\"\n\n def __init__(self, wsgi_application):\n self.wsgi_application = wsgi_application\n self.response_started = False\n\n async def __call__(self, scope, receive, send):\n if scope[\"type\"] != \"http\":\n raise ValueError(\"WSGI wrapper received a non-HTTP scope\")\n self.scope = scope\n with SpooledTemporaryFile(max_size=65536) as body:\n # Alright, wait for the http.request messages\n while True:\n message = await receive()\n if message[\"type\"] != \"http.request\":\n raise ValueError(\n \"WSGI wrapper received a non-HTTP-request message\")\n body.write(message.get(\"body\", b\"\"))\n if not message.get(\"more_body\"):\n break\n body.seek(0)\n\n # Wrap send so it can be called from the subthread\n self.sync_send = await_(send)\n # Call the WSGI app\n await self.run_wsgi_app(body)\n\n def build_environ(self, scope, body):\n \"\"\"Builds a scope and request body into a WSGI environ object.\"\"\"\n environ = {\n \"REQUEST_METHOD\": scope[\"method\"],\n \"SCRIPT_NAME\": scope.get(\"root_path\", \"\"),\n \"PATH_INFO\": scope[\"path\"],\n \"QUERY_STRING\": scope[\"query_string\"].decode(\"ascii\"),\n \"SERVER_PROTOCOL\": \"HTTP/%s\" % scope[\"http_version\"],\n \"wsgi.version\": (1, 0),\n \"wsgi.url_scheme\": scope.get(\"scheme\", \"http\"),\n \"wsgi.input\": body,\n \"wsgi.errors\": sys.stderr,\n \"wsgi.multithread\": True,\n \"wsgi.multiprocess\": True,\n \"wsgi.run_once\": False,\n }\n # Get server name and port - required in WSGI, not in ASGI\n if \"server\" in scope:\n environ[\"SERVER_NAME\"] = scope[\"server\"][0]\n environ[\"SERVER_PORT\"] = str(scope[\"server\"][1])\n else:\n environ[\"SERVER_NAME\"] = \"localhost\"\n environ[\"SERVER_PORT\"] = \"80\"\n\n if \"client\" in scope:\n environ[\"REMOTE_ADDR\"] = scope[\"client\"][0]\n\n # Go through headers and make them into environ entries\n for name, value in self.scope.get(\"headers\", []):\n name = name.decode(\"latin1\")\n if name == \"content-length\":\n corrected_name = \"CONTENT_LENGTH\"\n elif name == \"content-type\":\n corrected_name = \"CONTENT_TYPE\"\n else:\n corrected_name = \"HTTP_%s\" % name.upper().replace(\"-\", \"_\")\n # HTTPbis say only ASCII chars are allowed in headers, but we\n # latin1 just in case\n value = value.decode(\"latin1\")\n if corrected_name in environ:\n value = environ[corrected_name] + \",\" + value\n environ[corrected_name] = value\n return environ\n\n def start_response(self, status, response_headers, exc_info=None):\n \"\"\"WSGI start_response callable.\"\"\"\n\n # Don't allow re-calling once response has begun\n if self.response_started:\n raise exc_info[1].with_traceback(exc_info[2])\n # Don't allow re-calling without exc_info\n if hasattr(self, \"response_start\") and exc_info is None:\n raise ValueError(\n \"You cannot call start_response a second time without exc_info\"\n )\n # Extract status code\n status_code, _ = status.split(\" \", 1)\n status_code = int(status_code)\n # Extract headers\n headers = [\n (name.lower().encode(\"ascii\"), value.encode(\"ascii\"))\n for name, value in response_headers\n ]\n # Build and send response start message.\n self.response_start = {\n \"type\": \"http.response.start\",\n \"status\": status_code,\n \"headers\": headers,\n }\n\n @async_\n def run_wsgi_app(self, body):\n \"\"\"WSGI app greenlet.\"\"\"\n # Translate the scope and incoming request body into a WSGI environ\n environ = self.build_environ(self.scope, body)\n # Run the WSGI app\n for output in self.wsgi_application(environ, self.start_response):\n # If this is the first response, include the response headers\n if not self.response_started:\n self.response_started = True\n self.sync_send(self.response_start)\n self.sync_send({\"type\": \"http.response.body\", \"body\": output,\n \"more_body\": True})\n # Close connection\n if not self.response_started:\n self.response_started = True\n self.sync_send(self.response_start)\n self.sync_send({\"type\": \"http.response.body\"})\n" }, { "path": "src/aioflask/cli.py", "content": "from functools import wraps\nfrom inspect import iscoroutinefunction\nimport os\nimport sys\n\nfrom flask.cli import *\nfrom flask.cli import AppGroup, ScriptInfo, update_wrapper, \\\n SeparatedPathType, pass_script_info, get_debug_flag, NoAppException, \\\n prepare_import\nfrom flask.cli import _validate_key\nfrom flask.globals import _app_ctx_stack\nfrom flask.helpers import get_env\nfrom greenletio import await_\nfrom werkzeug.utils import import_string\nimport click\nimport uvicorn\n\ntry:\n import ssl\nexcept ImportError: # pragma: no cover\n ssl = None\n\nOriginalAppGroup = AppGroup\n\n\ndef _ensure_sync(func, with_appcontext=False):\n if not iscoroutinefunction(func):\n return func\n\n def decorated(*args, **kwargs):\n if with_appcontext:\n appctx = _app_ctx_stack.top\n\n @await_\n async def _coro():\n with appctx:\n return await func(*args, **kwargs)\n else:\n @await_\n async def _coro():\n return await func(*args, **kwargs)\n\n return _coro()\n\n return decorated\n\n\ndef with_appcontext(f):\n \"\"\"Wraps a callback so that it's guaranteed to be executed with the\n script's application context. If callbacks are registered directly\n to the ``app.cli`` object then they are wrapped with this function\n by default unless it's disabled.\n \"\"\"\n\n @click.pass_context\n def decorator(__ctx, *args, **kwargs):\n with __ctx.ensure_object(ScriptInfo).load_app().app_context():\n return __ctx.invoke(_ensure_sync(f, True), *args, **kwargs)\n\n return update_wrapper(decorator, f)\n\n\nclass AppGroup(OriginalAppGroup):\n \"\"\"This works similar to a regular click :class:`~click.Group` but it\n changes the behavior of the :meth:`command` decorator so that it\n automatically wraps the functions in :func:`with_appcontext`.\n Not to be confused with :class:`FlaskGroup`.\n \"\"\"\n\n def command(self, *args, **kwargs):\n \"\"\"This works exactly like the method of the same name on a regular\n :class:`click.Group` but it wraps callbacks in :func:`with_appcontext`\n unless it's disabled by passing ``with_appcontext=False``.\n \"\"\"\n wrap_for_ctx = kwargs.pop(\"with_appcontext\", True)\n\n def decorator(f):\n if wrap_for_ctx:\n f = with_appcontext(f)\n return click.Group.command(self, *args, **kwargs)(_ensure_sync(f))\n\n return decorator\n\n\ndef show_server_banner(env, debug, app_import_path, eager_loading):\n \"\"\"Show extra startup messages the first time the server is run,\n ignoring the reloader.\n \"\"\"\n if app_import_path is not None:\n message = f\" * Serving Flask app {app_import_path!r}\"\n\n click.echo(message)\n\n click.echo(f\" * Environment: {env}\")\n\n if debug is not None:\n click.echo(f\" * Debug mode: {'on' if debug else 'off'}\")\n\n\nclass CertParamType(click.ParamType):\n \"\"\"Click option type for the ``--cert`` option. Allows either an\n existing file, the string ``'adhoc'``, or an import for a\n :class:`~ssl.SSLContext` object.\n \"\"\"\n\n name = \"path\"\n\n def __init__(self):\n self.path_type = click.Path(exists=True, dir_okay=False,\n resolve_path=True)\n\n def convert(self, value, param, ctx):\n if ssl is None:\n raise click.BadParameter('Using \"--cert\" requires Python to be '\n 'compiled with SSL support.',\n ctx, param)\n\n try:\n return self.path_type(value, param, ctx)\n except click.BadParameter:\n value = click.STRING(value, param, ctx).lower()\n\n if value == \"adhoc\":\n raise click.BadParameter(\"Aad-hoc certificates are currently \"\n \"not supported by aioflask.\",\n ctx, param)\n\n return value\n\n obj = import_string(value, silent=True)\n\n if isinstance(obj, ssl.SSLContext):\n return obj\n\n raise\n\n\n@click.command(\"run\", short_help=\"Run a development server.\")\n@click.option(\"--host\", \"-h\", default=\"127.0.0.1\",\n help=\"The interface to bind to.\")\n@click.option(\"--port\", \"-p\", default=5000, help=\"The port to bind to.\")\n@click.option(\n \"--cert\", type=CertParamType(),\n help=\"Specify a certificate file to use HTTPS.\"\n)\n@click.option(\n \"--key\",\n type=click.Path(exists=True, dir_okay=False, resolve_path=True),\n callback=_validate_key,\n expose_value=False,\n help=\"The key file to use when specifying a certificate.\",\n)\n@click.option(\n \"--reload/--no-reload\",\n default=None,\n help=\"Enable or disable the reloader. By default the reloader \"\n \"is active if debug is enabled.\",\n)\n@click.option(\n \"--debugger/--no-debugger\",\n default=None,\n help=\"Enable or disable the debugger. By default the debugger \"\n \"is active if debug is enabled.\",\n)\n@click.option(\n \"--eager-loading/--lazy-loading\",\n default=None,\n help=\"Enable or disable eager loading. By default eager \"\n \"loading is enabled if the reloader is disabled.\",\n)\n@click.option(\n \"--with-threads/--without-threads\",\n default=True,\n help=\"Enable or disable multithreading.\",\n)\n@click.option(\n \"--extra-files\",\n default=None,\n type=SeparatedPathType(),\n help=(\n \"Extra files that trigger a reload on change. Multiple paths\"\n f\" are separated by {os.path.pathsep!r}.\"\n ),\n)\n@pass_script_info\ndef run_command(info, host, port, reload, debugger, eager_loading,\n with_threads, cert, extra_files):\n \"\"\"Run a local development server.\n This server is for development purposes only. It does not provide\n the stability, security, or performance of production WSGI servers.\n The reloader and debugger are enabled by default if\n FLASK_ENV=development or FLASK_DEBUG=1.\n \"\"\"\n debug = get_debug_flag()\n\n if reload is None:\n reload = debug\n\n if debugger is None:\n debugger = debug\n if debugger:\n os.environ['AIOFLASK_USE_DEBUGGER'] = 'true'\n\n certfile = None\n keyfile = None\n if cert is not None and len(cert) == 2:\n certfile = cert[0]\n keyfile = cert[1]\n\n show_server_banner(get_env(), debug, info.app_import_path, eager_loading)\n\n app_import_path = info.app_import_path\n if app_import_path is None:\n for path in ('wsgi', 'app'):\n if os.path.exists(path) or os.path.exists(path + '.py'):\n app_import_path = path\n break\n if app_import_path is None:\n raise NoAppException(\n \"Could not locate a Flask application. You did not provide \"\n 'the \"FLASK_APP\" environment variable, and a \"wsgi.py\" or '\n '\"app.py\" module was not found in the current directory.'\n )\n if app_import_path.endswith('.py'):\n app_import_path = app_import_path[:-3]\n\n factory = False\n if app_import_path.endswith('()'):\n # TODO: this needs to be expanded to accept arguments for the factory\n # function\n app_import_path = app_import_path[:-2]\n factory = True\n\n if ':' not in app_import_path:\n app_import_path += ':app'\n\n import_name, app_name = app_import_path.split(':')\n import_name = prepare_import(import_name)\n\n uvicorn.run(\n import_name + ':' + app_name,\n factory=factory,\n host=host,\n port=port,\n reload=reload,\n workers=1,\n log_level='debug' if debug else 'info',\n ssl_certfile=certfile,\n ssl_keyfile=keyfile,\n )\n\n # currently not supported:\n # - eager_loading\n # - with_threads\n # - adhoc certs\n # - extra_files\n" }, { "path": "src/aioflask/ctx.py", "content": "import sys\nfrom greenletio import async_\nfrom flask.ctx import *\nfrom flask.ctx import AppContext as OriginalAppContext, \\\n RequestContext as OriginalRequestContext, _sentinel, _app_ctx_stack, \\\n _request_ctx_stack, appcontext_popped\n\n\nclass AppContext(OriginalAppContext):\n async def apush(self):\n \"\"\"Binds the app context to the current context.\"\"\"\n self.push()\n\n async def apop(self, exc=_sentinel):\n \"\"\"Pops the app context.\"\"\"\n try:\n self._refcnt -= 1\n if self._refcnt <= 0:\n if exc is _sentinel: # pragma: no cover\n exc = sys.exc_info()[1]\n\n @async_\n def do_teardown_async():\n _app_ctx_stack.push(self)\n self.app.do_teardown_appcontext(exc)\n _app_ctx_stack.pop()\n\n await do_teardown_async()\n finally:\n rv = _app_ctx_stack.pop()\n assert rv is self, \\\n f\"Popped wrong app context. ({rv!r} instead of {self!r})\"\n appcontext_popped.send(self.app)\n\n async def __aenter__(self):\n await self.apush()\n return self\n\n async def __aexit__(self, exc_type, exc_value, tb):\n await self.apop(exc_value)\n\n\nclass RequestContext(OriginalRequestContext):\n async def apush(self):\n self.push()\n\n async def apop(self, exc=_sentinel):\n app_ctx = self._implicit_app_ctx_stack.pop()\n clear_request = False\n\n try:\n if not self._implicit_app_ctx_stack:\n if hasattr(self, 'preserved'): # Flask < 2.2\n self.preserved = False\n self._preserved_exc = None\n if exc is _sentinel: # pragma: no cover\n exc = sys.exc_info()[1]\n\n @async_\n def do_teardown():\n _request_ctx_stack.push(self)\n self.app.do_teardown_request(exc)\n _request_ctx_stack.pop()\n\n await do_teardown()\n\n request_close = getattr(self.request, \"close\", None)\n if request_close is not None: # pragma: no branch\n request_close()\n clear_request = True\n finally:\n rv = _request_ctx_stack.pop()\n\n # get rid of circular dependencies at the end of the request\n # so that we don't require the GC to be active.\n if clear_request:\n rv.request.environ[\"werkzeug.request\"] = None\n\n # Get rid of the app as well if necessary.\n if app_ctx is not None:\n await app_ctx.apop(exc)\n\n assert (\n rv is self\n ), f\"Popped wrong request context. ({rv!r} instead of {self!r})\"\n\n async def aauto_pop(self, exc):\n if hasattr(self, 'preserved'): # Flask < 2.2\n if self.request.environ.get(\"flask._preserve_context\") or (\n exc is not None and self.app.preserve_context_on_exception\n ): # pragma: no cover\n self.preserved = True\n self._preserved_exc = exc\n else:\n await self.apop(exc)\n else:\n await self.apop(exc)\n\n async def __aenter__(self):\n await self.apush()\n return self\n\n async def __aexit__(self, exc_type, exc_value, tb):\n await self.aauto_pop(exc_value)\n" }, { "path": "src/aioflask/patch.py", "content": "from functools import wraps\nfrom aioflask import current_app\n\n\ndef patch_decorator(decorator):\n def patched_decorator(f):\n @wraps(f)\n def ensure_sync(*a, **kw):\n return current_app.ensure_sync(f)(*a, **kw)\n\n return decorator(ensure_sync)\n return patched_decorator\n\n\ndef patch_decorator_with_args(decorator):\n def patched_decorator(*args, **kwargs):\n def inner_patched_decorator(f):\n @wraps(f)\n def ensure_sync(*a, **kw):\n return current_app.ensure_sync(f)(*a, **kw)\n\n return decorator(*args, **kwargs)(ensure_sync)\n return inner_patched_decorator\n return patched_decorator\n\n\ndef patch_decorator_method(class_, method_name):\n original_decorator = getattr(class_, method_name)\n\n def patched_decorator_method(self, f):\n @wraps(f)\n def ensure_sync(*a, **kw):\n return current_app.ensure_sync(f)(*a, **kw)\n\n return original_decorator(self, ensure_sync)\n return patched_decorator_method\n\n\ndef patch_decorator_method_with_args(class_, method_name):\n original_decorator = getattr(class_, method_name)\n\n def patched_decorator_method(self, *args, **kwargs):\n def inner_patched_decorator_method(f):\n @wraps(f)\n def ensure_sync(*a, **kw):\n return current_app.ensure_sync(f)(*a, **kw)\n\n return original_decorator(self, *args, **kwargs)(ensure_sync)\n return inner_patched_decorator_method\n return patched_decorator_method\n" }, { "path": "src/aioflask/patched/__init__.py", "content": "" }, { "path": "src/aioflask/patched/flask_login/__init__.py", "content": "from functools import wraps\nimport sys\nfrom werkzeug.local import LocalProxy\nfrom aioflask import current_app, g\nfrom flask import _request_ctx_stack\nfrom aioflask.patch import patch_decorator, patch_decorator_method\nimport flask_login\nfrom flask_login import login_required, fresh_login_required, \\\n LoginManager as OriginalLoginManager\n\nfor symbol in flask_login.__all__:\n try:\n globals()[symbol] = getattr(flask_login, symbol)\n except AttributeError:\n pass\n\n\ndef _user_context_processor():\n return {'current_user': _get_user()}\n\n\ndef _load_user():\n # Obtain the current user and preserve it in the g object. Flask-Login\n # saves the user in a custom attribute of the request context, but that\n # doesn't work with aioflask because when a copy of the request context is\n # made, custom attributes are not carried over to the copy.\n current_app.login_manager._load_user()\n g.flask_login_current_user = _request_ctx_stack.top.user\n\n\ndef _get_user():\n # Return the current user. This function is linked to the current_user\n # context local, but unlike the original in Flask-Login, it does not\n # attempt to load the user, it just returns the user that was pre-loaded.\n # This avoids the somewhat tricky complication of triggering database\n # operations that need to be awaited, which would require using something\n # like (await current_user)\n if hasattr(g, 'flask_login_current_user'):\n return g.flask_login_current_user\n return current_app.login_manager.anonymous_user()\n\n\nclass LoginManager(OriginalLoginManager):\n def init_app(self, app, add_context_processor=True):\n super().init_app(app, add_context_processor=False)\n if add_context_processor:\n app.context_processor(_user_context_processor)\n\n # To prevent the current_user context local from triggering I/O at a\n # random time when it is first referenced (which is a big complication\n # if the I/O is async and needs to be awaited), we force the user to be\n # loaded before each request. This isn't a perfect solution, because\n # a before request handler registered before this one will not see the\n # current user.\n app.before_request(_load_user)\n\n # the decorators that register callbacks need to be patched to support\n # async views\n user_loader = patch_decorator_method(OriginalLoginManager, 'user_loader')\n header_loader = patch_decorator_method(\n OriginalLoginManager, 'header_loader')\n request_loader = patch_decorator_method(\n OriginalLoginManager, 'request_loader')\n unauthorized_handler = patch_decorator_method(\n OriginalLoginManager, 'unauthorized_handler')\n needs_refresh_handler = patch_decorator_method(\n OriginalLoginManager, 'needs_refresh_handler')\n\n\n# patch the two login_required decorators so that they accept async views\nlogin_required = patch_decorator(login_required)\nfresh_login_required = patch_decorator(fresh_login_required)\n\n\n# redefine the current_user context local\ncurrent_user = LocalProxy(_get_user)\n\n# patch the _get_user() function in the flask_login.utils module so that any\n# calls to get current_user in Flask-Login functions are redirected here\nsetattr(sys.modules['flask_login.utils'], '_get_user', _get_user)\n" }, { "path": "src/aioflask/templating.py", "content": "from flask.templating import *\nfrom flask.templating import _app_ctx_stack, before_render_template, \\\n template_rendered\n\n\nasync def _render(template, context, app):\n \"\"\"Renders the template and fires the signal\"\"\"\n\n before_render_template.send(app, template=template, context=context)\n rv = await template.render_async(context)\n template_rendered.send(app, template=template, context=context)\n return rv\n\n\nasync def render_template(template_name_or_list, **context):\n \"\"\"Renders a template from the template folder with the given\n context.\n :param template_name_or_list: the name of the template to be\n rendered, or an iterable with template names\n the first one existing will be rendered\n :param context: the variables that should be available in the\n context of the template.\n \"\"\"\n ctx = _app_ctx_stack.top\n ctx.app.update_template_context(context)\n return await _render(\n ctx.app.jinja_env.get_or_select_template(template_name_or_list),\n context,\n ctx.app,\n )\n\n\nasync def render_template_string(source, **context):\n \"\"\"Renders a template from the given template source string\n with the given context. Template variables will be autoescaped.\n :param source: the source code of the template to be\n rendered\n :param context: the variables that should be available in the\n context of the template.\n \"\"\"\n ctx = _app_ctx_stack.top\n ctx.app.update_template_context(context)\n return await _render(ctx.app.jinja_env.from_string(source), context,\n ctx.app)\n" }, { "path": "src/aioflask/testing.py", "content": "from flask.testing import *\nfrom flask.testing import FlaskClient as OriginalFlaskClient, \\\n FlaskCliRunner as OriginalFlaskCliRunner\nfrom flask import _request_ctx_stack\nfrom werkzeug.test import run_wsgi_app\nfrom greenletio import async_\n\n\nclass FlaskClient(OriginalFlaskClient):\n def run_wsgi_app(self, environ, buffered=False):\n \"\"\"Runs the wrapped WSGI app with the given environment.\n :meta private:\n \"\"\"\n if self.cookie_jar is not None:\n self.cookie_jar.inject_wsgi(environ)\n\n rv = run_wsgi_app(self.application.wsgi_app, environ,\n buffered=buffered)\n\n if self.cookie_jar is not None:\n self.cookie_jar.extract_wsgi(environ, rv[2])\n\n return rv\n\n async def get(self, *args, **kwargs):\n return await async_(super().get)(*args, **kwargs)\n\n async def post(self, *args, **kwargs):\n return await async_(super().post)(*args, **kwargs)\n\n async def put(self, *args, **kwargs):\n return await async_(super().put)(*args, **kwargs)\n\n async def patch(self, *args, **kwargs):\n return await async_(super().patch)(*args, **kwargs)\n\n async def delete(self, *args, **kwargs):\n return await async_(super().delete)(*args, **kwargs)\n\n async def head(self, *args, **kwargs):\n return await async_(super().head)(*args, **kwargs)\n\n async def options(self, *args, **kwargs):\n return await async_(super().options)(*args, **kwargs)\n\n async def trace(self, *args, **kwargs):\n return await async_(super().trace)(*args, **kwargs)\n\n async def __aenter__(self):\n if self.preserve_context:\n raise RuntimeError(\"Cannot nest client invocations\")\n self.preserve_context = True\n return self\n\n async def __aexit__(self, exc_type, exc_value, tb):\n self.preserve_context = False\n\n # Normally the request context is preserved until the next\n # request in the same thread comes. When the client exits we\n # want to clean up earlier. Pop request contexts until the stack\n # is empty or a non-preserved one is found.\n while True:\n top = _request_ctx_stack.top\n\n if top is not None and top.preserved:\n await top.apop()\n else:\n break\n\n\nclass FlaskCliRunner(OriginalFlaskCliRunner):\n async def invoke(self, *args, **kwargs):\n return await async_(super().invoke)(*args, **kwargs)\n" }, { "path": "tests/__init__.py", "content": "" }, { "path": "tests/templates/template.html", "content": "{{ g.x }}{{ session.y }}\n" }, { "path": "tests/test_app.py", "content": "import asyncio\nimport os\nimport unittest\nfrom unittest import mock\nimport aioflask\nfrom .utils import async_test\n\n\nclass TestApp(unittest.TestCase):\n @async_test\n async def test_app(self):\n app = aioflask.Flask(__name__)\n\n @app.route('/async')\n async def async_route():\n await asyncio.sleep(0)\n assert aioflask.current_app._get_current_object() == app\n return 'async'\n\n @app.route('/sync')\n def sync_route():\n assert aioflask.current_app._get_current_object() == app\n return 'sync'\n\n client = app.test_client()\n response = await client.get('/async')\n assert response.data == b'async'\n response = await client.get('/sync')\n assert response.data == b'sync'\n\n @async_test\n async def test_g(self):\n app = aioflask.Flask(__name__)\n app.secret_key = 'secret'\n\n @app.before_request\n async def async_before_request():\n aioflask.g.asyncvar = 'async'\n\n @app.before_request\n def sync_before_request():\n aioflask.g.syncvar = 'sync'\n\n @app.route('/async')\n async def async_route():\n aioflask.session['a'] = 'async'\n return f'{aioflask.g.asyncvar}-{aioflask.g.syncvar}'\n\n @app.route('/sync')\n async def sync_route():\n aioflask.session['s'] = 'sync'\n return f'{aioflask.g.asyncvar}-{aioflask.g.syncvar}'\n\n @app.route('/session')\n async def session():\n return f'{aioflask.session.get(\"a\")}-{aioflask.session.get(\"s\")}'\n\n @app.after_request\n async def after_request(rv):\n rv.data += f'/{aioflask.g.asyncvar}-{aioflask.g.syncvar}'.encode()\n return rv\n\n client = app.test_client()\n response = await client.get('/session')\n assert response.data == b'None-None/async-sync'\n response = await client.get('/async')\n assert response.data == b'async-sync/async-sync'\n response = await client.get('/session')\n assert response.data == b'async-None/async-sync'\n response = await client.get('/sync')\n assert response.data == b'async-sync/async-sync'\n response = await client.get('/session')\n assert response.data == b'async-sync/async-sync'\n\n @mock.patch('aioflask.app.uvicorn')\n def test_app_run(self, uvicorn):\n app = aioflask.Flask(__name__)\n\n app.run()\n uvicorn.run.assert_called_with('tests.test_app:app',\n host='127.0.0.1', port=5000,\n reload=False, workers=1,\n log_level='info', ssl_certfile=None,\n ssl_keyfile=None)\n app.run(host='1.2.3.4', port=3000)\n uvicorn.run.assert_called_with('tests.test_app:app',\n host='1.2.3.4', port=3000,\n reload=False, workers=1,\n log_level='info', ssl_certfile=None,\n ssl_keyfile=None)\n app.run(debug=True)\n uvicorn.run.assert_called_with('tests.test_app:app',\n host='127.0.0.1', port=5000,\n reload=True, workers=1,\n log_level='debug', ssl_certfile=None,\n ssl_keyfile=None)\n app.run(debug=True, use_reloader=False)\n uvicorn.run.assert_called_with('tests.test_app:app',\n host='127.0.0.1', port=5000,\n reload=False, workers=1,\n log_level='debug', ssl_certfile=None,\n ssl_keyfile=None)\n if 'FLASK_DEBUG' in os.environ:\n del os.environ['FLASK_DEBUG']\n if 'AIOFLASK_USE_DEBUGGER' in os.environ:\n del os.environ['AIOFLASK_USE_DEBUGGER']\n" }, { "path": "tests/test_cli.py", "content": "import os\nimport unittest\nfrom unittest import mock\nimport click\nfrom click.testing import CliRunner\nimport aioflask\nimport aioflask.cli\nfrom .utils import async_test\n\n\nclass TestCli(unittest.TestCase):\n @async_test\n async def test_command_with_appcontext(self):\n app = aioflask.Flask('testapp')\n\n @app.cli.command(with_appcontext=True)\n async def testcmd():\n click.echo(aioflask.current_app.name)\n\n result = await app.test_cli_runner().invoke(testcmd)\n assert result.exit_code == 0\n assert result.output == \"testapp\\n\"\n\n @async_test\n async def test_command_without_appcontext(self):\n app = aioflask.Flask('testapp')\n\n @app.cli.command(with_appcontext=False)\n async def testcmd():\n click.echo(aioflask.current_app.name)\n\n result = await app.test_cli_runner().invoke(testcmd)\n assert result.exit_code == 1\n assert type(result.exception) == RuntimeError\n\n @async_test\n async def test_with_appcontext(self):\n @click.command()\n @aioflask.cli.with_appcontext\n async def testcmd():\n click.echo(aioflask.current_app.name)\n\n app = aioflask.Flask('testapp')\n\n result = await app.test_cli_runner().invoke(testcmd)\n assert result.exit_code == 0\n assert result.output == \"testapp\\n\"\n\n @mock.patch('aioflask.cli.uvicorn')\n def test_aiorun(self, uvicorn):\n app = aioflask.Flask('testapp')\n obj = aioflask.cli.ScriptInfo(app_import_path='app.py',\n create_app=lambda: app)\n\n result = CliRunner().invoke(aioflask.cli.run_command, obj=obj)\n assert result.exit_code == 0\n uvicorn.run.assert_called_with('app:app', factory=False,\n host='127.0.0.1', port=5000,\n reload=False, workers=1,\n log_level='info', ssl_certfile=None,\n ssl_keyfile=None)\n result = CliRunner().invoke(aioflask.cli.run_command,\n '--host 1.2.3.4 --port 3000', obj=obj)\n assert result.exit_code == 0\n uvicorn.run.assert_called_with('app:app', factory=False,\n host='1.2.3.4', port=3000,\n reload=False, workers=1,\n log_level='info', ssl_certfile=None,\n ssl_keyfile=None)\n os.environ['FLASK_DEBUG'] = 'true'\n result = CliRunner().invoke(aioflask.cli.run_command, obj=obj)\n assert result.exit_code == 0\n uvicorn.run.assert_called_with('app:app', factory=False,\n host='127.0.0.1', port=5000,\n reload=True, workers=1,\n log_level='debug', ssl_certfile=None,\n ssl_keyfile=None)\n os.environ['FLASK_DEBUG'] = 'true'\n result = CliRunner().invoke(aioflask.cli.run_command, '--no-reload',\n obj=obj)\n assert result.exit_code == 0\n uvicorn.run.assert_called_with('app:app', factory=False,\n host='127.0.0.1', port=5000,\n reload=False, workers=1,\n log_level='debug', ssl_certfile=None,\n ssl_keyfile=None)\n\n if 'FLASK_DEBUG' in os.environ:\n del os.environ['FLASK_DEBUG']\n if 'AIOFLASK_USE_DEBUGGER' in os.environ:\n del os.environ['AIOFLASK_USE_DEBUGGER']\n\n @mock.patch('aioflask.cli.uvicorn')\n def test_aiorun_with_factory(self, uvicorn):\n app = aioflask.Flask('testapp')\n obj = aioflask.cli.ScriptInfo(app_import_path='app:create_app()',\n create_app=lambda: app)\n\n result = CliRunner().invoke(aioflask.cli.run_command, obj=obj)\n assert result.exit_code == 0\n uvicorn.run.assert_called_with('app:create_app', factory=True,\n host='127.0.0.1', port=5000,\n reload=False, workers=1,\n log_level='info', ssl_certfile=None,\n ssl_keyfile=None)\n" }, { "path": "tests/test_ctx.py", "content": "import unittest\nimport pytest\nimport aioflask\nfrom .utils import async_test\n\n\nclass TestApp(unittest.TestCase):\n @async_test\n async def test_app_context(self):\n app = aioflask.Flask(__name__)\n called_t1 = False\n called_t2 = False\n\n @app.teardown_appcontext\n async def t1(exc):\n nonlocal called_t1\n called_t1 = True\n\n @app.teardown_appcontext\n def t2(exc):\n nonlocal called_t2\n called_t2 = True\n\n async with app.app_context():\n assert aioflask.current_app == app\n async with app.app_context():\n assert aioflask.current_app == app\n assert aioflask.current_app == app\n\n assert called_t1\n assert called_t2\n with pytest.raises(RuntimeError):\n print(aioflask.current_app)\n\n @async_test\n async def test_req_context(self):\n app = aioflask.Flask(__name__)\n called_t1 = False\n called_t2 = False\n\n @app.teardown_appcontext\n async def t1(exc):\n nonlocal called_t1\n called_t1 = True\n\n @app.teardown_appcontext\n def t2(exc):\n nonlocal called_t2\n called_t2 = True\n\n async with app.test_request_context('/foo'):\n assert aioflask.current_app == app\n assert aioflask.request.path == '/foo'\n\n assert called_t1\n assert called_t2\n\n async with app.app_context():\n async with app.test_request_context('/bar') as reqctx:\n assert aioflask.current_app == app\n assert aioflask.request.path == '/bar'\n async with reqctx:\n assert aioflask.current_app == app\n assert aioflask.request.path == '/bar'\n\n with pytest.raises(RuntimeError):\n print(aioflask.current_app)\n" }, { "path": "tests/test_patch.py", "content": "import unittest\nimport aioflask\nimport aioflask.patch\nfrom .utils import async_test\n\n\nclass TestPatch(unittest.TestCase):\n @async_test\n async def test_decorator(self):\n def foo(f):\n def decorator(*args, **kwargs):\n return f(*args, **kwargs) + '-decorated'\n\n return decorator\n\n foo = aioflask.patch.patch_decorator(foo)\n\n app = aioflask.Flask(__name__)\n\n @app.route('/abc/