fresco 3.2.0__py3-none-any.whl → 3.3.1__py3-none-any.whl

fresco/__init__.py

@@ -12,16 +12,117 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
-__version__ = "3.2.0"
+__version__ = "3.3.1"
 
 DEFAULT_CHARSET = "UTF-8"
 
-from .request import *  # noqa
-from .requestcontext import context  # noqa
-from .response import *  # noqa
-from .core import *  # noqa
-from .routing import *  # noqa
-from .routeargs import *  # noqa
-from .subrequests import *  # noqa
+__all__ = [
+    "Request",
+    "currentrequest",
+    "context",
+    "Response",
+    "FrescoApp",
+    "urlfor",
+    "ALL_METHODS",
+    "DEFAULT_CHARSET",
+    "GET",
+    "HEAD",
+    "POST",
+    "PUT",
+    "DELETE",
+    "OPTIONS",
+    "TRACE",
+    "CONNECT",
+    "VERSION_CONTROL",
+    "REPORT",
+    "CHECKOUT",
+    "CHECKIN",
+    "UNCHECKOUT",
+    "MKWORKSPACE",
+    "UPDATE",
+    "LABEL",
+    "MERGE",
+    "BASELINE_CONTROL",
+    "MKACTIVITY",
+    "ORDERPATCH",
+    "ACL",
+    "SEARCH",
+    "PATCH",
+    "DelegateRoute",
+    "Options",
+    "Route",
+    "RouteCollection",
+    "RRoute",
+    "routearg",
+    "FormArg",
+    "PostArg",
+    "QueryArg",
+    "GetArg",
+    "CookieArg",
+    "SessionArg",
+    "RequestObject",
+    "FormData",
+    "PostData",
+    "QueryData",
+    "GetData",
+    "routefor",
+    "XForwarded",
+    "subrequest",
+    "subrequest_bytes",
+    "subrequest_raw",
+    "object_or_404",
+]
 
-from .util.common import *  # noqa
+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

@@ -151,9 +151,9 @@ class FrescoApp(RouteCollection):
 
     def get_response(
         self,
-        request,
-        path,
-        method,
+        request: Request,
+        path: str,
+        method: str,
         currentcontext=context.currentcontext,
         normpath=normpath,
     ):
@@ -259,12 +259,12 @@ class FrescoApp(RouteCollection):
 
         # Is the URL just missing a trailing '/'?
         if not path or path[-1] != "/":
-            for _ in self.get_methods(request, path + "/"):
+            if self.get_methods(request, path + "/"):
                 return Response.unrestricted_redirect_permanent(path + "/")
 
         return Response.not_found()
 
-    def view(self, request=None) -> Response:
+    def view(self, request: t.Optional[Request] = None) -> Response:
         request = request or context.request
         try:
             path = request.path_info
@@ -287,7 +287,9 @@ class FrescoApp(RouteCollection):
 
         return response
 
-    def handle_http_error_response(self, request, response):
+    def handle_http_error_response(
+        self, request: Request, response: Response
+    ) -> Response:
         """
         Call any process_http_error_response handlers and return the
         (potentially modified) response object.
@@ -303,8 +305,8 @@ class FrescoApp(RouteCollection):
                 self.log_exception(request)
         return response
 
-    def get_methods(self, request, path):
-        """\
+    def get_methods(self, request: Request, path: str) -> Set[str]:
+        """
         Return the HTTP methods valid in routes to the given path
         """
         methods: Set[str] = set()

fresco/middleware.py

@@ -12,7 +12,7 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 #
-__all__ = "XForwarded"
+__all__ = ["XForwarded"]
 
 
 class XForwarded(object):

fresco/multidict.py

@@ -16,12 +16,24 @@
 An order preserving multidict implementation
 """
 from collections.abc import MutableMapping
+from collections.abc import Mapping
 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
+else:
+    SupportsKeysAndGetItem = Mapping
+
+SupportsKeysAndGetItemOrIterable = t.Union[
+    SupportsKeysAndGetItem, t.Iterable[t.Tuple[Any, Any]]
+]
+
+
 class MultiDict(MutableMapping):
     """
     Dictionary-like object that supports multiple values per key. Insertion
@@ -44,9 +56,13 @@ class MultiDict(MutableMapping):
 
     """
 
+    _dict: Dict[Any, Any]
+    _order: t.List[Any]
     setdefault = MutableMapping.setdefault
 
-    def __init__(self, *args, **kwargs):
+    def __init__(
+        self, mapping_or_iterable: SupportsKeysAndGetItemOrIterable = tuple(), **kwargs
+    ):
         """
         MultiDicts can be constructed in the following ways:
 
