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

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,24 @@ 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"}
@@ -143,7 +162,6 @@ class TestLoadKeyValuePairs:
 
 
 class TestLoadOptions:
-
     def check_loadoptions(self, tmpdir, files, sources="*", tags=[], expected={}):
         """
         Write the files indicated in ``sources`` to the given temporary directory,
@@ -192,6 +210,11 @@ class TestLoadOptions:
     def test_it_loads_py_files(self, tmpdir):
         self.check_loadoptions(tmpdir, {"a.py": "x = 2 * 2"}, expected={"x": 4})
 
+    def test_py_files_have_options_in_namespace(self, tmpdir):
+        self.check_loadoptions(
+            tmpdir, {"a.py": "options['foo'] = 'bar'"}, expected={"foo": "bar"}
+        )
+
     def test_it_selects_by_tag(self, tmpdir):
         with self.check_loadoptions(
             tmpdir,
@@ -217,14 +240,38 @@ class TestLoadOptions:
         with self.check_loadoptions(
             tmpdir,
             {
-                "a": "a = 0",
-                "a.dev.txt": "a = ${a}-1",
-                "a.local.txt": "a = ${a}-2",
-                "b.dev.txt": "a = ${a}-3",
+                "a": "a = 'a'",
+                "a.0-dev.txt": "a = ${a} a.dev",
+                "a.local.txt": "a = ${a} a.local",
+                "b.dev.txt": "a = ${a} b.dev",
+            },
+        ) as loadopts:
+            assert loadopts("*", ["dev", "local"]) == {"a": "a a.dev b.dev a.local"}
+            assert loadopts("*", ["local", "dev"]) == {"a": "a a.local a.dev b.dev"}
+
+    def test_it_loads_in_priority_order(self, tmpdir):
+        with self.check_loadoptions(
+            tmpdir,
+            {
+                "a": "a = 'a'",
+                "a.100-dev.txt": "a = ${a} a.100-dev",
+                "a.local.txt": "a = ${a} a.local",
+                "b.dev.txt": "a = ${a} b.dev",
             },
         ) as loadopts:
-            assert loadopts("*", ["dev", "local"]) == {"a": "0-1-3-2"}
-            assert loadopts("*", ["local", "dev"]) == {"a": "0-2-1-3"}
+            assert loadopts("*", ["dev", "local"]) == {"a": "a b.dev a.local a.100-dev"}
+            assert loadopts("*", ["local", "dev"]) == {"a": "a a.local b.dev a.100-dev"}
+
+    def test_it_loads_in_priority_order_without_tags(self, tmpdir):
+        with self.check_loadoptions(
+            tmpdir,
+            {
+                "a": "a = a",
+                "b.100": "a = ${a} b",
+                "a.200.txt": "a = ${a} 100",
+            },
+        ) as loadopts:
+            assert loadopts("*") == {"a": "a b 100"}
 
     def test_it_loads_from_os_environ(self, tmpdir):
         with setenv(a="2"):
@@ -252,7 +299,7 @@ class TestLoadOptions:
             tmpdir,
             {"a.txt": "a=1", "b.txt": "b=1"},
             sources=["a.*", "b.*"],
-            expected={"a": 1, "b": 1}
+            expected={"a": 1, "b": 1},
         )
 
     def test_it_substitutes_from_environment_variables(self, tmpdir):
@@ -261,7 +308,7 @@ class TestLoadOptions:
                 tmpdir,
                 {"a.txt": "a=1", "a.bar.txt": "a=2"},
                 tags=["{FOO}"],
-                expected={"a": 2}
+                expected={"a": 2},
             )
 
         with setenv(FOO="baz"):
@@ -269,7 +316,7 @@ class TestLoadOptions:
                 tmpdir,
                 {"a.txt": "a=1", "a.bar.txt": "a=2"},
                 tags=["{FOO}"],
-                expected={"a": 1}
+                expected={"a": 1},
             )
 
     def test_it_allows_missing_environment_variables(self, tmpdir):
@@ -278,19 +325,16 @@ class TestLoadOptions:
             tmpdir,
             {"a.txt": "a=1", "a.bar.txt": "a=2"},
             tags=["{FOO}"],
-            expected={"a": 1}
+            expected={"a": 1},
         )
 
 
 class TestDictFromOptions:
-
     def test_it_splits_on_prefix(self):
-
         options = Options(FOO_BAR=1, FOO_BAZ=2, FOO_BAR_BAZ=3, BAR=4)
         assert dict_from_options("FOO_", options) == {"BAR": 1, "BAZ": 2, "BAR_BAZ": 3}
 
     def test_it_splits_recursively(self):
-
         options = Options(
             A_A=1,
             A_B_C_D=2,
@@ -303,7 +347,7 @@ class TestDictFromOptions:
             "A": 1,
             "B": {"C": {"D": 2}, "E": 3},
             "F": {"G": {"H": 4}},
-            "I": 5
+            "I": 5,
         }
 
 

fresco/tests/test_request.py

@@ -99,7 +99,7 @@ class TestRequestProperties(object):
             CONTENT_LENGTH="2",
             CONTENT_TYPE="text/plain; charset=UTF-8",
         ) as c:
-            c.request.body_bytes == b"\xc3a"
+            assert c.request.body_bytes == b"\xc3a"
 
     def test_get_json_decodes_json(self):
         with context(
@@ -107,7 +107,7 @@ class TestRequestProperties(object):
             CONTENT_LENGTH="14",
             CONTENT_TYPE="application/json",
         ) as c:
-            c.request.get_json() == {"foo": "bar"}
+            assert c.request.get_json() == {"foo": "bar"}
 
     def test_get_json_ignores_mime_type(self):
         with context(
@@ -115,7 +115,7 @@ class TestRequestProperties(object):
             CONTENT_LENGTH="14",
             CONTENT_TYPE="application/broken",
         ) as c:
-            c.request.get_json() == {"foo": "bar"}
+            assert c.request.get_json() == {"foo": "bar"}
 
     def test_get_json_passes_args_to_decoder(self):
         with context(
@@ -123,19 +123,30 @@ class TestRequestProperties(object):
             CONTENT_LENGTH="10",
             CONTENT_TYPE="application/broken",
         ) as c:
-            c.request.get_json(parse_int=lambda s: s + "!") == {"foo": "1!"}
+            assert c.request.get_json(parse_int=lambda s: s + "!") == {"foo": "1!"}
 
-    def test_get_does_type_conversion(self):
+    def test_get_required_raises_badrequest(self):
         with context(
             QUERY_STRING="x=10",
             CONTENT_LENGTH="10",
             CONTENT_TYPE="application/broken",
         ) as c:
-            assert c.request.get("x") == "10"
-            assert c.request.get("x", type=int) == 10
+            req = c.request
+            assert req.get("x", required=True) == "10"
             with pytest.raises(exceptions.BadRequest):
-                c.request.get("y", type=int)
-            assert c.request.get("y", None, type=int) is None
+                req.get("y", required=True)
+
+    def test_get_does_type_conversion(self):
+        with context(
+            QUERY_STRING="x=10",
+            CONTENT_LENGTH="10",
+            CONTENT_TYPE="application/broken",
+        ) as c:
+            req = c.request
+            assert req.get("x") == "10"
+            assert req.get("x", type=int) == 10
+            assert req.get("y", type=int) is None
+            assert req.get("y", "20", type=int) == "20"
 
     def test_is_secure_returns_correct_value(self):
         with context("https://example.org/") as c:
@@ -150,7 +161,7 @@ class TestRequestProperties(object):
     def test_getint_raises_badrequest(self):
         with pytest.raises(exceptions.BadRequest):
             with context("http://example.org/") as c:
-                c.request.getint("a")
+                c.request.getint("a", required=True)
 
         with pytest.raises(exceptions.BadRequest):
             with context("http://example.org/?a=four") as c:

fresco/tests/test_response.py

@@ -87,6 +87,12 @@ class TestCannedResponses(object):
             r = Response.redirect("http://bad.example.com/", "gloop", barfle=23)
         assert r.get_header("Location") == "http://localhost/arfle/23"
 
+    def test_redirect_uses_fallback_for_empty_url(self):
+        app = FrescoApp()
+        with app.requestcontext():
+            r = Response.redirect("", "http://localhost/foo")
+        assert r.get_header("Location") == "http://localhost/foo"
+
     def test_not_found(self):
         with FrescoApp().requestcontext():
             r = Response.not_found()
@@ -130,6 +136,16 @@ class TestCannedResponses(object):
         assert r.status == "200 OK"
         assert r.get_header("Content-Type") == "text/html"
 
+    def test_meta_refresh_to_view(self):
+
+        app = FrescoApp()
+        view = Mock(return_value=Response())
+        app.route("/arfle/<barfle:int>", GET, view)
+        with app.requestcontext():
+            r = Response.meta_refresh(view, barfle=42)
+        content = b"".join(r.content_iterator)
+        assert b'url=http://localhost/arfle/42"' in content
+
     def test_json(self):
         with FrescoApp().requestcontext():
             r = Response.json(

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,
@@ -43,6 +47,10 @@ from fresco.routing import (
 from . import fixtures
 
 
+def dummyview() -> Response:
+    return Response()
+
+
 def assert_method_bound_to(method, ob):
     try:
         assert method.__self__ is ob
@@ -114,6 +122,31 @@ 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
+
+    def test_multiple_methods_can_be_expressed_using_kwargs(self):
+        def view():
+            return Response()
+
+        app = FrescoApp()
+        app.route("/x", GET_POST=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))) == 0
+
 
 class TestRouteBeforeHooks(object):
     def test_hook_is_called(self):
@@ -330,36 +363,36 @@ 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, dummyview, name="1")
+        r2 = Route("/2", POST, dummyview, 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, dummyview, name="1")
+        r2 = Route("/", POST, dummyview, name="2")
+        r3 = Route("/", POST, dummyview, name="3")
         rc = RouteCollection([r1, RouteCollection([r2, r3])])
         assert [r.name for r in rc] == ["1", "2", "3"]
 
     def test_it_adds_dunderroutes_from_constructor(self):
-        r1 = Route("/", GET, None, name="1")
-        r2 = Route("/", POST, None, name="2")
-        r3 = Route("/", POST, None, name="3")
+        r1 = Route("/", GET, dummyview, name="1")
+        r2 = Route("/", POST, dummyview, name="2")
+        r3 = Route("/", POST, dummyview, name="3")
 
         class A:
             __routes__ = [r2, r3]
@@ -368,8 +401,8 @@ class TestRouteCollection(object):
         assert [r.name for r in rc] == ["1", "2", "3"]
 
     def test_get_routes_matches_on_method(self):
-        r_get = Route("/", GET, None)
-        r_post = Route("/", POST, None)
+        r_get = Route("/", GET, dummyview)
+        r_post = Route("/", POST, dummyview)
 
         rc = RouteCollection([r_post, r_get])
 
@@ -377,8 +410,8 @@ class TestRouteCollection(object):
         assert [r.route for r in rc.get_route_traversals("/", POST)] == [r_post]
 
     def test_get_routes_matches_on_path(self):
-        r1 = Route("/1", GET, None)
-        r2 = Route("/2", GET, None)
+        r1 = Route("/1", GET, dummyview)
+        r2 = Route("/2", GET, dummyview)
 
         rc = RouteCollection([r1, r2])
 
@@ -386,8 +419,8 @@ class TestRouteCollection(object):
         assert [r.route for r in rc.get_route_traversals("/2", GET)] == [r2]
 
     def test_get_routes_can_match_all_methods(self):
-        r1 = Route("/1", GET, None)
-        r2 = Route("/1", POST, None)
+        r1 = Route("/1", GET, dummyview)
+        r2 = Route("/1", POST, dummyview)
 
         rc = RouteCollection([r1, r2])
         assert [r.route for r in rc.get_route_traversals("/1", None)] == [
@@ -399,8 +432,8 @@ class TestRouteCollection(object):
         a = RouteCollection()
         b = RouteCollection()
 
-        a_route = Route("/harvey", GET, lambda: None)
-        b_route = Route("/harvey", GET, lambda: None)
+        a_route = Route("/harvey", GET, dummyview)
+        b_route = Route("/harvey", GET, dummyview)
 
         a.add_route(a_route)
         b.add_route(b_route)
@@ -411,7 +444,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, (), {}, (), {}),
@@ -508,7 +541,9 @@ class TestRouteCollection(object):
         ]
 
     def test_add_prefix_returns_prefixed_collection(self):
-        rc = RouteCollection([Route("/fish", GET, None), Route("/beans", GET, None)])
+        rc = RouteCollection(
+            [Route("/fish", GET, dummyview), Route("/beans", GET, dummyview)]
+        )
         prefixed = rc.add_prefix("/jelly")
         assert [str(r.pattern) for r in prefixed] == [
             "/jelly/fish",
@@ -611,15 +646,14 @@ class TestRouteCollection(object):
         assert list(response.content_iterator) == [b"ok"]
 
     def test_it_isolates_request_for_wsgi_app(self):
-
         params: t.Dict[str, t.Any] = {}
         outerapp = FrescoApp()
         innerapp = FrescoApp()
         innerapp.route("/y", GET=Response)
         outerapp.route_wsgi("/x", innerapp)
 
-        innerapp.process_request(partial(params.__setitem__, 'inner_request'))
-        outerapp.process_request(partial(params.__setitem__, 'outer_request'))
+        innerapp.process_request(partial(params.__setitem__, "inner_request"))
+        outerapp.process_request(partial(params.__setitem__, "outer_request"))
 
         with outerapp.requestcontext("/x/y"):
             outerapp.view()
@@ -894,25 +928,25 @@ class TestRRoute:
 
 class TestViewArgs(object):
     def test_it_uses_args(self):
-        routes = RouteCollection([Route("/", GET, None, args=(1, 2))])
+        routes = RouteCollection([Route("/", GET, dummyview, args=(1, 2))])
         assert list(routes.get_route_traversals("/", GET)) == [
             tms.InstanceOf(RouteTraversal, args=(1, 2))
         ]
 
     def test_it_uses_view_args(self):
-        routes = RouteCollection([Route("/", GET, None, view_args=(1, 2))])
+        routes = RouteCollection([Route("/", GET, dummyview, view_args=(1, 2))])
         assert list(routes.get_route_traversals("/", GET)) == [
             tms.InstanceOf(RouteTraversal, args=(1, 2))
         ]
 
     def test_it_appends_args_extracted_from_path(self):
-        routes = RouteCollection([Route("/<:int>", GET, None, view_args=(1, 2))])
+        routes = RouteCollection([Route("/<:int>", GET, dummyview, view_args=(1, 2))])
         assert list(routes.get_route_traversals("/3", GET)) == [
             tms.InstanceOf(RouteTraversal, args=(1, 2, 3))
         ]
 
     def test_it_keeps_traversal_args_separate(self):
-        routes = RouteCollection([Route("/<:int>", GET, None, view_args=(1,))])
+        routes = RouteCollection([Route("/<:int>", GET, dummyview, view_args=(1,))])
         assert list(routes.get_route_traversals("/2", GET)) == [
             tms.InstanceOf(
                 RouteTraversal,
@@ -928,25 +962,27 @@ class TestViewArgs(object):
 
 class TestViewKwargs(object):
     def test_it_reads_from_route_kwargs(self):
-        routes = RouteCollection([Route("/", GET, None, x=1)])
+        routes = RouteCollection([Route("/", GET, dummyview, x=1)])
         assert list(routes.get_route_traversals("/", GET)) == [
             tms.InstanceOf(RouteTraversal, kwargs={"x": 1})
         ]
 
     def test_it_reads_from_kwargs(self):
-        routes = RouteCollection([Route("/", GET, None, kwargs={"x": 1})])
+        routes = RouteCollection([Route("/", GET, dummyview, kwargs={"x": 1})])
         assert list(routes.get_route_traversals("/", GET)) == [
             tms.InstanceOf(RouteTraversal, kwargs={"x": 1})
         ]
 
     def test_it_reads_from_view_kwargs(self):
-        routes = RouteCollection([Route("/", GET, None, view_kwargs={"x": 1})])
+        routes = RouteCollection([Route("/", GET, dummyview, view_kwargs={"x": 1})])
         assert list(routes.get_route_traversals("/", GET)) == [
             tms.InstanceOf(RouteTraversal, kwargs={"x": 1})
         ]
 
     def test_it_keeps_traversal_kwargs_separate(self):
-        routes = RouteCollection([Route("/<x:int>", GET, None, view_kwargs={"y": 1})])
+        routes = RouteCollection(
+            [Route("/<x:int>", GET, dummyview, view_kwargs={"y": 1})]
+        )
         assert list(routes.get_route_traversals("/2", GET)) == [
             tms.InstanceOf(
                 RouteTraversal,
@@ -1113,7 +1149,6 @@ class TestRouteCache(object):
 
 
 class TestRouteAll:
-
     def test_route_all_matches_on_separator(self):
         def view():
             return Response()
@@ -1124,3 +1159,48 @@ 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 TestRequestParameter:
+    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/tests/util/test_http.py

@@ -42,7 +42,7 @@ class TestParseQueryString(object):
         return list(parse_querystring(value))
 
     def test_empty(self):
-        self.p("") == []
+        assert self.p("") == []
 
     def test_simple_key_value(self):
         assert self.p("a=b") == [("a", "b")]
@@ -276,12 +276,10 @@ class TestParseFormEncodedData(object):
 class TestEncodeMultipart(object):
     def test_it_encodes_a_data_dict(self):
         data, headers = encode_multipart([("foo", "bar baf")])
-        data = data.getvalue()
         assert b'Content-Disposition: form-data; name="foo"\r\n\r\nbar baf' in data
 
     def test_it_encodes_a_file_tuple(self):
         data, headers = encode_multipart(files=[("foo", "foo.txt", "ascii", "bar")])
-        data = data.getvalue()
         expected = (
             b"Content-Disposition: form-data; "
             b'name="foo"; filename="foo.txt"\r\n'

fresco/tests/util/test_urls.py

@@ -15,6 +15,7 @@
 from fresco.core import FrescoApp
 from fresco.util.urls import normpath, make_query
 from fresco.util.urls import is_safe_url
+from fresco.util.urls import add_query
 
 # Greek letters as unicode strings (require multi-byte representation in UTF-8)
 alpha = b"\xce\xb1".decode("utf8")
@@ -174,3 +175,22 @@ class TestSafeURL(object):
         ]
         for u in unsafe:
             assert is_safe_url(u, allowed_hosts={"good.example.org"}) is False
+
+
+class TestAddQuery:
+
+    def test_it_adds_query(self):
+        url = add_query("http://localhost", {"foo": "bar"})
+        assert url == "http://localhost?foo=bar"
+
+    def test_it_adds_query_from_list(self):
+        url = add_query("http://localhost", [("foo", "bar")])
+        assert url == "http://localhost?foo=bar"
+
+    def test_it_adds_query_from_keywords(self):
+        url = add_query("http://localhost", foo="bar")
+        assert url == "http://localhost?foo=bar"
+
+    def test_it_appends_query(self):
+        url = add_query("http://localhost?foo=bar", {"foo": "baz"})
+        assert url == "http://localhost?foo=bar&foo=baz"

fresco/types.py

@@ -1,6 +1,32 @@
+from collections.abc import Mapping
+from collections.abc import Iterable
+from collections.abc import Callable
+from types import TracebackType
+from typing import Any
+from typing import Optional
 import typing as t
 
+import fresco.response # noqa
+
+
 QuerySpec = t.Union[
-    t.Mapping[str, t.Any],
-    t.Iterable[t.Tuple[str, t.Any]]
+    Mapping[str, Any],
+    Iterable[tuple[str, Any]]
+]
+ViewCallable = Callable[..., "fresco.response.Response"]
+ExcInfo = tuple[type[BaseException], BaseException, TracebackType]
+OptionalExcInfo = Optional[ExcInfo]
+
+
+HeaderList = list[tuple[str, str]]
+HeadersList = HeaderList
+WSGIEnviron = dict[str, Any]
+WriteCallable = Callable[[bytes], object]
+StartResponse = Callable[[str, HeaderList, OptionalExcInfo], WriteCallable]
+WSGIApplication = Callable[
+    [
+        WSGIEnviron,
+        StartResponse,
+    ],
+    Iterable[bytes]
 ]

fresco/util/cache.py

@@ -1,4 +1,5 @@
 from typing import Any
+from typing import Callable
 from typing import Dict
 from typing import List
 import sys
@@ -46,7 +47,7 @@ def cache_generator(original_function, maxsize):
             link[NEXT] = root
 
 
-def make_cache(original_function, maxsize=100):
+def make_cache(original_function, maxsize=100) -> Callable[[Any], Any]:
     "Create a cache around a function that takes a single argument"
     c = cache_generator(original_function, maxsize)
     next(c)