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

fresco/routing.py

@@ -14,22 +14,20 @@
 #
 import re
 import sys
+import inspect
 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
 
@@ -38,6 +36,8 @@ from fresco.response import Response
 from fresco.request import Request
 from fresco.requestcontext import context
 from fresco.routeargs import RouteArg
+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
@@ -128,7 +128,7 @@ PathMatch = namedtuple(
 
 
 class RouteTraversal(
-    namedtuple("RouteTraversal", "route args kwargs collections_traversed")
+    namedtuple("RouteTraversal", "route view args kwargs collections_traversed")
 ):
     """
     Encapsulate a route traversal.
@@ -137,6 +137,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.
@@ -175,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)
@@ -206,7 +208,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",
 )
 
 
@@ -244,7 +246,7 @@ class Pattern(object):
     URL path.
     """
 
-    segments: t.List["PatternSegment"]
+    segments: list["PatternSegment"]
 
     def match(self, path):
         """
@@ -277,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:
@@ -336,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):
         """
@@ -517,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 += "$"
@@ -528,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"""
@@ -593,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
@@ -604,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::
 
@@ -618,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:
@@ -628,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)
@@ -640,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)
@@ -677,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
@@ -687,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
@@ -702,21 +717,20 @@ 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)
     )
 
-    #: Always provide an positional ``request`` argument to views
-    provide_request = False
+    provide_request: Optional[bool] = None
 
     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,
@@ -724,13 +738,15 @@ 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
         :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
@@ -743,12 +759,15 @@ 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.
-        :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.
@@ -795,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:
@@ -830,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}
@@ -841,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
@@ -861,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):
@@ -879,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)
 
@@ -904,14 +930,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) -> ViewCallable:
+        """
+        Resolve and return the raw view callable.
         """
         try:
             return self._cached_views[method]
@@ -930,8 +956,14 @@ class Route(object):
                     raise RouteNotReady()
                 uview = getattr(self.instance, uview)
 
-        self._cached_views[method] = uview
-        return 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  # type: ignore
 
     @classmethod
     def _add_route_hint(cls, viewfunc, hinttype, func):
@@ -1166,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)
@@ -1206,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
@@ -1274,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()
 
@@ -1394,8 +1424,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]
@@ -1437,6 +1467,13 @@ 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
+            else:
+                view = route.getview(method)
 
             # Process any args/kwargs defined in the Route declaration.
             if request:
@@ -1468,7 +1505,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(
@@ -1493,17 +1530,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,
                     [
@@ -1532,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,
@@ -1572,7 +1613,7 @@ class RouteCollection(MutableSequence):
     def route_wsgi(
         self,
         path: str,
-        wsgiapp: t.Union[t.Callable, str],
+        wsgiapp: t.Union[WSGIApplication, str],
         rewrite_script_name: bool = True,
         *args,
         **kwargs,
@@ -1600,7 +1641,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,
@@ -1708,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``
 
@@ -1716,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):
@@ -1739,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
         """
@@ -1753,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):
@@ -1775,3 +1816,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/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

@@ -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
@@ -174,7 +172,7 @@ def subrequest_raw(view, *args, **kwargs) -> Response:
 
             response = view(*args, **kwargs)
 
-        return response
+        return response  # type: ignore
     finally:
         context.pop()
 
@@ -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_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):