update sim

Author: joeblackwaslike

src/quart_sqlalchemy/retry.py

@@ -99,6 +99,7 @@ async def add_user_post(db, user_id, post_values):
 import sqlalchemy.exc
 import sqlalchemy.orm
 import tenacity
+from tenacity import RetryError
 
 
 sa = sqlalchemy

src/quart_sqlalchemy/sim/app.py

@@ -1,145 +1,88 @@
-import json
 import logging
-import re
 import typing as t
+from copy import deepcopy
+from functools import wraps
 
-import sqlalchemy as sa
-from pydantic import BaseModel
 from quart import g
 from quart import Quart
 from quart import request
-from quart import Request
 from quart import Response
+from quart.typing import ResponseReturnValue
+from quart_schema import APIKeySecurityScheme
+from quart_schema import HttpSecurityScheme
 from quart_schema import QuartSchema
+from werkzeug.utils import import_string
 
-from quart_sqlalchemy import Base
-from quart_sqlalchemy import SQLAlchemyConfig
-from quart_sqlalchemy.framework import QuartSQLAlchemy
-from quart_sqlalchemy.sim.util import ObjectID
 
-
-AUTHORIZATION_PATTERN = re.compile(r"Bearer (?P<token>.+)")
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-class MyBase(Base):
-    type_annotation_map = {ObjectID: sa.Integer}
-
-
-app = Quart(__name__)
-db = QuartSQLAlchemy(
-    SQLAlchemyConfig.parse_obj(
-        {
-            "model_class": MyBase,
-            "binds": {
-                "default": {
-                    "engine": {"url": "sqlite:///file:mem.db?mode=memory&cache=shared&uri=true"},
-                    "session": {"expire_on_commit": False},
-                },
-                "read-replica": {
-                    "engine": {"url": "sqlite:///file:mem.db?mode=memory&cache=shared&uri=true"},
-                    "session": {"expire_on_commit": False},
-                    "read_only": True,
-                },
-                "async": {
-                    "engine": {
-                        "url": "sqlite+aiosqlite:///file:mem.db?mode=memory&cache=shared&uri=true"
-                    },
-                    "session": {"expire_on_commit": False},
-                },
-            },
-        }
-    )
+BLUEPRINTS = ("quart_sqlalchemy.sim.views.api",)
+EXTENSIONS = (
+    "quart_sqlalchemy.sim.db.db",
+    "quart_sqlalchemy.sim.app.schema",
+    "quart_sqlalchemy.sim.auth.auth",
 )
-openapi = QuartSchema(app)
-
-
-class RequestAuth(BaseModel):
-    client: t.Optional[t.Any] = None
-    user: t.Optional[t.Any] = None
-
-    @property
-    def has_client(self):
-        return self.client is not None
-
-    @property
-    def has_user(self):
-        return self.user is not None
-
-    @property
-    def is_anonymous(self):
-        return all([self.has_client is False, self.has_user is False])
-
 
-def get_request_client(request: Request):
-    api_key = request.headers.get("X-Public-API-Key")
-    if not api_key:
-        return
+DEFAULT_CONFIG = {
+    "QUART_AUTH_SECURITY_SCHEMES": {
+        "public-api-key": APIKeySecurityScheme(in_="header", name="X-Public-API-Key"),
+        "session-token-bearer": HttpSecurityScheme(scheme="bearer", bearer_format="opaque"),
+    },
+    "REGISTER_BLUEPRINTS": ["quart_sqlalchemy.sim.views.api"],
+}
 
-    with g.bind.Session() as session:
-        try:
-            magic_client = g.h.MagicClient(session).get_by_public_api_key(api_key)
-        except ValueError:
-            return
-        else:
-            return magic_client
 
+schema = QuartSchema(security_schemes=DEFAULT_CONFIG["QUART_AUTH_SECURITY_SCHEMES"])
 
-def get_request_user(request: Request):
-    auth_header = request.headers.get("Authorization")
 
-    if not auth_header:
-        return
-    m = AUTHORIZATION_PATTERN.match(auth_header)
-    if m is None:
-        raise RuntimeError("invalid authorization header")
+def wrap_response(func: t.Callable) -> t.Callable:
+    @wraps(func)
+    async def decorator(result: ResponseReturnValue) -> Response:
+        # import pdb
 
-    auth_token = m.group("auth_token")
+        # pdb.set_trace()
+        return await func(result)
 
-    with g.bind.Session() as session:
-        try:
-            auth_user = g.h.AuthUser(session).get_by_session_token(auth_token)
-        except ValueError:
-            return
-        else:
-            return auth_user
+    return decorator
 
 
-@app.before_request
-def set_ethereum_network():
-    g.request_network = request.headers.get("X-Fortmatic-Network", "GOERLI").upper()
+def create_app(
+    override_config: t.Optional[t.Dict[str, t.Any]] = None,
+    extensions: t.Sequence[str] = EXTENSIONS,
+    blueprints: t.Sequence[str] = BLUEPRINTS,
+):
+    override_config = override_config or {}
 
+    config = deepcopy(DEFAULT_CONFIG)
+    config.update(override_config)
 
-@app.before_request
-def set_bind_handlers_for_request():
-    from quart_sqlalchemy.sim.handle import Handlers
+    app = Quart(__name__)
+    app.config.from_mapping(config)
 
-    g.db = db
+    for path in extensions:
+        extension = import_string(path)
+        extension.init_app(app)
 
-    method = request.method
-    if method in ["GET", "OPTIONS", "TRACE", "HEAD"]:
-        bind = "read-replica"
-    else:
-        bind = "default"
+    for path in blueprints:
+        bp = import_string(path)
+        app.register_blueprint(bp)
 
-    g.bind = db.get_bind(bind)
-    g.h = Handlers(g.bind)
+    @app.before_request
+    def set_ethereum_network():
+        g.network = request.headers.get("X-Ethereum-Network", "GOERLI").upper()
 
+    # app.make_response = wrap_response(app.make_response)
 
-@app.before_request
-def set_request_auth():
-    g.auth = RequestAuth(
-        client=get_request_client(request),
-        user=get_request_user(request),
-    )
+    return app
 
 
-@app.after_request
-async def add_json_response_envelope(response: Response) -> Response:
-    if response.mimetype != "application/json":
-        return response
-    data = await response.get_json()
-    payload = dict(status="ok", message="", data=data)
-    response.set_data(json.dumps(payload))
-    return response
+# @app.after_request
+# async def add_json_response_envelope(response: Response) -> Response:
+#     if response.mimetype != "application/json":
+#         return response
+#     data = await response.get_json()
+#     payload = dict(status="ok", message="", data=data)
+#     response.set_data(json.dumps(payload))
+#     return response