fix

Cookies

.gitignore

@@ -1,6 +1,7 @@
 .vscode/
 .cache
 .idea
+.python-version
 .coverage
 .pytest_cache
 .DS_Store

CHANGELOG.md

@@ -1,3 +1,15 @@
+# v0.1.2
+- Cookies support.
+
+# v0.1.1
+- Default routes.
+
+# v0.1.0
+- Prototype of static application support.
+
+# v0.0.10
+- Bufgix for async class-based views.
+
 # v0.0.9
 - Bugfix for async class-based views.
 

Pipfile

@@ -14,6 +14,7 @@ twine = "*"
 flask = "*"
 sphinx = "*"
 marshmallow = "*"
+pytest-cov = "*"
 
 [requires]
 python_version = "3.7"

docs/source/deployment.rst

@@ -0,0 +1,57 @@
+Deploying Responder
+===================
+
+You can deploy Responder anywhere you can deploy a basic Python application.
+
+Docker Deployment
+-----------------
+
+Assuming existing ``api.py`` and ``Pipfile.lock`` containing ``responder``.
+
+``Dockerfile``::
+
+    from kennethreitz/pipenv
+
+    COPY . /app
+    CMD python3 api.py
+
+That's it!
+
+Heroku Deployment
+-----------------
+
+The basics::
+
+    $ mkdir my-api
+    $ cd my-api
+    $ git init
+    $ heroku create
+    ...
+
+Install Responder::
+
+    $ pipenv install responder
+    ...
+
+Write out an ``api.py``::
+
+    import responder
+
+    api = responder.API()
+
+    @api.route("/")
+    async def hello(req, resp):
+        resp.text = "hello, world!"
+
+    if __name__ == "__main__":
+        api.run()
+
+Write out a ``Procfile``::
+
+    web: python api.py
+
+That's it! Next, we commit and push to Heroku::
+
+    $ git add -A
+    $ git commit -m 'initial commit'
+    $ git push heroku master

docs/source/index.rst

@@ -56,6 +56,7 @@ Features
 - Background tasks, spawned off in a ``ThreadPoolExecutor``.
 - GraphQL (with *GraphiQL*) support!
 - OpenAPI schema generation.
+- Single-page webapp support!
 
 Testimonials
 ------------
@@ -103,6 +104,7 @@ User Guides
 
    quickstart
    tour
+   deployment
    api
 
 

docs/source/tour.rst

@@ -140,6 +140,15 @@ Responder gives you the ability to mount another ASGI / WSGI app at a subroute::
 
 That's it!
 
+Single-Page Web Apps
+--------------------
+
+If you have a single-page webapp, you can tell Responder to serve up your ``static/index.html`` at a route, like so::
+
+    api.add_route("/", static=True)
+
+This will make ``index.html`` the default response to all undefined routes.
+
 HSTS (Redirect to HTTPS)
 ------------------------
 

pytest.ini

@@ -1,4 +1,4 @@
 [pytest]
-; addopts= -rsxX -s -v --strict
+;addopts= -rsxX -s -v --strict
 filterwarnings =
     error::UserWarning

responder/__version__.py

@@ -1 +1 @@
-__version__ = "0.0.10"
+__version__ = "0.1.2"

responder/api.py

@@ -11,6 +11,7 @@ from graphql_server import encode_execution_results, json_encode, default_format
 from starlette.routing import Router
 from starlette.staticfiles import StaticFiles
 from starlette.testclient import TestClient
+from starlette.middleware.gzip import GZipMiddleware
 from apispec import APISpec
 from apispec.ext.marshmallow import MarshmallowPlugin
 from apispec import yaml_utils
@@ -42,6 +43,7 @@ class API:
         openapi=None,
         openapi_route="/schema.yml",
         static_dir="static",
+        static_route="/static",
         templates_dir="templates",
         enable_hsts=False,
     ):
@@ -49,7 +51,7 @@ class API:
         self.version = version
         self.openapi_version = openapi
         self.static_dir = Path(os.path.abspath(static_dir))
