websockets

doc: fix Class-based views

CHANGELOG.md

@@ -1,3 +1,16 @@
+# v0.2.0
+- WebSocket support.
+
+# v0.1.6
+- 500 support.
+
+# v0.1.5
+- Improvements to sequential media reading.
+- File upload support.
+
+# v0.1.4
+- Stability.
+
 # v0.1.3
 - Sessions support.
 
@@ -11,7 +24,7 @@
 - Prototype of static application support.
 
 # v0.0.10
-- Bufgix for async class-based views.
+- Bugfix for async class-based views.
 
 # v0.0.9
 - Bugfix for async class-based views.
@@ -32,7 +45,7 @@
  - Safe load/dump yaml.
 
 # v0.0.4:
- - Asyncronous support for data uploads.
+ - Asynchronous support for data uploads.
  - Bug fixes.
 
 # v0.0.3:

Pipfile.lock

@@ -72,6 +72,12 @@
             ],
             "version": "==7.0"
         },
+        "docopt": {
+            "hashes": [
+                "sha256:49b3a825280bd66b3aa83585ef59c4a8c82f2c8a522dbe754a8bc8d08c85c491"
+            ],
+            "version": "==0.6.2"
+        },
         "graphene": {
             "hashes": [
                 "sha256:b8ec446d17fa68721636eaad3d6adc1a378cb6323e219814c8f98c9928fc9642",
@@ -114,9 +120,10 @@
         },
         "itsdangerous": {
             "hashes": [
-                "sha256:cbb3fcf8d3e33df861709ecaf89d9e6629cff0a217bc2848f1b41cd30d360519"
+                "sha256:a7de3201740a857380421ef286166134e10fe58846bcefbc9d6424a69a0b99ec",
+                "sha256:aca4fc561b7671115a2156f625f2eaa5e0e3527e0adf2870340e7968c0a81f85"
             ],
-            "version": "==0.24"
+            "version": "==1.0.0"
         },
         "jinja2": {
             "hashes": [
@@ -174,6 +181,13 @@
             ],
             "version": "==2.20.0"
         },
+        "requests-toolbelt": {
+            "hashes": [
+                "sha256:42c9c170abc2cacb78b8ab23ac957945c7716249206f90874651971a4acff237",
+                "sha256:f6a531936c6fa4c6cfce1b9c10d5c4f498d16528d2a54a22ca00011205a187b5"
+            ],
+            "version": "==0.8.0"
+        },
         "responder": {
             "editable": true,
             "path": "."
@@ -214,9 +228,9 @@
         },
         "uvicorn": {
             "hashes": [
-                "sha256:30096b58325cdca8e547a6f5f4300040d0b8763f573cb1843abfa96f81a49cf8"
+                "sha256:7c4550c7e6f7c8727fa5ccd5200baf62c9e055895e058933ee88f5d0c246ca0c"
             ],
-            "version": "==0.3.13"
+            "version": "==0.3.14"
         },
         "websockets": {
             "hashes": [
@@ -473,9 +487,10 @@
         },
         "itsdangerous": {
             "hashes": [
-                "sha256:cbb3fcf8d3e33df861709ecaf89d9e6629cff0a217bc2848f1b41cd30d360519"
+                "sha256:a7de3201740a857380421ef286166134e10fe58846bcefbc9d6424a69a0b99ec",
+                "sha256:aca4fc561b7671115a2156f625f2eaa5e0e3527e0adf2870340e7968c0a81f85"
             ],
-            "version": "==0.24"
+            "version": "==1.0.0"
         },
         "jinja2": {
             "hashes": [

README.md

@@ -86,7 +86,7 @@ class Query(graphene.ObjectType):
     hello = graphene.String(name=graphene.String(default_value="stranger"))
 
     def resolve_hello(self, info, name):
-        return "Hello " + name
+        return f"Hello {name}"
 
 api.add_route("/graph", graphene.Schema(query=Query))
 ```

docs/source/index.rst

@@ -50,6 +50,7 @@ Features
 - A pleasant API, with a single import statement.
 - Class-based views without inheritence.
 - ASGI framework, the future of Python web services.
+- WebSocket support!
 - The ability to mount any ASGI / WSGI app at a subroute.
 - *f-string syntax* route declaration.
 - Mutable response object, passed into each view. No need to return anything.

docs/source/tour.rst

@@ -9,7 +9,7 @@ Class-based views (and setting some headers and stuff)::
 
     @api.route("/{greeting}")
     class GreetingResource:
-        def on_request(req, resp, *, greeting):   # or on_get...
+        def on_request(self, req, resp, *, greeting):   # or on_get...
             resp.text = f"{greeting}, world!"
             resp.headers.update({'X-Life': '42'})
             resp.status_code = api.status_codes.HTTP_416
@@ -43,7 +43,7 @@ Serve a GraphQL API::
         hello = graphene.String(name=graphene.String(default_value="stranger"))
 
         def resolve_hello(self, info, name):
-            return "Hello " + name
+            return f"Hello {name}"
 
     api.add_route("/graph", graphene.Schema(query=Query))
 
@@ -147,7 +147,11 @@ If you have a single-page webapp, you can tell Responder to serve up your ``stat
 
     api.add_route("/", static=True)
 
-This will make ``index.html`` the default response to all undefined routes.
+This will make ``index.html`` the default response to all undefined routes. Responder's CLI comes with a ``build`` command that will call ``npm run build`` for you::
+
+    responder build
+
+For an example of how to seamlessly integrate a React single page app with Responder check out `this project <https://github.com/metakermit/responder-react>`_.
 
 Reading / Writing Cookies
 -------------------------
@@ -169,8 +173,24 @@ Responder has built-in support for cookie-based sessions. To enable cookie-based
 
 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(...)``.
 
+WebSocket Support
+-----------------
+
+Responder supports WebSockets::
+
+    @api.ws_route('/ws')
+    async def hello(ws):
+        await ws.accept()
+        await ws.send_text("Hello via websocket!")
+        await ws.close()
+
 
 HSTS (Redirect to HTTPS)
 ------------------------

responder/__version__.py

@@ -1 +1 @@
-__version__ = "0.1.3"
+__version__ = "0.2.0"

responder/api.py

@@ -25,6 +25,7 @@ from .routes import Route
 from .formats import get_formats
 from .background import BackgroundQueue
 from .templates import GRAPHIQL
+from .models import WebSocket
 
 # TODO: consider moving status codes here
 class API:
@@ -32,6 +33,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.
     """
 
@@ -47,6 +49,7 @@ class API:
         static_dir="static",
         static_route="/static",
         templates_dir="templates",
+        auto_escape=True,
         secret_key="NOTASECRET",
         enable_hsts=False,
     ):
@@ -62,6 +65,7 @@ class API:
         )
         self.routes = {}
         self.schemas = {}
+        self.session_cookie = "Responder-Session"
 
         self.hsts_enabled = enable_hsts
         self.static_files = StaticFiles(directory=str(self.static_dir))
@@ -86,6 +90,16 @@ class API:
         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(
@@ -135,13 +149,22 @@ class API:
         # Call the main dispatcher.
         async def asgi(receive, send):
             nonlocal scope, self
+            if scope["type"] == "websocket":
 
-            req = models.Request(scope, receive=receive, api=self)
-            resp = await self._dispatch_request(req)
-            await resp(receive, send)
+                ws = WebSocket(scope, receive, send)
+                await self._dispatch_ws(ws)
+            else:
+                req = models.Request(scope, receive=receive, api=self)
+                resp = await self._dispatch_request(req)
+                await resp(receive, send)
 
         return asgi
 
+    async def _dispatch_ws(self, ws):
+        route = self.path_matches_route(ws.url.path, protocol="ws")
+        route = self.routes.get(route)
+        await self._dispatch(route, ws=ws)
+
     def add_schema(self, name, schema, check_existing=True):
         """Adds a mashmallow schema to the API specification."""
         if check_existing:
@@ -168,17 +191,17 @@ class API:
 
         return decorator
 
-    def path_matches_route(self, path):
+    # TODO: Remove protocol
+    def path_matches_route(self, path, protocol="http"):
         """Given a path portion of a URL, tests that it matches against any registered route.
 
         :param path: The path portion of a URL, to test all known routes against.
         """
         for (route, route_object) in self.routes.items():
-            if route_object.does_match(path):
+            if route_object.does_match(path, protocol):
                 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
@@ -191,78 +214,130 @@ class API:
 
         if resp.session:
             data = self._signer.sign(json.dumps(resp.session).encode("utf-8"))
-            resp.cookies["Responder-Session"] = data.decode("utf-8")
+            resp.cookies[self.session_cookie] = data.decode("utf-8")
+
+    @staticmethod
+    def no_response(req, resp, **params):
+        pass
 
     async def _dispatch_request(self, req):
         # Set formats on Request object.
         req.formats = self.formats
 
+        # Get the route.
         route = self.path_matches_route(req.url.path)
+        route = self.routes.get(route)
+
+        # Create the response object.
         resp = models.Response(req=req, formats=self.formats)
+        self.default_response(req, resp)
 
-        if route:
-            try:
-                params = self.routes[route].incoming_matches(req.url.path)
-                result = self.routes[route].endpoint(req, resp, **params)
-                if hasattr(result, "cr_running"):
-                    await result
-            # The request is using class-based views.
-            except TypeError as e:
-                try:
-                    view = self.routes[route].endpoint(**params)
-                except TypeError:
-                    view = self.routes[route].endpoint
-
-                    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:
-                    r = getattr(view, "on_request")(req, resp, **params)
-                    if hasattr(r, "send"):
-                        await r
-                except AttributeError:
-                    pass
-
-                # Then on_get.
-                method = req.method
-
-                try:
-                    r = getattr(view, f"on_{method}")(req, resp, **params)
-                    if hasattr(r, "send"):
-                        await r
-                except AttributeError:
-                    pass
-        else:
-            self.default_response(req, resp)
+        await self._dispatch(route, req=req, resp=resp)
 
         self._prepare_session(resp)
         self._prepare_cookies(resp)
 
         return resp
 
+    async def _dispatch(self, route, **kwargs):
+
+        cont = False
+
+        if route:
+            if "req" in kwargs:
+                params = route.incoming_matches(kwargs["req"].url.path)
+            elif "ws" in kwargs:
+                params = route.incoming_matches(kwargs["ws"].url.path)
+            else:
+                params = {}
+
+            if route.is_graphql:
+                await self.graphql_response(schema=route.endpoint, **kwargs)
+
+            elif route.is_function:
+                try:
+                    try:
+                        # Run the view.
+                        r = route.endpoint(**kwargs, **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(error=True, **kwargs)
+
+            if route.is_class_based or cont:
+                try:
+                    view = route.endpoint(**params)
+                except TypeError:
+                    view = route.endpoint
+
+                # Run on_request first.
+                try:
+                    # Run the view.
+                    r = getattr(view, "on_request", self.no_response)(
+                        **kwargs, **params
+                    )
+                    # If it's async, await it.
+                    if hasattr(r, "send"):
+                        await r
+                except Exception:
+                    self.default_response(error=True, **kwargs)
+
+                # Then on_get.
+                if "req" in kwargs:
+                    method = kwargs["req"].method
+                elif "ws" in kwargs:
+                    method = kwargs["ws"].method
+                else:
+                    method = "get"
+
+                # Run on_request first.
+                try:
+                    # Run the view.
+                    r = getattr(view, f"on_{method}", self.no_response)(
+                        **kwargs, **params
+                    )
+                    # If it's async, await it.
+                    if hasattr(r, "send"):
+                        await r
+                except Exception as e:
+                    self.default_response(error=True, **kwargs)
+
+        else:
+            self.default_response(notfound=True, **kwargs)
+
+        return kwargs
+
     def add_route(
-        self, route, endpoint=None, *, default=False, static=False, check_existing=True
+        self,
+        route,
+        endpoint=None,
+        *,
+        default=False,
+        websocket=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, or graphene schema (GraphQL).
         :param default: If ``True``, all unknown requests will route to this view.
+        :param websocket: If ``True``, Requests to route will be treated as websockets.
         :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 websocket:
+            protocol = "ws"
+        else:
+            protocol = "http"
+
         if check_existing:
-            assert route not in self.routes
+            assert not (
+                route in self.routes and self.routes[route].protocol == protocol
+            )
 
         if not endpoint and static:
             endpoint = self.static_response
@@ -270,18 +345,32 @@ class API:
 
         if default:
             self.default_endpoint = endpoint
-        self.routes[route] = Route(route, endpoint)
+
+        try:
+            if callable(endpoint):
+                endpoint.is_routed = True
+        except AttributeError:
+            pass
+
+        self.routes[route] = Route(route, endpoint, protocol)
         # TODO: A better datastructer or sort it once the app is loaded
         self.routes = dict(
             sorted(self.routes.items(), key=lambda item: item[1]._weight())
         )
 
-    def default_response(self, req, resp):
+    def default_response(self, req, resp, notfound=False, error=False):
+        if resp.status_code is None:
+            resp.status_code = 200
+
         if self.default_endpoint:
             self.default_endpoint(req, resp)
         else:
-            resp.status_code = status_codes.HTTP_404
-            resp.text = "Not found."
+            if notfound:
+                resp.status_code = status_codes.HTTP_404
+                resp.text = "Not found."
+            if error:
+                resp.status_code = status_codes.HTTP_500
+                resp.text = "Application error."
 
     def static_response(self, req, resp):
         index = (self.static_dir / "index.html").resolve()
@@ -318,7 +407,11 @@ class API:
 
         if "json" in req.mimetype:
             json_media = await req.media("json")
-            return json_media["query"], json_media.get("variables"), json_media.get("operationName")
+            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
@@ -345,7 +438,9 @@ class API:
             return
 
         query, variables, operation_name = await self._resolve_graphql_query(req)
-        result = schema.execute(query, variables=variables, operation_name=operation_name)
+        result = schema.execute(
+            query, variables=variables, operation_name=operation_name
+        )
         result, status_code = encode_execution_results(
             [result],
             is_batch=False,
@@ -400,69 +495,53 @@ class API:
         for (route, route_object) in self.routes.items():
             if route_object.endpoint == endpoint:
                 return route_object.url(testing=testing, **params)
+            elif route_object.endpoint_name == endpoint:
+                return route_object.url(testing=testing, **params)
         raise ValueError
 
     def static_url(self, asset):
         """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 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):
+    def run(self, address=None, port=None, debug=False, **options):
         """Runs the application with uvicorn. If the ``PORT`` environment
         variable is set, requests will be served on that port automatically to all
         known hosts.
 
         :param address: The address to bind to.
         :param port: The port to bind to. If none is provided, one will be selected at random.
+        :param debug: Run uvicorn server in debug mode.
         :param options: Additional keyword arguments to send to ``uvicorn.run()``.
         """
+
         if "PORT" in os.environ:
             if address is None:
                 address = "0.0.0.0"
@@ -473,4 +552,4 @@ class API:
         if port is None:
             port = 5042
 
-        uvicorn.run(self, host=address, port=port, **options)
+        uvicorn.run(self, host=address, port=port, debug=debug, **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/formats.py

@@ -1,10 +1,17 @@
+from urllib.parse import parse_qs
+
 import yaml
 import json
+from parse import findall
+from .models import QueryDict
+from requests_toolbelt.multipart import decoder
 
 
 async def format_form(r, encode=False):
-    if not encode:
-        return await r._starlette.form()
+    if encode:
+        pass
+    else:
+        return QueryDict(await r.text)
 
 
 async def format_yaml(r, encode=False):
@@ -23,5 +30,36 @@ async def format_json(r, encode=False):
         return json.loads(await r.content)
 
 
+async def format_files(r, encode=False):
+    if encode:
+        pass
+    else:
+        decoded = decoder.MultipartDecoder(await r.content, r.mimetype)
+        dump = {}
+        for part in decoded.parts:
+            header = part.headers[b"Content-Disposition"].decode("utf-8")
+            filename = None
+
+            for section in [h.strip() for h in header.split(";")]:
+                split = section.split("=")
+                if len(split) > 1:
+                    key = split[0]
+                    value = split[1]
+
+                    value = value[1:-1]
+
+                    if key == "filename":
+                        filename = value
+
+            if filename:
+                dump[filename] = part.content
+        return dump
+
+
 def get_formats():
-    return {"json": format_json, "yaml": format_yaml, "form": format_form}
+    return {
+        "json": format_json,
+        "yaml": format_yaml,
+        "form": format_form,
+        "files": format_files,
+    }

responder/models.py

@@ -13,6 +13,7 @@ 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 starlette.websockets import WebSocket as StarletteWebSocket
 
 from urllib.parse import parse_qs
 
@@ -90,13 +91,14 @@ class QueryDict(dict):
 
 # TODO: add slots
 class Request:
-    __slots__ = ["_starlette", "formats", "_headers", "_encoding", "api"]
+    __slots__ = ["_starlette", "formats", "_headers", "_encoding", "api", "_content"]
 
     def __init__(self, scope, receive, api=None):
         self._starlette = StarletteRequest(scope, receive)
         self.formats = None
         self._encoding = None
         self.api = api
+        self._content = None
 
         headers = CaseInsensitiveDict()
         for header, value in self._starlette.headers.items():
@@ -108,7 +110,7 @@ class Request:
     def session(self):
         """The session data, in dict form, from the Request."""
         if "Responder-Session" in self.cookies:
-            data = self.cookies["Responder-Session"]
+            data = self.cookies[self.api.session_cookie]
             data = self.api._signer.unsign(data)
             return json.loads(data)
         return {}
@@ -143,7 +145,6 @@ class Request:
         cookies = RequestsCookieJar()
         cookie_header = self.headers.get("cookie", "")
 
-        # if cookie_header:
         bc = SimpleCookie(cookie_header)
         for k, v in bc.items():
             cookies[k] = v
@@ -180,12 +181,14 @@ class Request:
     @property
     async def content(self):
         """The Request body, as bytes. Must be awaited."""
-        return await self._starlette.body()
+        if not self._content:
+            self._content = await self._starlette.body()
+        return self._content
 
     @property
     async def text(self):
         """The Request body, as unicode. Must be awaited."""
-        return (await self._starlette.body()).decode(await self.encoding)
+        return (await self.content).decode(await self.encoding)
 
     @property
     async def declared_encoding(self):
@@ -242,7 +245,7 @@ class Response:
 
     def __init__(self, req, *, formats):
         self.req = req
-        self.status_code = HTTP_200  #: The HTTP Status Code to use for the Response.
+        self.status_code = None  #: The HTTP Status Code to use for the Response.
         self.text = None  #: A unicode representation of the response body.
         self.content = None  #: A bytes representation of the response body.
         self.encoding = DEFAULT_ENCODING
@@ -251,10 +254,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."""
+        self.session = (
+            req.session.copy()
+        )  #: The cookie-based session data, in dict form, to add to the Response.
 
     @property
     async def body(self):
@@ -283,3 +288,65 @@ class Response:
             body, status_code=self.status_code, headers=headers
         )
         await response(receive, send)
+
+
+class WebSocket:
+    __slots__ = ("_starlette", "_headers")
+
+    def __init__(self, scope, receive, send):
+        self._starlette = StarletteWebSocket(scope, receive, send)
+
+        headers = CaseInsensitiveDict()
+        for header, value in self._starlette.headers.items():
+            headers[header] = value
+
+        self._headers = headers
+
+    @property
+    def url(self):
+        return rfc3986.urlparse(str(self._starlette.url))
+
+    @property
+    def params(self):
+        """A dictionary of the parsed query parameters used for the Request."""
+        try:
+            return QueryDict(self.url.query)
+        except AttributeError:
+            return QueryDict({})
+
+    async def accept(self):
+        return await self._starlette.accept()
+
+    async def receive(self):
+        return await self._starlette.receive()
+
+    async def content(self):
+        """Receive bytes."""
+        return await self._starlette.receive_bytes()
+
+    async def text(self):
+        """Receive text."""
+        return await self._starlette.receive_text()
+
+    # async def json(self):
+    #     """Receive json"""
+    #     return await self._starlette.receive_json()
+
+    # async def media(self):
+    #     """Receive json"""
+    #     return (await self.receive_json())
+
+    async def send(self):
+        await self._starlette.send()
+
+    async def send_text(self, data):
+        await self._starlette.send_text(data)
+
+    # async def send_json(self, data):
+    #     await self._starlette.send_json(data)
+
+    # async def send_media(self, data):
+    #     await self.send_json(data)
+
+    async def close(self, code=1000):
+        await self._starlette.close(code)

responder/routes.py

@@ -3,10 +3,10 @@ from parse import parse
 
 
 def memoize(f):
-    def helper(self, s):
+    def helper(self, s, *args, **kwargs):
         memoize_key = f"{f.__name__}:{s}"
         if memoize_key not in self._memo:
-            self._memo[memoize_key] = f(self, s)
+            self._memo[memoize_key] = f(self, s, *args, **kwargs)
         return self._memo[memoize_key]
 
     return helper
@@ -15,9 +15,10 @@ def memoize(f):
 class Route:
     _param_pattern = re.compile(r"{([^{}]*)}")
 
-    def __init__(self, route, endpoint):
+    def __init__(self, route, endpoint, protocol="http"):
         self.route = route
         self.endpoint = endpoint
+        self.protocol = protocol
         self._memo = {}
 
     def __repr__(self):
@@ -31,6 +32,10 @@ class Route:
             # Strings.
             return self.does_match(other)
 
+    @property
+    def endpoint_name(self):
+        return self.endpoint.__name__
+
     @property
     def description(self):
         return self.endpoint.__doc__
@@ -40,8 +45,10 @@ class Route:
         return bool(self._param_pattern.search(self.route))
 
     @memoize
-    def does_match(self, s):
+    def does_match(self, s, protocol="http"):
         if s == self.route:
+            if self.protocol != protocol:
+                return False
             return True
 
         named = self.incoming_matches(s)
@@ -61,9 +68,19 @@ class Route:
 
     def _weight(self):
         params = set(self._param_pattern.findall(self.route))
-        params_count = -len(params) or 0
-        return params_count != 0, params_count
+        params_count = len(params)
+        return params_count != 0, -params_count
 
     @property
     def is_graphql(self):
         return hasattr(self.endpoint, "get_graphql_type")
+
+    @property
+    def is_class_based(self):
+        return hasattr(self.endpoint, "__class__")
+
+    def is_function(self):
+        routed = hasattr(self.endpoint, "is_routed")
+        code = hasattr(self.endpoint, "__code__")
+        kwdefaults = hasattr(self.endpoint, "__kwdefaults__")
+        return all((routed, code, kwdefaults))

setup.py

@@ -38,7 +38,9 @@ required = [
     "apispec>=1.0.0b1",
     "marshmallow",
     "asgiref",
+    "docopt",
     "itsdangerous",
+    "requests-toolbelt",
 ]
 
 
@@ -118,9 +120,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"],

tests/test_encodings.py

@@ -22,15 +22,3 @@ def test_bytes_encoding(api, session):
 
     r = session.get(api.url_for(route), data=data)
     assert r.content == data
-
-
-def test_false_encoding_raises(api, session):
-    data = "hi mom!"
-
-    @api.route("/")
-    async def route(req, resp):
-        req.encoding = "non-existient"
-        resp.text = await req.text
-
-    with pytest.raises(LookupError):
-        session.get(api.url_for(route), data=data)

tests/test_responder.py

@@ -1,6 +1,7 @@
 import pytest
 import yaml
 import responder
+import io
 
 
 def test_api_basic_route(api):
@@ -150,7 +151,7 @@ def test_request_and_get(api, session):
         def on_request(self, req, resp):
             resp.headers.update({"DEATH": "666"})
 
-        def on_get(self, request, resp):
+        def on_get(self, req, resp):
             resp.headers.update({"LIFE": "42"})
 
     r = session.get(api.url_for(ThingsResource))
@@ -395,5 +396,56 @@ def test_sessions(api, session):
     assert "Responder-Session" in r.cookies
 
     r = session.get(api.url_for(view))
-    assert r.cookies['Responder-Session'] == '{"hello": "world"}.r3EB04hEEyLYIJaAXCEq3d4YEbs'
+    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"
+
+
+def test_file_uploads(api, session):
+    @api.route("/")
+    async def upload(req, resp):
+
+        files = await req.media("files")
+        files["hello"] = files["hello"].decode("utf-8")
+        resp.media = {"files": files}
+
+    world = io.StringIO("world")
+    data = {"hello": world}
+    r = session.post(api.url_for(upload), files=data)
+    assert r.json() == {"files": {"hello": "world"}}
+
+
+def test_500(api, session):
+    @api.route("/")
+    def view(req, resp):
+        raise ValueError
+
+    r = session.get(api.url_for(view))
+    assert not r.ok
+
+
+def test_404(session):
+    r = session.get("/foo")
+
+    assert r.status_code == responder.status_codes.HTTP_404
+
+
+def test_kinda_websockets(api):
+    @api.route("/ws", websocket=True)
+    async def websocket(ws):
+        await ws.accept()
+        await ws.send_text("Hello via websocket!")
+        await ws.close()
+
+