fresco 3.0.0__tar.gz → 3.9.0__tar.gz

{fresco-3.0.0 → fresco-3.9.0}/CHANGELOG.rst

@@ -1,6 +1,101 @@
 Changelog
 =========
 
+3.9.0 (released 2026-02-02)
+---------------------------
+
+- Bugfix: fix request.get and request.getint type annotations
+- Allow multiple methods to be routed using kwargs, eg ``Route(GET_POST=my_view)``
+- Add support for Python 3.13, 3.14 and drop support for Python 3.9
+
+3.8.0 (released 2025-07-17)
+---------------------------
+
+- Add Response.bad_request ``message`` argument
+- Add warnings when loading option files creates undefined keys
+
+3.7.0 (released 2025-05-05)
+---------------------------
+
+- Add a ``fresco.util.url.add_query`` function
+
+3.6.0 (released 2025-05-03)
+---------------------------
+
+- Replace ``fresco.DEFAULT_CHARSET`` with ``fresco.defaults.DEFAULT_CHARSET``
+- Add a ``required`` argument to Request.get
+- Add new request.get* functions: ``getfloat``, ``getbool`` and ``getdecimal``
+
+3.5.0 (released 2025-02-25)
+---------------------------
+
+- Refactor middleware.XForwarded to clean up error tracebacks and add a new ``force_https`` option
+- Add new ``fresco.options.override_options`` function to aid testing
+- Automatically add a ``request`` argument where the routed function's first
+  positional parameter is annotated as type ``fresco.request.Request``.
+  view
+
+3.4.0 (released 2024-10-16)
+---------------------------
+
+- Add new ``ALL`` shortcut method, allowing all HTTP methods to be routed to a
+  view
+
+3.3.4 (released 2024-08-06)
+---------------------------
+
+- Bugfix: ensure option files are loaded in a well defined order
+
+3.3.3 (released 2024-05-01)
+---------------------------
+
+- Bugfix: request.now returns the correct time on non-UTC systems
+- Add support for Python 3.12 and drop support for 3.8
+
+3.3.2 (released 2023-05-31)
+---------------------------
+
+- Bugfix: a fresco app routed through route_wsgi now receives a fresh request
+  and environ dict, isolated from the containing app.
+
+3.3.1 (released 2023-05-18)
+---------------------------
+
+- The ``route_wsgi`` and ``route_all`` methods now only match at a
+  path separator boundary (``'/'``).
+- Bugfix: subrequest now works with views routed via ``RRoute`` (and so expect
+  an initial ``request`` argument)
+
+3.3.0 (released 2023-05-02)
+----------------------------
+
+- Options: fresco.options.Options can now take a list of paths as its first argument
+- Options: tags can now be specified with environment variable substitutions
+  (eg "{FOO}" would load files tagged with the current value of the 'FOO'
+  environment variable)
+- Options: add ``fresco.options.list_from_str`` and ``fresco.options.dict_from_options``
+
+3.2.0 (released 2023-04-16)
+---------------------------
+
+- Bugfix: fixed cases where the close methods of WSGI content iterators were
+  not called, notably when using subrequests
+- Bugfix: fix ``ResourceWarnings`` caused by unclosed temporary files
+- Added ``route_class`` argument to ``RouteCollection.route``
+- Modified ``RouteCollection.route_wsgi`` to allow it to take a string path to
+  the WSGI callable instead of the callable itself, making its signature more
+  consistent with ``RouteCollection.route``
+- Added ``fresco.process_request_once``
+- ``request.make_url`` and ``fresco.util.url.make_query`` now drop items from
+  the generated query string if the value is ``None``
+
+3.1.0 (released 2022-05-04)
+---------------------------
+
+- Bugfix: passing URL paths to subrequests no longer raises an exception
+- Added an ``_env`` argument to ``fresco.subrequest.subrequest`` to allow custom
+  WSGI environ keys to be passed to the subrequest
+
 3.0.0 (released 2022-05-02)
 ---------------------------
 

{fresco-3.0.0/fresco.egg-info → fresco-3.9.0}/PKG-INFO

@@ -1,23 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fresco
-Version: 3.0.0
+Version: 3.9.0
 Summary: A Web/WSGI micro-framework