-        self.static_route = f"/{static_dir}"
+        self.static_route = static_route
         self.templates_dir = Path(os.path.abspath(templates_dir))
         self.built_in_templates_dir = Path(
             os.path.abspath(os.path.dirname(__file__) + "/templates")
@@ -74,6 +76,10 @@ class API:
         if self.openapi_version:
             self.add_route(openapi_route, self.schema_response)
 
+        self.default_endpoint = None
+        self.app = self.dispatch
+        self.add_middleware(GZipMiddleware)
+
     @property
     def _apispec(self):
         spec = APISpec(
@@ -99,6 +105,9 @@ class API:
     def openapi(self):
         return self._apispec.to_yaml()
 
+    def add_middleware(self, middleware_cls, **middleware_config):
+        self.app = middleware_cls(self.app, **middleware_config)
+
     def __call__(self, scope):
         path = scope["path"]
         root_path = scope.get("root_path", "")
@@ -114,6 +123,9 @@ class API:
                     app = WsgiToAsgi(app)
                     return app(scope)
 
+        return self.app(scope)
+
+    def dispatch(self, scope):
         # Call the main dispatcher.
         async def asgi(receive, send):
             nonlocal scope, self
@@ -159,6 +171,11 @@ class API:
             if route_object.does_match(path):
                 return route
 
+    def _prepare_cookies(self, resp):
+        if resp.cookies:
+            header = " ".join([f"{k}={v}" for k, v in resp.cookies.items()])
+            resp.headers["Set-Cookie"] = header
+
     async def _dispatch_request(self, req):
         # Set formats on Request object.
         req.formats = self.formats
@@ -198,8 +215,8 @@ class API:
 
                 # Run on_request first.
                 try:
-                    r = getattr(view, "on_request")(req, resp)
-                    if hasattr(r, 'send'):
+                    r = getattr(view, "on_request")(req, resp, **params)
+                    if hasattr(r, "send"):
                         await r
                 except AttributeError:
                     pass
@@ -208,25 +225,38 @@ class API:
                 method = req.method
 
                 try:
-                    r = getattr(view, f"on_{method}")(req, resp)
-                    if hasattr(r, 'send'):
+                    r = getattr(view, f"on_{method}")(req, resp, **params)
+                    if hasattr(r, "send"):
                         await r
                 except AttributeError:
                     pass
         else:
             self.default_response(req, resp)
 
+        self._prepare_cookies(resp)
+
         return resp
 
-    def add_route(self, route, endpoint, *, check_existing=True):
+    def add_route(
+        self, route, endpoint=None, *, default=False, static=False, check_existing=True
+    ):
         """Add a route to the API.
 
         :param route: A string representation of the route.
-        :param endpoint: The endpoint for the route -- can be a callable, a class, a WSGI application, or graphene schema (GraphQL).
+        :param endpoint: The endpoint for the route -- can be a callable, a class, or graphene schema (GraphQL).
+        :param default: If ``True``, all unknown requests will route to this view.
+        :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 check_existing:
             assert route not in self.routes
+
+        if not endpoint and static:
+            endpoint = self.static_response
+            default = True
+
+        if default:
+            self.default_endpoint = endpoint
         self.routes[route] = Route(route, endpoint)
         # TODO: A better datastructer or sort it once the app is loaded
         self.routes = dict(
@@ -234,8 +264,17 @@ class API:
         )
 
     def default_response(self, req, resp):
-        resp.status_code = status_codes.HTTP_404
-        resp.text = "Not found."
+        if self.default_endpoint:
+            self.default_endpoint(req, resp)
+        else:
+            resp.status_code = status_codes.HTTP_404
+            resp.text = "Not found."
+
+    def static_response(self, req, resp):
+        index = (self.static_dir / "index.html").resolve()
+        if os.path.exists(index):
+            with open(index, "r") as f:
+                resp.text = f.read()
 
     def schema_response(self, req, resp):
         resp.status_code = status_codes.HTTP_200
@@ -351,12 +390,12 @@ class API:
         """Given a static asset, return its URL path."""
         return f"{self.static_route}/{str(asset)}"
 
-    def template(self, name, auto_escape=True, **values):
+    def template(self, name_, auto_escape=True, **values):
         """Renders the given `jinja2 <http://jinja.pocoo.org/docs/>`_ template, with provided values supplied.
 
         Note: The current ``api`` instance is always passed into the view.
 
-        :param name: The filename of the jinja2 template, in ``templates_dir``.
+        :param name_: The filename of the jinja2 template, in ``templates_dir``.
         :param auto_escape: If ``True``, HTML and XML will automatically be escaped.
         :param values: Data to pass into the template.
         """
@@ -371,7 +410,7 @@ class API:
             autoescape=jinja2.select_autoescape(["html", "xml"] if auto_escape else []),
         )
 
-        template = env.get_template(name)
+        template = env.get_template(name_)
         return template.render(**values)
 
     def template_string(self, s, auto_escape=True, **values):

responder/models.py

@@ -1,17 +1,19 @@
 import io
 import json
 import gzip
+from http.cookies import SimpleCookie
+
 
 import chardet
 import rfc3986
 import graphene
 import yaml
 from requests.structures import CaseInsensitiveDict
+from requests.cookies import RequestsCookieJar
 from starlette.datastructures import MutableHeaders
 from starlette.requests import Request as StarletteRequest
 from starlette.responses import Response as StarletteResponse
 
-
 from urllib.parse import parse_qs
 
 from .status_codes import HTTP_200
@@ -88,12 +90,7 @@ class QueryDict(dict):
 
 # TODO: add slots
 class Request:
-    __slots__ = [
-        "_starlette",
-        "formats",
-        "_headers",
-        "_encoding",
-    ]
+    __slots__ = ["_starlette", "formats", "_headers", "_encoding"]
 
     def __init__(self, scope, receive):
         self._starlette = StarletteRequest(scope, receive)
@@ -130,6 +127,18 @@ class Request:
         """The parsed URL of the Request."""
         return rfc3986.urlparse(self.full_url)
 
+    @property
+    def cookies(self):
+        cookies = RequestsCookieJar()
+        cookie_header = self.headers.get("cookie", "")
+
+        # if cookie_header:
+        bc = SimpleCookie(cookie_header)
+        for k, v in bc.items():
+            cookies[k] = v
+
+        return cookies.get_dict()
+
     @property
     def params(self):
         """A dictionary of the parsed query parameters used for the Request."""
@@ -191,7 +200,7 @@ class Request:
         return content_type in self.headers.get("Accept", [])
 
     async def media(self, format=None):
-        """Renders incoming json/yaml/form data as Python objects.
+        """Renders incoming json/yaml/form data as Python objects. Must be awaited.
 
         :param format: The name of the format being used. Alternatively accepts a custom callable for the format type.
         """
@@ -216,6 +225,7 @@ class Response:
         "media",
         "headers",
         "formats",
+        "cookies",
     ]
 
     def __init__(self, req, *, formats):
@@ -231,6 +241,7 @@ class Response:
             {}
         )  #: A Python dictionary of {Key: value}, representing the headers of the response.
         self.formats = formats
