fresco 3.3.4__py3-none-any.whl → 3.5.0__py3-none-any.whl

fresco/__init__.py

@@ -12,7 +12,7 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
-__version__ = "3.3.4"
+__version__ = "3.5.0"
 
 DEFAULT_CHARSET = "UTF-8"
 

fresco/core.py

@@ -46,7 +46,7 @@ from fresco.routing import (
 )
 from fresco.options import Options
 
-__all__ = ("FrescoApp", "urlfor")
+__all__ = ("FrescoApp", "urlfor", "context")
 
 logger = logging.getLogger(__name__)
 
@@ -184,13 +184,13 @@ class FrescoApp(RouteCollection):
                         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),
                         )

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.typing import WSGICallable
+from fresco.typing import WSGIEnviron
+from fresco.typing 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: WSGICallable,
+        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)

fresco/options.py

@@ -12,7 +12,9 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
+import contextlib
 import inspect
+import itertools
 import json
 import logging
 import typing as t
@@ -217,9 +219,11 @@ class Options(dict):
                 for ts in sorted(
                     tagged_sources,
                     key=(
-                        lambda ts: ([], ts[1])
-                        if len(ts[0]) == 0
-                        else (sorted(tags.index(t) for t in ts[0]), ts[1])
+                        lambda ts: (
+                            ([], ts[1])
+                            if len(ts[0]) == 0 else
+                            (sorted(tags.index(t) for t in ts[0]), ts[1])
+                        )
                     )
                 )
             ]
@@ -314,6 +318,45 @@ class Options(dict):
         self.update_from_dict(dict(inspect.getmembers(ob)), load_all)
 
 
