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

fresco/__init__.py

@@ -12,10 +12,63 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
-__version__ = "3.3.4"
+from fresco.request import Request
+from fresco.request import currentrequest
+from fresco.requestcontext import context
+from fresco.response import Response
+from fresco.core import FrescoApp
+from fresco.core import urlfor
+from fresco.defaults import DEFAULT_CHARSET
+from fresco.options import Options
+from fresco.routing import Route
+from fresco.routing import RRoute
+from fresco.routing import RouteCollection
+from fresco.routing import DelegateRoute
+from fresco.routing import routefor
+from fresco.routing import ALL_METHODS
+from fresco.routing import GET
+from fresco.routing import HEAD
+from fresco.routing import POST
+from fresco.routing import PUT
+from fresco.routing import DELETE
+from fresco.routing import OPTIONS
+from fresco.routing import TRACE
+from fresco.routing import CONNECT
+from fresco.routing import VERSION_CONTROL
+from fresco.routing import REPORT
+from fresco.routing import CHECKOUT
+from fresco.routing import CHECKIN
+from fresco.routing import UNCHECKOUT
+from fresco.routing import MKWORKSPACE
+from fresco.routing import UPDATE
+from fresco.routing import LABEL
+from fresco.routing import MERGE
+from fresco.routing import BASELINE_CONTROL
+from fresco.routing import MKACTIVITY
+from fresco.routing import ORDERPATCH
+from fresco.routing import ACL
+from fresco.routing import SEARCH
+from fresco.routing import PATCH
+from fresco.routeargs import routearg
+from fresco.routeargs import FormArg
+from fresco.routeargs import PostArg
+from fresco.routeargs import QueryArg
+from fresco.routeargs import GetArg
+from fresco.routeargs import CookieArg
+from fresco.routeargs import SessionArg
+from fresco.routeargs import RequestObject
+from fresco.routeargs import FormData
+from fresco.routeargs import PostData
+from fresco.routeargs import QueryData
+from fresco.routeargs import GetData
+from fresco.middleware import XForwarded
+from fresco.subrequests import subrequest
+from fresco.subrequests import subrequest_bytes
+from fresco.subrequests import subrequest_raw
+from fresco.util.common import object_or_404
 
-DEFAULT_CHARSET = "UTF-8"
 
