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

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_routing.py

@@ -47,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
@@ -363,22 +367,22 @@ class TestRouteNames(object):
 
 class TestRouteCollection(object):
     def test_it_adds_routes_from_constructor(self):
-        r1 = Route("/1", GET, lambda: None, name="1")
-        r2 = Route("/2", POST, lambda: 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, lambda: None, name="1")
-        r2 = Route("/", POST, lambda: None, name="2")
-        r3 = Route("/", POST, lambda: 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]
@@ -387,8 +391,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])
 
@@ -396,8 +400,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])
 
@@ -405,8 +409,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)] == [
@@ -418,8 +422,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)
@@ -527,7 +531,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",
@@ -630,15 +636,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()
@@ -913,25 +918,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,
@@ -947,25 +952,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,
@@ -1132,7 +1139,6 @@ class TestRouteCache(object):
 
 
 class TestRouteAll:
-
     def test_route_all_matches_on_separator(self):
         def view():
             return Response()
@@ -1145,10 +1151,8 @@ class TestRouteAll:
         assert len(list(app.get_route_traversals("/xy", GET))) == 0
 
 
-class TestRequestParamter:
-
+class TestRequestParameter:
     def test_has_request_parameter(self):
-
         def a(request: Request):
             pass
 
@@ -1175,7 +1179,6 @@ class TestRequestParamter:
         assert _has_request_parameter(f) is False
 
     def test_request_is_provided_automatically(self):
-
         def a(request: Request):
             return Response("a")
 

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/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)

fresco/util/http.py

@@ -20,6 +20,8 @@ Utilities for working with data on the HTTP level
 from binascii import hexlify
 from collections import namedtuple
 from collections import deque
+from collections.abc import Collection
+from collections.abc import Mapping
 from email.header import Header
 from email.message import Message
 from email.parser import BytesFeedParser
@@ -43,6 +45,7 @@ from urllib.parse import unquote_plus
 from shutil import copyfileobj
 
 import fresco
+from fresco.defaults import DEFAULT_CHARSET
 from fresco.exceptions import RequestParseError
 from fresco.util.io import io_iterator
 from fresco.util.io import ByteIterator
