fresco 3.2.0__tar.gz → 3.9.0__tar.gz

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

@@ -1,6 +1,79 @@
 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)
 ---------------------------

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

@@ -1,22 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fresco
-Version: 3.2.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
+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
 ========================================

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.2.0 → fresco-3.9.0}/fresco/core.py

@@ -33,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
@@ -46,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):
     """\
@@ -115,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``.
@@ -123,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.
@@ -151,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
@@ -178,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),
                         )
@@ -259,19 +268,21 @@ 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
         except ResponseException as e:
             response = e.response
         else:
-            response = self.get_response(request, path, request.method)
+            response = self.get_response(
+                request, path, request.environ["REQUEST_METHOD"]
+            )
 
         for f in self.process_response_handlers:
             try:
@@ -287,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.
@@ -303,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()
@@ -322,12 +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(
@@ -344,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)
@@ -404,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.
@@ -417,7 +422,7 @@ class FrescoApp(RouteCollection):
         """
         if wsgi_app is None:
 
-            def wsgi_app(
+            def _wsgi_app(
                 environ,
                 start_response,
                 view=self.view,
@@ -426,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,
@@ -600,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
         """
@@ -666,7 +678,9 @@ 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)
@@ -691,12 +705,12 @@ class FrescoApp(RouteCollection):
         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 = ""
+            wsgi_input = b""
         else:
             wsgi_input = make_query(data).encode("ascii")
 

{fresco-3.2.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

fresco-3.9.0/fresco/defaults.py

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

{fresco-3.2.0 → fresco-3.9.0}/fresco/middleware.py

@@ -12,11 +12,17 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
-__all__ = "XForwarded"
+import typing as t
+
+from fresco.types import WSGIApplication
+from fresco.types import WSGIEnviron
+from fresco.types import StartResponse
+
+__all__ = ["XForwarded"]
 
 
 class XForwarded(object):
-    """\
+    """
     Modify the WSGI environment so that the X_FORWARDED_* headers are observed
     and generated URIs are correct in a proxied environment.
 
@@ -33,6 +39,13 @@ class XForwarded(object):
     the wsgi.url_scheme is modified to ``https`` and ``HTTPS`` is set to
     ``on``.
 
+    :param trusted:
+        List of IP addresses trusted to set the HTTP_X_FORWARDED_* headers
+
+    :param force_https:
+        If True, the following environ keys will be set unconditionally:
+        ``"HTTPS": "on"`` and ``"wsgi.url_scheme": "https"`` will be set
+
     Example::
 
         >>> from fresco import FrescoApp, context, GET, Response
@@ -68,24 +81,36 @@ class XForwarded(object):
         u'URL is https://real-name/; REMOTE_ADDR is 1.2.3.4'
     """
 
-    def __init__(self, app, trusted=None):
+    def __init__(
+        self,
+        app: WSGIApplication,
+        trusted: t.Optional[t.Iterable[str]] = None,
+        force_https: t.Optional[bool] = None,
+    ) -> None:
         self.app = app
+        self.force_https = force_https
         if trusted:
             self.trusted = set(trusted)
         else:
             self.trusted = set()
 
-    def __call__(self, environ, start_response):
-        """\
+    def __call__(
+        self, environ: WSGIEnviron, start_response: StartResponse
+    ) -> t.Iterable[bytes]:
+        """
         Call the WSGI app, passing it a modified environ
         """
         env = environ.get
-        is_ssl = (
-            env("HTTP_X_FORWARDED_PROTO") == "https"
-            or env("HTTP_X_FORWARDED_SSL") == "on"
-        )
 
+        if self.force_https is None:
+            is_ssl = (
+                env("HTTP_X_FORWARDED_PROTO") == "https"
+                or env("HTTP_X_FORWARDED_SSL") == "on"
+            )
+        else:
+            is_ssl = self.force_https
         host = env("HTTP_X_FORWARDED_HOST")
+
         if host is not None:
             if ":" in host:
                 port = host.split(":")[1]
@@ -99,21 +124,17 @@ class XForwarded(object):
             environ["wsgi.url_scheme"] = "https"
             environ["HTTPS"] = "on"
 
-        try:
-            forwards = environ["HTTP_X_FORWARDED_FOR"].split(", ") + [
-                env("REMOTE_ADDR", "")
-            ]
-        except KeyError:
-            # No X-Forwarded-For header?
-            return self.app(environ, start_response)
-
-        if self.trusted:
-            for ip in forwards[::-1]:
-                # Find the first non-trusted ip; this is our remote address
-                if ip not in self.trusted:
-                    environ["REMOTE_ADDR"] = ip
-                    break
-        else:
-            environ["REMOTE_ADDR"] = forwards[0]
+        forwarded_for = env("HTTP_X_FORWARDED_FOR")
+        if forwarded_for:
+            addrs = forwarded_for.split(", ")
+
+            if self.trusted:
+                for ip in addrs[::-1]:
+                    # Find the first non-trusted ip; this is our remote address
+                    if ip not in self.trusted:
+                        environ["REMOTE_ADDR"] = ip
+                        break
+            else:
+                environ["REMOTE_ADDR"] = addrs[0]
 
         return self.app(environ, start_response)