-Home-page: https://ollycope.com/software/fresco/latest/
-Author: Oliver Cope
-Author-email: oliver@redgecko.org
-License: Apache
-Keywords: wsgi web www framework
-Platform: UNKNOWN
+Author-email: Oliver Cope <oliver@redgecko.org>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://ollycope.com/software/fresco/latest/
+Keywords: wsgi,web,www,framework
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
 Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
+Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
+Dynamic: license-file
 
 Fresco, a web micro-framework for Python
 ========================================
@@ -46,5 +44,3 @@ Read the
 <https://ollycope.com/software/fresco/latest/>`_ for
 more about the framework, or
 visit the `source repo <https://sr.ht/~olly/fresco/>`_.
-
-

fresco-3.9.0/fresco/__init__.py

@@ -0,0 +1,127 @@
+# Copyright 2015 Oliver Cope
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+#
+from fresco.request import Request
+from fresco.request import currentrequest
+from fresco.requestcontext import context
+from fresco.response import Response
+from fresco.core import FrescoApp
+from fresco.core import urlfor
+from fresco.defaults import DEFAULT_CHARSET
+from fresco.options import Options
+from fresco.routing import Route
+from fresco.routing import RRoute
+from fresco.routing import RouteCollection
+from fresco.routing import DelegateRoute
+from fresco.routing import routefor
+from fresco.routing import ALL_METHODS
+from fresco.routing import GET
+from fresco.routing import HEAD
+from fresco.routing import POST
+from fresco.routing import PUT
+from fresco.routing import DELETE
+from fresco.routing import OPTIONS
+from fresco.routing import TRACE
+from fresco.routing import CONNECT
+from fresco.routing import VERSION_CONTROL
+from fresco.routing import REPORT
+from fresco.routing import CHECKOUT
+from fresco.routing import CHECKIN
+from fresco.routing import UNCHECKOUT
+from fresco.routing import MKWORKSPACE
+from fresco.routing import UPDATE
+from fresco.routing import LABEL
+from fresco.routing import MERGE
+from fresco.routing import BASELINE_CONTROL
+from fresco.routing import MKACTIVITY
+from fresco.routing import ORDERPATCH
+from fresco.routing import ACL
+from fresco.routing import SEARCH
+from fresco.routing import PATCH
+from fresco.routeargs import routearg
+from fresco.routeargs import FormArg
+from fresco.routeargs import PostArg
+from fresco.routeargs import QueryArg
+from fresco.routeargs import GetArg
+from fresco.routeargs import CookieArg
+from fresco.routeargs import SessionArg
+from fresco.routeargs import RequestObject
+from fresco.routeargs import FormData
+from fresco.routeargs import PostData
+from fresco.routeargs import QueryData
+from fresco.routeargs import GetData
+from fresco.middleware import XForwarded
+from fresco.subrequests import subrequest
+from fresco.subrequests import subrequest_bytes
+from fresco.subrequests import subrequest_raw
+from fresco.util.common import object_or_404
+
+
+__version__ = "3.9.0"
+__all__ = [
+    "Request",
+    "currentrequest",
+    "context",
+    "Response",
+    "FrescoApp",
+    "urlfor",
+    "ALL_METHODS",
+    "DEFAULT_CHARSET",
+    "GET",
+    "HEAD",
+    "POST",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "TRACE",
+    "CONNECT",
+    "VERSION_CONTROL",
+    "REPORT",
+    "CHECKOUT",
+    "CHECKIN",
+    "UNCHECKOUT",
+    "MKWORKSPACE",
+    "UPDATE",
+    "LABEL",
+    "MERGE",
+    "BASELINE_CONTROL",
+    "MKACTIVITY",
+    "ORDERPATCH",
+    "ACL",
+    "SEARCH",
+    "PATCH",
+    "DelegateRoute",
+    "Options",
+    "Route",
+    "RouteCollection",
+    "RRoute",
+    "routearg",
+    "FormArg",
+    "PostArg",
+    "QueryArg",
+    "GetArg",
+    "CookieArg",
+    "SessionArg",
+    "RequestObject",
+    "FormData",
+    "PostData",
+    "QueryData",
+    "GetData",
+    "routefor",
+    "XForwarded",
+    "subrequest",
+    "subrequest_bytes",
+    "subrequest_raw",
+    "object_or_404",
+]

{fresco-3.0.0 → fresco-3.9.0}/fresco/cookie.py