+__version__ = "3.9.0"
 __all__ = [
     "Request",
     "currentrequest",
@@ -72,57 +125,3 @@ __all__ = [
     "subrequest_raw",
     "object_or_404",
 ]
-
-from fresco.request import Request
-from fresco.request import currentrequest
-from fresco.requestcontext import context
-from fresco.response import Response
-from fresco.core import FrescoApp
-from fresco.core import urlfor
-from fresco.options import Options
-from fresco.routing import Route
-from fresco.routing import RRoute
-from fresco.routing import RouteCollection
-from fresco.routing import DelegateRoute
-from fresco.routing import routefor
-from fresco.routing import ALL_METHODS
-from fresco.routing import GET
-from fresco.routing import HEAD
-from fresco.routing import POST
-from fresco.routing import PUT
-from fresco.routing import DELETE
-from fresco.routing import OPTIONS
-from fresco.routing import TRACE
-from fresco.routing import CONNECT
-from fresco.routing import VERSION_CONTROL
-from fresco.routing import REPORT
-from fresco.routing import CHECKOUT
-from fresco.routing import CHECKIN
-from fresco.routing import UNCHECKOUT
-from fresco.routing import MKWORKSPACE
-from fresco.routing import UPDATE
-from fresco.routing import LABEL
-from fresco.routing import MERGE
-from fresco.routing import BASELINE_CONTROL
-from fresco.routing import MKACTIVITY
-from fresco.routing import ORDERPATCH
-from fresco.routing import ACL
-from fresco.routing import SEARCH
-from fresco.routing import PATCH
-from fresco.routeargs import routearg
-from fresco.routeargs import FormArg
-from fresco.routeargs import PostArg
-from fresco.routeargs import QueryArg
-from fresco.routeargs import GetArg
-from fresco.routeargs import CookieArg
-from fresco.routeargs import SessionArg
-from fresco.routeargs import RequestObject
-from fresco.routeargs import FormData
-from fresco.routeargs import PostData
-from fresco.routeargs import QueryData
-from fresco.routeargs import GetData
-from fresco.middleware import XForwarded
-from fresco.subrequests import subrequest
-from fresco.subrequests import subrequest_bytes
-from fresco.subrequests import subrequest_raw
-from fresco.util.common import object_or_404

fresco/core.py

@@ -33,7 +33,10 @@ from fresco.util.http import encode_multipart
 from fresco.util.urls import normpath, make_query
 from fresco.util.common import fq_path
 from fresco.util.wsgi import make_environ
-from fresco.typing import WSGICallable
+from fresco.types import WSGIApplication
+from fresco.types import HeaderList
+from fresco.types import OptionalExcInfo
+from fresco.types import WriteCallable
 
 from fresco.exceptions import ResponseException
 from fresco.requestcontext import context
@@ -46,10 +49,12 @@ from fresco.routing import (
 )
 from fresco.options import Options
 
-__all__ = ("FrescoApp", "urlfor")
+__all__ = ("FrescoApp", "urlfor", "context")
 
 logger = logging.getLogger(__name__)
 
+ExcInfo = tuple[t.Type[BaseException], BaseException, types.TracebackType]
+
 
 class FrescoApp(RouteCollection):
     """\
@@ -115,7 +120,9 @@ class FrescoApp(RouteCollection):
         #: If a function returns a value (other than ``None``),
         #: this value will be
         #: returned as the response instead of calling the scheduled view.
-        self.process_http_error_response_handlers: List[Tuple[int, Callable]] = []
+        self.process_http_error_response_handlers: list[
+            tuple[t.Optional[int], Callable[[Request, Response], t.Optional[Response]]]
+        ] = []
 
         #: Functions to be called if an exception is raised during a view
         #: Each function will be passed ``request, exc_info``.
@@ -123,7 +130,9 @@ class FrescoApp(RouteCollection):
         #: this value will be
         #: returned as the response and the error will not be propagated.
         #: If all exception handlers return None then the error will be raised
-        self.process_exception_handlers: List[Tuple[Exception, Callable]] = []
+        self.process_exception_handlers: list[
+            tuple[Type[Exception], Callable[[Request, ExcInfo], Union[Response, None]]]
+        ] = []
 
         #: Functions to be called at the end of request processing,
         #: after all content has been output.
@@ -156,7 +165,7 @@ class FrescoApp(RouteCollection):
         method: str,
         currentcontext=context.currentcontext,
         normpath=normpath,
-    ):
+    ) -> Response:
         ctx = currentcontext()
         ctx["app"] = self
         environ = request.environ
@@ -178,19 +187,19 @@ class FrescoApp(RouteCollection):
 
         try:
             for traversal in self.get_route_traversals(path, method, request):
+                route = traversal.route
                 try:
-                    route = traversal.route
                     environ["wsgiorg.routing_args"] = (
                         traversal.args,
                         traversal.kwargs,
                     )
-                    view = route.getview(method)
+                    view = traversal.view
                     ctx["view_self"] = getattr(view, "__self__", None)
                     ctx["route_traversal"] = traversal
                     if self.logger:
                         self.logger.info(
                             "matched route: %s %r => %r",
-                            request.method,
+                            method,
                             path,
                             fq_path(view),
                         )
@@ -271,7 +280,9 @@ class FrescoApp(RouteCollection):
         except ResponseException as e:
             response = e.response
         else:
-            response = self.get_response(request, path, request.method)
+            response = self.get_response(
+                request, path, request.environ["REQUEST_METHOD"]
+            )
 
         for f in self.process_response_handlers:
             try:
@@ -324,12 +335,7 @@ class FrescoApp(RouteCollection):
             exc_info=exc_info,
         )
 
-    def handle_exception(
-        self, request, allow_reraise=True
-    ) -> Union[
-        Response,
-        Tuple[Type[BaseException], BaseException, types.TracebackType],
-    ]:
+    def handle_exception(self, request, allow_reraise=True) -> Response:
         exc_info = sys.exc_info()
         if exc_info[0] is None:
             raise AssertionError(
@@ -346,10 +352,7 @@ class FrescoApp(RouteCollection):
         # server handle it
         if allow_reraise and not have_error_handlers:
             raise exc_info[1].with_traceback(exc_info[2])  # type: ignore
-        response: Union[
-            Response,
-            Tuple[Type[BaseException], BaseException, types.TracebackType],
-        ] = Response.internal_server_error()
+        response: Response = Response.internal_server_error()
 
         if not self.process_exception_handlers:
             self.log_exception(request, exc_info)
@@ -406,7 +409,7 @@ class FrescoApp(RouteCollection):
         self.reset_wsgi_app()
         self._middleware.insert(position, (middleware, args, kwargs))
 
-    def make_wsgi_app(self, wsgi_app=None, use_middleware=True) -> WSGICallable:
+    def make_wsgi_app(self, wsgi_app=None, use_middleware=True) -> WSGIApplication:
         """
         Return a WSGI (PEP-3333) compliant application that drives this
         FrescoApp object.
@@ -419,7 +422,7 @@ class FrescoApp(RouteCollection):
         """
         if wsgi_app is None:
 
-            def wsgi_app(
+            def _wsgi_app(
                 environ,
                 start_response,
                 view=self.view,
@@ -428,15 +431,18 @@ class FrescoApp(RouteCollection):
                 request = request_class(environ)
                 return view(request)(environ, start_response)
 
+        else:
+            _wsgi_app = wsgi_app
+
         if use_middleware:
             for m, m_args, m_kwargs in self._middleware:
-                wsgi_app = m(wsgi_app, *m_args, **m_kwargs)
+                _wsgi_app = m(_wsgi_app, *m_args, **m_kwargs)
 
         def fresco_wsgi_app(
             environ,
             start_response,
             frescoapp=self,
-            wsgi_app=wsgi_app,
+            wsgi_app=_wsgi_app,
             request_class=self.request_class,
             process_teardown_handlers=self.process_teardown_handlers,
             call_process_teardown_handlers=self.call_process_teardown_handlers,
@@ -602,7 +608,11 @@ class FrescoApp(RouteCollection):
         self.process_response_handlers.append(func)
         return func
 
-    def process_exception(self, func, exc_type=Exception):
+    def process_exception(
+        self,
+        func: Callable[[Request, ExcInfo], Union[Response, None]],
+        exc_type: Type[Exception] = Exception,
+    ):
         """
         Register a ``process_exception`` hook function
         """
@@ -668,7 +678,9 @@ class FrescoApp(RouteCollection):
             start_response("200 OK", [])
             yield b""
 
-        def fake_start_response(status, headers, exc_info=None):
+        def fake_start_response(
+            status: str, headers: HeaderList, exc_info: OptionalExcInfo = None
+        ) -> WriteCallable:
             return lambda s: None
 
         environ = make_environ(url, environ, wsgi_input, **kwargs)
@@ -693,12 +705,12 @@ class FrescoApp(RouteCollection):
         if multipart:
             wsgi_input, headers = encode_multipart(data, files)
             kwargs.update(headers)
-        elif hasattr(data, "read"):
+        elif isinstance(data, t.BinaryIO):
             wsgi_input = data.read()
         elif isinstance(data, bytes):
             wsgi_input = data
         elif data is None:
-            wsgi_input = ""
+            wsgi_input = b""
         else:
             wsgi_input = make_query(data).encode("ascii")
 

fresco/decorators.py

@@ -14,20 +14,23 @@
 #
 import sys
 from functools import wraps
+import typing as t
 
 from fresco import Response
 
 _marker = object()
 
 
-def onerror(exceptions, handler):
-    """\
+def onerror(
+    exceptions: t.Union[t.Type[Exception], tuple[t.Type[Exception], ...]], handler
+) -> t.Callable:
+    """
     Return a decorator that can replace or update the return value of the
     function if an exception is raised
     """
 
     try:
-        if isinstance(exceptions, Exception):
+        if isinstance(exceptions, type):
             exceptions = (exceptions,)
     except TypeError:
         pass

fresco/defaults.py

@@ -0,0 +1 @@
+DEFAULT_CHARSET = "UTF-8"

fresco/middleware.py

@@ -12,11 +12,17 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
+import typing as t
+
+from fresco.types import WSGIApplication
+from fresco.types import WSGIEnviron
+from fresco.types import StartResponse
+
 __all__ = ["XForwarded"]
 
 
 class XForwarded(object):
-    """\
+    """
     Modify the WSGI environment so that the X_FORWARDED_* headers are observed
     and generated URIs are correct in a proxied environment.
 
@@ -33,6 +39,13 @@ class XForwarded(object):
     the wsgi.url_scheme is modified to ``https`` and ``HTTPS`` is set to
     ``on``.
 
+    :param trusted:
+        List of IP addresses trusted to set the HTTP_X_FORWARDED_* headers
+
+    :param force_https:
+        If True, the following environ keys will be set unconditionally:
+        ``"HTTPS": "on"`` and ``"wsgi.url_scheme": "https"`` will be set
+
     Example::
 
         >>> from fresco import FrescoApp, context, GET, Response
@@ -68,24 +81,36 @@ class XForwarded(object):
         u'URL is https://real-name/; REMOTE_ADDR is 1.2.3.4'
     """
 
-    def __init__(self, app, trusted=None):
+    def __init__(
+        self,
+        app: WSGIApplication,
+        trusted: t.Optional[t.Iterable[str]] = None,
+        force_https: t.Optional[bool] = None,
+    ) -> None:
         self.app = app
+        self.force_https = force_https
         if trusted:
             self.trusted = set(trusted)
         else:
             self.trusted = set()
 
-    def __call__(self, environ, start_response):
-        """\
+    def __call__(
+        self, environ: WSGIEnviron, start_response: StartResponse
+    ) -> t.Iterable[bytes]:
+        """
         Call the WSGI app, passing it a modified environ
         """
         env = environ.get
-        is_ssl = (
-            env("HTTP_X_FORWARDED_PROTO") == "https"
-            or env("HTTP_X_FORWARDED_SSL") == "on"
-        )
 
+        if self.force_https is None:
+            is_ssl = (
+                env("HTTP_X_FORWARDED_PROTO") == "https"
+                or env("HTTP_X_FORWARDED_SSL") == "on"
+            )
+        else:
+            is_ssl = self.force_https
         host = env("HTTP_X_FORWARDED_HOST")
+
         if host is not None:
             if ":" in host:
                 port = host.split(":")[1]
@@ -99,21 +124,17 @@ class XForwarded(object):
             environ["wsgi.url_scheme"] = "https"
             environ["HTTPS"] = "on"
 
-        try:
-            forwards = environ["HTTP_X_FORWARDED_FOR"].split(", ") + [
-                env("REMOTE_ADDR", "")
-            ]
-        except KeyError:
-            # No X-Forwarded-For header?
-            return self.app(environ, start_response)
-
-        if self.trusted:
-            for ip in forwards[::-1]:
-                # Find the first non-trusted ip; this is our remote address
-                if ip not in self.trusted:
-                    environ["REMOTE_ADDR"] = ip
-                    break
-        else:
-            environ["REMOTE_ADDR"] = forwards[0]
+        forwarded_for = env("HTTP_X_FORWARDED_FOR")
+        if forwarded_for:
+            addrs = forwarded_for.split(", ")
+
+            if self.trusted:
+                for ip in addrs[::-1]:
+                    # Find the first non-trusted ip; this is our remote address
+                    if ip not in self.trusted:
+                        environ["REMOTE_ADDR"] = ip
+                        break
+            else:
+                environ["REMOTE_ADDR"] = addrs[0]
 
         return self.app(environ, start_response)

fresco/multidict.py

@@ -15,17 +15,19 @@
 """
 An order preserving multidict implementation
 """
-from collections.abc import MutableMapping
 from collections.abc import Mapping
+from collections.abc import KeysView
+from collections.abc import ItemsView
+from collections.abc import ValuesView
+from collections.abc import MutableMapping
 from itertools import repeat
 import typing as t
 from typing import Any
 from typing import Dict
-from typing import Set
 
 
 if t.TYPE_CHECKING:
-    from typeshed import SupportsKeysAndGetItem
+    from typeshed import SupportsKeysAndGetItem  # type: ignore
 else:
     SupportsKeysAndGetItem = Mapping
 
@@ -33,6 +35,8 @@ SupportsKeysAndGetItemOrIterable = t.Union[
     SupportsKeysAndGetItem, t.Iterable[t.Tuple[Any, Any]]
 ]
 
+_NO_DEFAULT = object()
+
 
 class MultiDict(MutableMapping):
     """
@@ -58,11 +62,11 @@ class MultiDict(MutableMapping):
 
     _dict: Dict[Any, Any]
     _order: t.List[Any]
+    __slots__ = ("_dict", "_order")
+
     setdefault = MutableMapping.setdefault
 
-    def __init__(
-        self, mapping_or_iterable: SupportsKeysAndGetItemOrIterable = tuple(), **kwargs
-    ):
+    def __init__(self, other: SupportsKeysAndGetItemOrIterable = tuple(), **kwargs):
         """
         MultiDicts can be constructed in the following ways:
 
@@ -94,7 +98,7 @@ class MultiDict(MutableMapping):
         """
         self._order = []
         self._dict = {}
-        self._update(mapping_or_iterable, True, kwargs)
+        self._update(other, True, kwargs)
 
     def __getitem__(self, key):
         """
@@ -134,7 +138,7 @@ class MultiDict(MutableMapping):
         """
         Return an iterator over all keys
         """
-        return (k for k in self._dict)
+        return iter(self._dict)
 
     def get(self, key, default=None):
         """
@@ -155,7 +159,7 @@ class MultiDict(MutableMapping):
         """
         return self._dict.get(key, [])
 
-    def copy(self):
+    def copy(self) -> "MultiDict":
         """\
         Return a shallow copy of the dictionary:
 
@@ -169,7 +173,7 @@ class MultiDict(MutableMapping):
         return self.__class__(self)
 
     @classmethod
-    def fromkeys(cls, seq, value=None):
+    def fromkeys(cls, seq, value=None) -> "MultiDict":
         """\
         Create a new MultiDict with keys from seq and values set to value.
 
@@ -189,8 +193,8 @@ class MultiDict(MutableMapping):
         """
         return cls(zip(seq, repeat(value)))
 
-    def items(self):
-        """\
+    def items(self) -> ItemsView:
+        """
         Return a list of ``(key, value)`` tuples. Only the first ``(key,
         value)`` is returned where keys have multiple values:
 
@@ -198,14 +202,9 @@ class MultiDict(MutableMapping):
             >>> list(d.items())
             [('a', 1), ('b', 3)]
         """
-        seen: Set[Any] = set()
-        for k, v in self._order:
-            if k in seen:
-                continue
-            yield k, v
-            seen.add(k)
+        return {k: v[0] for k, v in self._dict.items()}.items()
 
-    def listitems(self):
+    def listitems(self) -> ItemsView:
         """\
         Like ``items``, but returns lists of values:
 
@@ -213,10 +212,9 @@ class MultiDict(MutableMapping):
             >>> list(d.listitems())
             [('a', [1, 2]), ('b', [3])]
         """
-        for k in self.keys():
-            yield k, self._dict[k]
+        return self._dict.items()
 
-    def allitems(self):
+    def allitems(self) -> t.Iterable[tuple[t.Any, t.Any]]:
         """\
         Return ``(key, value)`` pairs for each item in the MultiDict.
         Items with multiple keys will have multiple key-value pairs returned:
@@ -228,7 +226,7 @@ class MultiDict(MutableMapping):
         """
         return iter(self._order)
 
-    def keys(self):
+    def keys(self) -> KeysView:
         """\
         Return dictionary keys. Each key is returned only once, even if
         multiple values are present.
@@ -238,10 +236,10 @@ class MultiDict(MutableMapping):
             >>> list(d.keys())
             ['a', 'b']
         """
-        return (k for k, v in self.items())
+        return self._dict.keys()
 
-    def values(self):
-        """\
+    def values(self) -> ValuesView:
+        """
         Return values from the dictionary. Where keys have multiple values,
         only the first is returned:
 
@@ -250,9 +248,9 @@ class MultiDict(MutableMapping):
             >>> list(d.values())
             [1, 3]
         """
-        return (v for k, v in self.items())
+        return {k: v[0] for k, v in self._dict.items()}.values()
 
-    def listvalues(self):
+    def listvalues(self) -> ValuesView:
         """\
         Return an iterator over lists of values. Each item will be the list of
         values associated with a single key.
@@ -264,9 +262,9 @@ class MultiDict(MutableMapping):
             >>> list(d.listvalues())
             [[1, 2], [3]]
         """
-        return (self._dict[k] for k in self.keys())
+        return self._dict.values()
 
-    def pop(self, key, *args):
+    def pop(self, key, default=_NO_DEFAULT) -> t.Any:
         """
         Dictionary ``pop`` method. Return and remove the value associated with
         ``key``. If more than one value is associated with ``key``, only the
@@ -288,16 +286,12 @@ class MultiDict(MutableMapping):
                 ...
             KeyError: 'a'
         """
-        if len(args) > 1:
-            raise TypeError(
-                "pop expected at most 2 arguments, got %d" % (1 + len(args))
-            )
         try:
             value = self._dict[key].pop(0)
         except (KeyError, IndexError):
-            if args:
-                return args[0]
-            raise KeyError(key)
+            if default is _NO_DEFAULT:
+                raise KeyError(key)
+            return default
         self._order.remove((key, value))
         return value
 
@@ -326,17 +320,9 @@ class MultiDict(MutableMapping):
             raise KeyError("popitem(): dictionary is empty")
         return key, self.pop(key)
 
-    @t.overload
     def update(
-        self, mapping_or_iterable: SupportsKeysAndGetItem, /, **kwargs: Any
+        self, other: SupportsKeysAndGetItemOrIterable = tuple(), /, **kwargs: Any
     ) -> None:
-        ...
-
-    @t.overload
-    def update(self, /, **kwargs: Any) -> None:
-        ...
-
-    def update(self, mapping_or_iterable=tuple(), **kwargs):
         r"""
         Update the MultiDict from another MultiDict, regular dictionary or a
         iterable of ``(key, value)`` pairs. New keys overwrite old keys - use
@@ -371,17 +357,15 @@ class MultiDict(MutableMapping):
                 >>> d.update(mood='okay')
 
         """
-        self._update(mapping_or_iterable, True, kwargs)
+        self._update(other, True, kwargs)
 
-    def extend(
-        self, mapping_or_iterable: SupportsKeysAndGetItemOrIterable = tuple(), **kwargs
-    ):
+    def extend(self, other: SupportsKeysAndGetItemOrIterable = tuple(), **kwargs):
         """
         Extend the MultiDict with another MultiDict, regular dictionary or a
         iterable of ``(key, value)`` pairs. This is similar to :meth:`update`
         except that new keys are added to old keys.
         """
-        return self._update(mapping_or_iterable, False, kwargs)
+        return self._update(other, False, kwargs)
 
     def _update(
         self,