@@ -76,13 +92,9 @@ class MultiDict(MutableMapping):
                 MultiDict(...)
 
         """
-        if len(args) > 1:
-            raise TypeError(
-                "%s expected at most 2 arguments, got %d"
-                % (self.__class__.__name__, 1 + len(args))
-            )
-        self.clear()
-        self.update(*args, **kwargs)
+        self._order = []
+        self._dict = {}
+        self._update(mapping_or_iterable, True, kwargs)
 
     def __getitem__(self, key):
         """
@@ -289,7 +301,7 @@ class MultiDict(MutableMapping):
         self._order.remove((key, value))
         return value
 
-    def popitem(self):
+    def popitem(self) -> t.Tuple[Any, Any]:
         """
         Return and remove a ``(key, value)`` pair from the dictionary.
 
@@ -314,7 +326,17 @@ class MultiDict(MutableMapping):
             raise KeyError("popitem(): dictionary is empty")
         return key, self.pop(key)
 
-    def update(self, *args, **kwargs):
+    @t.overload
+    def update(
+        self, mapping_or_iterable: SupportsKeysAndGetItem, /, **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
@@ -349,29 +371,24 @@ class MultiDict(MutableMapping):
                 >>> d.update(mood='okay')
 
         """
-        if len(args) > 1:
-            raise TypeError("expected at most 1 argument, got %d" % (1 + len(args),))
-        if args:
-            other = args[0]
-        else:
-            other = []
-        return self._update(other, True, **kwargs)
+        self._update(mapping_or_iterable, True, kwargs)
 