@@ -163,7 +163,6 @@ def parse_cookie_header(cookie_string, unquote=unquote):
     cookies = []
 
     for part in cookie_string.split(";"):
-
         try:
             k, v = part.strip().split("=", 1)
         except ValueError:

{fresco-3.0.0 → fresco-3.9.0}/fresco/core.py

@@ -13,6 +13,7 @@
 #     limitations under the License.
 #
 from functools import partial
+from functools import wraps
 from typing import Callable
 from typing import Dict
 from typing import List
@@ -20,6 +21,7 @@ from typing import Tuple
 from typing import Type
 from typing import Set
 from typing import Union
+import typing as t
 import contextlib
 import logging
 import sys
@@ -31,7 +33,10 @@ from fresco.util.http import encode_multipart
 from fresco.util.urls import normpath, make_query
 from fresco.util.common import fq_path
 from fresco.util.wsgi import make_environ
-from fresco.typing import WSGICallable
+from fresco.types import WSGIApplication
+from fresco.types import HeaderList
+from fresco.types import OptionalExcInfo
+from fresco.types import WriteCallable
 
 from fresco.exceptions import ResponseException
 from fresco.requestcontext import context
@@ -44,10 +49,12 @@ from fresco.routing import (
 )
 from fresco.options import Options
 
-__all__ = ("FrescoApp", "urlfor")
+__all__ = ("FrescoApp", "urlfor", "context")
 
 logger = logging.getLogger(__name__)
 
+ExcInfo = tuple[t.Type[BaseException], BaseException, types.TracebackType]
+
 
 class FrescoApp(RouteCollection):
     """\
@@ -64,7 +71,6 @@ class FrescoApp(RouteCollection):
     request_class = Request
 
     def __init__(self, *args, **kwargs):
-
         views = kwargs.pop("views", None)
         path = kwargs.pop("path", None)
         super(FrescoApp, self).__init__(*args, **kwargs)
@@ -114,7 +120,9 @@ class FrescoApp(RouteCollection):
         #: If a function returns a value (other than ``None``),
         #: this value will be
         #: returned as the response instead of calling the scheduled view.
-        self.process_http_error_response_handlers: List[Tuple[int, Callable]] = []
+        self.process_http_error_response_handlers: list[
+            tuple[t.Optional[int], Callable[[Request, Response], t.Optional[Response]]]
+        ] = []
 
         #: Functions to be called if an exception is raised during a view
         #: Each function will be passed ``request, exc_info``.
@@ -122,7 +130,9 @@ class FrescoApp(RouteCollection):
         #: this value will be
         #: returned as the response and the error will not be propagated.
         #: If all exception handlers return None then the error will be raised
-        self.process_exception_handlers: List[Tuple[Exception, Callable]] = []
+        self.process_exception_handlers: list[
+            tuple[Type[Exception], Callable[[Request, ExcInfo], Union[Response, None]]]
+        ] = []
 
         #: Functions to be called at the end of request processing,
         #: after all content has been output.
@@ -150,12 +160,12 @@ class FrescoApp(RouteCollection):
 
     def get_response(
         self,
-        request,
-        path,
-        method,
+        request: Request,
+        path: str,
+        method: str,
         currentcontext=context.currentcontext,
         normpath=normpath,
-    ):
+    ) -> Response:
         ctx = currentcontext()
         ctx["app"] = self
         environ = request.environ
@@ -177,19 +187,19 @@ class FrescoApp(RouteCollection):
 
         try:
             for traversal in self.get_route_traversals(path, method, request):
+                route = traversal.route
                 try:
-                    route = traversal.route
                     environ["wsgiorg.routing_args"] = (
                         traversal.args,
                         traversal.kwargs,
                     )
-                    view = route.getview(method)
+                    view = traversal.view
                     ctx["view_self"] = getattr(view, "__self__", None)
                     ctx["route_traversal"] = traversal
                     if self.logger:
                         self.logger.info(
                             "matched route: %s %r => %r",
-                            request.method,
+                            method,
                             path,
                             fq_path(view),
                         )
@@ -258,12 +268,12 @@ class FrescoApp(RouteCollection):
 
         # Is the URL just missing a trailing '/'?
         if not path or path[-1] != "/":
-            for _ in self.get_methods(request, path + "/"):
+            if self.get_methods(request, path + "/"):
                 return Response.unrestricted_redirect_permanent(path + "/")
 
         return Response.not_found()
 
-    def view(self, request=None) -> Response:
+    def view(self, request: t.Optional[Request] = None) -> Response:
         request = request or context.request
         try:
             path = request.path_info
@@ -271,9 +281,7 @@ class FrescoApp(RouteCollection):
             response = e.response
         else:
             response = self.get_response(
-                request,
-                path,
-                request.method
+                request, path, request.environ["REQUEST_METHOD"]
             )
 
         for f in self.process_response_handlers:
@@ -290,7 +298,9 @@ class FrescoApp(RouteCollection):
 
         return response
 
-    def handle_http_error_response(self, request, response):
+    def handle_http_error_response(
+        self, request: Request, response: Response
+    ) -> Response:
         """
         Call any process_http_error_response handlers and return the
         (potentially modified) response object.
