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

fresco/routeargs.py

@@ -12,6 +12,7 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
+from collections.abc import Sequence
 from operator import attrgetter, itemgetter, methodcaller
 from fresco.exceptions import MissingRouteArg
 from fresco.request import Request
@@ -19,6 +20,7 @@ from itertools import cycle
 from typing import Any
 from typing import Callable
 from typing import Mapping
+from typing import Union
 
 __all__ = (
     "routearg",
@@ -138,7 +140,7 @@ def map_magics(dest):
 
 
 @map_magics("raise_exception")
-class LazyException(object):
+class LazyException:
     """
     A lazy exception uses magic methods to intercept any access to the object
     and raise an exception.
@@ -151,7 +153,7 @@ class LazyException(object):
         raise self.__dict__["_exception"]
 
 
-class RouteArg(object):
+class RouteArg:
     """
     RouteArg objects can be used as keyword arguments in a route definition.
     RouteArgs can extract information from the request and make it available
@@ -194,7 +196,7 @@ class RouteArg(object):
         self.route = route
         self.name = name
 
-    def __call__(self, request):
+    def __call__(self, request: Request) -> Any:
         return None
 
 
@@ -225,7 +227,7 @@ def routearg(func, *args, **kwargs):
 
 
 class RequestArg(RouteArg):
-    """\
+    """
     Extract a view keyword argument from the request object.
     """
 
@@ -241,9 +243,19 @@ class RequestArg(RouteArg):
     #: input
     converter_exceptions = (ValueError, TypeError)
 
+    converter: Union[
+        Callable[[list[str]], Any],
+        Callable[[str], Any],
+    ]
+
     def __init__(
         self,
-        converter=None,
+        converter: Union[
+            Sequence[
+                Callable[[str], Any],
+            ],
+            Callable[[str], Any]
+        ] = str,
         key=None,
         default=_marker,
         exception=MissingRouteArg,
@@ -251,11 +263,13 @@ class RequestArg(RouteArg):
         super(RequestArg, self).__init__(default, exception)
         self.formkey = key
         self.getter: Callable[[Mapping], Any]
-        self.is_list = isinstance(converter, list)
+        self.is_list = isinstance(converter, Sequence)
         if self.is_list:
-            self.converter = lambda vs: [c(v) for c, v in zip(cycle(converter), vs)]
+            def list_converter(vs: list[str]) -> list[Any]:
+                return [c(v) for c, v in zip(cycle(converter), vs)]  # type: ignore
+            self.converter = list_converter
         else:
-            self.converter = converter
+            self.converter = converter  # type: ignore
 
     def configure(self, route, name):
         if self.formkey is None:
@@ -372,7 +386,7 @@ class CookieArg(RequestArg):
 
     source = RequestArg.cookies
 
-    def getter(self, cookies):
+    def getter(self, cookies):  # type: ignore
         if self.is_list:
             return cookies.getlist(self.formkey)
         else:

fresco/routing.py

@@ -19,18 +19,15 @@ import warnings
 from copy import copy
 from collections import defaultdict
 from collections import namedtuple
+from collections.abc import Collection
 from collections.abc import MutableSequence
 from importlib import import_module
 from functools import partial
 from typing import Any
 from typing import Callable
-from typing import Dict
-from typing import List
 from typing import Mapping
 from typing import Optional
 from typing import Union
-from typing import Set
-from typing import Tuple
 from weakref import WeakKeyDictionary
 import typing as t
 
@@ -39,7 +36,8 @@ 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.types import WSGIApplication
+from fresco.types import ViewCallable
 from fresco.util.cache import make_cache
 from fresco.util.common import fq_path
 from fresco.util.urls import join_path
@@ -178,6 +176,7 @@ class RouteTraversal(
         else:
             viewspecs = [viewspec]
         collections_traversed_iter = iter(self.collections_traversed)
+        route = None
         for item in viewspecs:
             while True:
                 ct = next(collections_traversed_iter, None)
@@ -247,7 +246,7 @@ class Pattern(object):
     URL path.
     """
 
-    segments: t.List["PatternSegment"]
+    segments: list["PatternSegment"]
 
     def match(self, path):
         """
@@ -280,8 +279,8 @@ class Pattern(object):
         raise NotImplementedError()
 
 
-class Converter(object):
-    """\
+class Converter:
+    """
     Responsible for converting arguments to and from URL components.
 
     A ``Converter`` class should provide two instance methods:
@@ -339,11 +338,11 @@ class StrConverter(Converter):
 
     pattern = r"[^/]+"
 
-    def to_string(self, s):
+    def to_string(self, ob):
         """
         Return ``s`` converted to an ``str`` object.
         """
-        return s
+        return ob
 
     def from_string(self, s):
         """
@@ -520,7 +519,15 @@ class ExtensiblePattern(Pattern):
 
         self.segments = list(self._make_segments())
         self.args = [item for item in self.segments if item.converter is not None]
-
+        self.segments_from_string = [
+            (s.name, s.converter.from_string)
+            for s in self.segments
+            if s.converter is not None
+        ]
+        self.positional_args = tuple(a.converter for a in self.args if a.name is None)
+        self.keyword_args = {
+            a.name: a.converter for a in self.args if a.name is not None
+        }
         regex = "".join(segment.regex for segment in self.segments)
         if self.match_entire_path:
             regex += "$"
@@ -531,9 +538,7 @@ class ExtensiblePattern(Pattern):
         self.regex_match = self.regex.match
 
     def path_argument_info(self):
-        positional = tuple(a.converter for a in self.args if a.name is None)
-        keyword = {a.name: a.converter for a in self.args if a.name is not None}
-        return (positional, keyword)
+        return (self.positional_args, self.keyword_args)
 
     def _make_segments(self):
         r"""
@@ -596,8 +601,8 @@ class ExtensiblePattern(Pattern):
 
         try:
             group_items = [
-                (segment.name, segment.converter.from_string(value))
-                for value, segment in zip(groups, self.args)
+                (name, from_string(value))
+                for value, (name, from_string) in zip(groups, self.segments_from_string)
             ]
         except ValueError:
             return None
@@ -607,7 +612,9 @@ class ExtensiblePattern(Pattern):
         kwargs = {name: value for name, value in group_items if name}
         return PathMatch(matched, path[len(matched) :], args, kwargs)
 
-    def pathfor(self, *args, **kwargs) -> Tuple[str, List[Any], Dict[Any, Any]]:
+    def pathfor(
+        self, *args, _strjoin="".join, **kwargs
+    ) -> tuple[str, list[Any], dict[Any, Any]]:
         """
         Example usage::
 
@@ -621,8 +628,7 @@ class ExtensiblePattern(Pattern):
         """
 
         arg_list = list(args)
-        kwargs = kwargs
-        result: List[str] = []
+        result: list[str] = []
         result_append = result.append
         for seg in self.segments:
             if not seg.converter:
@@ -631,7 +637,7 @@ class ExtensiblePattern(Pattern):
             elif seg.name:
                 try:
                     value = kwargs.pop(seg.name)
-                except IndexError:
+                except KeyError:
                     raise URLGenerationError(
                         "Argument %r not specified for url %r"
                         % (seg.name, self.pattern)
@@ -643,11 +649,11 @@ class ExtensiblePattern(Pattern):
                     value = arg_list.pop(0)
                 except IndexError:
                     raise URLGenerationError(
-                        "Not enough positional arguments for url %r" % (self.pattern,)
+                        f"Not enough positional arguments for url {self.pattern}"
                     )
                 result_append(seg.converter.to_string(value))
 
-        return "".join(result), arg_list, kwargs
+        return _strjoin(result), arg_list, kwargs
 
     def add_prefix(self, prefix):
         return self.__class__(join_path(prefix, self.pattern), self.match_entire_path)
@@ -680,7 +686,7 @@ class ExtensiblePattern(Pattern):
         return "%s" % (self.pattern,)
 
 
-class PatternSegment(object):
+class PatternSegment:
     """
     Represent a single segment of a URL pattern, storing information about the
     ``source``, ``regex`` used to pattern match the segment, ``name`` for
@@ -690,7 +696,13 @@ class PatternSegment(object):
 
     __slots__ = ["source", "regex", "name", "converter"]
 
-    def __init__(self, source, regex, name, converter):
+    def __init__(
+        self,
+        source: str,
+        regex: str,
+        name: Optional[str],
+        converter: Optional[Converter],
+    ):
         self.source = source
         self.regex = regex
         self.name = name
@@ -705,9 +717,9 @@ class Route(object):
     #: The default class to use for URL pattern matching
     pattern_class = ExtensiblePattern
 
-    fallthrough_statuses: Optional[Set[int]]
+    fallthrough_statuses: Optional[set[int]]
 
-    _route_hints: Dict[Callable, Dict[str, List[Callable]]] = defaultdict(
+    _route_hints: dict[Callable, dict[str, list[Callable]]] = defaultdict(
         lambda: defaultdict(list)
     )
 
@@ -716,9 +728,9 @@ class Route(object):
     def __init__(
         self,
         pattern: t.Union[str, Pattern],
-        methods=None,
-        view=None,
-        kwargs=None,
+        methods: Optional[Collection[str]] = None,
+        view: Optional[Union[ViewCallable, "RouteCollection", str]] = None,
+        kwargs: Optional[dict[str, Any]] = None,
         args=None,
         name=None,
         predicate=None,
@@ -726,7 +738,7 @@ class Route(object):
         filters=None,
         fallthrough_on=None,
         provide_request: Optional[bool] = None,
-        **_kwargs,
+        **_kwargs: ViewCallable,
     ):
         """
         :param pattern:     A string that can be compiled into a path pattern
@@ -747,7 +759,7 @@ class Route(object):
                             before invoking it
         :param filters:     Filter functions to apply to the view's return
                             value before returning the final response object
-        :param fallthrough_on: A List of http status codes which, if returned
+        :param fallthrough_on: A list of http status codes which, if returned
                                by a view will cause the current response to be
                                discarded with routing continuing to the next
                                available route.
@@ -802,8 +814,9 @@ class Route(object):
             'http://localhost/thumbnail'
 
         """
-        method_view_map: Dict[str, Callable] = {}
+        method_view_map: dict[str, t.Union[ViewCallable, RouteCollection, str]] = {}
         if methods:
+            assert view is not None
             if isinstance(methods, str):
                 methods = [methods]
             else:
@@ -837,7 +850,7 @@ class Route(object):
         self.name = name
         self.predicate = predicate
         self.decorators = decorators or []
-        self.before_hooks: List[Callable] = []
+        self.before_hooks: list[Callable] = []
         self.filters = filters or []
         if fallthrough_on:
             self.fallthrough_statuses = {int(i) for i in fallthrough_on}
@@ -848,14 +861,14 @@ class Route(object):
             self.provide_request = provide_request
 
         #: Default values to use for path generation
-        self.routed_args_default: Dict[str, Any] = {}
+        self.routed_args_default: dict[str, Any] = {}
 
         self.pattern = pattern
         self.methods = set(method_view_map)
         self.instance = None
 
         # Cached references to view functions
-        self._cached_views: Dict[str, Callable] = {}
+        self._cached_views: dict[str, ViewCallable] = {}
 
         # Cached references to decorated view function. We use weakrefs in case
         # a process_view hook substitutes the view function used as a key
@@ -868,8 +881,12 @@ class Route(object):
             if default is not _marker:
                 self.routed_args_default[k] = default
 
-        self.view_args = tuple(args or _kwargs.pop("view_args", tuple()))
-        self.view_kwargs = dict(kwargs or _kwargs.pop("view_kwargs", {}), **_kwargs)
+        self.view_args: tuple[Any] = tuple(
+            args or _kwargs.pop("view_args", tuple())  # type: ignore
+        )
+        self.view_kwargs: dict[str, Any] = dict(
+            kwargs or _kwargs.pop("view_kwargs", {}), **_kwargs   # type: ignore
+        )
 
         for arg in self.view_args:
             if isinstance(arg, RouteArg):
@@ -886,7 +903,9 @@ class Route(object):
         self.viewspecs = method_view_map
 
     def __repr__(self):
-        view_methods_map: Mapping[Callable, Set[str]] = defaultdict(set)
+        view_methods_map: Mapping[
+            t.Union[RouteCollection, ViewCallable, str], set[str]
+        ] = defaultdict(set)
         for method, viewspec in self.viewspecs.items():
             view_methods_map[viewspec].add(method)
 
@@ -916,7 +935,7 @@ class Route(object):
             return None
         return self.pattern.match(path)
 
-    def getview(self, method: str) -> Callable[..., Any]:
+    def getview(self, method: str) -> ViewCallable:
         """
         Resolve and return the raw view callable.
         """
@@ -937,14 +956,14 @@ class Route(object):
                     raise RouteNotReady()
                 uview = getattr(self.instance, uview)
 
-        self._cached_views[method] = uview
+        self._cached_views[method] = uview  # type: ignore
         if self.provide_request is None:
             if callable(uview):
                 self.provide_request = _has_request_parameter(uview)
             else:
                 self.provide_request = False
 
-        return uview
+        return uview  # type: ignore
 
     @classmethod
     def _add_route_hint(cls, viewfunc, hinttype, func):
@@ -1179,7 +1198,7 @@ class RRoute(Route):
 
 def split_iter(pattern, string):
     """
-    Generate alternate strings and match objects for all occurances of
+    Generate alternate strings and match objects for all occurences of
     ``pattern`` in ``string``.
     """
     matcher = pattern.finditer(string)
@@ -1219,10 +1238,8 @@ class RouteCollection(MutableSequence):
     _route_cache = None
 
     def __init__(self, routes=None, route_class=None, cache=True):
-        self.__routes__: List[Route] = []
-        self.__routed_views__: Dict[
-            Union[str, Callable], Union[Route, RouteNotFound]
-        ] = {}
+        self.__routes__: list[Route] = []
+        self.__routed_views__: dict[Any, Union[Route, RouteNotFound]] = {}
         if cache:
             self.reinit_route_cache()
         self.route_class = route_class or self.route_class
@@ -1287,8 +1304,8 @@ class RouteCollection(MutableSequence):
         )
         self._route_cache = make_cache(self._get_routes, cache_size)
 
-    def insert(self, position, item):
-        self.__routes__.insert(position, item)
+    def insert(self, index, value):
+        self.__routes__.insert(index, value)
         if self._route_cache is not None:
             self.reinit_route_cache()
 
@@ -1451,6 +1468,7 @@ class RouteCollection(MutableSequence):
             # View function arguments extracted while traversing the path
             traversal_args, traversal_kwargs = result.args, result.kwargs
             if method is None:
+                view = None
                 for m in route.viewspecs:
                     view = route.getview(m)
                     break
@@ -1555,8 +1573,8 @@ class RouteCollection(MutableSequence):
     def route(
         self,
         pattern: t.Union[str, Pattern],
-        methods: t.Optional[t.Union[str, t.Iterable[str]]] = None,
-        view: t.Optional[t.Union[str, t.Callable]] = None,
+        methods: t.Optional[t.Union[str, t.Collection[str]]] = None,
+        view: t.Optional[t.Union[str, ViewCallable]] = None,
         *args,
         route_class: t.Optional[t.Type[Route]] = None,
         **kwargs,
@@ -1595,7 +1613,7 @@ class RouteCollection(MutableSequence):
     def route_wsgi(
         self,
         path: str,
-        wsgiapp: t.Union[WSGICallable, str],
+        wsgiapp: t.Union[WSGIApplication, str],
         rewrite_script_name: bool = True,
         *args,
         **kwargs,
@@ -1731,7 +1749,7 @@ class RouteCollection(MutableSequence):
             if r is route:
                 del self.__routed_views__[k]
 
-    def remove(self, viewspec):
+    def remove(self, value):
         """
         Remove the route(s) identified by ``viewspec``
 
@@ -1739,7 +1757,7 @@ class RouteCollection(MutableSequence):
                          ('package.module.view_function'), or the name of a
                          named route
         """
-        self.replace(viewspec, None)
+        self.replace(value, None)
 
 
 class DelegateRoute(Route):
@@ -1762,7 +1780,7 @@ class DelegateRoute(Route):
                 view = RouteCollection(routes)
         super(DelegateRoute, self).__init__(pattern, ALL_METHODS, view, *args, **kwargs)
 
-    def _dynamic_routecollectionfactory(self, *args, **kwargs):
+    def _dynamic_routecollectionfactory(self, *args, **kwargs) -> RouteCollection:
         """\
         Return the RouteCollection responsible for paths under this route
         """
@@ -1776,8 +1794,8 @@ class DelegateRoute(Route):
             (r.bindto(routes) for r in routes.__routes__), cache=False
         )
 
-    def _static_routecollectionfactory(self, *args, **kwargs):
-        return self.getview(GET)
+    def _static_routecollectionfactory(self, *args, **kwargs) -> RouteCollection:
+        return self.getview(GET)  # type: ignore
 
 
 def register_converter(name, registry=ExtensiblePattern):

fresco/static.py

@@ -57,7 +57,7 @@ def serve_static_file(path, content_type=None, bufsize=8192, **kwargs):
     file_wrapper = request.environ.get("wsgi.file_wrapper")
     if file_wrapper is not None:
 
-        def content_iterator(f):
+        def content_iterator(f):  # type: ignore
             return file_wrapper(f, bufsize)
 
     else:

fresco/subrequests.py

@@ -172,7 +172,7 @@ def subrequest_raw(view, *args, **kwargs) -> Response:
 
             response = view(*args, **kwargs)
 
-        return response
+        return response  # type: ignore
     finally:
         context.pop()
 

fresco/tests/test_core.py

@@ -178,10 +178,10 @@ class TestFrescoApp(object):
 
     def test_get_methods_matches_on_path(self):
         app = FrescoApp()
-        app.route("/1", POST, lambda: None)
-        app.route("/1", PUT, lambda: None)
-        app.route("/2", GET, lambda: None)
-        app.route("/2", DELETE, lambda: None)
+        app.route("/1", POST, Response)
+        app.route("/1", PUT, Response)
+        app.route("/2", GET, Response)
+        app.route("/2", DELETE, Response)
 
         with app.requestcontext() as c:
             assert app.get_methods(c.request, "/1") == set([POST, PUT])

fresco/tests/test_multidict.py

@@ -88,7 +88,7 @@ class TestMultDict(object):
 
     def test_keys(self):
         m = MultiDict([("a", 1), ("a", 2), ("b", 3)])
-        i = m.keys()
+        i = iter(m.keys())
         assert next(i) == "a"
         assert next(i) == "b"
         with pytest.raises(StopIteration):
@@ -96,7 +96,7 @@ class TestMultDict(object):
 
     def test_values(self):
         m = MultiDict([("a", 1), ("a", 2), ("b", 3)])
-        i = m.values()
+        i = iter(m.values())
         assert next(i) == 1
         assert next(i) == 3
         with pytest.raises(StopIteration):

fresco/tests/test_options.py

@@ -106,7 +106,6 @@ class TestOptions(object):
 
 
 class TestOverrideOptions:
-
     def test_override_options_with_object(self):
         options = Options(foo=1)
         with override_options(options, {"foo": 2, "bar": "a"}):
@@ -163,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,
@@ -212,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,
@@ -237,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": "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("*", ["dev", "local"]) == {"a": "0-1-3-2"}
-            assert loadopts("*", ["local", "dev"]) == {"a": "0-2-1-3"}
+            assert loadopts("*") == {"a": "a b 100"}
 
     def test_it_loads_from_os_environ(self, tmpdir):
         with setenv(a="2"):
@@ -272,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):
@@ -281,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"):
@@ -289,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):
@@ -298,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,
@@ -323,7 +347,7 @@ class TestDictFromOptions:
             "A": 1,
             "B": {"C": {"D": 2}, "E": 3},
             "F": {"G": {"H": 4}},
-            "I": 5
+            "I": 5,
         }