before_request

DOC: change dockerfile instruction `from` to use UPPERCASE

CHANGELOG.md

@@ -1,3 +1,6 @@
+# v1.1.0
+- Support for `before_request`.
+
 # v1.0.4
 - Potential bufix for cookies.
 

docs/source/deployment.rst

@@ -10,7 +10,7 @@ Assuming existing ``api.py`` and ``Pipfile.lock`` containing ``responder``.
 
 ``Dockerfile``::
 
-    from kennethreitz/pipenv
+    FROM kennethreitz/pipenv
 
     COPY . /app
     CMD python3 api.py

docs/source/tour.rst

@@ -173,6 +173,17 @@ You can easily read a Request's session data, that can be trusted to have origin
 
     api = responder.API(secret_key=os.environ['SECRET_KEY'])
 
+Using ``before_request``
+------------------------
+
+If you'd like a view to be executed before every request, simply do the following::
+
+    @api.route(before_request=True)
+    def prepare_response(req, resp):
+        resp.headers["X-Pizza"] = "42"
+
+Now all requests to your HTTP Service will include an ``X-Pizza`` header.
+
 Using Requests Test Client
 --------------------------
 

responder/__version__.py

@@ -1 +1 @@
-__version__ = "1.0.4"
+__version__ = "1.1.0"

responder/api.py

@@ -1,6 +1,7 @@
 import json
 import os
 
+from uuid import uuid4
 from pathlib import Path
 from base64 import b64encode
 
@@ -145,6 +146,15 @@ class API:
     def _default_wsgi_app(*args, **kwargs):
         pass
 
+    @property
+    def before_requests(self):
+        def gen():
+            for route in self.routes:
+                if self.routes[route].before_request:
+                    yield self.routes[route]
+
+        return [g for g in gen()]
+
     @property
     def _apispec(self):
         spec = APISpec(
@@ -270,67 +280,16 @@ class API:
         route = self.path_matches_route(req.url.path)
         route = self.routes.get(route)
 
-        # Create the response object.
-        cont = False
         if route:
             if route.uses_websocket:
                 resp = WebSocket(**options)
-
             else:
                 resp = models.Response(req=req, formats=self.formats)
 
-            params = route.incoming_matches(req.url.path)
-
-            if route.is_function:
-                try:
-                    try:
-                        # Run the view.
-                        r = route.endpoint(req, resp, **params)
-                        # If it's async, await it.
-                        if hasattr(r, "cr_running"):
-                            await r
-                    except TypeError as e:
-                        cont = True
-                except Exception:
-                    self.default_response(req, resp, error=True)
-                    raise
-
-            elif route.is_class_based or cont:
-                try:
-                    view = route.endpoint(**params)
-                except TypeError:
-                    try:
-                        view = route.endpoint()
-                    except TypeError:
-                        view = route.endpoint
-
-                # Run on_request first.
-                try:
-                    # Run the view.
-                    r = getattr(view, "on_request", self.no_response)(
-                        req, resp, **params
-                    )
-                    # If it's async, await it.
-                    if hasattr(r, "send"):
-                        await r
-                except Exception:
-                    self.default_response(req, resp, error=True)
-                    raise
-
-                # Then run on_method.
-                method = req.method
-                try:
-                    # Run the view.
-                    r = getattr(view, f"on_{method}", self.no_response)(
-                        req, resp, **params
-                    )
-                    # If it's async, await it.
-                    if hasattr(r, "send"):
-                        await r
-                except Exception as e:
-
-                    self.default_response(req, resp, error=True)
+            for before_request in self.before_requests:
+                await self._execute_route(route=before_request, req=req, resp=resp)
 
+            await self._execute_route(route=route, req=req, resp=resp, **options)
         else:
             resp = models.Response(req=req, formats=self.formats)
             self.default_response(req, resp, notfound=True)
@@ -341,6 +300,56 @@ class API:
 
         return resp
 
+    async def _execute_route(self, *, route, req, resp, **options):
+
+        params = route.incoming_matches(req.url.path)
+
+        if route.is_function:
+            try:
+                try:
+                    # Run the view.
+                    r = route.endpoint(req, resp, **params)
+                    # If it's async, await it.
+                    if hasattr(r, "cr_running"):
+                        await r
+                except TypeError as e:
+                    cont = True
+            except Exception:
+                self.default_response(req, resp, error=True)
+                raise
+
+        elif route.is_class_based or cont:
+            try:
+                view = route.endpoint(**params)
+            except TypeError:
+                try:
+                    view = route.endpoint()
+                except TypeError:
+                    view = route.endpoint
+
+            # Run on_request first.
+            try:
+                # Run the view.
+                r = getattr(view, "on_request", self.no_response)(req, resp, **params)
+                # If it's async, await it.
+                if hasattr(r, "send"):
+                    await r
+            except Exception:
+                self.default_response(req, resp, error=True)
+                raise
+
+            # Then run on_method.
+            method = req.method
+            try:
+                # Run the view.
+                r = getattr(view, f"on_{method}", self.no_response)(req, resp, **params)
+                # If it's async, await it.
+                if hasattr(r, "send"):
+                    await r
+            except Exception as e:
+
+                self.default_response(req, resp, error=True)
+
     def add_event_handler(self, event_type, handler):
         """Adds an event handler to the API.
 
@@ -352,13 +361,14 @@ class API:
 
     def add_route(
         self,
-        route,
+        route=None,
         endpoint=None,
         *,
         default=False,
         static=False,
         check_existing=True,
         websocket=False,
+        before_request=False,
     ):
         """Adds a route to the API.
 
@@ -368,6 +378,9 @@ class API:
         :param static: If ``True``, and no endpoint was passed, render "static/index.html", and it will become a default route.
         :param check_existing: If ``True``, an AssertionError will be raised, if the route is already defined.
         """
+        if route is None:
+            route = f"/{uuid4().hex}"
+
         if check_existing:
             assert route not in self.routes
 
@@ -378,7 +391,9 @@ class API:
         if default:
             self.default_endpoint = endpoint
 
-        self.routes[route] = Route(route, endpoint, websocket=websocket)
+        self.routes[route] = Route(
+            route, endpoint, websocket=websocket, before_request=before_request
+        )
         # TODO: A better data structure or sort it once the app is loaded
         self.routes = dict(
             sorted(self.routes.items(), key=lambda item: item[1]._weight())
@@ -457,7 +472,7 @@ class API:
 
         return decorator
 
-    def route(self, route, **options):
+    def route(self, route=None, **options):
         """Decorator for creating new routes around function and class definitions.
 
         Usage::

responder/routes.py

@@ -15,10 +15,11 @@ def memoize(f):
 class Route:
     _param_pattern = re.compile(r"{([^{}]*)}")
 
-    def __init__(self, route, endpoint, *, websocket=False):
+    def __init__(self, route, endpoint, *, websocket=False, before_request=False):
         self.route = route
         self.endpoint = endpoint
         self.uses_websocket = websocket
+        self.before_request = before_request
         self._memo = {}
 
     def __repr__(self):

tests/test_responder.py

@@ -545,3 +545,17 @@ def test_session_thoroughly(api, session):
     r = session.get(api.url_for(get))
     print(r.request.headers)
     assert r.json() == {"session": {"hello": "world"}}
+
+def test_before_responpse(api, session):
+
+    @api.route("/get")
+    def get(req, resp):
+        resp.media = req.session
+
+
+    @api.route(before_request=True)
+    def before_request(req, resp):
+        resp.headers["x-pizza"] = "1"
+
+    r = session.get(api.url_for(get))
+    assert 'x-pizza' in r.headers