@@ -306,8 +316,8 @@ class FrescoApp(RouteCollection):
                 self.log_exception(request)
         return response
 
-    def get_methods(self, request, path):
-        """\
+    def get_methods(self, request: Request, path: str) -> Set[str]:
+        """
         Return the HTTP methods valid in routes to the given path
         """
         methods: Set[str] = set()
@@ -325,13 +335,7 @@ class FrescoApp(RouteCollection):
             exc_info=exc_info,
         )
 
-    def handle_exception(
-        self, request, allow_reraise=True
-    ) -> Union[
-        Response,
-        Tuple[Type[BaseException], BaseException, types.TracebackType],
-    ]:
-
+    def handle_exception(self, request, allow_reraise=True) -> Response:
         exc_info = sys.exc_info()
         if exc_info[0] is None:
             raise AssertionError(
@@ -348,10 +352,7 @@ class FrescoApp(RouteCollection):
         # server handle it
         if allow_reraise and not have_error_handlers:
             raise exc_info[1].with_traceback(exc_info[2])  # type: ignore
-        response: Union[
-            Response,
-            Tuple[Type[BaseException], BaseException, types.TracebackType],
-        ] = Response.internal_server_error()
+        response: Response = Response.internal_server_error()
 
         if not self.process_exception_handlers:
             self.log_exception(request, exc_info)
@@ -408,7 +409,7 @@ class FrescoApp(RouteCollection):
         self.reset_wsgi_app()
         self._middleware.insert(position, (middleware, args, kwargs))
 
-    def make_wsgi_app(self, wsgi_app=None, use_middleware=True) -> WSGICallable:
+    def make_wsgi_app(self, wsgi_app=None, use_middleware=True) -> WSGIApplication:
         """
         Return a WSGI (PEP-3333) compliant application that drives this
         FrescoApp object.
@@ -421,7 +422,7 @@ class FrescoApp(RouteCollection):
         """
         if wsgi_app is None:
 
-            def wsgi_app(
+            def _wsgi_app(
                 environ,
                 start_response,
                 view=self.view,
@@ -430,15 +431,18 @@ class FrescoApp(RouteCollection):
                 request = request_class(environ)
                 return view(request)(environ, start_response)
 
+        else:
+            _wsgi_app = wsgi_app
+
         if use_middleware:
             for m, m_args, m_kwargs in self._middleware:
-                wsgi_app = m(wsgi_app, *m_args, **m_kwargs)
+                _wsgi_app = m(_wsgi_app, *m_args, **m_kwargs)
 
         def fresco_wsgi_app(
             environ,
             start_response,
             frescoapp=self,
-            wsgi_app=wsgi_app,
+            wsgi_app=_wsgi_app,
             request_class=self.request_class,
             process_teardown_handlers=self.process_teardown_handlers,
             call_process_teardown_handlers=self.call_process_teardown_handlers,
@@ -450,8 +454,7 @@ class FrescoApp(RouteCollection):
             iterator = None
             try:
                 iterator = wsgi_app(environ, start_response)
-                for item in iterator:
-                    yield item
+                yield from iterator
             except Exception:
                 exc_info = sys.exc_info()
                 try:
@@ -464,14 +467,15 @@ class FrescoApp(RouteCollection):
                     def exc_start_response(s, h, exc_info=exc_info):
                         return start_response(s, h, exc_info)
 
-                    for item in response(environ, exc_start_response):
-                        yield item
+                    yield from response(environ, exc_start_response)
                 finally:
                     del exc_info
             finally:
                 try:
                     if process_teardown_handlers:
                         call_process_teardown_handlers(request)
+                    for item in request.teardown_handlers:
+                        item()
                 finally:
                     try:
                         close = getattr(iterator, "close", None)
@@ -562,6 +566,27 @@ class FrescoApp(RouteCollection):
             except Exception:
                 self.log_exception(request)
 
+    def process_request_once(
+        self, func: Callable[[Request], t.Optional[Response]]
+    ) -> Callable[[Request], t.Optional[Response]]:
+        """
+        Register a ``process_request`` hook function that is called only once
+
+        When running fresco with multiple worker threads/processes the hook
+        function will be called at most once per worker.
+        """
+
+        @self.process_request
+        @wraps(func)
+        def process_request_once(request: Request) -> t.Optional[Response]:
+            try:
+                self.process_request_handlers.remove(process_request_once)
+            except ValueError:
+                return None
+            return func(request)
+
+        return func
+
     def process_request(self, func):
         """
         Register a ``process_request`` hook function
