v0.1.4

Store Jinja enviroment in between template render calls

.gitignore

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

CHANGELOG.md

@@ -1,3 +1,21 @@
+# v0.1.4
+- Stability.
+
+# v0.1.3
+- Sessions support.
+
+# 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"

Pipfile.lock

@@ -1,7 +1,7 @@
 {
     "_meta": {
         "hash": {
-            "sha256": "9b959d9507c521f6088646507633207db03afec6ac31aeab07adf0d737dbb45b"
+            "sha256": "7bbe1f0addd73250027de73d6fb749aa2be3149af9744b107820c5e10498428e"
         },
         "pipfile-spec": 6,
         "requires": {
@@ -72,6 +72,12 @@
             ],
             "version": "==7.0"
         },
+        "docopt": {
+            "hashes": [
+                "sha256:49b3a825280bd66b3aa83585ef59c4a8c82f2c8a522dbe754a8bc8d08c85c491"
+            ],
+            "version": "==0.6.2"
+        },
         "graphene": {
             "hashes": [
                 "sha256:b8ec446d17fa68721636eaad3d6adc1a378cb6323e219814c8f98c9928fc9642",
@@ -112,6 +118,13 @@
             ],
             "version": "==2.7"
         },
+        "itsdangerous": {
+            "hashes": [
+                "sha256:a7de3201740a857380421ef286166134e10fe58846bcefbc9d6424a69a0b99ec",
+                "sha256:aca4fc561b7671115a2156f625f2eaa5e0e3527e0adf2870340e7968c0a81f85"
+            ],
+            "version": "==1.0.0"
+        },
         "jinja2": {
             "hashes": [
                 "sha256:74c935a1b8bb9a3947c50a54766a969d4846290e1e788ea44c1392163723c3bd",
@@ -163,10 +176,10 @@
         },
         "requests": {
             "hashes": [
-                "sha256:63b52e3c866428a224f97cab011de738c36aec0185aa91cfacd418b5d58911d1",
-                "sha256:ec22d826a36ed72a7358ff3fe56cbd4ba69dd7a6718ffd450ff0e9df7a47ce6a"
+                "sha256:99dcfdaaeb17caf6e526f32b6a7b780461512ab3f1d992187801694cba42770c",
+                "sha256:a84b8c9ab6239b578f22d1c21d51b696dcfe004032bb80ea832398d6909d7279"
             ],
-            "version": "==2.19.1"
+            "version": "==2.20.0"
         },
         "responder": {
             "editable": true,
@@ -195,22 +208,22 @@
         },
         "starlette": {
             "hashes": [
-                "sha256:2c7ec085440fce7146a9be2b6d53b7110c3866ce6fa03d901efdc1fbe97e0f36"
+                "sha256:ce5c684fad4edb2967cd491518cd3c2724e420508202c2d48f519ea68dcec9d6"
             ],
-            "version": "==0.4.2"
+            "version": "==0.5.4"
         },
         "urllib3": {
             "hashes": [
-                "sha256:a68ac5e15e76e7e5dd2b8f94007233e01effe3e50e8daddf69acfd81cb686baf",
-                "sha256:b5725a0bd4ba422ab0e66e89e030c806576753ea3ee08554382c14e685d117b5"
+                "sha256:41c3db2fc01e5b907288010dec72f9d0a74e37d6994e6eb56849f59fea2265ae",
+                "sha256:8819bba37a02d143296a4d032373c4dd4aca11f6d4c9973335ca75f9c8475f59"
             ],
-            "version": "==1.23"
+            "version": "==1.24"
         },
         "uvicorn": {
             "hashes": [
-                "sha256:8de03999a936d8704f07cc3b1d3a3edb6922a068b64d84b4f5e49604c8b70a11"
+                "sha256:30096b58325cdca8e547a6f5f4300040d0b8763f573cb1843abfa96f81a49cf8"
             ],
-            "version": "==0.3.12"
+            "version": "==0.3.13"
         },
         "websockets": {
             "hashes": [
@@ -389,6 +402,38 @@
             "markers": "sys_platform == 'win32'",
             "version": "==0.4.0"
         },
+        "coverage": {
+            "hashes": [
+                "sha256:043d55226aec1d2baf4b2fcab5c204561ccf184a388096f41e396c1c092aff38",
+                "sha256:10bfd0b80b01d0684f968abbe1186bc19962e07b4b7601bb43b175b617cf689d",
+                "sha256:17e59864f19b3233032edb0566f26c25cc7f599503fb34d2645b5ce1fd6c2c3c",
+                "sha256:2105ee183c51fed27e2b6801029b3903f5c2774c78e3f53bd920ca468d0f5679",
+                "sha256:236505d15af6c7b7bfe2a9485db4b2bdea21d9239351483326184314418c79a8",
+                "sha256:237284425271db4f30d458b355decf388ab20b05278bdf8dc9a65de0973726c6",
+                "sha256:26d8eea4c840b73c61a1081d68bceb57b21a2d4f7afda6cac8ac38cb05226b00",
+                "sha256:39a3740f7721155f4269aedf67b211101c07bd2111b334dfd69b807156ab15d9",
+                "sha256:4bd0c42db8efc8a60965769796d43a5570906a870bc819f7388860aa72779d1b",
+                "sha256:4dcddadea47ac30b696956bd18365cd3a86724821656601151e263b86d34798f",
+                "sha256:51ea341289ac4456db946a25bd644f5635e5ae3793df262813cde875887d25c8",
+                "sha256:5415cafb082dad78935b3045c2e5d8907f436d15ad24c3fdb8e1839e084e4961",
+                "sha256:5631f1983074b33c35dbb84607f337b9d7e9808116d7f0f2cb7b9d6d4381d50e",
+                "sha256:5e9249bc361cd22565fd98590a53fd25a3dd666b74791ed7237fa99de938bbed",
+                "sha256:6a48746154f1331f28ef9e889c625b5b15a36cb86dd8021b4bdd1180a2186aa5",
+                "sha256:71d376dbac64855ed693bc1ca121794570fe603e8783cdfa304ec6825d4e768f",
+                "sha256:749ebd8a615337747592bd1523dfc4af7199b2bf6403b55f96c728668aeff91f",
+                "sha256:8ec528b585b95234e9c0c31dcd0a89152d8ed82b4567aa62dbcb3e9a0600deee",
+                "sha256:a1a9ccd879811437ca0307c914f136d6edb85bd0470e6d4966c6397927bcabd9",
+                "sha256:abd956c334752776230b779537d911a5a12fcb69d8fd3fe332ae63a140301ae6",
+                "sha256:ad18f836017f2e8881145795f483636564807aaed54223459915a0d4735300cf",
+                "sha256:b07ac0b1533298ddbc54c9bf3464664895f22899fec027b8d6c8d3ac59023283",
+                "sha256:d9385f1445e30e8e42b75a36a7899ea1fd0f5784233a626625d70f9b087de404",
+                "sha256:db2d1fcd32dbeeb914b2660af1838e9c178b75173f95fd221b1f9410b5d3ef1d",
+                "sha256:e1dec211147f1fd7cb7a0f9a96aeeca467a5af02d38911307b3b8c2324f9917e",
+                "sha256:e96dffc1fa57bb8c1c238f3d989341a97302492d09cb11f77df031112621c35c",
+                "sha256:ed4d97eb0ecdee29d0748acd84e6380729f78ce5ba0c7fe3401801634c25a1c5"
+            ],
+            "version": "==5.0a3"
+        },
         "docutils": {
             "hashes": [
                 "sha256:02aec4bd92ab067f6ff27a38a38a41173bf01bed8f89157768c1573f53e474a6",
@@ -435,9 +480,10 @@
         },
         "itsdangerous": {
             "hashes": [
-                "sha256:cbb3fcf8d3e33df861709ecaf89d9e6629cff0a217bc2848f1b41cd30d360519"
+                "sha256:a7de3201740a857380421ef286166134e10fe58846bcefbc9d6424a69a0b99ec",
+                "sha256:aca4fc561b7671115a2156f625f2eaa5e0e3527e0adf2870340e7968c0a81f85"
             ],
-            "version": "==0.24"
+            "version": "==1.0.0"
         },
         "jinja2": {
             "hashes": [
@@ -490,10 +536,10 @@
         },
         "pluggy": {
             "hashes": [
-                "sha256:6e3836e39f4d36ae72840833db137f7b7d35105079aee6ec4a62d9f80d594dd1",
-                "sha256:95eb8364a4708392bae89035f45341871286a333f749c3141c20573d2b3876e1"
+                "sha256:447ba94990e8014ee25ec853339faf7b0fc8050cdc3289d4d71f7f410fb90095",
+                "sha256:bde19360a8ec4dfd8a20dcb811780a30998101f078fc7ded6162f0076f50508f"
             ],
-            "version": "==0.7.1"
+            "version": "==0.8.0"
         },
         "py": {
             "hashes": [
@@ -538,11 +584,19 @@
         },
         "pytest": {
             "hashes": [
-                "sha256:7e258ee50338f4e46957f9e09a0f10fb1c2d05493fa901d113a8dafd0790de4e",
-                "sha256:9332147e9af2dcf46cd7ceb14d5acadb6564744ddff1fe8c17f0ce60ece7d9a2"
+                "sha256:10e59f84267370ab20cec9305bafe7505ba4d6b93ecbf66a1cce86193ed511d5",
+                "sha256:8c827e7d4816dfe13e9329c8226aef8e6e75d65b939bc74fda894143b6d1df59"
             ],
             "index": "pypi",
-            "version": "==3.8.2"
+            "version": "==3.9.1"
+        },
+        "pytest-cov": {
+            "hashes": [
+                "sha256:513c425e931a0344944f84ea47f3956be0e416d95acbd897a44970c8d926d5d7",
+                "sha256:e360f048b7dae3f2f2a9a4d067b2dd6b6a015d384d1577c994a43f3f7cbad762"
+            ],
+            "index": "pypi",
+            "version": "==2.6.0"
         },
         "pytz": {
             "hashes": [
@@ -560,10 +614,10 @@
         },
         "requests": {
             "hashes": [
-                "sha256:63b52e3c866428a224f97cab011de738c36aec0185aa91cfacd418b5d58911d1",
-                "sha256:ec22d826a36ed72a7358ff3fe56cbd4ba69dd7a6718ffd450ff0e9df7a47ce6a"
+                "sha256:99dcfdaaeb17caf6e526f32b6a7b780461512ab3f1d992187801694cba42770c",
+                "sha256:a84b8c9ab6239b578f22d1c21d51b696dcfe004032bb80ea832398d6909d7279"
             ],
-            "version": "==2.19.1"
+            "version": "==2.20.0"
         },
         "requests-toolbelt": {
             "hashes": [
@@ -625,10 +679,10 @@
         },
         "urllib3": {
             "hashes": [
-                "sha256:a68ac5e15e76e7e5dd2b8f94007233e01effe3e50e8daddf69acfd81cb686baf",
-                "sha256:b5725a0bd4ba422ab0e66e89e030c806576753ea3ee08554382c14e685d117b5"
+                "sha256:41c3db2fc01e5b907288010dec72f9d0a74e37d6994e6eb56849f59fea2265ae",
+                "sha256:8819bba37a02d143296a4d032373c4dd4aca11f6d4c9973335ca75f9c8475f59"
             ],
-            "version": "==1.23"
+            "version": "==1.24"
         },
         "webencodings": {
             "hashes": [

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,43 @@ 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.
+
+Reading / Writing Cookies
+-------------------------
+
+Responder makes it very easy to interact with cookies from a Request, or add some to a Response::
+
+    >>> resp.cookies["hello"] = "world"
+
+    >>> req.cookies
+    {"hello": "world"}
+
+
+Using Cookie-Based Sessions
+---------------------------
+
+Responder has built-in support for cookie-based sessions. To enable cookie-based sessions, simply add something to the ``resp.session`` dictionary::
+
+    >>> resp.session['username'] = 'kennethreitz'
+
+A cookie called ``Responder-Session`` will be set, which contains all the data in ``resp.session``. It is signed, for verification purposes.
+
+You can easily read a Request's session data, that can be trusted to have originated from the API::
+
+    >>> req.session
+    {'username': 'kennethreitz'}
+
+**Note**: if you are using this in production, you should pass the ``secret_key`` argument to ``API(...)``.
+
+
 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.9"
+__version__ = "0.1.4"

responder/api.py

@@ -7,10 +7,13 @@ import uvicorn
 
 import asyncio
 import jinja2
+import itsdangerous
 from graphql_server import encode_execution_results, json_encode, default_format_error
 from starlette.routing import Router
 from starlette.staticfiles import StaticFiles
 from starlette.testclient import TestClient
+from starlette.middleware.gzip import GZipMiddleware
+from starlette.middleware.httpsredirect import HTTPSRedirectMiddleware
 from apispec import APISpec
 from apispec.ext.marshmallow import MarshmallowPlugin
 from apispec import yaml_utils
@@ -29,6 +32,7 @@ class API:
 
         :param static_dir: The directory to use for static files. Will be created for you if it doesn't already exist.
         :param templates_dir: The directory to use for templates. Will be created for you if it doesn't already exist.
+        :param auto_escape: If ``True``, HTML and XML templates will automatically be escaped.
         :param enable_hsts: If ``True``, send all responses to HTTPS URLs.
     """
 
@@ -42,20 +46,25 @@ class API:
         openapi=None,
         openapi_route="/schema.yml",
         static_dir="static",
+        static_route="/static",
         templates_dir="templates",
+        auto_escape=True,
+        secret_key="NOTASECRET",
         enable_hsts=False,
     ):
+        self.secret_key = secret_key
         self.title = title
         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")
         )
         self.routes = {}
         self.schemas = {}
+        self.session_cookie = 'Responder-Session'
 
         self.hsts_enabled = enable_hsts
         self.static_files = StaticFiles(directory=str(self.static_dir))
@@ -74,6 +83,26 @@ 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)
+        if self.hsts_enabled:
+            self.add_middleware(HTTPSRedirectMiddleware)
+
+        # Jinja enviroment
+        self.jinja_env = jinja2.Environment(
+            loader=jinja2.FileSystemLoader(
+                [str(self.templates_dir), str(self.built_in_templates_dir)],
+                followlinks=True,
+            ),
+            autoescape=jinja2.select_autoescape(
+                ["html", "xml"] if auto_escape else []
+            )
+        )
+        self.jinja_values_base = {
+            "api": self, # Give reference to self.
+        }
+
     @property
     def _apispec(self):
         spec = APISpec(
@@ -99,6 +128,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,11 +146,14 @@ 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
 
-            req = models.Request(scope, receive=receive)
+            req = models.Request(scope, receive=receive, api=self)
             resp = await self._dispatch_request(req)
             await resp(receive, send)
 
@@ -159,6 +194,22 @@ class API:
             if route_object.does_match(path):
                 return route
 
+    def _prepare_cookies(self, resp):
+        # print(resp.cookies)
+        if resp.cookies:
+            header = " ".join([f"{k}={v}" for k, v in resp.cookies.items()])
+            resp.headers["Set-Cookie"] = header
+
+    @property
+    def _signer(self):
+        return itsdangerous.Signer(self.secret_key)
+
+    def _prepare_session(self, resp):
+
+        if resp.session:
+            data = self._signer.sign(json.dumps(resp.session).encode("utf-8"))
+            resp.cookies[self.session_cookie] = data.decode("utf-8")
+
     async def _dispatch_request(self, req):
         # Set formats on Request object.
         req.formats = self.formats
@@ -166,11 +217,6 @@ class API:
         route = self.path_matches_route(req.url.path)
         resp = models.Response(req=req, formats=self.formats)
 
-        if self.hsts_enabled:
-            if req.url.startswith("http://"):
-                url = req.url.replace("http://", "https://", 1)
-                self.redirect(resp, location=url)
-
         if route:
             try:
                 params = self.routes[route].incoming_matches(req.url.path)
@@ -187,18 +233,13 @@ class API:
                     if self.routes[route].is_graphql:
                         await self.graphql_response(req, resp, schema=view)
                     else:
-                        # WSGI App.
-                        # try:
-                        #     return view(
-                        #         environ=req._environ, start_response=req._start_response
-                        #     )
-                        # except TypeError:
-                        #     pass
                         pass
 
                 # Run on_request first.
                 try:
-                    getattr(view, "on_request")(req, resp)
+                    r = getattr(view, "on_request")(req, resp, **params)
+                    if hasattr(r, "send"):
+                        await r
                 except AttributeError:
                     pass
 
@@ -206,25 +247,39 @@ 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_session(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(
@@ -232,8 +287,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
@@ -260,25 +324,28 @@ class API:
 
     @staticmethod
     async def _resolve_graphql_query(req):
+        # TODO: Get variables and operation_name from form data, params, request text?
+
         if "json" in req.mimetype:
-            return (await req.media("json"))["query"]
+            json_media = await req.media("json")
+            return json_media["query"], json_media.get("variables"), json_media.get("operationName")
 
         # Support query/q in form data.
         # Form data is awaiting https://github.com/encode/starlette/pull/102
         # if "query" in req.media("form"):
-        #     return req.media("form")["query"]
+        #     return req.media("form")["query"], None, None
         # if "q" in req.media("form"):
-        #     return req.media("form")["q"]
+        #     return req.media("form")["q"], None, None
 
         # Support query/q in params.
         if "query" in req.params:
-            return req.params["query"]
+            return req.params["query"], None, None
         if "q" in req.params:
-            return req.params["q"]
+            return req.params["q"], None, None
 
         # Otherwise, the request text is used (typical).
         # TODO: Make some assertions about content-type here.
-        return req.text
+        return req.text, None, None
 
     async def graphql_response(self, req, resp, schema):
         show_graphiql = req.method == "get" and req.accepts("text/html")
@@ -287,8 +354,8 @@ class API:
             resp.content = self.template_string(GRAPHIQL, endpoint=req.url.path)
             return
 
-        query = await self._resolve_graphql_query(req)
-        result = schema.execute(query)
+        query, variables, operation_name = await self._resolve_graphql_query(req)
+        result = schema.execute(query, variables=variables, operation_name=operation_name)
         result, status_code = encode_execution_results(
             [result],
             is_batch=False,
@@ -349,52 +416,38 @@ 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_, **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.
+        Note: The current ``api`` instance is by default passed into the view. This is set in the dict ``api.jinja_values_base``.
 
-        :param name: The filename of the jinja2 template, in ``templates_dir``.
-        :param auto_escape: If ``True``, HTML and XML will automatically be escaped.
+        :param name_: The filename of the jinja2 template, in ``templates_dir``.
         :param values: Data to pass into the template.
         """
-        # Give reference to self.
-        values.update(api=self)
+        # Prepopulate values with base
+        values = {
+            **self.jinja_values_base,
+            **values,
+        }
 
-        env = jinja2.Environment(
-            loader=jinja2.FileSystemLoader(
-                [str(self.templates_dir), str(self.built_in_templates_dir)],
-                followlinks=True,
-            ),
-            autoescape=jinja2.select_autoescape(["html", "xml"] if auto_escape else []),
-        )
-
-        template = env.get_template(name)
+        template = self.jinja_env.get_template(name_)
         return template.render(**values)
 
-    def template_string(self, s, auto_escape=True, **values):
+    def template_string(self, s_, **values):
         """Renders the given `jinja2 <http://jinja.pocoo.org/docs/>`_ template string, with provided values supplied.
 
-        Note: The current ``api`` instance is always passed into the view.
+        Note: The current ``api`` instance is by default passed into the view. This is set in the dict ``api.jinja_values_base``.
 
-        :param s: The template to use.
-        :param auto_escape: If ``True``, HTML and XML will automatically be escaped.
+        :param s_: The template to use.
         :param values: Data to pass into the template.
         """
-        # Give reference to self.
-        values.update(api=self)
+        # Prepopulate values with base
+        values = {
+            **self.jinja_values_base,
+            **values,
+        }
 
-        if auto_escape:
-            env = jinja2.Environment(
-                loader=jinja2.BaseLoader,
-                autoescape=jinja2.select_autoescape(["html", "xml"]),
-            )
-        else:
-            env = jinja2.Environment(
-                loader=jinja2.BaseLoader, autoescape=jinja2.select_autoescape([])
-            )
-
-        template = env.from_string(s)
+        template = self.jinja_env.from_string(s_)
         return template.render(**values)
 
     def run(self, address=None, port=None, **options):

responder/cli.py

@@ -0,0 +1,43 @@
+"""Responder.
+
+Usage:
+  responder
+  responder run [--build] [--debug] <module>
+  responder build
+  responder --version
+
+Options:
+  -h --help     Show this screen.
+  -v --version  Show version.
+
+"""
+
+import os
+
+import docopt
+from .__version__ import __version__
+
+
+def cli():
+    args = docopt.docopt(
+        __doc__, argv=None, help=True, version=__version__, options_first=False
+    )
+
+    module = args["<module>"]
+    build = args["build"] or args["--build"]
+    run = args["run"]
+
+    if build:
+        os.system("npm run build")
+
+    if run:
+        split_module = module.split(":")
+
+        if len(split_module) > 1:
+            module = split_module[0]
+            prop = split_module[1]
+        else:
+            prop = "api"
+
+        app = __import__(module)
+        getattr(app, prop).run()

responder/core.py

@@ -1,2 +1,3 @@
 from .api import API
 from .models import Request, Response
+from .cli import cli

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,17 +90,13 @@ class QueryDict(dict):
 
 # TODO: add slots
 class Request:
-    __slots__ = [
-        "_starlette",
-        "formats",
-        "_headers",
-        "_encoding",
-    ]
+    __slots__ = ["_starlette", "formats", "_headers", "_encoding", "api"]
 
-    def __init__(self, scope, receive):
+    def __init__(self, scope, receive, api=None):
         self._starlette = StarletteRequest(scope, receive)
         self.formats = None
         self._encoding = None
+        self.api = api
 
         headers = CaseInsensitiveDict()
         for header, value in self._starlette.headers.items():
@@ -106,6 +104,15 @@ class Request:
 
         self._headers = headers
 
+    @property
+    def session(self):
+        """The session data, in dict form, from the Request."""
+        if "Responder-Session" in self.cookies:
+            data = self.cookies[self.api.session_cookie]
+            data = self.api._signer.unsign(data)
+            return json.loads(data)
+        return {}
+
     @property
     def headers(self):
         """A case-insensitive dictionary, containing all headers sent in the Request."""
@@ -130,6 +137,18 @@ class Request:
         """The parsed URL of the Request."""
         return rfc3986.urlparse(self.full_url)
 
+    @property
+    def cookies(self):
+        """The cookies sent in the Request, as a dictionary."""
+        cookies = RequestsCookieJar()
+        cookie_header = self.headers.get("cookie", "")
+
+        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 +210,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 +235,8 @@ class Response:
         "media",
         "headers",
         "formats",
+        "cookies",
+        "session",
     ]
 
     def __init__(self, req, *, formats):
@@ -229,8 +250,12 @@ class Response:
         )  #: A Python object that will be content-negotiated and sent back to the client. Typically, in JSON formatting.
         self.headers = (
             {}
-        )  #: A Python dictionary of {Key: value}, representing the headers of the response.
+        )  #: A Python dictionary of ``{key: value}``, representing the headers of the response.
         self.formats = formats
+        self.cookies = {}  #: The cookies set in the Response, as a dictionary
+        self.session = (
+            req.session.copy()
+        )  #: The cookie-based session data, in dict form, to add to the Response.
 
     @property
     async def body(self):
@@ -250,35 +275,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)
 
@@ -286,8 +284,3 @@ class Response:
             body, status_code=self.status_code, headers=headers
         )
         await response(receive, send)
-
-
-class Schema(graphene.Schema):
-    def on_request(self, req, resp):
-        pass

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

setup.py

@@ -38,6 +38,8 @@ required = [
     "apispec>=1.0.0b1",
     "marshmallow",
     "asgiref",
+    "docopt",
+    "itsdangerous",
 ]
 
 
@@ -117,9 +119,7 @@ setup(
     author_email="me@kennethreitz.org",
     url="https://github.com/kennethreitz/responder",
     packages=find_packages(exclude=["tests"]),
-    # entry_points={
-    #     "console_scripts": ["responder=responder:cli"]
-    # },
+    entry_points={"console_scripts": ["responder=responder.cli:cli"]},
     package_data={
         # "": ["LICENSE", "NOTICES"],
         #     "pipenv.vendor.requests": ["*.pem"],

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,39 @@ 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"}}
+
+
+def test_sessions(api, session):
+    @api.route("/")
+    def view(req, resp):
+        resp.session["hello"] = "world"
+        resp.media = resp.session
+
+    r = session.get(api.url_for(view))
+    assert "Responder-Session" in r.cookies
+
+    r = session.get(api.url_for(view))
+    assert r.cookies['Responder-Session'] == '{"hello": "world"}.lJVWJULPqR9kdao_oT4pUglV281bxHfGvcKQ7XF8qNqaiIZlRcMvqKNdA1-d5z7DycAx5eqmzJZoqWPP759-Cw'
+    assert r.json() == {"hello": "world"}
+
+def test_template_rendering(api, session):
+    @api.route('/')
+    def view(req, resp):
+        resp.content = api.template_string("{{ var }}", var="hello")
+
+    r = session.get(api.url_for(view))
+    assert r.text == "hello"

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