-    def extend(self, *args, **kwargs):
+    def extend(
+        self, mapping_or_iterable: 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.
         """
-        if len(args) > 1:
-            raise TypeError("expected at most 1 argument, got %d", (1 + len(args),))
-        if args:
-            other = args[0]
-        else:
-            other = []
-        return self._update(other, False, **kwargs)
+        return self._update(mapping_or_iterable, False, kwargs)
 
-    def _update(self, *args, **kwargs):
+    def _update(
+        self,
+        other: SupportsKeysAndGetItemOrIterable,
+        replace: bool,
+        extra_kwargs: Dict[Any, Any],
+    ):
         """
         Update the MultiDict from another object and optionally kwargs.
 
@@ -380,17 +397,15 @@ class MultiDict(MutableMapping):
         :param replace: if ``True``, entries will replace rather than extend
                         existing entries (second positional arg)
         """
-        other, replace = args
-
         if isinstance(other, self.__class__):
             items = list(other.allitems())
-        elif isinstance(other, dict):
+        elif isinstance(other, Mapping):
             items = list(other.items())
         else:
             items = list(other)
 
-        if kwargs:
-            items += list(kwargs.items())
+        if extra_kwargs:
+            items += list(extra_kwargs.items())
 
         if replace:
             replaced = {k for k, v in items if k in self._dict}
@@ -398,9 +413,11 @@ class MultiDict(MutableMapping):
             for key in replaced:
                 self._dict[key] = []
 
+        setdefault = self._dict.setdefault
+        append_order = self._order.append
         for k, v in items:
-            self._dict.setdefault(k, []).append(v)
-            self._order.append((k, v))
+            setdefault(k, []).append(v)
+            append_order((k, v))
 
     def __repr__(self):
         """
@@ -428,4 +445,4 @@ class MultiDict(MutableMapping):
 
     def clear(self):
         self._order = []
-        self._dict: Dict[Any, Any] = {}
+        self._dict = {}

fresco/options.py

@@ -15,6 +15,7 @@
 import inspect
 import json
 import logging
+import typing as t
 import os
 import re
 from decimal import Decimal
@@ -31,6 +32,8 @@ from typing import Union
 
 from fresco.exceptions import OptionsLoadedException
 
+__all__ = ["Options"]
+
 logger = logging.getLogger(__name__)
 
 
@@ -72,25 +75,39 @@ class Options(dict):
         for func in self._loaded_callbacks:
             func(self)
 
+    def trigger_onload(self):
+        """
+        Mark the options object as having loaded and call any registered
+        onload callbacks
+        """
+        if self._is_loaded:
+            raise OptionsLoadedException("Options have already been loaded")
+        self.do_loaded_callbacks()
+        self.__dict__["_is_loaded"] = True
+
     def copy(self):
         return self.__class__(super().copy())
 
     def load(
         self,
-        sources: str,
+        sources: t.Union[str, t.Iterable[t.Union[Path, str]]],
         tags: Sequence[str] = [],
         use_environ=False,
         strict=True,
         dir=None,
+        trigger_onload=True,
     ):
         """
         Find all files matching glob pattern ``sources`` and populates the
         options object from those with matching filenames containing ``tags``.
 
-        :param sources: glob pattern or glob patterns separated by ";"
-        :param tags: a list of tags to look for in file names. If a filename
-                     contains multiple tags, all the tags in the filename must
-                     match for it to be loaded.
+        :param sources:
+            one or more glob patterns separated by ";",
+            or a list of glob patterns
+
+        :param tags:
+            a list of tags to look for in file names.
+
         :param use_environ: if true, environment variables matching previously
                             loaded keys will be loaded into the options object.
                             This happens after all files have been processed.
@@ -102,13 +119,21 @@ class Options(dict):
         format. Any other files will be interpreted as simple lists of
         ```key=value`` pairs.
 
-        Tags in filenames should be delimited with periods, eg ".env.production.py". For
-        For example the filename ``setttings.dev.local.ini`` would be
-        considered to have the tags, ``('dev', 'local')``
+        Tags in filenames are delimited with periods,
+        for example ".env.production.py".
+        The filename ``setttings.dev.local.ini`` would be
+        considered to have the tags ``('dev', 'local')``
+
+        Where filename contain multiple tags, all tags must match for the file
+        to be loaded.
+
+        Tag names may contain the names of environment variable surrounded by
+        braces, for example ``{USER}``. These will be substituted for the
+        environment variable's value, with any dots or path separators replaced
+        by underscores.
 
-        The string '{hostname}' can be included as part of a tag name: it will
-        be substituted for the current host's name with dots replaced by
-        underscores.
+        The special variable ``{hostname}`` will be substituted for the current
+        host's name with dots replaced by underscores.
 
         Files with the suffix ".sample" are unconditionally excluded.
 
@@ -118,7 +143,7 @@ class Options(dict):
         Example::
 
             opts = Options()
-            opts.load(Options(), ".env*", ["dev", "host-{hostname}", "local"])
+            opts.load(".env*", ["dev", "host-{hostname}", "local"])
 
         Would load options from files named ``.env``, ``.env.json``, ``.env.dev.py``
         and ``.env.local.py.``
@@ -126,15 +151,24 @@ class Options(dict):
         """
         if self._is_loaded:
             raise OptionsLoadedException("Options have already been loaded")
-        hostname = gethostname().replace(".", "_")
+
+        tag_substitutions = os.environ.copy()
+        tag_substitutions["hostname"] = gethostname()
+        tag_substitutions = {
+            k: v.replace(".", "_").replace(os.pathsep, "_")
+            for k, v in tag_substitutions.items()
+        }
+
         candidates: List[Path] = []
         if dir is None:
             dir = Path(".")
         else:
             dir = Path(dir)
 
-        for source in sources.split(";"):
-            sourcepath = dir / Path(source.strip())
+        if isinstance(sources, str):
+            sources = [s.strip() for s in sources.split(";")]
+        for source in sources:
+            sourcepath = dir / Path(source)
             candidates.extend(
                 p
                 for p in sourcepath.parent.glob(sourcepath.name)
@@ -142,7 +176,13 @@ class Options(dict):
             )
 
         if tags:
-            tags = [t.format(hostname=hostname) for t in tags]
+            subbed_tags = []
+            for tag in tags:
+                try:
+                    subbed_tags.append(tag.format(**tag_substitutions))
+                except KeyError:
+                    pass
+            tags = subbed_tags
             tagged_sources = []
             for p in candidates:
                 candidate_tags = [t for t in str(p.name).split(".") if t][1:]
@@ -216,8 +256,9 @@ class Options(dict):
                     if k in os.environ:
                         self[k] = parse_value(self, os.environ[k])
 
-        self.do_loaded_callbacks()
-        self.__dict__["_is_loaded"] = True
+        if trigger_onload:
+            self.do_loaded_callbacks()
+            self.__dict__["_is_loaded"] = True
         return self
 
     def update_from_file(self, path, load_all=False):
@@ -256,9 +297,11 @@ class Options(dict):
 
     def update_from_object(self, ob, load_all=False):
         """
-        Update the instance with any symbols listed in object `ob`
-        :param load_all: If true private symbols will also be loaded into the
-                         options object.
+        Update the instance with any symbols found in object ``ob``.
+
+        :param load_all:
+            If true private symbols will also be loaded into the options
+            object.
         """
         self.update_from_dict(dict(inspect.getmembers(ob)), load_all)
 
@@ -298,3 +341,70 @@ def parse_key_value_pairs(options, lines: Iterable[str]):
         k = k.strip()
         values[k] = options[k] = parse_value(options, v)
     return values
+
+
+def list_from_str(s, separator=","):
+    """
+    Return the value of ``s`` split into a list of times by ``separator``.
+    Spaces around items will be stripped.
+    """
+    if isinstance(s, str):
+        if not s.strip():
+            return []
+        return [item.strip() for item in s.split(",")]
+    raise TypeError(f"Expected string, got {s!r}")
+
+
+def dict_from_options(
+    prefix: str, options: t.Mapping[str, Any], recursive: bool = False
+) -> t.Dict[str, Any]:
+    """
+    Create a dictionary containing all items in ``options`` whose keys start
+    with ``prefix``, with that prefix stripped.
+
+    Example:
+
+        >>> from fresco.options import Options, dict_from_options
+        >>> options = Options(
+        ...      {"DATABASE_HOST": "127.0.0.1", "DATABASE_USER": "scott"}
+        ... )
+        >>> dict_from_options("DATABASE_", options)
+        {'HOST': '127.0.0.1', 'USER': 'scott'}
+
+    If ``recursive`` is True, a recursive splitting will be
+    applied. The last character of ``prefix`` will be used as the separator,
+    for example::
+
+        >>> from fresco.options import dict_from_options
+        >>> options = Options(
+        ...      {
+        ...          "DATABASE_DEV_HOST": "127.0.0.1",
+        ...          "DATABASE_DEV_USER": "scott",
+        ...          "DATABASE_PROD_HOST": "192.168.0.78",
+        ...          "DATABASE_PROD_HOST": "tiger",
+        ...      }
+        ... )
+        >>> dict_from_options("DATABASE_", options, recursive=True)
+        {'DEV': {'HOST': '127.0.0.1', ...}, 'PROD': {'HOST', ...}}
+
+    """
+
+    prefixlen = len(prefix)
+    d = {k[prefixlen:]: v for k, v in options.items() if k.startswith(prefix)}
+
+    def recursive_split(d: t.Mapping[str, Any], sep: str) -> t.Dict[str, Any]:
+        d_: t.Dict[str, Any] = {}
+        for k in d:
+            if sep in k:
+                ks = k.split(sep)
+                subdict = d_
+                for subkey in ks[:-1]:
+                    subdict = subdict.setdefault(subkey, {})
+                subdict[ks[-1]] = d[k]
+            else:
+                d_[k] = d[k]
+        return d_
+
+    if recursive:
+        return recursive_split(d, prefix[-1])
+    return d

fresco/request.py

@@ -137,7 +137,7 @@ class Request(object):
         the ``query`` property.
         """
         if self._form is None:
-            if self.environ["REQUEST_METHOD"] in ("PUT", "POST"):
+            if self.environ["REQUEST_METHOD"] in {"PUT", "POST"}:
                 items, close = parse_post(
                     self.environ,
                     self.environ["wsgi.input"],

fresco/requestcontext.py

@@ -16,13 +16,16 @@ from collections import defaultdict
 from threading import get_ident
 from typing import Any
 from typing import Dict
-from typing import List
+import typing as t
 
-__all__ = "context", "RequestContext"
+__all__ = ["context", "RequestContext"]
+
+ContextDict = t.Dict[str, Any]
+ContextStack = t.List[ContextDict]
 
 
 class RequestContext(object):
-    """\
+    """
     A local storage class that maintains different values for each request
     context in which it is used.
 
@@ -42,13 +45,17 @@ class RequestContext(object):
 
     __slots__ = ["_contexts", "_ident_func"]
 
-    def __init__(self, ident_func=get_ident, setattr=object.__setattr__):
-        c: Dict[Any, List] = defaultdict(list)
+    def __init__(
+        self,
+        ident_func: t.Callable[[], t.Any] = get_ident,
+        setattr=object.__setattr__
+    ):
+        c: Dict[Any, ContextStack] = defaultdict(list)
         c[ident_func()] = [{}]
         setattr(self, "_contexts", c)
         setattr(self, "_ident_func", ident_func)
 
-    def push(self, **bindnames):
+    def push(self, **bindnames: t.Any):
         self._contexts[self._ident_func()].append(bindnames)
 
     def pop(self):
@@ -58,7 +65,7 @@ class RequestContext(object):
         if not ctx:
             del self._contexts[ident]
 
-    def currentcontext(self):
+    def currentcontext(self) -> ContextDict:
         return self._contexts[self._ident_func()][-1]
 
     def __getattr__(self, item):
@@ -67,7 +74,7 @@ class RequestContext(object):
         except (KeyError, IndexError):
             raise AttributeError(item)
 
-    def __setattr__(self, item, ob):
+    def __setattr__(self, item: str, ob: t.Any):
         self._contexts[self._ident_func()][-1][item] = ob
 
     def __delattr__(self, item):
@@ -81,7 +88,7 @@ class RequestContext(object):
     __setitem__ = __setattr__
     __delitem__ = __delattr__
 
-    def get(self, item, default=None):
+    def get(self, item: str, default=None):
         return self.currentcontext().get(item, default)
 
     def __repr__(self):

fresco/response.py

@@ -261,7 +261,7 @@ default_charset = "UTF-8"
 
 
 def encoder(stream, charset):
-    r"""\
+    """
     Encode a response iterator using the given character set.
     """
     if charset is None:
@@ -326,7 +326,7 @@ def make_headers(
 
 
 class Response(object):
-    """\
+    """
     Model an HTTP response
     """
 
@@ -500,7 +500,7 @@ class Response(object):
         )
 
     def get_headers(self, name):
-        """\
+        """
         Return the list of headers set with the given name.
 
         Synopsis::
@@ -515,7 +515,7 @@ class Response(object):
         ]
 
     def get_header(self, name, default=""):
-        """\
+        """
         Return the concatenated values of the named header(s) or ``default`` if
         the header has not been set.
 
@@ -547,7 +547,7 @@ class Response(object):
 
     @property
     def content_type(self):
-        """\
+        """
         Return the value of the ``Content-Type`` header if set, otherwise
         ``None``.
         """
@@ -557,7 +557,7 @@ class Response(object):
         return None
 
     def add_header(self, name, value, make_header_name=make_header_name):
-        """\
+        """
         Return a new response object with the given additional header.
 
         Synopsis::
@@ -571,7 +571,7 @@ class Response(object):
         return self.replace(headers=(self.headers + [(make_header_name(name), value)]))
 
     def add_headers(self, headers=[], **kwheaders):
-        """\
+        """
         Return a new response object with the given additional headers.
 
         Synopsis::
@@ -587,7 +587,7 @@ class Response(object):
         return self.replace(headers=make_headers(self.headers + headers, kwheaders))
 
     def remove_headers(self, *headers):
-        """\
+        """
         Return a new response object with the named headers removed.
 
         Synopsis::
@@ -617,7 +617,7 @@ class Response(object):
         httponly=False,
         samesite="Lax",
     ):
-        """\
+        """
         Return a new response object with the given cookie added.
 
         Synopsis::
@@ -720,7 +720,7 @@ class Response(object):
         )
 
     def buffered(self):