@@ -583,7 +608,11 @@ class FrescoApp(RouteCollection):
         self.process_response_handlers.append(func)
         return func
 
-    def process_exception(self, func, exc_type=Exception):
+    def process_exception(
+        self,
+        func: Callable[[Request, ExcInfo], Union[Response, None]],
+        exc_type: Type[Exception] = Exception,
+    ):
         """
         Register a ``process_exception`` hook function
         """
@@ -649,33 +678,39 @@ class FrescoApp(RouteCollection):
             start_response("200 OK", [])
             yield b""
 
-        def fake_start_response(status, headers, exc_info=None):
+        def fake_start_response(
+            status: str, headers: HeaderList, exc_info: OptionalExcInfo = None
+        ) -> WriteCallable:
             return lambda s: None
 
         environ = make_environ(url, environ, wsgi_input, **kwargs)
         app = self.make_wsgi_app(wsgi_app=fake_app, use_middleware=middleware)
         result = app(environ, fake_start_response)
-        close = getattr(result, "close", lambda: None)
+        close = getattr(result, "close", None)
         content_iterator = iter(result)
-        next(content_iterator, None)
-        yield context
-        list(content_iterator)
-        close()
+        try:
+            next(content_iterator, None)
+            yield context
+            list(content_iterator)
+        finally:
+            if close is not None:
+                close()
 
     def requestcontext_with_payload(
         self, url="/", data=None, environ=None, files=None, multipart=False, **kwargs
     ):
-
         if files:
             multipart = True
 
         if multipart:
             wsgi_input, headers = encode_multipart(data, files)
             kwargs.update(headers)
-        elif hasattr(data, "read"):
+        elif isinstance(data, t.BinaryIO):
             wsgi_input = data.read()
         elif isinstance(data, bytes):
             wsgi_input = data
+        elif data is None:
+            wsgi_input = b""
         else:
             wsgi_input = make_query(data).encode("ascii")
 

{fresco-3.0.0 → fresco-3.9.0}/fresco/decorators.py

@@ -14,20 +14,23 @@
 #
 import sys
 from functools import wraps
+import typing as t
 
 from fresco import Response
 
 _marker = object()
 
 
-def onerror(exceptions, handler):
-    """\
+def onerror(
+    exceptions: t.Union[t.Type[Exception], tuple[t.Type[Exception], ...]], handler
+) -> t.Callable:
+    """
     Return a decorator that can replace or update the return value of the
     function if an exception is raised
     """
 
     try:
-        if isinstance(exceptions, Exception):
+        if isinstance(exceptions, type):
             exceptions = (exceptions,)
     except TypeError:
         pass
@@ -79,9 +82,7 @@ def json_response(
         def json_response_decorator(func):
             @wraps(func)
             def json_response_decorated(*fa, **fkw):
-                return Response.json(
-                    func(*fa, **fkw), indent, separators, **kwargs
-                )
+                return Response.json(func(*fa, **fkw), indent, separators, **kwargs)
 
             return json_response_decorated
 

fresco-3.9.0/fresco/defaults.py

@@ -0,0 +1 @@
+DEFAULT_CHARSET = "UTF-8"