From cf2a363e5e0c0c208b384b87964c9cbe0d6edb8b Mon Sep 17 00:00:00 2001 From: lixxu Date: Thu, 9 Feb 2017 16:44:23 +0800 Subject: [PATCH 01/12] improve url_for to support multi values for one arg, add _anchor/_external/_scheme options --- sanic/sanic.py | 18 +++++++++++----- sanic/utils.py | 6 +++++- tests/test_url_building.py | 43 +++++++++++++++++++++++++++++++++++--- 3 files changed, 58 insertions(+), 9 deletions(-) diff --git a/sanic/sanic.py b/sanic/sanic.py index 951632be..7b3e5d22 100644 --- a/sanic/sanic.py +++ b/sanic/sanic.py @@ -230,6 +230,16 @@ class Sanic: matched_params = re.findall( self.router.parameter_pattern, uri) + # _method is only a placeholder now, don't know how to support it + kwargs.pop('_method', None) + anchor = kwargs.pop('_anchor', '') + # _external need SERVER_NAME in config or pass _server arg + external = kwargs.pop('_external', False) + scheme = kwargs.pop('_scheme', '') + if scheme and not external: + raise ValueError('When specifying _scheme, _external must be True') + + netloc = kwargs.pop('_server', self.config.get('SERVER_NAME', '')) for match in matched_params: name, _type, pattern = self.router.parse_parameter_string( match) @@ -271,11 +281,9 @@ class Sanic: # parse the remainder of the keyword arguments into a querystring if kwargs: - query_string = urlencode(kwargs) - out = urlunparse(( - '', '', out, - '', query_string, '' - )) + query_string = urlencode(kwargs, doseq=True) + # scheme://netloc/path;parameters?query#fragment + out = urlunparse((scheme, netloc, out, '', query_string, anchor)) return out diff --git a/sanic/utils.py b/sanic/utils.py index 8e8f8124..da13f478 100644 --- a/sanic/utils.py +++ b/sanic/utils.py @@ -6,7 +6,11 @@ PORT = 42101 async def local_request(method, uri, cookies=None, *args, **kwargs): - url = 'http://{host}:{port}{uri}'.format(host=HOST, port=PORT, uri=uri) + if uri.startswith(('http:', 'https:', 'ftp:', 'ftps://' '//')): + url = uri + else: + url = 'http://{host}:{port}{uri}'.format(host=HOST, port=PORT, uri=uri) + log.info(url) async with aiohttp.ClientSession(cookies=cookies) as session: async with getattr( diff --git a/tests/test_url_building.py b/tests/test_url_building.py index 480313b3..f2377c3a 100644 --- a/tests/test_url_building.py +++ b/tests/test_url_building.py @@ -5,7 +5,7 @@ from sanic import Sanic from sanic.response import text from sanic.views import HTTPMethodView from sanic.blueprints import Blueprint -from sanic.utils import sanic_endpoint_test +from sanic.utils import sanic_endpoint_test, PORT as test_port from sanic.exceptions import URLBuildError import string @@ -39,6 +39,30 @@ def test_simple_url_for_getting(simple_app): assert response.text == letter +def test_simple_url_for_getting_with_duplicate_params(simple_app): + kw = dict(arg1=['value1', 'value2'], _anchor='anchor') + for letter in string.ascii_letters: + url = simple_app.url_for(letter, **kw) + + assert url == '/{}?arg1=value1&arg1=value2#anchor'.format(letter) + request, response = sanic_endpoint_test(simple_app, uri=url) + assert response.status == 200 + assert response.text == letter + + +def test_simple_url_for_getting_with_special_params(simple_app): + kw = dict(arg1='value1', _anchor='anchor', _scheme='http', + _server='localhost:{}'.format(test_port), _external=True) + url_fmt = 'http://localhost:{}/{}?arg1=value1#anchor' + for letter in string.ascii_letters: + url = simple_app.url_for(letter, **kw) + + assert url == url_fmt.format(test_port, letter) + request, response = sanic_endpoint_test(simple_app, uri=url) + assert response.status == 200 + assert response.text == letter + + def test_fails_if_endpoint_not_found(): app = Sanic('fail_url_build') @@ -75,6 +99,19 @@ def test_fails_url_build_if_param_not_passed(): assert 'Required parameter `Z` was not passed to url_for' in str(e.value) +def test_fails_url_build_if_params_not_passed(): + app = Sanic('fail_url_build') + + @app.route('/fail') + def fail(): + return text('this should fail') + + with pytest.raises(ValueError) as e: + app.url_for('fail', _scheme='http') + + assert str(e.value) == 'When specifying _scheme, _external must be True' + + COMPLEX_PARAM_URL = ( '///' '//') @@ -179,11 +216,11 @@ def blueprint_app(): return text( 'foo from first : {}'.format(param)) - @second_print.route('/foo') # noqa + @second_print.route('/foo') # noqa def foo(): return text('foo from second') - @second_print.route('/foo/') # noqa + @second_print.route('/foo/') # noqa def foo_with_param(request, param): return text( 'foo from second : {}'.format(param)) From fb419eaa3649e1d7367f6f51ea7c5ca42a1f8256 Mon Sep 17 00:00:00 2001 From: lixxu Date: Thu, 9 Feb 2017 18:26:17 +0800 Subject: [PATCH 02/12] fix bug: netloc always in url if SERVER_NAME defined in config even _external not true --- sanic/sanic.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/sanic/sanic.py b/sanic/sanic.py index 7b3e5d22..821c2b89 100644 --- a/sanic/sanic.py +++ b/sanic/sanic.py @@ -239,7 +239,10 @@ class Sanic: if scheme and not external: raise ValueError('When specifying _scheme, _external must be True') - netloc = kwargs.pop('_server', self.config.get('SERVER_NAME', '')) + netloc = kwargs.pop('_server', None) + if netloc is None and external: + netloc = self.config.get('SERVER_NAME', '') + for match in matched_params: name, _type, pattern = self.router.parse_parameter_string( match) From 281077bc26c9772af4d7f3e5c910037016e2d40c Mon Sep 17 00:00:00 2001 From: Superman132 Date: Mon, 13 Feb 2017 19:35:03 -0500 Subject: [PATCH 03/12] Update README.rst --- README.rst | 4 ---- 1 file changed, 4 deletions(-) diff --git a/README.rst b/README.rst index b9414b0d..109d0e97 100644 --- a/README.rst +++ b/README.rst @@ -78,10 +78,6 @@ Documentation TODO ---- * Streamed file processing -* File output -* Examples of integrations with 3rd-party modules -* RESTful router - Limitations ----------- * No wheels for uvloop and httptools on Windows :( From 84f5faf65301a9924400a9a9889954e5aef877c4 Mon Sep 17 00:00:00 2001 From: Superman132 Date: Mon, 13 Feb 2017 20:48:37 -0500 Subject: [PATCH 04/12] Update README.rst --- README.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/README.rst b/README.rst index 109d0e97..3f565f71 100644 --- a/README.rst +++ b/README.rst @@ -78,6 +78,7 @@ Documentation TODO ---- * Streamed file processing +* http2 Limitations ----------- * No wheels for uvloop and httptools on Windows :( From 4839ede64f81856d5020541fb4aa79ab3df78a52 Mon Sep 17 00:00:00 2001 From: lixxu Date: Tue, 14 Feb 2017 10:26:30 +0800 Subject: [PATCH 05/12] update test for url_for and update routing.md doc --- docs/sanic/routing.md | 24 +++++++++++++++++++++- sanic/sanic.py | 7 +++---- tests/test_url_building.py | 41 +++++++++++++++++++------------------- 3 files changed, 47 insertions(+), 25 deletions(-) diff --git a/docs/sanic/routing.md b/docs/sanic/routing.md index 0cadd707..5d0442e4 100644 --- a/docs/sanic/routing.md +++ b/docs/sanic/routing.md @@ -11,7 +11,7 @@ from sanic.response import json @app.route("/") async def test(request): return json({ "hello": "world" }) -``` +``` When the url `http://server.url/` is accessed (the base url of the server), the final `/` is matched by the router to the handler function, `test`, which then @@ -145,6 +145,28 @@ Other things to keep in mind when using `url_for`: url = app.url_for('post_handler', post_id=5, arg_one='one', arg_two='two') # /posts/5?arg_one=one&arg_two=two ``` +- Multivalue argument can be passed to `url_for`. For example: +```python +url = app.url_for('post_handler', post_id=5, arg_one=['one', 'two']) +# /posts/5?arg_one=one&arg_one=two +``` +- Also some special arguments (`_anchor`, `_external`, `_scheme`, `_method`, `_server`) passed to `url_for` will have special url building (`_method` is not support now and will be ignored). For example: +```python +url = app.url_for('post_handler', post_id=5, arg_one='one', _anchor='anchor') +# /posts/5?arg_one=one#anchor + +url = app.url_for('post_handler', post_id=5, arg_one='one', _external=True) +# //server/posts/5?arg_one=one +# _external requires passed argument _server or SERVER_NAME in app.config or url will be same as no _external + +url = app.url_for('post_handler', post_id=5, arg_one='one', _scheme='http', _external=True) +# http://server/posts/5?arg_one=one +# when specifying _scheme, _external must be True + +# you can pass all special arguments one time +url = app.url_for('post_handler', post_id=5, arg_one=['one', 'two'], arg_two=2, _anchor='anchor', _scheme='http', _external=True, _server='another_server:8888') +# http://another_server:8888/posts/5?arg_one=one&arg_one=two&arg_two=2#anchor +``` - All valid parameters must be passed to `url_for` to build a URL. If a parameter is not supplied, or if a parameter does not match the specified type, a `URLBuildError` will be thrown. diff --git a/sanic/sanic.py b/sanic/sanic.py index 821c2b89..c6b10383 100644 --- a/sanic/sanic.py +++ b/sanic/sanic.py @@ -283,10 +283,9 @@ class Sanic: replacement_regex, supplied_param, out) # parse the remainder of the keyword arguments into a querystring - if kwargs: - query_string = urlencode(kwargs, doseq=True) - # scheme://netloc/path;parameters?query#fragment - out = urlunparse((scheme, netloc, out, '', query_string, anchor)) + query_string = urlencode(kwargs, doseq=True) if kwargs else '' + # scheme://netloc/path;parameters?query#fragment + out = urlunparse((scheme, netloc, out, '', query_string, anchor)) return out diff --git a/tests/test_url_building.py b/tests/test_url_building.py index f2377c3a..02cbce31 100644 --- a/tests/test_url_building.py +++ b/tests/test_url_building.py @@ -10,6 +10,14 @@ from sanic.exceptions import URLBuildError import string +URL_FOR_ARGS1 = dict(arg1=['v1', 'v2']) +URL_FOR_VALUE1 = '/myurl?arg1=v1&arg1=v2' +URL_FOR_ARGS2 = dict(arg1=['v1', 'v2'], _anchor='anchor') +URL_FOR_VALUE2 = '/myurl?arg1=v1&arg1=v2#anchor' +URL_FOR_ARGS3 = dict(arg1='v1', _anchor='anchor', _scheme='http', + _server='localhost:{}'.format(test_port), _external=True) +URL_FOR_VALUE3 = 'http://localhost:{}/myurl?arg1=v1#anchor'.format(test_port) + def _generate_handlers_from_names(app, l): for name in l: @@ -39,28 +47,21 @@ def test_simple_url_for_getting(simple_app): assert response.text == letter -def test_simple_url_for_getting_with_duplicate_params(simple_app): - kw = dict(arg1=['value1', 'value2'], _anchor='anchor') - for letter in string.ascii_letters: - url = simple_app.url_for(letter, **kw) +@pytest.mark.parametrize('args,url', + [(URL_FOR_ARGS1, URL_FOR_VALUE1), + (URL_FOR_ARGS2, URL_FOR_VALUE2), + (URL_FOR_ARGS3, URL_FOR_VALUE3)]) +def test_simple_url_for_getting_with_more_params(args, url): + app = Sanic('more_url_build') - assert url == '/{}?arg1=value1&arg1=value2#anchor'.format(letter) - request, response = sanic_endpoint_test(simple_app, uri=url) - assert response.status == 200 - assert response.text == letter + @app.route('/myurl') + def passes(request): + return text('this should pass') - -def test_simple_url_for_getting_with_special_params(simple_app): - kw = dict(arg1='value1', _anchor='anchor', _scheme='http', - _server='localhost:{}'.format(test_port), _external=True) - url_fmt = 'http://localhost:{}/{}?arg1=value1#anchor' - for letter in string.ascii_letters: - url = simple_app.url_for(letter, **kw) - - assert url == url_fmt.format(test_port, letter) - request, response = sanic_endpoint_test(simple_app, uri=url) - assert response.status == 200 - assert response.text == letter + assert url == app.url_for('passes', **args) + request, response = sanic_endpoint_test(app, uri=url) + assert response.status == 200 + assert response.text == 'this should pass' def test_fails_if_endpoint_not_found(): From d57d90fe6b6fa4d103a82e8704ff3ec1202756f3 Mon Sep 17 00:00:00 2001 From: growingdever Date: Tue, 14 Feb 2017 14:23:22 +0900 Subject: [PATCH 06/12] - make blueprint add_route method support view instance - update documentation that doesn't specify url_prefix parameter --- docs/sanic/blueprints.md | 4 ++-- sanic/blueprints.py | 12 ++++++++---- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/docs/sanic/blueprints.md b/docs/sanic/blueprints.md index 120aa1dd..02d387b2 100644 --- a/docs/sanic/blueprints.md +++ b/docs/sanic/blueprints.md @@ -131,8 +131,8 @@ can be used to implement our API versioning scheme. from sanic.response import text from sanic import Blueprint -blueprint_v1 = Blueprint('v1') -blueprint_v2 = Blueprint('v2') +blueprint_v1 = Blueprint('v1', url_prefix='/v1') +blueprint_v2 = Blueprint('v2', url_prefix='/v2') @blueprint_v1.route('/') async def api_v1_root(request): diff --git a/sanic/blueprints.py b/sanic/blueprints.py index 64a37da0..c07cc398 100644 --- a/sanic/blueprints.py +++ b/sanic/blueprints.py @@ -1,5 +1,6 @@ from collections import defaultdict, namedtuple +from sanic.constants import HTTP_METHODS FutureRoute = namedtuple('Route', ['handler', 'uri', 'methods', 'host']) FutureListener = namedtuple('Listener', ['handler', 'uri', 'methods', 'host']) @@ -82,15 +83,18 @@ class Blueprint: return handler return decorator - def add_route(self, handler, uri, methods=None, host=None): + def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None): """ Creates a blueprint route from a function. - :param handler: Function to handle uri request. + :param handler: function or class instance to handle uri request. :param uri: Endpoint at which the route will be accessible. :param methods: List of acceptable HTTP methods. + :return: function or class instance """ - route = FutureRoute(handler, uri, methods, host) - self.routes.append(route) + # Handle HTTPMethodView differently + if hasattr(handler, 'view_class'): + methods = frozenset(HTTP_METHODS) + self.route(uri=uri, methods=methods, host=host)(handler) return handler def listener(self, event): From b66a6bddbc49583cd353017c17fcd423aa7828fb Mon Sep 17 00:00:00 2001 From: growingdever Date: Tue, 14 Feb 2017 14:30:07 +0900 Subject: [PATCH 07/12] fix typo --- sanic/blueprints.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sanic/blueprints.py b/sanic/blueprints.py index c07cc398..237f1b51 100644 --- a/sanic/blueprints.py +++ b/sanic/blueprints.py @@ -86,7 +86,7 @@ class Blueprint: def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None): """ Creates a blueprint route from a function. - :param handler: function or class instance to handle uri request. + :param handler: Function or class instance to handle uri request. :param uri: Endpoint at which the route will be accessible. :param methods: List of acceptable HTTP methods. :return: function or class instance From 07aa0ee7ad535db4e79ec3fbc40748459d66ac6d Mon Sep 17 00:00:00 2001 From: growingdever Date: Tue, 14 Feb 2017 17:15:38 +0900 Subject: [PATCH 08/12] - copy codes from Sonic.add_route - modify comment by r0fls --- sanic/blueprints.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/sanic/blueprints.py b/sanic/blueprints.py index 237f1b51..a123a7a3 100644 --- a/sanic/blueprints.py +++ b/sanic/blueprints.py @@ -1,6 +1,7 @@ from collections import defaultdict, namedtuple from sanic.constants import HTTP_METHODS +from sanic.views import CompositionView FutureRoute = namedtuple('Route', ['handler', 'uri', 'methods', 'host']) FutureListener = namedtuple('Listener', ['handler', 'uri', 'methods', 'host']) @@ -86,14 +87,23 @@ class Blueprint: def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None): """ Creates a blueprint route from a function. - :param handler: Function or class instance to handle uri request. + :param handler: Function for handling uri requests. Accepts function, or class instance with a view_class method. :param uri: Endpoint at which the route will be accessible. :param methods: List of acceptable HTTP methods. :return: function or class instance """ # Handle HTTPMethodView differently if hasattr(handler, 'view_class'): - methods = frozenset(HTTP_METHODS) + methods = set() + + for method in HTTP_METHODS: + if getattr(handler.view_class, method.lower(), None): + methods.add(method) + + # handle composition view differently + if isinstance(handler, CompositionView): + methods = handler.handlers.keys() + self.route(uri=uri, methods=methods, host=host)(handler) return handler From 81a8a99b6e7fd0865ab87e70b8c3af2a782d3047 Mon Sep 17 00:00:00 2001 From: growingdever Date: Tue, 14 Feb 2017 17:20:39 +0900 Subject: [PATCH 09/12] wrap over width comment --- sanic/blueprints.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sanic/blueprints.py b/sanic/blueprints.py index a123a7a3..155d187b 100644 --- a/sanic/blueprints.py +++ b/sanic/blueprints.py @@ -87,7 +87,8 @@ class Blueprint: def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None): """ Creates a blueprint route from a function. - :param handler: Function for handling uri requests. Accepts function, or class instance with a view_class method. + :param handler: Function for handling uri requests. Accepts function, + or class instance with a view_class method. :param uri: Endpoint at which the route will be accessible. :param methods: List of acceptable HTTP methods. :return: function or class instance From 797891d6cf452f6b77306a8efa33f3514ca2dff8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kyle=20Bl=C3=B6m?= Date: Tue, 14 Feb 2017 09:27:39 -0800 Subject: [PATCH 10/12] Added raw response for bag o' bytes responses --- sanic/response.py | 21 +++++++++++++++++++-- 1 file changed, 19 insertions(+), 2 deletions(-) diff --git a/sanic/response.py b/sanic/response.py index 2f5c0135..47b0f407 100644 --- a/sanic/response.py +++ b/sanic/response.py @@ -154,15 +154,32 @@ def json(body, status=200, headers=None, **kwargs): status=status, content_type="application/json") -def text(body, status=200, headers=None): +def text(body, status=200, headers=None, + content_type="text/plain; charset=utf-8"): """ Returns response object with body in text format. :param body: Response data to be encoded. :param status: Response code. :param headers: Custom Headers. + :param content_type: + the content type (string) of the response """ return HTTPResponse(body, status=status, headers=headers, - content_type="text/plain; charset=utf-8") + content_type=content_type) + + +def raw(body, status=200, headers=None, + content_type="application/octet-stream"): + """ + Returns response object with body in text format. + :param body: Response data to be encoded. + :param status: Response code. + :param headers: Custom Headers. + :param content_type: + the content type (string) of the response + """ + return HTTPResponse(body_bytes=body, status=status, headers=headers, + content_type=content_type) def html(body, status=200, headers=None): From 747b7567d7ecd098ad7d1c5bda06638ac348f23e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kyle=20Bl=C3=B6m?= Date: Tue, 14 Feb 2017 09:40:33 -0800 Subject: [PATCH 11/12] Changed docstring for raw response --- sanic/response.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sanic/response.py b/sanic/response.py index 47b0f407..d80d4bb3 100644 --- a/sanic/response.py +++ b/sanic/response.py @@ -171,8 +171,8 @@ def text(body, status=200, headers=None, def raw(body, status=200, headers=None, content_type="application/octet-stream"): """ - Returns response object with body in text format. - :param body: Response data to be encoded. + Returns response object without encoding the body. + :param body: Response data. :param status: Response code. :param headers: Custom Headers. :param content_type: From 51611c3934bedc2838a4b0a5e775906474559550 Mon Sep 17 00:00:00 2001 From: Angus Hollands Date: Tue, 14 Feb 2017 19:10:19 +0000 Subject: [PATCH 12/12] Pep8 cleanups (#429) * PEP8 cleanups * PEP8 cleanups (server.py) * PEP8 cleanups (blueprints.py) * PEP8 cleanups (config.py) * PEP8 cleanups (cookies.py) * PEP8 cleanups (handlers.py) * PEP8 cleanups (request.py) * PEP8 cleanups (response.py) * PEP8 cleanups (router.py) * PEP8 cleanups (sanic.py) #2 * PEP8 cleanups (server.py) #2 * PEP8 cleanups (static.py) * PEP8 cleanups (utils.py) * PEP8 cleanups (views.py) Updated docstring --- sanic/blueprints.py | 46 ++++++++++++++------------------ sanic/config.py | 10 ++++--- sanic/cookies.py | 12 +++------ sanic/handlers.py | 8 +++--- sanic/request.py | 18 +++++-------- sanic/response.py | 10 +++---- sanic/router.py | 35 ++++++++++++------------- sanic/sanic.py | 64 ++++++++++++++++++--------------------------- sanic/server.py | 35 ++++++++++++------------- sanic/static.py | 2 +- sanic/utils.py | 4 +-- sanic/views.py | 9 +++---- 12 files changed, 108 insertions(+), 145 deletions(-) diff --git a/sanic/blueprints.py b/sanic/blueprints.py index 155d187b..10a1fcca 100644 --- a/sanic/blueprints.py +++ b/sanic/blueprints.py @@ -13,9 +13,9 @@ FutureStatic = namedtuple('Route', class Blueprint: def __init__(self, name, url_prefix=None, host=None): - """ - Creates a new blueprint - :param name: Unique name of the blueprint + """Create a new blueprint + + :param name: unique name of the blueprint :param url_prefix: URL to be prefixed before all route URLs """ self.name = name @@ -29,9 +29,7 @@ class Blueprint: self.statics = [] def register(self, app, options): - """ - Registers the blueprint to the sanic app. - """ + """Register the blueprint to the sanic app.""" url_prefix = options.get('url_prefix', self.url_prefix) @@ -73,10 +71,10 @@ class Blueprint: app.listener(event)(listener) def route(self, uri, methods=frozenset({'GET'}), host=None): - """ - Creates a blueprint route from a decorated function. - :param uri: Endpoint at which the route will be accessible. - :param methods: List of acceptable HTTP methods. + """Create a blueprint route from a decorated function. + + :param uri: endpoint at which the route will be accessible. + :param methods: list of acceptable HTTP methods. """ def decorator(handler): route = FutureRoute(handler, uri, methods, host) @@ -85,12 +83,12 @@ class Blueprint: return decorator def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None): - """ - Creates a blueprint route from a function. - :param handler: Function for handling uri requests. Accepts function, + """Create a blueprint route from a function. + + :param handler: function for handling uri requests. Accepts function, or class instance with a view_class method. - :param uri: Endpoint at which the route will be accessible. - :param methods: List of acceptable HTTP methods. + :param uri: endpoint at which the route will be accessible. + :param methods: list of acceptable HTTP methods. :return: function or class instance """ # Handle HTTPMethodView differently @@ -109,8 +107,8 @@ class Blueprint: return handler def listener(self, event): - """ - Create a listener from a decorated function. + """Create a listener from a decorated function. + :param event: Event to listen to. """ def decorator(listener): @@ -119,9 +117,7 @@ class Blueprint: return decorator def middleware(self, *args, **kwargs): - """ - Creates a blueprint middleware from a decorated function. - """ + """Create a blueprint middleware from a decorated function.""" def register_middleware(_middleware): future_middleware = FutureMiddleware(_middleware, args, kwargs) self.middlewares.append(future_middleware) @@ -136,9 +132,7 @@ class Blueprint: return register_middleware def exception(self, *args, **kwargs): - """ - Creates a blueprint exception from a decorated function. - """ + """Create a blueprint exception from a decorated function.""" def decorator(handler): exception = FutureException(handler, args, kwargs) self.exceptions.append(exception) @@ -146,9 +140,9 @@ class Blueprint: return decorator def static(self, uri, file_or_directory, *args, **kwargs): - """ - Creates a blueprint static route from a decorated function. - :param uri: Endpoint at which the route will be accessible. + """Create a blueprint static route from a decorated function. + + :param uri: endpoint at which the route will be accessible. :param file_or_directory: Static asset. """ static = FutureStatic(uri, file_or_directory, args, kwargs) diff --git a/sanic/config.py b/sanic/config.py index 59d68f52..3b9a102a 100644 --- a/sanic/config.py +++ b/sanic/config.py @@ -39,8 +39,9 @@ class Config(dict): self[attr] = value def from_envvar(self, variable_name): - """Loads a configuration from an environment variable pointing to + """Load a configuration from an environment variable pointing to a configuration file. + :param variable_name: name of the environment variable :return: bool. ``True`` if able to load config, ``False`` otherwise. """ @@ -52,8 +53,9 @@ class Config(dict): return self.from_pyfile(config_file) def from_pyfile(self, filename): - """Updates the values in the config from a Python file. Only the uppercase - variables in that module are stored in the config. + """Update the values in the config from a Python file. + Only the uppercase variables in that module are stored in the config. + :param filename: an absolute path to the config file """ module = types.ModuleType('config') @@ -69,7 +71,7 @@ class Config(dict): return True def from_object(self, obj): - """Updates the values from the given object. + """Update the values from the given object. Objects are usually either modules or classes. Just the uppercase variables in that object are stored in the config. diff --git a/sanic/cookies.py b/sanic/cookies.py index f3568a9b..238c2d86 100644 --- a/sanic/cookies.py +++ b/sanic/cookies.py @@ -39,8 +39,7 @@ _is_legal_key = re.compile('[%s]+' % re.escape(_LegalChars)).fullmatch class CookieJar(dict): - """ - CookieJar dynamically writes headers as cookies are added and removed + """CookieJar dynamically writes headers as cookies are added and removed It gets around the limitation of one header per name by using the MultiHeader class to provide a unique key that encodes to Set-Cookie. """ @@ -75,9 +74,7 @@ class CookieJar(dict): class Cookie(dict): - """ - This is a stripped down version of Morsel from SimpleCookie #gottagofast - """ + """A stripped down version of Morsel from SimpleCookie #gottagofast""" _keys = { "expires": "expires", "path": "Path", @@ -128,9 +125,8 @@ class Cookie(dict): class MultiHeader: - """ - Allows us to set a header within response that has a unique key, - but may contain duplicate header names + """String-holding object which allow us to set a header within response + that has a unique key, but may contain duplicate header names """ def __init__(self, name): self.name = name diff --git a/sanic/handlers.py b/sanic/handlers.py index 35807213..294695c5 100644 --- a/sanic/handlers.py +++ b/sanic/handlers.py @@ -35,8 +35,8 @@ class ErrorHandler: self.handlers[exception] = handler def response(self, request, exception): - """ - Fetches and executes an exception handler and returns a response object + """Fetches and executes an exception handler and returns a response + object :param request: Request :param exception: Exception to handle @@ -79,9 +79,7 @@ class ErrorHandler: class ContentRangeHandler: - """ - This class is for parsing the request header - """ + """Class responsible for parsing request header""" __slots__ = ('start', 'end', 'size', 'total', 'headers') def __init__(self, request, stats): diff --git a/sanic/request.py b/sanic/request.py index 8fd2c0e9..9ab50ce2 100644 --- a/sanic/request.py +++ b/sanic/request.py @@ -16,8 +16,7 @@ DEFAULT_HTTP_CONTENT_TYPE = "application/octet-stream" class RequestParameters(dict): - """ - Hosts a dict with lists as values where get returns the first + """Hosts a dict with lists as values where get returns the first value of the list and getlist returns the whole shebang """ @@ -31,9 +30,7 @@ class RequestParameters(dict): class Request(dict): - """ - Properties of an HTTP request such as URL, headers, etc. - """ + """Properties of an HTTP request such as URL, headers, etc.""" __slots__ = ( 'url', 'headers', 'version', 'method', '_cookies', 'transport', 'query_string', 'body', @@ -73,8 +70,8 @@ class Request(dict): @property def token(self): - """ - Attempts to return the auth header token. + """Attempt to return the auth header token. + :return: token related to request """ auth_header = self.headers.get('Authorization') @@ -146,11 +143,10 @@ File = namedtuple('File', ['type', 'body', 'name']) def parse_multipart_form(body, boundary): - """ - Parses a request body and returns fields and files + """Parse a request body and returns fields and files - :param body: Bytes request body - :param boundary: Bytes multipart boundary + :param body: bytes request body + :param boundary: bytes multipart boundary :return: fields (RequestParameters), files (RequestParameters) """ files = RequestParameters() diff --git a/sanic/response.py b/sanic/response.py index 2f5c0135..7ab6fc52 100644 --- a/sanic/response.py +++ b/sanic/response.py @@ -177,8 +177,8 @@ def html(body, status=200, headers=None): async def file(location, mime_type=None, headers=None, _range=None): - """ - Returns response object with file data. + """Return a response object with file data. + :param location: Location of file on system. :param mime_type: Specific mime_type. :param headers: Custom Headers. @@ -205,14 +205,12 @@ async def file(location, mime_type=None, headers=None, _range=None): def redirect(to, headers=None, status=302, content_type="text/html; charset=utf-8"): - """ - Aborts execution and causes a 302 redirect (by default). + """Abort execution and cause a 302 redirect (by default). :param to: path or fully qualified URL to redirect to :param headers: optional dict of headers to include in the new request :param status: status code (int) of the new request, defaults to 302 - :param content_type: - the content type (string) of the response + :param content_type: the content type (string) of the response :returns: the redirecting Response """ headers = headers or {} diff --git a/sanic/router.py b/sanic/router.py index 24d0438f..1163cce4 100644 --- a/sanic/router.py +++ b/sanic/router.py @@ -32,8 +32,7 @@ class RouteDoesNotExist(Exception): class Router: - """ - Router supports basic routing with parameters and method checks + """Router supports basic routing with parameters and method checks Usage: @@ -71,8 +70,9 @@ class Router: self.hosts = None def parse_parameter_string(self, parameter_string): - """ - Parse a parameter string into its constituent name, type, and pattern + """Parse a parameter string into its constituent name, type, and + pattern + For example: `parse_parameter_string(' ('param_one', str, '[A-z]') @@ -94,14 +94,13 @@ class Router: return name, _type, pattern def add(self, uri, methods, handler, host=None): - """ - Adds a handler to the route list + """Add a handler to the route list - :param uri: Path to match - :param methods: Array of accepted method names. - If none are provided, any method is allowed - :param handler: Request handler function. - When executed, it should provide a response object. + :param uri: path to match + :param methods: sequence of accepted method names. If none are + provided, any method is allowed + :param handler: request handler function. + When executed, it should provide a response object. :return: Nothing """ @@ -239,8 +238,7 @@ class Router: @lru_cache(maxsize=ROUTER_CACHE_SIZE) def find_route_by_view_name(self, view_name): - """ - Find a route in the router based on the specified view name. + """Find a route in the router based on the specified view name. :param view_name: string of view name to search by :return: tuple containing (uri, Route) @@ -255,8 +253,7 @@ class Router: return (None, None) def get(self, request): - """ - Gets a request handler based on the URL of the request, or raises an + """Get a request handler based on the URL of the request, or raises an error :param request: Request object @@ -270,11 +267,11 @@ class Router: @lru_cache(maxsize=ROUTER_CACHE_SIZE) def _get(self, url, method, host): - """ - Gets a request handler based on the URL of the request, or raises an + """Get a request handler based on the URL of the request, or raises an error. Internal method for caching. - :param url: Request URL - :param method: Request method + + :param url: request URL + :param method: request method :return: handler, arguments, keyword arguments """ url = host + url diff --git a/sanic/sanic.py b/sanic/sanic.py index e27f25d8..45bf0653 100644 --- a/sanic/sanic.py +++ b/sanic/sanic.py @@ -22,8 +22,7 @@ from .views import CompositionView class Sanic: - def __init__(self, name=None, router=None, - error_handler=None): + def __init__(self, name=None, router=None, error_handler=None): # Only set up a default log handler if the # end-user application didn't set anything up. if not logging.root.handlers and log.level == logging.NOTSET: @@ -33,9 +32,12 @@ class Sanic: handler.setFormatter(formatter) log.addHandler(handler) log.setLevel(logging.INFO) + + # Get name from previous stack frame if name is None: frame_records = stack()[1] name = getmodulename(frame_records[1]) + self.name = name self.router = router or Router() self.error_handler = error_handler or ErrorHandler() @@ -53,9 +55,7 @@ class Sanic: @property def loop(self): - """ - Synonymous with asyncio.get_event_loop() - """ + """Synonymous with asyncio.get_event_loop().""" return get_event_loop() # -------------------------------------------------------------------- # @@ -63,13 +63,12 @@ class Sanic: # -------------------------------------------------------------------- # def add_task(self, task): - """ - Schedule a task to run later, after the loop has started. + """Schedule a task to run later, after the loop has started. Different from asyncio.ensure_future in that it does not also return a future, and the actual ensure_future call is delayed until before server start. - :param task: A future, couroutine or awaitable. + :param task: future, couroutine or awaitable """ @self.listener('before_server_start') def run(app, loop): @@ -80,10 +79,9 @@ class Sanic: # Decorator def listener(self, event): - """ - Create a listener from a decorated function. + """Create a listener from a decorated function. - :param event: Event to listen to. + :param event: event to listen to """ def decorator(listener): self.listeners[event].append(listener) @@ -92,8 +90,7 @@ class Sanic: # Decorator def route(self, uri, methods=frozenset({'GET'}), host=None): - """ - Decorates a function to be registered as a route + """Decorate a function to be registered as a route :param uri: path of the URL :param methods: list or tuple of methods allowed @@ -136,8 +133,7 @@ class Sanic: return self.route(uri, methods=frozenset({"DELETE"}), host=host) def add_route(self, handler, uri, methods=frozenset({'GET'}), host=None): - """ - A helper method to register class instance or + """A helper method to register class instance or functions as a handler to the application url routes. @@ -168,8 +164,7 @@ class Sanic: # Decorator def exception(self, *exceptions): - """ - Decorates a function to be registered as a handler for exceptions + """Decorate a function to be registered as a handler for exceptions :param exceptions: exceptions :return: decorated function @@ -184,9 +179,8 @@ class Sanic: # Decorator def middleware(self, middleware_or_request): - """ - Decorates and registers middleware to be called before a request - can either be called as @app.middleware or @app.middleware('request') + """Decorate and register middleware to be called before a request. + Can either be called as @app.middleware or @app.middleware('request') """ def register_middleware(middleware, attach_to='request'): if attach_to == 'request': @@ -206,16 +200,14 @@ class Sanic: # Static Files def static(self, uri, file_or_directory, pattern='.+', use_modified_since=True, use_content_range=False): - """ - Registers a root to serve files from. The input can either be a file - or a directory. See + """Register a root to serve files from. The input can either be a + file or a directory. See """ static_register(self, uri, file_or_directory, pattern, use_modified_since, use_content_range) def blueprint(self, blueprint, **options): - """ - Registers a blueprint on the application. + """Register a blueprint on the application. :param blueprint: Blueprint object :param options: option dictionary with blueprint defaults @@ -242,7 +234,7 @@ class Sanic: return self.blueprint(*args, **kwargs) def url_for(self, view_name: str, **kwargs): - """Builds a URL based on a view name and the values provided. + """Build a URL based on a view name and the values provided. In order to build a URL, all request parameters must be supplied as keyword arguments, and each parameter must pass the test for the @@ -252,7 +244,7 @@ class Sanic: Keyword arguments that are not request parameters will be included in the output URL's query string. - :param view_name: A string referencing the view name + :param view_name: string referencing the view name :param **kwargs: keys and values that are used to build request parameters and query string arguments. @@ -342,9 +334,8 @@ class Sanic: pass async def handle_request(self, request, response_callback): - """ - Takes a request from the HTTP Server and returns a response object to - be sent back The HTTP Server only expects a response object, so + """Take a request from the HTTP Server and return a response object + to be sent back The HTTP Server only expects a response object, so exception handling must be done here :param request: HTTP Request object @@ -426,9 +417,8 @@ class Sanic: after_start=None, before_stop=None, after_stop=None, ssl=None, sock=None, workers=1, loop=None, protocol=HttpProtocol, backlog=100, stop_event=None, register_sys_signals=True): - """ - Runs the HTTP Server and listens until keyboard interrupt or term - signal. On termination, drains connections before closing. + """Run the HTTP Server and listen until keyboard interrupt or term + signal. On termination, drain connections before closing. :param host: Address to host on :param port: Port to host on @@ -478,9 +468,7 @@ class Sanic: before_stop=None, after_stop=None, ssl=None, sock=None, loop=None, protocol=HttpProtocol, backlog=100, stop_event=None): - """ - Asynchronous version of `run`. - """ + """Asynchronous version of `run`.""" server_settings = self._helper( host=host, port=port, debug=debug, before_start=before_start, after_start=after_start, before_stop=before_stop, @@ -501,9 +489,7 @@ class Sanic: after_stop=None, ssl=None, sock=None, workers=1, loop=None, protocol=HttpProtocol, backlog=100, stop_event=None, register_sys_signals=True, run_async=False): - """ - Helper function used by `run` and `create_server`. - """ + """Helper function used by `run` and `create_server`.""" if loop is not None: if debug: diff --git a/sanic/server.py b/sanic/server.py index c4d3ad97..0e49c25c 100644 --- a/sanic/server.py +++ b/sanic/server.py @@ -33,8 +33,7 @@ class Signal: class CIDict(dict): - """ - Case Insensitive dict where all keys are converted to lowercase + """Case Insensitive dict where all keys are converted to lowercase This does not maintain the inputted case when calling items() or keys() in favor of speed, since headers are case insensitive """ @@ -228,8 +227,8 @@ class HttpProtocol(asyncio.Protocol): self._total_request_size = 0 def close_if_idle(self): - """ - Close the connection if a request is not being sent or received + """Close the connection if a request is not being sent or received + :return: boolean - True if closed, false if staying open """ if not self.parser: @@ -239,9 +238,8 @@ class HttpProtocol(asyncio.Protocol): def update_current_time(loop): - """ - Caches the current time, since it is needed - at the end of every keep-alive request to update the request timeout time + """Cache the current time, since it is needed at the end of every + keep-alive request to update the request timeout time :param loop: :return: @@ -252,7 +250,8 @@ def update_current_time(loop): def trigger_events(events, loop): - """ + """Trigger event callbacks (functions or async) + :param events: one or more sync or async functions to execute :param loop: event loop """ @@ -267,31 +266,30 @@ def serve(host, port, request_handler, error_handler, before_start=None, request_timeout=60, ssl=None, sock=None, request_max_size=None, reuse_port=False, loop=None, protocol=HttpProtocol, backlog=100, register_sys_signals=True, run_async=False): - """ - Starts asynchronous HTTP Server on an individual process. + """Start asynchronous HTTP Server on an individual process. :param host: Address to host on :param port: Port to host on :param request_handler: Sanic request handler with middleware :param error_handler: Sanic error handler with middleware - :param before_start: Function to be executed before the server starts + :param before_start: function to be executed before the server starts listening. Takes arguments `app` instance and `loop` - :param after_start: Function to be executed after the server starts + :param after_start: function to be executed after the server starts listening. Takes arguments `app` instance and `loop` - :param before_stop: Function to be executed when a stop signal is + :param before_stop: function to be executed when a stop signal is received before it is respected. Takes arguments `app` instance and `loop` - :param after_stop: Function to be executed when a stop signal is + :param after_stop: function to be executed when a stop signal is received after it is respected. Takes arguments `app` instance and `loop` - :param debug: Enables debug output (slows server) + :param debug: enables debug output (slows server) :param request_timeout: time in seconds :param ssl: SSLContext :param sock: Socket for the server to accept connections from :param request_max_size: size in bytes, `None` for no limit :param reuse_port: `True` for multiple workers :param loop: asyncio compatible event loop - :param protocol: Subclass of asyncio protocol class + :param protocol: subclass of asyncio protocol class :return: Nothing """ if not run_async: @@ -377,9 +375,8 @@ def serve(host, port, request_handler, error_handler, before_start=None, def serve_multiple(server_settings, workers, stop_event=None): - """ - Starts multiple server processes simultaneously. Stops on interrupt - and terminate signals, and drains connections when complete. + """Start multiple server processes simultaneously. Stop on interrupt + and terminate signals, and drain connections when complete. :param server_settings: kw arguments to be passed to the serve function :param workers: number of workers to launch diff --git a/sanic/static.py b/sanic/static.py index 564101e6..aa48cecc 100644 --- a/sanic/static.py +++ b/sanic/static.py @@ -18,7 +18,7 @@ def register(app, uri, file_or_directory, pattern, # make a good effort here. Modified-since is nice, but we could # also look into etags, expires, and caching """ - Registers a static directory handler with Sanic by adding a route to the + Register a static directory handler with Sanic by adding a route to the router and registering a handler. :param app: Sanic diff --git a/sanic/utils.py b/sanic/utils.py index 298f952c..890a2af5 100644 --- a/sanic/utils.py +++ b/sanic/utils.py @@ -21,8 +21,8 @@ async def local_request(method, uri, cookies=None, *args, **kwargs): def sanic_endpoint_test(app, method='get', uri='/', gather_request=True, - debug=False, server_kwargs={}, - *request_args, **request_kwargs): + debug=False, server_kwargs={}, *request_args, + **request_kwargs): results = [None, None] exceptions = [] diff --git a/sanic/views.py b/sanic/views.py index d6da9145..b434d44a 100644 --- a/sanic/views.py +++ b/sanic/views.py @@ -3,7 +3,7 @@ from .constants import HTTP_METHODS class HTTPMethodView: - """ Simple class based implementation of view for the sanic. + """Simple class based implementation of view for the sanic. You should implement methods (get, post, put, patch, delete) for the class to every HTTP method you want to support. @@ -45,9 +45,8 @@ class HTTPMethodView: @classmethod def as_view(cls, *class_args, **class_kwargs): - """ Converts the class into an actual view function that can be used - with the routing system. - + """Return view function for use with the routing system, that + dispatches request to appropriate handler method. """ def view(*args, **kwargs): self = view.view_class(*class_args, **class_kwargs) @@ -66,7 +65,7 @@ class HTTPMethodView: class CompositionView: - """ Simple method-function mapped view for the sanic. + """Simple method-function mapped view for the sanic. You can add handler functions to methods (get, post, put, patch, delete) for every HTTP method you want to support.