-        """\
+        """
         Return a new response object with the content buffered into a list.
         This will also generate a content-length header.
 
@@ -756,7 +756,7 @@ class Response(object):
 
     @classmethod
     def not_found(cls, request=None):
-        """\
+        """
         Return an HTTP not found response (404).
 
         Synopsis::
@@ -824,7 +824,7 @@ class Response(object):
 
     @classmethod
     def forbidden(cls, message="Sorry, access is denied"):
-        """\
+        """
         Return an HTTP forbidden response (403).
 
         Synopsis::
@@ -840,7 +840,7 @@ class Response(object):
 
     @classmethod
     def bad_request(cls, request=None):
-        """\
+        """
         Return an HTTP bad request response.
 
         Synopsis::
@@ -863,7 +863,7 @@ class Response(object):
 
     @classmethod
     def length_required(cls, request=None):
-        """\
+        """
         Return an HTTP Length Required response (411).
 
         Synopsis::
@@ -886,7 +886,7 @@ class Response(object):
 
     @classmethod
     def payload_too_large(cls, request=None):
-        """\
+        """
         Return an HTTP Payload Too Large response (413)::
 
             >>> response = Response.payload_too_large()
@@ -901,7 +901,7 @@ class Response(object):
 
     @classmethod
     def method_not_allowed(cls, valid_methods):