+@contextlib.contextmanager
+def override_options(options, other=None, **kwargs):
+    """
+    Context manager that updates the given Options object with new values.
+    On exit, the old values will be restored.
+
+    This function is provided to assist with writing tests. It directly
+    modifies the given options object and does not prevent other threads from
+    accessing the modified values.
+    """
+    saved: list[tuple[str, t.Any]] = []
+    items: t.Iterable[tuple[str, t.Any]] = []
+    if other is not None:
+
+        keys = getattr(other, "keys", None)
+        if keys and callable(keys):
+            items = ((k, other[k]) for k in keys())
+
+    if kwargs:
+        items = itertools.chain(items, kwargs.items())
+
+    NOT_PRESENT = object()
+
+    for k, v in items:
+        if k in options:
+            saved.append((k, options[k]))
+        else:
+            saved.append((k, NOT_PRESENT))
+
+        options[k] = v
+
+    yield options
+    for k, v in saved:
+        if v is NOT_PRESENT:
+            del options[k]
+        else:
+            options[k] = v
+
+
 def parse_value(
     options: Mapping,
     v: str,

fresco/routing.py

@@ -14,6 +14,7 @@
 #
 import re
 import sys
+import inspect
 import warnings
 from copy import copy
 from collections import defaultdict
@@ -38,6 +39,7 @@ from fresco.response import Response
 from fresco.request import Request
 from fresco.requestcontext import context
 from fresco.routeargs import RouteArg
+from fresco.typing import WSGICallable
 from fresco.util.cache import make_cache
 from fresco.util.common import fq_path
 from fresco.util.urls import join_path
@@ -107,6 +109,9 @@ ALL_METHODS = HTTP_METHODS = set(
     + RFC5789_METHODS
 )
 
+#: Shortcut for specifying all methods as a kwarg
+ALL = "ALL"
+
 __all__ = [
     "ALL_METHODS",
     "Pattern",
@@ -125,7 +130,7 @@ PathMatch = namedtuple(
 
 
 class RouteTraversal(
-    namedtuple("RouteTraversal", "route args kwargs collections_traversed")
+    namedtuple("RouteTraversal", "route view args kwargs collections_traversed")
 ):
     """
     Encapsulate a route traversal.
@@ -134,6 +139,7 @@ class RouteTraversal(
 
     - ``route`` the final route traversed, allowing access to the view
         associated with the path.
+    - ``view``, the resolved view callable
     - ``args`` - positional args to be passed to the view. This is a
         combination of args extracted from the path and any added when
         constructing the route.
@@ -203,7 +209,7 @@ class RouteTraversal(
 #: An item of RouteTraversal.collections_traversed
 TraversedCollection = namedtuple(
     "TraversedCollection",
-    "collection path route args kwargs " "traversal_args traversal_kwargs",
+    "collection path route args kwargs traversal_args traversal_kwargs",
 )
 
 
@@ -705,8 +711,7 @@ class Route(object):
         lambda: defaultdict(list)
     )
 
-    #: Always provide an positional ``request`` argument to views
-    provide_request = False
+    provide_request: Optional[bool] = None
 
     def __init__(
         self,
@@ -727,7 +732,9 @@ class Route(object):
         :param pattern:     A string that can be compiled into a path pattern
         :param methods:     The list of HTTP methods the view is bound to
                             ('GET', 'POST', etc)
-        :param view:        The view function.
+        :param view:
+            The view function, or a string identifier which will later be resolved.
+
         :param kwargs:      A dictionary of default keyword arguments to pass
                             to the view callable
         :param args:        Positional arguments to pass to the view callable
@@ -744,8 +751,11 @@ class Route(object):
                                by a view will cause the current response to be
                                discarded with routing continuing to the next
                                available route.
-        :param provide_request: If True, provide the current request as the
-                                first argument to the view callable.
+        :param provide_request:
+            If True, provide the current request as the first argument to the
+            view callable. Defaults to ``None``, which will autodetect if the
+            view function has an initial parameter of type
+            :class:`~fresco.request.Request`
         :param **_kwargs:   Keyword arguments matching HTTP method names
                             (GET, POST etc) can used to specify views
                             associated with those methods.
@@ -803,10 +813,16 @@ class Route(object):
                         "HTTP methods must be specified as a string or iterable"
                     )
             for m in methods:
+                if m == ALL:
+                    methods = ALL_METHODS
+                    break
                 if m not in ALL_METHODS:
                     raise ValueError("{!r} is not a valid HTTP method".format(m))
             method_view_map.update((m, view) for m in methods)
 
+        if view := _kwargs.pop("ALL", None):
+            method_view_map |= {m: view for m in ALL_METHODS}
+
         for method in ALL_METHODS:
             if method in _kwargs:
                 method_view_map[method] = _kwargs.pop(method)
@@ -895,14 +911,14 @@ class Route(object):
         newroute.fallthrough_statuses = {int(s) for s in status_codes}
         return newroute
 
-    def match(self, path, method):
+    def match(self, path: str, method: t.Optional[str]) -> t.Optional[PathMatch]:
         if method and method not in self.methods:
             return None
         return self.pattern.match(path)
 
-    def getview(self, method: str) -> Callable:
-        """\
-        Return the raw view callable.
+    def getview(self, method: str) -> Callable[..., Any]:
+        """
+        Resolve and return the raw view callable.
         """
         try:
             return self._cached_views[method]
@@ -922,6 +938,12 @@ class Route(object):
                 uview = getattr(self.instance, uview)
 
         self._cached_views[method] = uview
+        if self.provide_request is None:
+            if callable(uview):
+                self.provide_request = _has_request_parameter(uview)
+            else:
+                self.provide_request = False
+
         return uview
 
     @classmethod
@@ -1385,8 +1407,8 @@ class RouteCollection(MutableSequence):
                     raise exc
 
     def _get_routes(
-        self, key: Tuple[t.Optional[str], str]
-    ) -> t.Sequence[t.Tuple[Route, PathMatch]]:
+        self, key: tuple[t.Optional[str], str]
+    ) -> t.Sequence[tuple[Route, PathMatch]]:
         method, path = key
         routes = ((r, r.match(path, method)) for r in self.__routes__)
         return [(r, t) for (r, t) in routes if t is not None]
@@ -1428,6 +1450,12 @@ class RouteCollection(MutableSequence):
 
             # View function arguments extracted while traversing the path
             traversal_args, traversal_kwargs = result.args, result.kwargs
+            if method is None:
+                for m in route.viewspecs:
+                    view = route.getview(m)
+                    break
+            else:
+                view = route.getview(method)
 
             # Process any args/kwargs defined in the Route declaration.
             if request:
@@ -1459,7 +1487,7 @@ class RouteCollection(MutableSequence):
                         raise exc
 
                     r = self.route_class("/", ALL_METHODS, raiser)
-                    yield RouteTraversal(r, (), {}, [(self, "", r)])
+                    yield RouteTraversal(r, r.getview("GET"), (), {}, [(self, "", r)])
                     continue
 
                 for sub in sub_routes.get_route_traversals(
@@ -1484,17 +1512,21 @@ class RouteCollection(MutableSequence):
                     # Dynamic routes consume their arguments when creating the
                     # sub RouteCollection.
                     if route.dynamic:
-                        yield RouteTraversal(sub.route, sub.args, sub.kwargs, traversed)
+                        yield RouteTraversal(
+                            sub.route, sub.view, sub.args, sub.kwargs, traversed
+                        )
                     else:
                         yield RouteTraversal(
                             sub.route,
+                            sub.view,
                             args + sub.args,
-                            dict(kwargs, **sub.kwargs),
+                            kwargs | sub.kwargs,
                             traversed,
                         )
             else:
                 yield RouteTraversal(
                     route,
+                    view,
                     args,
                     kwargs,
                     [
@@ -1563,7 +1595,7 @@ class RouteCollection(MutableSequence):
     def route_wsgi(
         self,
         path: str,
-        wsgiapp: t.Union[t.Callable, str],
+        wsgiapp: t.Union[WSGICallable, str],
         rewrite_script_name: bool = True,
         *args,
         **kwargs,
@@ -1591,7 +1623,7 @@ class RouteCollection(MutableSequence):
         resolved_wsgi_app = None
 
         def fresco_wsgi_view(
-            request,
+            request: Request,
             path=path,
             ws_path=ws_path,
             rewrite_script_name=rewrite_script_name,
@@ -1766,3 +1798,24 @@ def register_converter(name, registry=ExtensiblePattern):
         return cls
 
     return register_converter
+
+
+def _has_request_parameter(func: Callable[..., Any]) -> bool:
+    """
+    Return True if the given function has an initial parameter of type Request
+    """
+
+    def _is_request_annotation(a: Any) -> bool:
+        if isinstance(a, type) and issubclass(a, Request):
+            return True
+
+        origin = t.get_origin(a)
+        if origin is t.Union and any(
+            _is_request_annotation(arg) for arg in t.get_args(a)
+        ):
+            return True
+        return False
+
+    sig = inspect.signature(func)
+    firstparam = next(iter(sig.parameters.values()), None)
+    return bool(firstparam and _is_request_annotation(firstparam.annotation))

fresco/subrequests.py

@@ -1,7 +1,5 @@
 from itertools import chain
 from typing import Any
-from typing import Dict
-from typing import Tuple
 
 from fresco.core import context
 from fresco.request import Request
@@ -262,8 +260,8 @@ def resolve_viewspec(viewspec, *args, **kwargs):
 
 
 def _get_args_for_route(
-    route: Route, request: Request, args: Tuple, kwargs: Dict[str, Any]
-) -> Tuple[Tuple, Dict[str, Any]]:
+    route: Route, request: Request, args: tuple[Any, ...], kwargs: dict[str, Any]
+) -> tuple[tuple[Any, ...], dict[str, Any]]:
     """
     Return the args/kwargs required to pass to the view callable for ``route``.
     """

fresco/tests/test_options.py

@@ -24,6 +24,7 @@ import sys
 import pytest
 
 from fresco.options import Options
+from fresco.options import override_options
 from fresco.options import parse_key_value_pairs
 from fresco.options import dict_from_options
 
@@ -104,6 +105,25 @@ class TestOptions(object):
         assert isinstance(Options().copy(), Options)
 
 
+class TestOverrideOptions:
+
+    def test_override_options_with_object(self):
+        options = Options(foo=1)
+        with override_options(options, {"foo": 2, "bar": "a"}):
+            assert options["foo"] == 2
+            assert options["bar"] == "a"
+        assert options["foo"] == 1
+        assert "bar" not in options
+
+    def test_override_options_with_kwargs(self):
+        options = Options(foo=1)
+        with override_options(options, foo=2, bar="a"):
+            assert options["foo"] == 2
+            assert options["bar"] == "a"
+        assert options["foo"] == 1
+        assert "bar" not in options
+
+
 class TestLoadKeyValuePairs:
     def test_it_loads_strings(self):
         assert parse_key_value_pairs({}, ["a=b"]) == {"a": "b"}

fresco/tests/test_routing.py

@@ -24,11 +24,15 @@ import tms
 
 from fresco import FrescoApp
 from fresco.core import urlfor
+from fresco.request import Request
 from fresco.exceptions import NotFound
 from fresco.response import Response
 from fresco.routing import ALL_METHODS
+from fresco.routing import ALL
 from fresco.routing import GET
+from fresco.routing import OPTIONS
 from fresco.routing import POST
+from fresco.routing import _has_request_parameter
 from fresco.routing import (
     Route,
     DelegateRoute,
@@ -114,6 +118,21 @@ class TestRouteConstructor(object):
         with pytest.raises(ValueError):
             Route("/", ["GET", "FOO"], lambda: None)
 
+    def test_ALL_kwarg_routes_all_methods(self):
+        def view():
+            return Response()
+
+        app = FrescoApp()
+        app.route("/x", ALL, view)
+        assert len(list(app.get_route_traversals("/x", GET))) == 1
+        assert len(list(app.get_route_traversals("/x", POST))) == 1
+        assert len(list(app.get_route_traversals("/x", OPTIONS))) == 1
+
+        app.route("/y", ALL=view)
+        assert len(list(app.get_route_traversals("/y", GET))) == 1
+        assert len(list(app.get_route_traversals("/y", POST))) == 1
+        assert len(list(app.get_route_traversals("/y", OPTIONS))) == 1
+
 
 class TestRouteBeforeHooks(object):
     def test_hook_is_called(self):
@@ -330,29 +349,29 @@ class TestPredicates(object):
 
 class TestRouteNames(object):
     def test_name_present_in_route_keys(self):
-        r = Route("/", GET, None, name="foo")
+        r = Route("/", GET, lambda: None, name="foo")
         assert "foo" in list(r.route_keys())
 
     def test_name_with_other_kwargs(self):
-        r = Route("/", GET, None, name="foo", x="bar")
+        r = Route("/", GET, lambda: None, name="foo", x="bar")
         assert "foo" in list(r.route_keys())
 
     def test_name_cannot_contain_colon(self):
         with pytest.raises(ValueError):
-            Route("/", GET, None, name="foo:bar")
+            Route("/", GET, lambda: None, name="foo:bar")
 
 
 class TestRouteCollection(object):
     def test_it_adds_routes_from_constructor(self):
-        r1 = Route("/1", GET, None, name="1")
-        r2 = Route("/2", POST, None, name="2")
+        r1 = Route("/1", GET, lambda: None, name="1")
+        r2 = Route("/2", POST, lambda: None, name="2")
         rc = RouteCollection([r1, r2])
         assert [r.name for r in rc] == ["1", "2"]
 
     def test_it_adds_routecollections_from_constructor(self):
-        r1 = Route("/", GET, None, name="1")
-        r2 = Route("/", POST, None, name="2")
-        r3 = Route("/", POST, None, name="3")
+        r1 = Route("/", GET, lambda: None, name="1")
+        r2 = Route("/", POST, lambda: None, name="2")
+        r3 = Route("/", POST, lambda: None, name="3")
         rc = RouteCollection([r1, RouteCollection([r2, r3])])
         assert [r.name for r in rc] == ["1", "2", "3"]
 
@@ -411,7 +430,7 @@ class TestRouteCollection(object):
         a.add_route(a_delegate_route)
         b.add_route(b_delegate_route)
 
-        r = next(a.get_route_traversals("/rabbit/hole/rabbit/harvey", None))
+        r = next(a.get_route_traversals("/rabbit/hole/rabbit/harvey", "GET"))
 
         assert r.collections_traversed == [
             (a, "", a_delegate_route, (), {}, (), {}),
@@ -1124,3 +1143,51 @@ class TestRouteAll:
         assert len(list(app.get_route_traversals("/x", GET))) == 1
         assert len(list(app.get_route_traversals("/x/y", GET))) == 1
         assert len(list(app.get_route_traversals("/xy", GET))) == 0
+
+
+class TestRequestParamter:
+
+    def test_has_request_parameter(self):
+
+        def a(request: Request):
+            pass
+
+        def b(request: t.Optional[Request]):
+            pass
+
+        def c(request: t.Union[Request, None]):
+            pass
+
+        def d(request: t.Union[None, Request]):
+            pass
+
+        def e(request: int):
+            pass
+
+        def f(request):
+            pass
+
+        assert _has_request_parameter(a) is True
+        assert _has_request_parameter(b) is True
+        assert _has_request_parameter(c) is True
+        assert _has_request_parameter(d) is True
+        assert _has_request_parameter(e) is False
+        assert _has_request_parameter(f) is False
+
+    def test_request_is_provided_automatically(self):
+
+        def a(request: Request):
+            return Response("a")
+
+        def b():
+            return Response("b")
+
+        app = FrescoApp()
+        app.route("/a", GET=a)
+        app.route("/b", GET=b)
+
+        with app.requestcontext("/a"):
+            assert app.view().content == "a"
+
+        with app.requestcontext("/b"):
+            assert app.view().content == "b"

fresco/typing.py

@@ -1,11 +1,17 @@
 from types import TracebackType
 from typing import Any
 from typing import Callable
-from typing import Dict
 from typing import Iterable
-from typing import List
-from typing import Tuple
 
-WSGICallable = Callable[[Dict[str, Any], Callable], Iterable[bytes]]
-ExcInfoTuple = Tuple[type, BaseException, TracebackType]
-HeadersList = List[Tuple[str, str]]
+HeaderList = list[tuple[str, str]]
+HeadersList = HeaderList
+WSGIEnviron = dict[str, Any]
+StartResponse = Callable[[str, HeaderList], None]
+WSGICallable = Callable[
+    [
+        WSGIEnviron,
+        StartResponse,
+    ],
+    Iterable[bytes]
+]
+ExcInfoTuple = tuple[type, BaseException, TracebackType]

fresco/util/wsgi.py

@@ -27,7 +27,7 @@ from typing import Tuple
 import sys
 
 from fresco.typing import ExcInfoTuple
-from fresco.typing import HeadersList
+from fresco.typing import HeaderList
 from fresco.typing import WSGICallable
 
 logger = logging.getLogger(__name__)
@@ -407,16 +407,16 @@ def make_environ(url="/", environ=None, wsgi_input=b"", **kwargs):
 
 def apply_request(
     request, wsgicallable: WSGICallable
-) -> Tuple[str, HeadersList, Optional[ExcInfoTuple], List[bytes]]:
+) -> Tuple[str, HeaderList, Optional[ExcInfoTuple], List[bytes]]:
     """
     Execute ``wsgicallable`` with the given request, exhaust and close the
     content iterator and return the result.
     """
 
-    _start_response_result: List[Tuple[str, HeadersList, Optional[ExcInfoTuple]]] = []
+    _start_response_result: List[Tuple[str, HeaderList, Optional[ExcInfoTuple]]] = []
 
     def start_response(
-        status: str, headers: HeadersList, exc_info: Optional[ExcInfoTuple] = None
+        status: str, headers: HeaderList, exc_info: Optional[ExcInfoTuple] = None
     ):
         _start_response_result.append((status, headers, exc_info))
 

{fresco-3.3.4.dist-info → fresco-3.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: fresco
-Version: 3.3.4
+Version: 3.5.0
 Summary: A Web/WSGI micro-framework
 Author-email: Oliver Cope <oliver@redgecko.org>
 License: Apache

{fresco-3.3.4.dist-info → fresco-3.5.0.dist-info}/RECORD

@@ -1,20 +1,21 @@
-fresco/__init__.py,sha256=DkBKfTdD88kXZYGi5Pv686Es1twTgZ4fVO3mA2nf0GQ,3520
+fresco/__init__.py,sha256=qd3y9P7W77xtuDx9WtYQt7wIHeRNUobog6zq8W4J-zg,3520
 fresco/cookie.py,sha256=Qnx8yOjU4LUJ1fqi7YvqbhAA01rCsclJGl_fxI68slw,7055
-fresco/core.py,sha256=mwYR6UP0zRSjcFlNZf51-otX9EcmvgjEZ7GDVQoQexg,26615
+fresco/core.py,sha256=kBf_JY8wqvBSQzxP0pFUr0sOnvUoDltittL-5xDUlC8,26611
 fresco/decorators.py,sha256=84NUpRJ-M7GK6wDl42bmCRSvgoWzCsy1huyvGnSAPPw,3232
 fresco/exceptions.py,sha256=KE-LoYUGnho6KltzkU6cnm9vUiUhAiDIjPqn5ba-YCA,4410
-fresco/middleware.py,sha256=uCAuOtBnvaVBJGrQa8ecvLkSZ6aSKmWaJqxB8Rv4SsQ,4173
+fresco/middleware.py,sha256=XMpakA1YMZJqwHQyyxgw6TFhecDRTrUSSeNLDEkY8qA,4808
 fresco/multidict.py,sha256=0CaNNIcFnZ1hLk3NExhNvjc_BtK4zVB26L9gP_7MeNM,13362
-fresco/options.py,sha256=0RzwO1eyCUC70GxKFnCHNKDyZwsKc9Q-AmtlMAnfZ-Q,14004
+fresco/options.py,sha256=gzFzTv6vib16WazRxT1s2xD91f8IRfCGKijx3BbE1gU,15163
+fresco/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fresco/request.py,sha256=dC7pMg-4Kxa6PcqaaWFL4JviANQotuBjoKwlxZYywRY,27048
 fresco/requestcontext.py,sha256=P-SkKJkKLYVqNiR2zwooRROnSnE2VMj2P2-eD5DW5Qg,3504
 fresco/response.py,sha256=ADKHbtAGyhwtaUJxB7m_1nqVdZRKUryebmG4FDUjZVY,37072
 fresco/routeargs.py,sha256=dxNlqbQ1FrgIY6OCFzcEMdZ0OVyjlMQdQGLmUJgdPYU,10176
-fresco/routing.py,sha256=kTFqJ9Nn9cOHlul-lHqKDurBwqlEO4fg8tertb1jkoI,58709
+fresco/routing.py,sha256=BfUaC9xD9BL_RqRPMIkMNOdLbhbSgzWSJWooktRoeqc,60515
 fresco/static.py,sha256=9SKQ3P1YFTP45Qiic-ycvkpKRvqIURp1XSzPazTmYLI,2513
-fresco/subrequests.py,sha256=wFJWLuhVAcei5imYc5NBSCBaHBEm-X4_XswPtK3O4Zw,11081
+fresco/subrequests.py,sha256=zQlKJRZJVbfkxc0cQp3qoBFZH9pPFq77DgnYAJJvgAI,11052
 fresco/types.py,sha256=UHITRMDoS90s2zV2wNpqLFhRWESfaBAMuQnL4c21mqY,106
-fresco/typing.py,sha256=jQ1r_wme54J08XZUdmuuW4M8ve-gEhm1Wriwctls3r8,347
+fresco/typing.py,sha256=uQWLElgVCJSZ3X2OkGNu-1ihmPvytyqSLguPB6tm-Pc,412
 fresco/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fresco/tests/fixtures.py,sha256=eyo2zPivB3fItDkrJqWnOCvIS_A1q1JEhT4AutAB--o,1871
 fresco/tests/test_cookie.py,sha256=HTLmNCjcPoZDeFnZAzY3lJPeduzgU4mi9C-74eSQCec,2171
@@ -23,12 +24,12 @@ fresco/tests/test_decorators.py,sha256=VFXHo1gm2jldQXeaEF3NNo5fnpdJ-LXc8-vNymPJK
 fresco/tests/test_exceptions.py,sha256=R0Tn86m33iTKecZ69TgH4CqY9XSFP0FsLMH10O5Jth8,973
 fresco/tests/test_middleware.py,sha256=D_sWfX-w3bhItOm54nB_cuYPGoWopISvZCFIuMX68cU,3137
 fresco/tests/test_multidict.py,sha256=uDwDYII0dvVxaEyDO85zRTWlIWw3LO3StzYemJVm0E0,7565
-fresco/tests/test_options.py,sha256=Zx1tLVLeok8tO3dWua2PyTPZgeWbXFMXtN3FnorBmC8,10998
+fresco/tests/test_options.py,sha256=zKJveuxTz4HL9NeQYwe8qaki8WQw65ghhW3cLnXfaVI,11659
 fresco/tests/test_request.py,sha256=hoANrergrohlAeTbQufDMfIbvYURsPyPjCxOVKz7bVo,16389
 fresco/tests/test_requestcontext.py,sha256=t8hm-lzIk85ryb3sdlpVoPQyLDWpCjB86dg8nVG1yRw,3115
 fresco/tests/test_response.py,sha256=MrhHIDg81pJlTeEcn2rGtU-i59s1KzEccF81u4Up6xs,8934
 fresco/tests/test_routeargs.py,sha256=VMWUbrXegTLN9Tx2AcrpbjAAEaxAANzkcy02SmpFOmY,8162
-fresco/tests/test_routing.py,sha256=yfZGon6vKwszFp3pCP2Mtnf3W3u4WdELdvVcgIKHOVU,37890
+fresco/tests/test_routing.py,sha256=DkHP518f6UVAuG2pNVAyoyEcc2ej8T-Kw-moqkMB9gI,39851
 fresco/tests/test_static.py,sha256=y73dqzE2flpACQ_dvNhDzk_WlvNQfkhYF_8YY4MMGDo,4686
 fresco/tests/test_subrequests.py,sha256=7rluJnw-elXRXfrzvAQvGBHRBU93zwnL827mTxBGd3Y,7909
 fresco/tests/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -49,9 +50,9 @@ fresco/util/object.py,sha256=FjYNfPHzvBqq1rn0Y6As-2AVZ_SZOjH-lrSy4EbYmHY,370
 fresco/util/security.py,sha256=nXEdoCak_2c4OA1L1wGwhZygS22s2fzwR0Kp-DdwKZg,1058
 fresco/util/textproc.py,sha256=e5jLTofKCqdm6_Fy8XOyR43AJr5APtL59Kd8cNA9PrQ,2309
 fresco/util/urls.py,sha256=aaVovLyXNlVoGviiLN94ImqXf-LTQs_xooEIyi3LBc4,9195
-fresco/util/wsgi.py,sha256=2cr2b92RpvPSgS_P46X2mlYepoFg9Qji-V-fzxpSNzw,12971
-fresco-3.3.4.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fresco-3.3.4.dist-info/METADATA,sha256=v9NcXIhYp5MqENOecCV7XIsFrg7sC9GdRmIHuS912HI,1549
-fresco-3.3.4.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-fresco-3.3.4.dist-info/top_level.txt,sha256=p_1aMce5Shjq9fIfdbB-aN8wCDhjF_iYnn98bUebbII,7
-fresco-3.3.4.dist-info/RECORD,,
+fresco/util/wsgi.py,sha256=gllmrw9um9ecs_sFxXy-Uwh7M9YAdcBNw33S63AhB8E,12967
+fresco-3.5.0.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fresco-3.5.0.dist-info/METADATA,sha256=mL1SE-OBfPOlYjc7YBSbt6ftilgaol-pUNAYqt3k0A0,1549
+fresco-3.5.0.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+fresco-3.5.0.dist-info/top_level.txt,sha256=p_1aMce5Shjq9fIfdbB-aN8wCDhjF_iYnn98bUebbII,7
+fresco-3.5.0.dist-info/RECORD,,

{fresco-3.3.4.dist-info → fresco-3.5.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (75.8.1)
 Root-Is-Purelib: true
 Tag: py3-none-any