fresco 3.3.1__tar.gz → 3.8.0__tar.gz

{fresco-3.3.1 → fresco-3.8.0}/CHANGELOG.rst

@@ -1,6 +1,56 @@
 Changelog
 =========
 
+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)
 ---------------------------
 
@@ -9,8 +59,8 @@ Changelog
 - Bugfix: subrequest now works with views routed via ``RRoute`` (and so expect
   an initial ``request`` argument)
 
-3.3.0
------
+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

{fresco-3.3.1/fresco.egg-info → fresco-3.8.0}/PKG-INFO

@@ -1,22 +1,21 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: fresco
-Version: 3.3.1
+Version: 3.8.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.3.1 → fresco-3.8.0}/fresco/__init__.py

@@ -12,10 +12,63 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
-__version__ = "3.3.1"
+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
 
-DEFAULT_CHARSET = "UTF-8"
 
+__version__ = "3.8.0"
 __all__ = [
     "Request",
     "currentrequest",
@@ -72,57 +125,3 @@ __all__ = [
     "subrequest_raw",
     "object_or_404",
 ]
-
-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.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

{fresco-3.3.1 → fresco-3.8.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.
@@ -156,7 +165,7 @@ class FrescoApp(RouteCollection):
         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),
                         )
@@ -271,7 +280,9 @@ class FrescoApp(RouteCollection):
         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:
@@ -324,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(
@@ -346,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)
@@ -406,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.
@@ -419,7 +422,7 @@ class FrescoApp(RouteCollection):
         """
         if wsgi_app is None:
 
-            def wsgi_app(
+            def _wsgi_app(
                 environ,
                 start_response,
                 view=self.view,
@@ -428,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,
@@ -602,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
         """
@@ -668,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)
@@ -693,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.3.1 → fresco-3.8.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.8.0/fresco/defaults.py

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

{fresco-3.3.1 → fresco-3.8.0}/fresco/middleware.py

@@ -12,11 +12,17 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
+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)