-        """\
+        """
         Return an HTTP method not allowed response (405)::
 
             >>> from fresco import context
@@ -923,7 +923,7 @@ class Response(object):
 
     @classmethod
     def internal_server_error(cls):
-        """\
+        """
         Return an HTTP internal server error response (500).
 
         Synopsis::
@@ -944,7 +944,7 @@ class Response(object):
     def unrestricted_redirect(
         cls, location, request=None, status=STATUS_FOUND, **kwargs
     ):
-        """\
+        """
         Return an HTTP redirect reponse (30x).
 
         :param location: The redirect location or a view specification.
@@ -1060,7 +1060,8 @@ class Response(object):
         :param kwargs: kwargs to be passed to :func:`fresco.core.urlfor` to
                        construct the redirect URL, or the fallback in the case
                        that ``location`` is already a qualified URL.
-        Synopsis:
+
+        Synopsis::
 
             >>> def view():
             ...   return Response.redirect("/new-location")
@@ -1084,7 +1085,7 @@ class Response(object):
 
     @classmethod
     def redirect_permanent(cls, *args, **kwargs):
-        """\
+        """
         Return an HTTP permanent redirect reponse.
 
         :param location: the URI of the new location. If relative this will be
@@ -1097,7 +1098,7 @@ class Response(object):
 
     @classmethod
     def redirect_temporary(cls, *args, **kwargs):
