chisel 2.3.2__tar.gz → 2.4.1__tar.gz

{chisel-2.3.2/src/chisel.egg-info → chisel-2.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chisel
-Version: 2.3.2
+Version: 2.4.1
 Summary: Lightweight WSGI application framework, schema-validated JSON APIs, and API documentation
 Author-email: "Craig A. Hobbs" <craigahobbs@gmail.com>
 License-Expression: MIT
@@ -30,7 +30,7 @@ Dynamic: license-file
 [![GitHub](https://img.shields.io/github/license/craigahobbs/chisel)](https://github.com/craigahobbs/chisel/blob/main/LICENSE)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chisel)](https://pypi.org/project/chisel/)
 
-Chisel is a light-weight Python WSGI application framework built for creating well-documented,
+Chisel is a lightweight Python WSGI application framework built for creating well-documented,
 schema-validated JSON web APIs.
 
 
@@ -46,11 +46,13 @@ Chisel provides the [action](https://craigahobbs.github.io/chisel/action.html#ch
 decorator for easily implementing schema-validated JSON APIs.
 
 ~~~ python
+import chisel
+
 @chisel.action(spec='''
 # Sum a list of numbers
 action sum_numbers
     urls
-       GET
+        GET
 
     query
         # The list of numbers
@@ -87,6 +89,14 @@ status, _, content_bytes = application.request('GET', '/sum_numbers')
 b'{"error":"InvalidInput","message":"Required member \\"numbers\\" missing (query string)"}'
 ~~~
 
+A [chisel.Application](https://craigahobbs.github.io/chisel/app.html#chisel.Application) is a
+standard [WSGI](https://peps.python.org/pep-3333/) application object - host it with any WSGI
+server. For example:
+
+~~~ sh
+gunicorn module:application
+~~~
+
 
 ## API Documentation
 
@@ -99,8 +109,9 @@ application = chisel.Application()
 application.add_requests(chisel.create_doc_requests())
 ~~~
 
-By default the documentation application is hosted at "/doc/". An example of of Chisel's documentation output is
-available [here](https://craigahobbs.github.io/chisel/example/#var.vName='chisel_doc_request').
+By default the documentation application is hosted at "/doc/". An example of Chisel's
+[documentation output](https://craigahobbs.github.io/chisel/example/#var.vName='chisel_doc_request')
+is available.
 
 
 ## Development

{chisel-2.3.2 → chisel-2.4.1}/README.md

@@ -5,7 +5,7 @@
 [![GitHub](https://img.shields.io/github/license/craigahobbs/chisel)](https://github.com/craigahobbs/chisel/blob/main/LICENSE)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chisel)](https://pypi.org/project/chisel/)
 
-Chisel is a light-weight Python WSGI application framework built for creating well-documented,
+Chisel is a lightweight Python WSGI application framework built for creating well-documented,
 schema-validated JSON web APIs.
 
 
@@ -21,11 +21,13 @@ Chisel provides the [action](https://craigahobbs.github.io/chisel/action.html#ch
 decorator for easily implementing schema-validated JSON APIs.
 
 ~~~ python
+import chisel
+
 @chisel.action(spec='''
 # Sum a list of numbers
 action sum_numbers
     urls
-       GET
+        GET
 
     query
         # The list of numbers
@@ -62,6 +64,14 @@ status, _, content_bytes = application.request('GET', '/sum_numbers')
 b'{"error":"InvalidInput","message":"Required member \\"numbers\\" missing (query string)"}'
 ~~~
 
+A [chisel.Application](https://craigahobbs.github.io/chisel/app.html#chisel.Application) is a
+standard [WSGI](https://peps.python.org/pep-3333/) application object - host it with any WSGI
+server. For example:
+
+~~~ sh
+gunicorn module:application
+~~~
+
 
 ## API Documentation
 
@@ -74,8 +84,9 @@ application = chisel.Application()
 application.add_requests(chisel.create_doc_requests())
 ~~~
 
-By default the documentation application is hosted at "/doc/". An example of of Chisel's documentation output is
-available [here](https://craigahobbs.github.io/chisel/example/#var.vName='chisel_doc_request').
+By default the documentation application is hosted at "/doc/". An example of Chisel's
+[documentation output](https://craigahobbs.github.io/chisel/example/#var.vName='chisel_doc_request')
+is available.
 
 
 ## Development

{chisel-2.3.2 → chisel-2.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "chisel"
-version = "2.3.2"
+version = "2.4.1"
 description = "Lightweight WSGI application framework, schema-validated JSON APIs, and API documentation"
 readme = "README.md"
 license = "MIT"

{chisel-2.3.2 → chisel-2.4.1}/src/chisel/__init__.py

@@ -2,7 +2,7 @@
 # https://github.com/craigahobbs/chisel/blob/main/LICENSE
 
 """
-Chisel is a light-weight Python WSGI application framework with tools for building well-documented,
+Chisel is a lightweight Python WSGI application framework with tools for building well-documented,
 well-tested, schema-validated JSON web APIs.
 """
 

{chisel-2.3.2 → chisel-2.4.1}/src/chisel/action.py

@@ -17,7 +17,7 @@ from .request import Request
 
 
 # Regex for parsing the Content-Type header
-RE_CONTENT_TYPE_HEADER = re.compile(r'\bcharset\s*=\s*(?P<charset>\S+)')
+RE_CONTENT_TYPE_HEADER = re.compile(r'(?:^|[;\s])charset\s*=\s*"?(?P<charset>[^";\s]+)', re.IGNORECASE)
 
 
 def action(action_callback=None, **kwargs):
@@ -58,7 +58,8 @@ def action(action_callback=None, **kwargs):
      'message': 'Invalid value "1" (type "str") for member "numbers", expected '
                 'type "array" (query string)'}
 
-    When :attr:`~chisel.Application.validate_output` the response dictionary is also validated to the output schema.
+    When :attr:`~chisel.Application.validate_output` is True, the response dictionary is also validated against the
+    output schema.
 
     :param ~collections.abc.Callable action_callback: The action callback function
     """
@@ -128,25 +129,34 @@ class Action(Request):
     >>> def my_action(ctx, req):
     ...    return {}
 
-    The first arugument, "ctx", is the :class:`~chisel.Context` object. The second argument is the request object which
-    contiains the schema-validated, combined path parameters, query string parameters, and JSON request content
+    The first argument, "ctx", is the :class:`~chisel.Context` object. The second argument is the request object which
+    contains the schema-validated, combined path parameters, query string parameters, and JSON request content
     parameters.
 
     :param ~collections.abc.Callable action_callback: The action callback function
     :param str name: The action request name
     :param list(tuple) urls: The list of URL method/path tuples. The first value is the HTTP request method (e.g. 'GET')
-        or None to match any. The second value is the URL path or None to use the default path.
+        or None to match any. The second value is the URL path or None to use the default path. If the action's
+        specification contains a "urls" section, the specification's URLs take precedence.
     :param dict types: Optional dictionary of user type models
     :param str spec: Optional action `Schema Markdown <https://craigahobbs.github.io/schema-markdown-js/language/>`__ specification.
         If a specification isn't provided it can be provided through the "types" argument.
     :param bool wsgi_response: If True, the callback function's response is a WSGI application function
         response. Default is False.
-    :param str jsonp: Optional JSONP key
     """
 
-    __slots__ = ('action_callback', 'types', 'wsgi_response', 'jsonp')
+    __slots__ = (
+        'action_callback',
+        'types',
+        'wsgi_response',
+        '_input_type',
+        '_query_type',
+        '_path_type',
+        '_output_type',
+        '_error_type'
+    )
 
-    def __init__(self, action_callback, name=None, urls=(('POST', None),), types=None, spec=None, wsgi_response=False, jsonp=None):
+    def __init__(self, action_callback, name=None, urls=(('POST', None),), types=None, spec=None, wsgi_response=False):
 
         # Use the action callback name if no name is provided
         if name is None:
@@ -179,8 +189,12 @@ class Action(Request):
         #: If True, the callback function's response is a WSGI application function response.
         self.wsgi_response = wsgi_response
 
-        #: JSONP key or None
-        self.jsonp = jsonp
+        # Pre-compute the section types and the error response type
+        self._input_type = self._get_section_type('input')
+        self._query_type = self._get_section_type('query')
+        self._path_type = self._get_section_type('path')
+        self._output_type = self._get_section_type('output')
+        self._error_type = self._get_error_type()
 
     @property
     def model(self):
@@ -231,13 +245,13 @@ class Action(Request):
 
         # Handle the action
         is_get = (environ['REQUEST_METHOD'] == 'GET')
-        jsonp = None
+        app_validate_output = ctx.app.validate_output
         validate_output = True
         try:
             # Read the request content
             try:
                 content = None if is_get else environ['wsgi.input'].read()
-            except:
+            except Exception:
                 raise _ActionErrorInternal(HTTPStatus.REQUEST_TIMEOUT, 'IOError', message='Error reading request content')
 
             # De-serialize the JSON content
@@ -255,7 +269,7 @@ class Action(Request):
                 raise _ActionErrorInternal(HTTPStatus.BAD_REQUEST, 'InvalidInput', message=f'Invalid request JSON: {exc}')
 
             # Validate the content
-            input_types, input_type = self._get_section_type('input')
+            input_types, input_type = self._input_type
             try:
                 request = validate_type(input_types, input_type, request)
             except ValidationError as exc:
@@ -275,13 +289,8 @@ class Action(Request):
                 ctx.log.warning('Error decoding query string for action "%s": %.1000r', self.name, query_string)
                 raise _ActionErrorInternal(HTTPStatus.BAD_REQUEST, 'InvalidInput', message=f'{exc}')
 
-            # JSONP?
-            if is_get and self.jsonp and self.jsonp in request_query:
-                jsonp = f'{request_query[self.jsonp]}'
-                del request_query[self.jsonp]
-
             # Validate the query string
-            query_types, query_type = self._get_section_type('query')
+            query_types, query_type = self._query_type
             try:
                 request_query = validate_type(query_types, query_type, request_query)
             except ValidationError as exc:
@@ -294,7 +303,7 @@ class Action(Request):
                 )
 
             # Validate the path args
-            path_types, path_type = self._get_section_type('path')
+            path_types, path_type = self._path_type
             request_path = ctx.url_args if ctx.url_args is not None else {}
             try:
                 request_path = validate_type(path_types, path_type, request_path)
@@ -321,23 +330,23 @@ class Action(Request):
                     return response
                 if response is None:
                     response = {}
-                output_types, output_type = self._get_section_type('output')
+                output_types, output_type = self._output_type
             except ActionError as exc:
                 status = exc.status or HTTPStatus.BAD_REQUEST
                 response = {'error': exc.error}
                 if exc.message is not None:
                     response['message'] = exc.message
-                if ctx.app.validate_output:
-                    if exc.error in ('UnexpectedError',):
+                if app_validate_output:
+                    if exc.error == 'UnexpectedError':
                         validate_output = False
                     else:
-                        output_types, output_type = self._get_error_type()
-            except Exception as exc:
+                        output_types, output_type = self._error_type
+            except Exception:
                 ctx.log.exception('Unexpected error in action "%s"', self.name)
                 raise _ActionErrorInternal(HTTPStatus.INTERNAL_SERVER_ERROR, 'UnexpectedError')
 
             # Validate the response
-            if not self.wsgi_response and validate_output and ctx.app.validate_output:
+            if not self.wsgi_response and validate_output and app_validate_output:
                 try:
                     validate_type(output_types, output_type, response)
                 except ValidationError as exc:
@@ -353,4 +362,4 @@ class Action(Request):
                 response['member'] = exc.member
 
         # Serialize the response as JSON
-        return ctx.response_json(status, response, jsonp=jsonp)
+        return ctx.response_json(status, response)

{chisel-2.3.2 → chisel-2.4.1}/src/chisel/app.py

@@ -6,6 +6,7 @@ Chisel WSGI application base class and utilities
 """
 
 from datetime import datetime, timedelta, timezone
+from email.utils import format_datetime
 from http import HTTPStatus
 from io import BytesIO
 import logging
@@ -15,9 +16,8 @@ from urllib.parse import quote, unquote
 from schema_markdown import encode_query_string, JSONEncoder
 
 
-# Regular expression for matching URL arguments
-RE_URL_ARG = re.compile(r'/\{([A-Za-z]\w*)\}')
-RE_URL_ARG_ESC = re.compile(r'/\\{([A-Za-z]\w*)\\}')
+# Regular expression for matching a URL argument path segment (e.g. "{id}")
+RE_URL_ARG = re.compile(r'\{([A-Za-z][A-Za-z0-9_]*)\}')
 
 
 class Application:
@@ -35,7 +35,9 @@ class Application:
         'validate_output',
         'requests',
         '__request_urls',
-        '__request_regex'
+        '__request_paths',
+        '__request_regex',
+        '__request_regex_urls'
     )
 
     def __init__(self):
@@ -46,8 +48,8 @@ class Application:
         #: The application's log format string. The default is ``'%(levelname)s [%(process)s / %(thread)s] %(message)s'``.
         self.log_format = '%(levelname)s [%(process)s / %(thread)s] %(message)s'
 
-        #: Set to True for "pretty" request output. Individual requests can : use this application state they see
-        #: fit. For example, :class:`~chisel.Action` : requests return indented JSON when this value is True. Default is
+        #: Set to True for "pretty" request output. Individual requests can use this application state as they see
+        #: fit. For example, :class:`~chisel.Action` requests return indented JSON when this value is True. Default is
         #: False.
         self.pretty_output = False
 
@@ -60,32 +62,67 @@ class Application:
         self.requests = {}
 
         self.__request_urls = {}
+        self.__request_paths = set()
         self.__request_regex = []
+        self.__request_regex_urls = set()
 
     def add_request(self, request):
         """
-        Add a :class:`~chisel.Request` to the application.
+        Add a :class:`~chisel.Request` to the application. URL arguments (e.g. ``'/documents/{id}'``) must span an
+        entire path segment.
 
         :param ~chisel.Request request: The request object.
+        :raises ValueError: If the request name or a request URL is redefined, or if a request URL contains an
+            invalid URL argument
         """
 
         # Duplicate request name?
         if request.name in self.requests:
             raise ValueError(f'redefinition of request "{request.name}"')
-        self.requests[request.name] = request
 
-        # Add the request URLs
+        # Validate the request URLs - the request is added only if the entire request is valid
+        request_urls = {}
+        request_regex = []
         for method, url in request.urls:
 
             # URL with arguments?
-            if RE_URL_ARG.search(url):
-                request_regex = '^' + RE_URL_ARG_ESC.sub(r'/(?P<\1>[^/]+)', re.escape(url)) + '$'
-                self.__request_regex.append((method, re.compile(request_regex), request))
+            if '{' in url or '}' in url:
+
+                # Compute the URL regular expression - it is matched with fullmatch
+                url_args = []
+                regex_segments = []
+                for segment in url.split('/'):
+                    match_url_arg = RE_URL_ARG.fullmatch(segment)
+                    if match_url_arg is not None:
+                        url_arg = match_url_arg.group(1)
+                        if url_arg in url_args:
+                            raise ValueError(f'duplicate URL argument "{segment}" in URL "{url}" of request "{request.name}"')
+                        url_args.append(url_arg)
+                        regex_segments.append(f'(?P<{url_arg}>[^/]+)')
+                    elif '{' in segment or '}' in segment:
+                        raise ValueError(f'invalid URL argument "{segment}" in URL "{url}" of request "{request.name}"')
+                    else:
+                        regex_segments.append(re.escape(segment))
+
+                # Duplicate request URL? URL argument URLs match regardless of argument names.
+                url_key = (method, RE_URL_ARG.sub('{}', url))
+                if url_key in self.__request_regex_urls or any(key == url_key for key, _ in request_regex):
+                    raise ValueError(f'redefinition of request URL "{url}"')
+                request_regex.append((url_key, re.compile('/'.join(regex_segments))))
             else:
-                request_key = (method, url)
-                if request_key in self.__request_urls:
+                # Duplicate request URL?
+                url_key = (method, url)
+                if url_key in self.__request_urls or url_key in request_urls:
                     raise ValueError(f'redefinition of request URL "{url}"')
-                self.__request_urls[request_key] = request
+                request_urls[url_key] = request
+
+        # Add the request and its URLs
+        self.requests[request.name] = request
+        self.__request_urls.update(request_urls)
+        self.__request_paths.update(path for _, path in request_urls)
+        for url_key, url_regex in request_regex:
+            self.__request_regex_urls.add(url_key)
+            self.__request_regex.append((url_key[0], url_regex, request))
 
     def add_requests(self, requests):
         """
@@ -110,50 +147,37 @@ class Application:
         :rtype: tuple(chisel.Request or None, dict or None)
         """
 
-        # Exact match?
+        # Match the request by exact URL and method
         request = self.__request_urls.get((request_method, path_info))
         if request is not None:
             return request, None
 
-        # Match the request by method and URL regex
-        request, url_args = next(
-            (
-                (request, {unquote(url_arg): unquote(url_value) for url_arg, url_value in request_match.groupdict().items()})
-                for request, request_match in
-                (
-                    (request, regex.match(path_info)) for method, regex, request in self.__request_regex
-                    if method is not None and method == request_method
-                )
-                if request_match
-            ),
-            (None, None)
-        )
-        if request is not None:
-            return request, url_args
+        # Match the request by URL regular expression and method
+        for method, regex, request in self.__request_regex:
+            if method is not None and method == request_method:
+                match_path = regex.fullmatch(path_info)
+                if match_path is not None:
+                    return request, {unquote(url_arg): unquote(url_value) for url_arg, url_value in match_path.groupdict().items()}
 
         # Match the request by exact URL (any method)
-        request, url_args = self.__request_urls.get((None, path_info)), None
-        if request is None:
+        request = self.__request_urls.get((None, path_info))
+        if request is not None:
+            return request, None
 
-            # Match the request by URL regex (any method)
-            request, url_args = next(
-                (
-                    (request, {unquote(url_arg): unquote(url_value) for url_arg, url_value in request_match.groupdict().items()})
-                    for request, request_match in
-                    (
-                        (request, regex.match(path_info)) for method, regex, request in self.__request_regex
-                        if method is None
-                    )
-                    if request_match
-                ),
-                (None, None)
-            )
-        return request, url_args
+        # Match the request by URL regular expression (any method)
+        for method, regex, request in self.__request_regex:
+            if method is None:
+                match_path = regex.fullmatch(path_info)
+                if match_path is not None:
+                    return request, {unquote(url_arg): unquote(url_value) for url_arg, url_value in match_path.groupdict().items()}
+
+        # No matching request
+        return None, None
 
     def __call__(self, environ, start_response):
         """
-        The chisel application WSGI callback. When the application recieves an HTTP request, this method matches the
-        appropriate :class:`~chisel.Request' object and then calls its :func:`~chisel.Request.__call__` method. The
+        The chisel application WSGI callback. When the application receives an HTTP request, this method matches the
+        appropriate :class:`~chisel.Request` object and then calls its :func:`~chisel.Request.__call__` method. The
         application and URL path arguments (e.g. ``'/documents/{id}'``) are made available to the request through the
         request's :class:`~chisel.Context` object.
 
@@ -175,10 +199,12 @@ class Application:
         # Create the request context
         ctx = environ[Context.ENVIRON_CTX] = Context(self, environ, start_response, url_args)
 
-        # Request not found?
+        # Request not found? The request path exists if it matches an exact URL under any method or a URL regular
+        # expression under another method - match_request already tried this method's and any-method's regexes.
         if request is None:
-            if any(path == path_info for _, path in self.__request_urls) or \
-               any(regex.match(path_info) for _, regex, _ in self.__request_regex):
+            if path_info in self.__request_paths or \
+               any(regex.fullmatch(path_info)
+                   for method, regex, _ in self.__request_regex if method is not None and method != request_method):
                 response = ctx.response_text(HTTPStatus.METHOD_NOT_ALLOWED)
             else:
                 response = ctx.response_text(HTTPStatus.NOT_FOUND)
@@ -186,11 +212,22 @@ class Application:
             # Handle the request
             try:
                 response = request(ctx.environ, ctx.start_response)
-            except:
-                ctx.log.exception('exception raised by request "%s"', request.name)
+            except Exception:
+                # A logging failure (e.g. invalid log_format) must not suppress the error response
+                try:
+                    ctx.log.exception('exception raised by request "%s"', request.name)
+                except Exception:
+                    pass
                 response = ctx.response_text(HTTPStatus.INTERNAL_SERVER_ERROR)
 
         if is_head:
+            # PEP 3333 - the discarded response content must be closed. A close failure must not
+            # suppress the HEAD response.
+            if hasattr(response, 'close'):
+                try:
+                    response.close()
+                except Exception:
+                    pass
             return []
         return response
 
@@ -223,7 +260,7 @@ class Context:
     :param dict url_args: The parsed URL arguments dictionary
     """
 
-    __slots__ = ('app', 'environ', '_start_response', 'url_args', 'log', 'headers')
+    __slots__ = ('app', 'environ', '_start_response', 'url_args', '_log', 'headers')
 
     #: The context WSGI environ key
     ENVIRON_CTX = 'chisel.ctx'
@@ -244,19 +281,39 @@ class Context:
         #: The request's header map. These headers are added to the response.
         self.headers = {}
 
-        #: The python logger instance. Write log messages using this object directly.
-        self.log = logging.getLoggerClass()('')
-        self.log.setLevel(app.log_level)
-        wsgi_errors = environ.get('wsgi.errors') if environ else None
-        if wsgi_errors is None:
-            handler = logging.NullHandler()
-        else:
-            handler = logging.StreamHandler(wsgi_errors)
-        if callable(app.log_format):
-            handler.setFormatter(app.log_format(self))
-        else:
-            handler.setFormatter(logging.Formatter(app.log_format))
-        self.log.addHandler(handler)
+        self._log = None
+
+    @property
+    def log(self):
+        """
+        The python logger instance. Write log messages using this object directly. The logger is created lazily on
+        first access using the application's :attr:`~chisel.Application.log_level` and
+        :attr:`~chisel.Application.log_format`.
+        """
+
+        if self._log is None:
+            # Assign the logger before formatting so a callable log_format may access it
+            log = self._log = logging.getLoggerClass()('')
+            log.setLevel(self.app.log_level)
+            wsgi_errors = self.environ.get('wsgi.errors')
+            if wsgi_errors is None:
+                handler = logging.NullHandler()
+            else:
+                handler = logging.StreamHandler(wsgi_errors)
+            if callable(self.app.log_format):
+                handler.setFormatter(self.app.log_format(self))
+            else:
+                handler.setFormatter(logging.Formatter(self.app.log_format))
+            log.addHandler(handler)
+        return self._log
+
+    @log.setter
+    def log(self, log):
+        self._log = log
+
+    @log.deleter
+    def log(self):
+        self._log = None
 
     @staticmethod
     def create_environ(request_method, path_info, query_string='', wsgi_input=b'', environ=None):
@@ -268,7 +325,7 @@ class Context:
         :param str query_string: Optional query string
         :param bytes wsgi_input: Optional request content
         :param dict environ: Optional environ dict. If not provided, a minimal default environ is created.
-        :returns: The created :class:`~chisel.Context` object
+        :returns: The created environ dict
         """
 
         if environ is None:
@@ -302,7 +359,8 @@ class Context:
 
     def add_header(self, key, value):
         """
-        Add a header key/value to the request's response
+        Add a header key/value to the request's response. Adding a header key again replaces its value - repeated
+        response headers (e.g. multiple "Set-Cookie" headers) are not supported.
 
         >>> @chisel.action(spec='''
         ... action my_action
@@ -354,7 +412,8 @@ class Context:
 
         :param str control: ``'public'``, ``'private'``, or None (for no-cache)
         :param int ttl_seconds: Cache duration in seconds. Do not specify for no-cache.
-        :param ~datetime.datetime utcnow: A :func:`~datetime.datetime` to use as the current datetime
+        :param ~datetime.datetime utcnow: A :func:`~datetime.datetime` to use as the current datetime. A naive
+            datetime is assumed to be UTC.
         """
 
         if self.environ.get('REQUEST_METHOD') == 'GET':
@@ -362,13 +421,15 @@ class Context:
                 self.add_header('Cache-Control', 'no-cache')
             else:
                 assert control in ('public', 'private')
-                assert isinstance(ttl_seconds, int) and ttl_seconds > 0
+                assert isinstance(ttl_seconds, int) and not isinstance(ttl_seconds, bool) and ttl_seconds > 0
                 self.add_header('Cache-Control', f'{control},max-age={ttl_seconds}')
                 if utcnow is None:
-                    utcnow = datetime.utcnow()
+                    utcnow = datetime.now(timezone.utc)
+                elif utcnow.tzinfo is None:
+                    utcnow = utcnow.replace(tzinfo=timezone.utc)
                 else:
                     utcnow = utcnow.astimezone(timezone.utc)
-                self.add_header('Expires', (utcnow + timedelta(seconds=ttl_seconds)).strftime('%a, %d %b %Y %H:%M:%S GMT'))
+                self.add_header('Expires', format_datetime(utcnow + timedelta(seconds=ttl_seconds), usegmt=True))
 
     def response(self, status, content_type, content, headers=None):
         """
@@ -404,7 +465,7 @@ class Context:
         self.start_response(status, response_headers)
         return content
 
-    def response_text(self, status, text=None, content_type='text/plain', encoding='utf-8', headers=None):
+    def response_text(self, status, text=None, content_type=None, encoding='utf-8', headers=None):
         """
         A plain-text WSGI response
 
@@ -421,16 +482,19 @@ class Context:
         >>> application = chisel.Application()
         >>> application.add_request(my_action)
         >>> application.request('GET', '/my_action')
-        ('200 OK', [('Content-Type', 'text/plain')], b'Hello')
+        ('200 OK', [('Content-Type', 'text/plain; charset=utf-8')], b'Hello')
 
         :param status: The HTTP response status
         :type status: ~http.HTTPStatus or str
         :param str text: The response text
-        :param str content_type: The response content type. The default is "text/plain".
+        :param str content_type: The response content type. The default is "text/plain" with the
+            "encoding" parameter's charset.
         :param str encoding: The content encoding. The default is "utf-8".
         :param list(tuple) headers: Optional list of key/value header tuples to add to the response
         """
 
+        if content_type is None:
+            content_type = f'text/plain; charset={encoding}'
         if text is None:
             if isinstance(status, str):
                 text = status
@@ -438,7 +502,7 @@ class Context:
                 text = status.phrase
         return self.response(status, content_type, [text.encode(encoding)], headers=headers)
 
-    def response_json(self, status, response, content_type='application/json', encoding='utf-8', headers=None, jsonp=None):
+    def response_json(self, status, response, content_type='application/json', encoding='utf-8', headers=None):
         """
         A JSON response
 
@@ -463,7 +527,6 @@ class Context:
         :param str content_type: The response content type. The default is "application/json".
         :param str encoding: The content encoding. The default is "utf-8".
         :param list(tuple) headers: Optional list of key/value header tuples to add to the response
-        :param str jsonp: Optional JSONP key
         """
 
         encoder = JSONEncoder(
@@ -474,11 +537,7 @@ class Context:
             separators=(',', ': ') if self.app.pretty_output else (',', ':')
         )
         content = encoder.encode(response)
-        if jsonp:
-            content_list = [jsonp.encode(encoding), b'(', content.encode(encoding), b');']
-        else:
-            content_list = [content.encode(encoding)]
-        return self.response(status, content_type, content_list, headers=headers)
+        return self.response(status, content_type, [content.encode(encoding)], headers=headers)
 
     def reconstruct_url(self, path_info=None, query_string=None, relative=False):
         """
@@ -538,12 +597,9 @@ class StartResponse:
     ...     return [b'Hello']
     >>> start_response = chisel.app.StartResponse()
     >>> application({}, start_response)
+    [b'Hello']
     >>> start_response.status, start_response.headers
     ('200 OK', [('Content-Type', 'text/plain')])
-
-    :param status: The HTTP response status
-    :type status: ~http.HTTPStatus or str
-    :param list(tuple) headers: Optional list of key/value header tuples to add to the response
     """
 
     __slots__ = ('status', 'headers')

{chisel-2.3.2 → chisel-2.4.1}/src/chisel/doc.py

@@ -19,7 +19,7 @@ from .request import RedirectRequest, StaticRequest
 def create_doc_requests(requests=None, root_path='/doc', api=True, app=True, markdown_up=False):
     """
     Yield a series of requests for use with :meth:`~chisel.Application.add_requests` comprising the Chisel
-    documentation application. By default, the documenation application is hosted at "/doc/".
+    documentation application. By default, the documentation application is hosted at "/doc/".
 
     :param requests: A list of requests or None to use the application's requests
     :type requests: list(~chisel.Request)
@@ -112,18 +112,16 @@ action chisel_doc_index
         groups = {}
         for request in requests.values():
             request_group = request.doc_group or 'Uncategorized'
-            if request_group not in groups:
-                groups[request_group] = []
-            groups[request_group].append(request.name)
+            groups.setdefault(request_group, []).append(request.name)
         return {
-            'title': ctx.environ['HTTP_HOST'],
+            'title': ctx.environ.get('HTTP_HOST') or ctx.environ['SERVER_NAME'],
             'groups': {group: sorted(names) for group, names in groups.items()}
         }
 
 
 class DocRequest(Action):
     """
-    The documentation request API. This API provides all the information the documentation applicaton needs to render
+    The documentation request API. This API provides all the information the documentation application needs to render
     the request documentation page. The documentation request API's documentation is `here
     <doc/#name=chisel_doc_request>`__.
 

{chisel-2.3.2 → chisel-2.4.1}/src/chisel/request.py

@@ -8,7 +8,6 @@ Chisel request base class and common request classes
 from functools import partial
 import hashlib
 from http import HTTPStatus
-from itertools import chain
 import posixpath
 import re
 
@@ -37,8 +36,8 @@ def request(wsgi_callback=None, **kwargs):
     ...
     ('my_request', (('GET', '/my_request'),), 'This is my request', None)
 
-    The created :class:`~chisel.Request` object is passed to an application's :meth:`~chisel.add_request` method to host
-    it with that applicaton.
+    The created :class:`~chisel.Request` object is passed to an application's :meth:`~chisel.Application.add_request`
+    method to host it with that application.
 
     >>> application = chisel.Application()
     >>> application.add_request(my_request)
@@ -89,11 +88,10 @@ class Request:
             #: The list of URL method/path tuples
             self.urls = ((None, '/' + self.name),)
         else:
-            self.urls = tuple(chain.from_iterable(
-                ((None, '/' + self.name),) if url is None else \
-                ((url[0] and url[0].upper(), url[1] or '/' + self.name),)
+            self.urls = tuple(
+                (None, '/' + self.name) if url is None else (url[0] and url[0].upper(), url[1] or '/' + self.name)
                 for url in urls
-            ))
+            )
 
     def __call__(self, environ, start_response):
         """
@@ -110,11 +108,11 @@ class Request:
 
 class RedirectRequest(Request):
     """
-    A redirect reqeust
+    A redirect request
 
     :param list(tuple) urls: The list of URL method/path tuples. The first value is the HTTP request method (e.g. 'GET')
         or None to match any. The second value is the URL path or None to use the default path.
-    :param str redirect_url: The redirectd URL
+    :param str redirect_url: The redirected URL
     :param bool permanent: If True, this is a permanent redirect
     :param str name: The request name. By default the name is "redirect_<redirect_url>".
     :param doc: The documentation markdown text lines
@@ -126,7 +124,7 @@ class RedirectRequest(Request):
 
     def __init__(self, urls, redirect_url, permanent=True, name=None, doc=None, doc_group='Redirects'):
         if name is None:
-            name = re.sub(r'([^\w]|_)+', '_', f'redirect_{redirect_url}').rstrip('_')
+            name = re.sub(r'[\W_]+', '_', f'redirect_{redirect_url}').rstrip('_')
         if doc is None:
             doc = (f'Redirect to {redirect_url}',)
         super().__init__(name=name, urls=urls, doc=doc, doc_group=doc_group)
@@ -144,7 +142,7 @@ class StaticRequest(Request):
     """
     A static resource request
 
-    :param str name: The request name. The default name is the callback function's name.
+    :param str name: The request name
     :param bytes content: The static content
     :param str content_type: Optional content type string. If None, the content type is auto-determined.
     :param list(tuple) urls: The list of URL method/path tuples. The first value is the HTTP request method (e.g. 'GET')
@@ -165,7 +163,7 @@ class StaticRequest(Request):
         '.html': 'text/html; charset=utf-8',
         '.jpeg': 'image/jpeg',
         '.jpg': 'image/jpeg',
-        '.js': 'application/javascript; charset=utf-8',
+        '.js': 'text/javascript; charset=utf-8',
         '.json': 'application/json; charset=utf-8',
         '.markdown': 'text/markdown; charset=utf-8',
         '.md': 'text/markdown; charset=utf-8',
@@ -199,16 +197,14 @@ class StaticRequest(Request):
             assert content_type, f'Unknown content type for static resource "{name}"'
         self.content_type = content_type
 
-        # Compute the etag
-        md5 = hashlib.md5()
-        md5.update(self.content)
-        self.etag = md5.hexdigest()
+        # Compute the ETag - a quoted entity-tag per RFC 7232
+        self.etag = f'"{hashlib.md5(self.content, usedforsecurity=False).hexdigest()}"'
 
     def __call__(self, environ, start_response):
 
         # Check the etag - is the resource modified?
         if self.etag == environ.get('HTTP_IF_NONE_MATCH'):
-            start_response(self.STATUS_NOT_MODIFIED, [])
+            start_response(self.STATUS_NOT_MODIFIED, [('ETag', self.etag)])
             return []
 
         start_response(self.STATUS_OK, [('Content-Type', self.content_type), ('ETag', self.etag)])

{chisel-2.3.2 → chisel-2.4.1/src/chisel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chisel
-Version: 2.3.2
+Version: 2.4.1
 Summary: Lightweight WSGI application framework, schema-validated JSON APIs, and API documentation
 Author-email: "Craig A. Hobbs" <craigahobbs@gmail.com>
 License-Expression: MIT
@@ -30,7 +30,7 @@ Dynamic: license-file
 [![GitHub](https://img.shields.io/github/license/craigahobbs/chisel)](https://github.com/craigahobbs/chisel/blob/main/LICENSE)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/chisel)](https://pypi.org/project/chisel/)
 
-Chisel is a light-weight Python WSGI application framework built for creating well-documented,
+Chisel is a lightweight Python WSGI application framework built for creating well-documented,
 schema-validated JSON web APIs.
 
 
@@ -46,11 +46,13 @@ Chisel provides the [action](https://craigahobbs.github.io/chisel/action.html#ch
 decorator for easily implementing schema-validated JSON APIs.
 
 ~~~ python
+import chisel
+
 @chisel.action(spec='''
 # Sum a list of numbers
 action sum_numbers
     urls
-       GET
+        GET
 
     query
         # The list of numbers
@@ -87,6 +89,14 @@ status, _, content_bytes = application.request('GET', '/sum_numbers')
 b'{"error":"InvalidInput","message":"Required member \\"numbers\\" missing (query string)"}'
 ~~~
 
+A [chisel.Application](https://craigahobbs.github.io/chisel/app.html#chisel.Application) is a
+standard [WSGI](https://peps.python.org/pep-3333/) application object - host it with any WSGI
+server. For example:
+
+~~~ sh
+gunicorn module:application
+~~~
+
 
 ## API Documentation
 
@@ -99,8 +109,9 @@ application = chisel.Application()
 application.add_requests(chisel.create_doc_requests())
 ~~~
 
-By default the documentation application is hosted at "/doc/". An example of of Chisel's documentation output is
-available [here](https://craigahobbs.github.io/chisel/example/#var.vName='chisel_doc_request').
+By default the documentation application is hosted at "/doc/". An example of Chisel's
+[documentation output](https://craigahobbs.github.io/chisel/example/#var.vName='chisel_doc_request')
+is available.
 
 
 ## Development