@@ -90,23 +93,23 @@ def get_content_type_info(
 
 
 class TooBig(RequestParseError):
-    """\
+    """
     Request body is too big
     """
 
     def __init__(self, *args, **kwargs):
         super(TooBig, self).__init__(*args, **kwargs)
-        self.response = fresco.response.Response.payload_too_large()
+        self.response = fresco.Response.payload_too_large()
 
 
 class MissingContentLength(RequestParseError):
-    """\
+    """
     No ``Content-Length`` header given
     """
 
     def __init__(self, *args, **kwargs):
         super(MissingContentLength, self).__init__(*args, **kwargs)
-        self.response = fresco.response.Response.length_required()
+        self.response = fresco.Response.length_required()
 
 
 def parse_parameters(s, preserve_backslashes=False) -> Dict[str, str]:
@@ -212,7 +215,7 @@ def parse_querystring(
 
     :param data: The query string to parse.
     :param charset: Character encoding used to decode values. If not specified,
-                    ``fresco.DEFAULT_CHARSET`` will be used.
+                    ``fresco.defaults.DEFAULT_CHARSET`` will be used.
 
     :param keep_blank_values: if True, keys without associated values will be
                               returned as empty strings. if False, no key,
@@ -223,7 +226,7 @@ def parse_querystring(
     """
 
     if charset is None:
-        charset = fresco.DEFAULT_CHARSET
+        charset = DEFAULT_CHARSET
 
     result: List[Tuple[str, str]] = []
     append = result.append
@@ -275,7 +278,7 @@ def parse_post(
     ct, charset, ct_params = get_content_type_info(
         environ,
         "application/x-www-form-urlencoded",
-        default_charset or fresco.DEFAULT_CHARSET,
+        default_charset or DEFAULT_CHARSET,
     )
 
     try:
@@ -454,14 +457,15 @@ def parse_multipart(
             f.close()
         raise
 
-    close: Optional[Callable]
+    close: Optional[Callable]  # type: ignore
     if open_files:
 
         def close():
             for f in open_files:
                 f.close()
+
     else:
-        close = None
+        close = None  # type: ignore
 
     return fields, close
 
@@ -554,7 +558,6 @@ def read_until(
                     return
 
     def remainder():
-        nonlocal buf
         if buf:
             yield buf
         yield from stream
@@ -591,7 +594,21 @@ class FileUpload(object):
         copyfileobj(self.file, fileob)
 
 
-def encode_multipart(data=None, files=None, charset="UTF-8", **kwargs):
+def encode_multipart(
+    data: Optional[
+        Union[
+            Mapping[str, str],
+            Collection[tuple[str, str]],
+        ]
+    ] = None,
+    files: Optional[
+        Collection[
+            tuple[str, str, str, Union[bytes, t.Iterable[bytes], t.BinaryIO]]
+        ]
+    ] = None,
+    charset="UTF-8",
+    **kwargs
+) -> tuple[bytes, dict[str, str]]:
     """
     Encode ``data`` using multipart/form-data encoding, returning a tuple
     of ``(<encoded data>, <environ items>)``.
@@ -602,7 +619,7 @@ def encode_multipart(data=None, files=None, charset="UTF-8", **kwargs):
     :param charset: Encoding used for any string values encountered in
                     ``data``
 
-    :param files: list of ``(name, filename, content_type, data)`` tuples.
+    :param files: collection of ``(name, filename, content_type, data)`` tuples.
                     ``data`` may be either a byte string, iterator or
                     file-like object.
 
@@ -614,45 +631,22 @@ def encode_multipart(data=None, files=None, charset="UTF-8", **kwargs):
               dict.
     """
 
-    def header_block(name):
-        return [("Content-Disposition", 'form-data; name="%s"' % (name,))]
-
-    def file_header_block(name, filename, content_type):
-        return [
-            (
-                "Content-Disposition",
-                'form-data; name="%s"; filename="%s"' % (name, filename),
-            ),
-            ("Content-Type", content_type),
-        ]
-
-    def write_payload(stream, data):
-        "Write ``data`` to ``stream``, encoding as required"
-        if hasattr(data, "read"):
-            copyfileobj(data, stream)
-        elif isinstance(data, bytes):
-            stream.write(data)
-        elif isinstance(data, str):
-            stream.write(data.encode(charset))
-        else:
-            raise ValueError(data)
-
-    if data is None:
-        data = {}
-
     if files is None:
         files = []
 
-    try:
-        data = data.items()
-    except AttributeError:
-        pass
+    data_items: Iterable[tuple[str, str]]
+    if data is None:
+        data_items = []
+    elif isinstance(data, Mapping):
+        data_items = iter(data.items())  # type: ignore
+    else:
+        data_items = data
 
-    data = chain(data, kwargs.items())
+    data_items = chain(data_items, kwargs.items())
 
     boundary = b"-------" + hexlify(os.urandom(16))
     alldata = chain(
-        ((header_block(k), payload) for k, payload in data),
+        ((header_block(k), payload) for k, payload in data_items),
         ((file_header_block(k, fn, ct), payload) for k, fn, ct, payload in files),
     )
 
@@ -664,7 +658,7 @@ def encode_multipart(data=None, files=None, charset="UTF-8", **kwargs):
         for name, value in headers:
             post_data.write("{0}: {1}\r\n".format(name, value).encode("ascii"))
         post_data.write(CRLF)
-        write_payload(post_data, payload)
+        write_payload(post_data, payload, charset)
         post_data.write(b"\r\n--" + boundary)
     post_data.write(b"--\r\n")
     length = post_data.tell()
@@ -676,4 +670,30 @@ def encode_multipart(data=None, files=None, charset="UTF-8", **kwargs):
         ),
     }
 
-    return (post_data, wsgienv)
+    return (post_data.getvalue(), wsgienv)
+
+
+def header_block(name):
+    return [("Content-Disposition", 'form-data; name="%s"' % (name,))]
+
+
+def file_header_block(name, filename, content_type):
+    return [
+        (
+            "Content-Disposition",
+            'form-data; name="%s"; filename="%s"' % (name, filename),
+        ),
+        ("Content-Type", content_type),
+    ]
+
+
+def write_payload(stream, data, charset):
+    "Write ``data`` to ``stream``, encoding as required"
+    if hasattr(data, "read"):
+        copyfileobj(data, stream)
+    elif isinstance(data, bytes):
+        stream.write(data)
+    elif isinstance(data, str):
+        stream.write(data.encode(charset))
+    else:
+        raise ValueError(data)

fresco/util/urls.py

@@ -27,7 +27,7 @@ import posixpath
 import re
 import typing as t
 
-import fresco
+from fresco.defaults import DEFAULT_CHARSET
 from fresco.multidict import MultiDict
 from fresco.types import QuerySpec
 
@@ -174,13 +174,13 @@ def make_query(
     data: QuerySpec = [],
     separator: str = "&",
     charset: t.Optional[str] = None,
-    **kwargs,
+    **kwargs: t.Any,
 ) -> str:
     """
     Return a query string formed from the given dictionary data.
 
     If no encoding is given, unicode values are encoded using the character set
-    specified by ``fresco.DEFAULT_CHARSET``.
+    specified by ``fresco.defaults.DEFAULT_CHARSET``.
 
     Basic usage::
 
@@ -210,46 +210,48 @@ def make_query(
     :param charset: encoding to be used for unicode values
     :rtype: str
     """
-    items: t.Iterable[t.Tuple[str, t.Any]]
+    items: t.Iterable[tuple[str, t.Any]]
     if isinstance(data, MultiDict):
         items = data.allitems()
     elif isinstance(data, Mapping):
-        items = data.items()
+        items = data.items()  # type: ignore
     else:
         items = data
     if kwargs:
         items = chain(items, kwargs.items())
 
     if charset is None:
-        charset = fresco.DEFAULT_CHARSET
+        charset = DEFAULT_CHARSET
 
-    pairs: List[str] = []
+    pairs: list[str] = []
     append = pairs.append
     for k, v in items:
         if isinstance(v, (str, bytes)):
             append(f"{quote_plus(k, charset)}={quote_plus(v, charset)}")
+        elif v is None:
+            pass
         elif hasattr(v, "__iter__"):
             for v in v:
                 append(f"{quote_plus(k, charset)}={quote_plus(str(v), charset)}")
-        elif v is not None:
+        else:
             append(f"{quote_plus(k, charset)}={quote_plus(str(v), charset)}")
     return separator.join(pairs)
 
 
 def _qs_frag(key, value, charset=None):
-    """\
+    """
     Return a fragment of a query string in the format 'key=value'::
 
         >>> _qs_frag('search-by', 'author, editor')
         'search-by=author%2C+editor'
 
     If no encoding is specified, unicode values are encoded using the character
-    set specified by ``fresco.DEFAULT_CHARSET``.
+    set specified by ``fresco.defaults.DEFAULT_CHARSET``.
 
     :rtype: str
     """
     if charset is None:
-        charset = fresco.DEFAULT_CHARSET
+        charset = DEFAULT_CHARSET
 
     key = str(key).encode(charset)
     value = str(value).encode(charset)