-        """\
+        """
         Return an HTTP permanent redirect reponse.
 
         :param location: the URI of the new location. If relative this will be
@@ -1110,7 +1111,7 @@ class Response(object):
 
     @classmethod
     def meta_refresh(cls, location, delay=1, request=None):
-        """\
+        """
         Return an HTML page containing a <meta http-equiv="refresh"> tag,
         causing the browser to redirect to the given location after ``delay``
         seconds.
@@ -1172,7 +1173,7 @@ class Response(object):
 
 
 def dump_response(r, line_break=b"\r\n", encoding="UTF-8"):
-    """\
+    """
     Return a byte-string representation of the given response, as for a HTTP
     response.
     """

fresco/routing.py

@@ -370,15 +370,15 @@ class PathConverter(StrConverter):
 
 
 class MatchAllURLsPattern(Pattern):
-    """\
-    A pattern matcher that matches all URLs starting with the given prefix. No
-    arguments are parsed from the URL.
+    """
+    A pattern matcher that matches all paths starting with the given prefix.
+    No arguments are parsed from the URL.
     """
 
     def __init__(self, path):
         self.path = path
 
-    def match(self, path):
+    def match(self, path: str) -> t.Optional[PathMatch]:
         if path.startswith(self.path):
             return PathMatch(self.path, path[len(self.path) :], (), {})
         return None
@@ -400,6 +400,32 @@ class MatchAllURLsPattern(Pattern):
         return "%s*" % (self.path,)
 
 
+class PrefixPattern(MatchAllURLsPattern):
+    """
+    A pattern matcher that matches the given prefix. The prefix will only be
+    matched at a path separator boundary.
+
+    ``PrefixPattern('/foo')`` will match the paths ``/foo`` and ``/foo/bar``,
+    but not ``/foobar``.
+
+    No arguments are parsed from the URL.
+    """
+
+    def __init__(self, path):
+        super().__init__(path)
+        if path[-1] == "/":
+            self.path_with_sep = path
+        else:
+            self.path_with_sep = f"{self.path}/"
+
+    def match(self, path: str) -> t.Optional[PathMatch]:
+        prefix = path[: len(self.path_with_sep)]
+
+        if prefix == self.path or prefix == self.path_with_sep:
+            return PathMatch(self.path, path[len(self.path) :], (), {})
+        return None
+
+
 class ExtensiblePattern(Pattern):
     """\
     An extensible URL pattern matcher.
@@ -547,10 +573,10 @@ class ExtensiblePattern(Pattern):
         """
         return eval("(lambda *args, **kwargs: (args, kwargs))(%s)" % argstr)
 
-    def match(self, path):
+    def match(self, path) -> t.Optional[PathMatch]:
         """
-        Test ``path`` and return a tuple of parsed ``(args, kwargs)``, or
-        ``None`` if there was no match.
+        Test ``path`` and return a PathMatch object or ``None`` if there was no
+        match.
         """
         mo = self.regex_match(path)
         if mo is None:
@@ -1358,13 +1384,18 @@ class RouteCollection(MutableSequence):
                     exc = self.__routed_views__[viewspec] = RouteNotFound(viewspec)
                     raise exc
 