+        self.cookies = {}  # req.cookies
 
     @property
     async def body(self):
@@ -250,35 +261,8 @@ class Response:
             {"Content-Type": "application/json"},
         )
 
-    @property
-    async def gzipped_body(self):
-
-        body, headers = await self.body
-
-        if isinstance(body, str):
-            body = body.encode(self.encoding)
-
-        if "gzip" in self.req.headers["Accept-Encoding"].lower():
-            gzip_buffer = io.BytesIO()
-            gzip_file = gzip.GzipFile(mode="wb", fileobj=gzip_buffer)
-            gzip_file.write(body)
-            gzip_file.close()
-
-            new_headers = {
-                "Content-Encoding": "gzip",
-                "Vary": "Accept-Encoding",
-                "Content-Length": str(len(body)),
-            }
-            headers.update(new_headers)
-
-            return (gzip_buffer.getvalue(), headers)
-        else:
-            return (body, headers)
-
     async def __call__(self, receive, send):
         body, headers = await self.body
-        if len(await self.body) > 500:
-            body, headers = await self.gzipped_body
         if self.headers:
             headers.update(self.headers)
 

responder/routes.py

@@ -1,5 +1,5 @@
 import re
-from parse import parse, search
+from parse import parse
 
 
 def memoize(f):
@@ -13,6 +13,8 @@ def memoize(f):
 
 
 class Route:
+    _param_pattern = re.compile(r"{([^{}]*)}")
+
     def __init__(self, route, endpoint):
         self.route = route
         self.endpoint = endpoint
@@ -35,7 +37,7 @@ class Route:
 
     @property
     def has_parameters(self):
-        return all([("{" in self.route), ("}" in self.route)])
+        return bool(self._param_pattern.search(self.route))
 
     @memoize
     def does_match(self, s):
@@ -58,7 +60,8 @@ class Route:
         return url
 
     def _weight(self):
-        params_count = -len(set(re.findall(r"{([a-zA-Z]\w*)}", self.route)))
+        params = set(self._param_pattern.findall(self.route))
+        params_count = -len(params) or 0
         return params_count != 0, params_count
 
     @property

static/index.html

@@ -0,0 +1 @@
+lorem

tests/test_responder.py

@@ -61,6 +61,15 @@ def test_class_based_view_registration(api):
             resp.text = "42"
 
 
+def test_class_based_view_parameters(api):
+    @api.route("/{greeting}")
+    class Greeting:
+        def on_request(req, resp, *, greeting):
+            resp.text = f"{greeting}, world!"
+
+    assert api.session().get("http://;/Hello").ok
+
+
 def test_requests_session(api):
     assert api.session()
 
@@ -244,12 +253,13 @@ def test_graphql_schema_json_query(api, schema):
     r = api.session().post("http://;/", json={"query": "{ hello }"})
     assert r.ok
 
+
 def test_graphiql(api, schema):
     api.add_route("/", schema)
 
     r = api.session().get("http://;/", headers={"Accept": "text/html"})
     assert r.ok
-    assert 'GraphiQL' in r.text
+    assert "GraphiQL" in r.text
 
 
 def test_json_uploads(api, session):
@@ -359,3 +369,16 @@ def test_async_class_based_views(api, session):
     data = "frame"
     r = session.post(api.url_for(Resource), data=data)
     assert r.text == data
+
+def test_cookies(api, session):
+    @api.route("/")
+    def cookies(req, resp):
+        resp.media = {'cookies': req.cookies}
+        resp.cookies['sent'] = 'true'
+
+    r = session.get(api.url_for(cookies), cookies={'hello': 'universe'})
+    assert r.json() == {"cookies": {"hello": "universe"}}
+    assert 'sent' in r.cookies
+
+    r = session.get(api.url_for(cookies))
+    assert r.json() == {"cookies": {"sent": "true"}}

tests/test_routes.py

@@ -30,32 +30,32 @@ def test_equal():
     assert r != r3
 
 
-@pytest.mark.parametrize(
-    "path_param, actual, match",
-    [
-        pytest.param(
-            "/{greetings}", "/hello", {"greetings": "hello"}, id="with one strformat"
-        ),
-        pytest.param(
-            "/{greetings}.{name}",
-            "/hi.jane",
-            {"greetings": "hi", "name": "jane"},
-            id="with dot in url and two strformat",
-        ),
-        pytest.param(
-            "/{greetings}/{name}",
-            "/hi/john",
-            {"greetings": "hi", "name": "john"},
-            id="with sub url and two strformat",
-        ),
-        pytest.param(
-            "/concrete_path", "/foo", {}, id="test concrete path with no match"
-        ),
-    ],
-)
-def test_incoming_matches(path_param, actual, match):
-    r = routes.Route(path_param, "test_endpoint")
-    assert r.incoming_matches(actual) == match
+def test_incoming_matches():
+    # Test Route with one param
+    r = routes.Route("/{greetings}", "test_endpoint")
+    assert r.incoming_matches("/hello") == {"greetings": "hello"}
+    assert r.incoming_matches("/foo") == {"greetings": "foo"}
+
+    assert r._memo == {
+        "incoming_matches:/hello": {"greetings": "hello"},
+        "incoming_matches:/foo": {"greetings": "foo"},
+    }
+
+    # Test Route with two params
+    r = routes.Route("/{greetings}/{name}", "test_endpoint")
+    assert r.incoming_matches("/hi/john") == {"greetings": "hi", "name": "john"}
+    assert r.incoming_matches("/hello/jane") == {"greetings": "hello", "name": "jane"}
+
+    # Test Route with no param
+    assert r._memo == {
+        "incoming_matches:/hi/john": {"greetings": "hi", "name": "john"},
+        "incoming_matches:/hello/jane": {"greetings": "hello", "name": "jane"},
+    }
+
+    r = routes.Route("/hello", "test_endpoint")
+    assert r.incoming_matches("/hello") == {}
+    assert r.incoming_matches("/bye") == {}
+    assert r._memo == {"incoming_matches:/hello": {}, "incoming_matches:/bye": {}}
 
 
 def test_incoming_matches_with_concrete_path_no_match():
