fresco 3.2.0__tar.gz → 3.3.1__tar.gz

{fresco-3.2.0 → fresco-3.3.1}/CHANGELOG.rst

@@ -1,6 +1,22 @@
 Changelog
 =========
 
+3.3.1 (released 2023-05-18)
+---------------------------
+
+- The ``route_wsgi`` and ``route_all`` methods now only match at a
+  path separator boundary (``'/'``).
+- Bugfix: subrequest now works with views routed via ``RRoute`` (and so expect
+  an initial ``request`` argument)
+
+3.3.0
+-----
+
+- Options: fresco.options.Options can now take a list of paths as its first argument
+- Options: tags can now be specified with environment variable substitutions
+  (eg "{FOO}" would load files tagged with the current value of the 'FOO'
+  environment variable)
+- Options: add ``fresco.options.list_from_str`` and ``fresco.options.dict_from_options``
 
 3.2.0 (released 2023-04-16)
 ---------------------------

{fresco-3.2.0/fresco.egg-info → fresco-3.3.1}/PKG-INFO

@@ -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.3.1/fresco/__init__.py

@@ -0,0 +1,128 @@
+# Copyright 2015 Oliver Cope
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#     Unless required by applicable law or agreed to in writing, software
+#     distributed under the License is distributed on an "AS IS" BASIS,
+#     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#     See the License for the specific language governing permissions and
+#     limitations under the License.
+#
+__version__ = "3.3.1"
+
+DEFAULT_CHARSET = "UTF-8"
+
+__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 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-3.2.0 → fresco-3.3.1}/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-3.2.0 → fresco-3.3.1}/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-3.2.0 → fresco-3.3.1}/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-3.2.0 → fresco-3.3.1}/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-3.2.0 → fresco-3.3.1}/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"],