-    def _get_routes(self, key):
+    def _get_routes(
+        self, key: Tuple[t.Optional[str], str]
+    ) -> t.Sequence[t.Tuple[Route, t.Optional[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]
 
     def get_route_traversals(
-        self, path: str, method: Optional[str], request: Optional[Request] = None
+        self,
+        path: str,
+        method: Optional[str],
+        request: Optional[Request] = None,
     ) -> t.Iterator[RouteTraversal]:
         """
         Generate RouteTraversals for routes matching the given path and
@@ -1604,7 +1635,7 @@ class RouteCollection(MutableSequence):
         :param path: the path prefix at which the view will be routed
         """
         return self.route(
-            MatchAllURLsPattern(path),
+            PrefixPattern(path),
             methods,
             view,
             route_class=route_class,

fresco/subrequests.py

@@ -34,12 +34,12 @@ def subrequest(view, *args, **kwargs):
     - **A callable**: a new subrequest context will be created and
       ``view(*args, **kwargs)`` will be called. Middleware and application
       hooks will not be called, and any
-      :class:`~fresco.routeargs.RouteArg`s  defined will not be resolved.
+      :class:`~fresco.routeargs.RouteArg` instances will not be resolved.
 
     - **Any other value**: the view function is looked up using the same
       route resolution rules as :meth:`~fresco.core.FrescoApp.urlfor`.
       Middleware and hooks will be skipped, but
-      :class:`~fresco.routeargs.RouteArg`s will be resolved.
+      :class:`~fresco.routeargs.RouteArg` instances will be resolved.
 
     If you pass in a view callable you can force RouteArgs to be resolved by
     specifying ``_resolve=True``.
@@ -272,6 +272,7 @@ def _get_args_for_route(
     route_kwargs = {}
     route_args = list(
         chain(
+            [request] if route.provide_request else [],
             ((a(request) if isinstance(a, RouteArg) else a) for a in route.view_args),
             (
                 mutable_args.pop(0)

fresco/util/http.py

@@ -202,6 +202,7 @@ def parse_querystring(
     charset: Optional[str] = None,
     strict: bool = False,
     keep_blank_values: bool = True,
+    unquote_plus=unquote_plus,
 ) -> List[Tuple[str, str]]:
     """
     Return ``(key, value)`` pairs from the given querystring::
@@ -519,7 +520,7 @@ def read_until(
     exhausted.
     """
     buf = b""
-    found = None
+    found: t.Optional[bool] = None
 
     def _found():
         if found is None:

{fresco-3.2.0.dist-info → fresco-3.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fresco
-Version: 3.2.0
+Version: 3.3.1
 Summary: A Web/WSGI micro-framework
 Home-page: https://ollycope.com/software/fresco/latest/
 Author: Oliver Cope

{fresco-3.2.0.dist-info → fresco-3.3.1.dist-info}/RECORD

@@ -1,18 +1,18 @@
-fresco/__init__.py,sha256=20OR-r7Rhjf-tUQ6_Pf99TxkSO647PahYGmTeb44DBE,917
+fresco/__init__.py,sha256=e0KXsDXDex3v2Efu5cGbMvN-jttFfz1aDo7pyG7O_rE,3520
 fresco/cookie.py,sha256=Qnx8yOjU4LUJ1fqi7YvqbhAA01rCsclJGl_fxI68slw,7055
-fresco/core.py,sha256=PrixFhBBUUZUb4LUTW4gYnO6OuzR8remPhOZ7PNeLSk,26509
+fresco/core.py,sha256=mwYR6UP0zRSjcFlNZf51-otX9EcmvgjEZ7GDVQoQexg,26615
 fresco/decorators.py,sha256=84NUpRJ-M7GK6wDl42bmCRSvgoWzCsy1huyvGnSAPPw,3232
 fresco/exceptions.py,sha256=KE-LoYUGnho6KltzkU6cnm9vUiUhAiDIjPqn5ba-YCA,4410
-fresco/middleware.py,sha256=Tu4QoSBeqqLqwlXd--mVTAdo5W8TYF11HauayprYnII,4171
-fresco/multidict.py,sha256=_VsRb7Q112M6M_OJ6QL2Rx81d3ar3SoZwMrUzogYedE,13004
-fresco/options.py,sha256=sW-lDDljNPvH4IfXngS93dfCaz09moxEhEWLuHhKz6A,10272
-fresco/request.py,sha256=CQ7fqk0eaxNIQdD1uU0XKsBIaJp6tI57Klof4NTVAy4,27071
-fresco/requestcontext.py,sha256=eVl-xpSUTHedzAIphFPHWF2MVy0sAbWku5rT6mFRSRo,3339
-fresco/response.py,sha256=wEvHwhUdpgt5F3LGnn6UmWF0GmF6IOlGxAjKKpu3ZFM,37099
+fresco/middleware.py,sha256=uCAuOtBnvaVBJGrQa8ecvLkSZ6aSKmWaJqxB8Rv4SsQ,4173
+fresco/multidict.py,sha256=0CaNNIcFnZ1hLk3NExhNvjc_BtK4zVB26L9gP_7MeNM,13362
+fresco/options.py,sha256=JneUzO1Ep4c3UbX-1icBZ9cZGheVmZAXdvegrbI39mw,13614
+fresco/request.py,sha256=JCETzqzGZgPpS7IBdqi4Hk3CTwTGiaTtRXFW_nPP1yg,27071
+fresco/requestcontext.py,sha256=P-SkKJkKLYVqNiR2zwooRROnSnE2VMj2P2-eD5DW5Qg,3504
+fresco/response.py,sha256=Pz8icriWhHNVsTkB5x5y99yvcz-nFC7Eobuv7tfLE3s,37078
 fresco/routeargs.py,sha256=dxNlqbQ1FrgIY6OCFzcEMdZ0OVyjlMQdQGLmUJgdPYU,10176
-fresco/routing.py,sha256=BrzTcT788JG_u4eLHaFcViztee1-OWHloD8WZI1CSA8,57738
+fresco/routing.py,sha256=nh7TiyDPQ1Y4RCXJGj_Wk-BP1UqpNyh6BKqxhNHlQ8U,58670
 fresco/static.py,sha256=9SKQ3P1YFTP45Qiic-ycvkpKRvqIURp1XSzPazTmYLI,2513
-fresco/subrequests.py,sha256=fM0EFmevw4_umHucWWKxIGMRUFHmSKCMdjKaTcaSAiQ,11016
+fresco/subrequests.py,sha256=wFJWLuhVAcei5imYc5NBSCBaHBEm-X4_XswPtK3O4Zw,11081
 fresco/types.py,sha256=UHITRMDoS90s2zV2wNpqLFhRWESfaBAMuQnL4c21mqY,106
 fresco/typing.py,sha256=jQ1r_wme54J08XZUdmuuW4M8ve-gEhm1Wriwctls3r8,347
 fresco/util/__init__.py,sha256=mJkaZzvYgBnxsBAGv8y_P1yzonHqWgw6VF2Zs4rmJEA,7
@@ -20,15 +20,15 @@ fresco/util/cache.py,sha256=EjzF9EzzDw4U4coOykkJEgh_8HMDpwhEbYKBo_TeOZQ,1609
 fresco/util/common.py,sha256=8lvrjhELvYsUWxu7DZi1OJcUOFk2ILYndNsnaS0IqjM,1258
 fresco/util/contentencodings.py,sha256=kRFQze8pi6o8bh1nMJa2BZRTAZ5Ud6PPBIhofhhZNDQ,5484
 fresco/util/file.py,sha256=Vp7qJTo9RouUeHq25ExyBGkGTHuW-9Q7D_0GB54DFe8,1383
-fresco/util/http.py,sha256=xToyXIGqNoS_9qvKHrFLTQAX18O3d7BpWpQdgV_eqTI,22126
+fresco/util/http.py,sha256=GQC-wL0lUpOF8zogrFHrh_3D7UbrksrLg_OVsv1c74Y,22175
 fresco/util/io.py,sha256=xxwDNJOcewY8lAR4Ce3cmB_zlrys8JGsESgwGWE198Y,1289
 fresco/util/object.py,sha256=FjYNfPHzvBqq1rn0Y6As-2AVZ_SZOjH-lrSy4EbYmHY,370
 fresco/util/security.py,sha256=nXEdoCak_2c4OA1L1wGwhZygS22s2fzwR0Kp-DdwKZg,1058
 fresco/util/textproc.py,sha256=e5jLTofKCqdm6_Fy8XOyR43AJr5APtL59Kd8cNA9PrQ,2309
 fresco/util/urls.py,sha256=aaVovLyXNlVoGviiLN94ImqXf-LTQs_xooEIyi3LBc4,9195
 fresco/util/wsgi.py,sha256=dV69VjJ7W8OqAxWzlA0dz7vAuC1MliNBnbr1MSyB6Is,12970
-fresco-3.2.0.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-fresco-3.2.0.dist-info/METADATA,sha256=TF7FJ3TRRPYhrghF5mFi0Cb54eE6eMYFy_xcImUJtIo,1575
-fresco-3.2.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-fresco-3.2.0.dist-info/top_level.txt,sha256=p_1aMce5Shjq9fIfdbB-aN8wCDhjF_iYnn98bUebbII,7
-fresco-3.2.0.dist-info/RECORD,,
+fresco-3.3.1.dist-info/LICENSE.txt,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+fresco-3.3.1.dist-info/METADATA,sha256=DEjrYiyD-gUvPOYEjyZz8y1y8PBrzIUxPx9wFuv7w_o,1575
+fresco-3.3.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+fresco-3.3.1.dist-info/top_level.txt,sha256=p_1aMce5Shjq9fIfdbB-aN8wCDhjF_iYnn98bUebbII,7
+fresco-3.3.1.dist-info/RECORD,,