@@ -81,3 +81,25 @@ def test_incoming_matches_with_concrete_path_no_match():
 def test_does_match_with_route(route, match, expected):
     r = routes.Route(route, "test_endpoint")
     assert r.does_match(match) == expected
+
+
+@pytest.mark.parametrize(
+    "path_param, expected_weight",
+    [
+        pytest.param("/{greetings}", (True, -1), id="with one param"),
+        pytest.param(
+            "/{greetings}.{name}", (True, -2), id="with 2 params and dot in the middle"
+        ),
+        pytest.param("/{greetings}/{name}", (True, -2), id="with 2 param and subpath"),
+        pytest.param(
+            "/{greetings}/{name}/{hello}", (True, -3), id="with 3 param and subpath"
+        ),
+        pytest.param(
+            "/{greetings}_{name}", (True, -2), id="with 2 param and underscore"
+        ),
+        pytest.param("/hello", (False, 0), id="with 2 param and underscore"),
+    ],
+)
+def test_weight(path_param, expected_weight):
+    r = routes.Route(path_param, "test_endpoint")
+    assert r._weight() == expected_weight

tests/test_status_codes.py

@@ -0,0 +1,67 @@
+import pytest
+from responder import status_codes
+
+
+@pytest.mark.parametrize(
+    "status_code, expected",
+    [
+        pytest.param(101, True, id="Normal 101"),
+        pytest.param(199, True, id="Not actual status code but within 100"),
+        pytest.param(0, False, id="Zero case (below 100)"),
+        pytest.param(200, False, id="Above 100")
+    ],
+)
+def test_is_100(status_code, expected):
+    assert status_codes.is_100(status_code) is expected
+
+
+@pytest.mark.parametrize(
+    "status_code, expected",
+    [
+        pytest.param(201, True, id="Normal 201"),
+        pytest.param(299, True, id="Not actual status code but within 200"),
+        pytest.param(0, False, id="Zero case (below 200)"),
+        pytest.param(300, False, id="Above 200")
+    ],
+)
+def test_is_200(status_code, expected):
+    assert status_codes.is_200(status_code) is expected
+
+
+@pytest.mark.parametrize(
+    "status_code, expected",
+    [
+        pytest.param(301, True, id="Normal 301"),
+        pytest.param(399, True, id="Not actual status code but within 300"),
+        pytest.param(0, False, id="Zero case (below 300)"),
+        pytest.param(400, False, id="Above 300")
+    ],
+)
+def test_is_300(status_code, expected):
+    assert status_codes.is_300(status_code) is expected
+
+
+@pytest.mark.parametrize(
+    "status_code, expected",
+    [
+        pytest.param(401, True, id="Normal 401"),
+        pytest.param(499, True, id="Not actual status code but within 400"),
+        pytest.param(0, False, id="Zero case (below 400)"),
+        pytest.param(500, False, id="Above 400")
+    ],
+)
+def test_is_400(status_code, expected):
+    assert status_codes.is_400(status_code) is expected
+
+
+@pytest.mark.parametrize(
+    "status_code, expected",
+    [
+        pytest.param(501, True, id="Normal 401"),
+        pytest.param(599, True, id="Not actual status code but within 400"),
+        pytest.param(0, False, id="Zero case (below 400)"),
+        pytest.param(600, False, id="Above 500")
+    ],
+)
+def test_is_500(status_code, expected):
+    assert status_codes.is_500(status_code) is expected