plain 0.1.0__py3-none-any.whl

plain/test/utils.py

@@ -0,0 +1,255 @@
+import sys
+import warnings
+from functools import wraps
+from itertools import chain
+from unittest import TestCase
+
+from plain.packages import packages
+from plain.runtime import settings
+from plain.runtime.user_settings import UserSettingsHolder
+
+__all__ = (
+    "ContextList",
+    "ignore_warnings",
+    "modify_settings",
+    "override_settings",
+)
+
+
+class ContextList(list):
+    """
+    A wrapper that provides direct key access to context items contained
+    in a list of context objects.
+    """
+
+    def __getitem__(self, key):
+        if isinstance(key, str):
+            for subcontext in self:
+                if key in subcontext:
+                    return subcontext[key]
+            raise KeyError(key)
+        else:
+            return super().__getitem__(key)
+
+    def get(self, key, default=None):
+        try:
+            return self.__getitem__(key)
+        except KeyError:
+            return default
+
+    def __contains__(self, key):
+        try:
+            self[key]
+        except KeyError:
+            return False
+        return True
+
+    def keys(self):
+        """
+        Flattened keys of subcontexts.
+        """
+        return set(chain.from_iterable(d for subcontext in self for d in subcontext))
+
+
+class TestContextDecorator:
+    """
+    A base class that can either be used as a context manager during tests
+    or as a test function or unittest.TestCase subclass decorator to perform
+    temporary alterations.
+
+    `attr_name`: attribute assigned the return value of enable() if used as
+                 a class decorator.
+
+    `kwarg_name`: keyword argument passing the return value of enable() if
+                  used as a function decorator.
+    """
+
+    def __init__(self, attr_name=None, kwarg_name=None):
+        self.attr_name = attr_name
+        self.kwarg_name = kwarg_name
+
+    def enable(self):
+        raise NotImplementedError
+
+    def disable(self):
+        raise NotImplementedError
+
+    def __enter__(self):
+        return self.enable()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.disable()
+
+    def decorate_class(self, cls):
+        if issubclass(cls, TestCase):
+            decorated_setUp = cls.setUp
+
+            def setUp(inner_self):
+                context = self.enable()
+                inner_self.addCleanup(self.disable)
+                if self.attr_name:
+                    setattr(inner_self, self.attr_name, context)
+                decorated_setUp(inner_self)
+
+            cls.setUp = setUp
+            return cls
+        raise TypeError("Can only decorate subclasses of unittest.TestCase")
+
+    def decorate_callable(self, func):
+        @wraps(func)
+        def inner(*args, **kwargs):
+            with self as context:
+                if self.kwarg_name:
+                    kwargs[self.kwarg_name] = context
+                return func(*args, **kwargs)
+
+        return inner
+
+    def __call__(self, decorated):
+        if isinstance(decorated, type):
+            return self.decorate_class(decorated)
+        elif callable(decorated):
+            return self.decorate_callable(decorated)
+        raise TypeError("Cannot decorate object of type %s" % type(decorated))
+
+
+class override_settings(TestContextDecorator):
+    """
+    Act as either a decorator or a context manager. If it's a decorator, take a
+    function and return a wrapped function. If it's a contextmanager, use it
+    with the ``with`` statement. In either event, entering/exiting are called
+    before and after, respectively, the function/block is executed.
+    """
+
+    enable_exception = None
+
+    def __init__(self, **kwargs):
+        self.options = kwargs
+        super().__init__()
+
+    def enable(self):
+        # Keep this code at the beginning to leave the settings unchanged
+        # in case it raises an exception because INSTALLED_PACKAGES is invalid.
+        if "INSTALLED_PACKAGES" in self.options:
+            try:
+                packages.set_installed_packages(self.options["INSTALLED_PACKAGES"])
+            except Exception:
+                packages.unset_installed_packages()
+                raise
+        override = UserSettingsHolder(settings._wrapped)
+        for key, new_value in self.options.items():
+            setattr(override, key, new_value)
+        self.wrapped = settings._wrapped
+        settings._wrapped = override
+        # for key, new_value in self.options.items():
+        #     try:
+        #         setting_changed.send(
+        #             sender=settings._wrapped.__class__,
+        #             setting=key,
+        #             value=new_value,
+        #             enter=True,
+        #         )
+        #     except Exception as exc:
+        #         self.enable_exception = exc
+        #         self.disable()
+
+    def disable(self):
+        if "INSTALLED_PACKAGES" in self.options:
+            packages.unset_installed_packages()
+        settings._wrapped = self.wrapped
+        del self.wrapped
+        responses = []
+        for key in self.options:
+            getattr(settings, key, None)
+            # responses_for_setting = setting_changed.send_robust(
+            #     sender=settings._wrapped.__class__,
+            #     setting=key,
+            #     value=new_value,
+            #     enter=False,
+            # )
+            # responses.extend(responses_for_setting)
+        if self.enable_exception is not None:
+            exc = self.enable_exception
+            self.enable_exception = None
+            raise exc
+        for _, response in responses:
+            if isinstance(response, Exception):
+                raise response
+
+    def save_options(self, test_func):
+        if test_func._overridden_settings is None:
+            test_func._overridden_settings = self.options
+        else:
+            # Duplicate dict to prevent subclasses from altering their parent.
+            test_func._overridden_settings = {
+                **test_func._overridden_settings,
+                **self.options,
+            }
+
+
+class modify_settings(override_settings):
+    """
+    Like override_settings, but makes it possible to append, prepend, or remove
+    items instead of redefining the entire list.
+    """
+
+    def __init__(self, *args, **kwargs):
+        if args:
+            # Hack used when instantiating from SimpleTestCase.setUpClass.
+            assert not kwargs
+            self.operations = args[0]
+        else:
+            assert not args
+            self.operations = list(kwargs.items())
+        super(override_settings, self).__init__()
+
+    def save_options(self, test_func):
+        if test_func._modified_settings is None:
+            test_func._modified_settings = self.operations
+        else:
+            # Duplicate list to prevent subclasses from altering their parent.
+            test_func._modified_settings = (
+                list(test_func._modified_settings) + self.operations
+            )
+
+    def enable(self):
+        self.options = {}
+        for name, operations in self.operations:
+            try:
+                # When called from SimpleTestCase.setUpClass, values may be
+                # overridden several times; cumulate changes.
+                value = self.options[name]
+            except KeyError:
+                value = list(getattr(settings, name, []))
+            for action, items in operations.items():
+                # items my be a single value or an iterable.
+                if isinstance(items, str):
+                    items = [items]
+                if action == "append":
+                    value += [item for item in items if item not in value]
+                elif action == "prepend":
+                    value = [item for item in items if item not in value] + value
+                elif action == "remove":
+                    value = [item for item in value if item not in items]
+                else:
+                    raise ValueError("Unsupported action: %s" % action)
+            self.options[name] = value
+        super().enable()
+
+
+class ignore_warnings(TestContextDecorator):
+    def __init__(self, **kwargs):
+        self.ignore_kwargs = kwargs
+        if "message" in self.ignore_kwargs or "module" in self.ignore_kwargs:
+            self.filter_func = warnings.filterwarnings
+        else:
+            self.filter_func = warnings.simplefilter
+        super().__init__()
+
+    def enable(self):
+        self.catch_warnings = warnings.catch_warnings()
+        self.catch_warnings.__enter__()
+        self.filter_func("ignore", **self.ignore_kwargs)
+
+    def disable(self):
+        self.catch_warnings.__exit__(*sys.exc_info())

plain/urls/README.md

@@ -0,0 +1,3 @@
+# urls
+
+Route requests to views.

plain/urls/__init__.py

@@ -0,0 +1,40 @@
+from .base import (
+    clear_url_caches,
+    get_urlconf,
+    is_valid_path,
+    resolve,
+    reverse,
+    reverse_lazy,
+    set_urlconf,
+)
+from .conf import include, path, re_path
+from .converters import register_converter
+from .exceptions import NoReverseMatch, Resolver404
+from .resolvers import (
+    ResolverMatch,
+    URLPattern,
+    URLResolver,
+    get_ns_resolver,
+    get_resolver,
+)
+
+__all__ = [
+    "NoReverseMatch",
+    "URLPattern",
+    "URLResolver",
+    "Resolver404",
+    "ResolverMatch",
+    "clear_url_caches",
+    "get_ns_resolver",
+    "get_resolver",
+    "get_urlconf",
+    "include",
+    "is_valid_path",
+    "path",
+    "re_path",
+    "register_converter",
+    "resolve",
+    "reverse",
+    "reverse_lazy",
+    "set_urlconf",
+]

plain/urls/base.py

@@ -0,0 +1,118 @@
+from threading import local
+
+from plain.utils.functional import lazy
+
+from .exceptions import NoReverseMatch, Resolver404
+from .resolvers import _get_cached_resolver, get_ns_resolver, get_resolver
+
+# Overridden URLconfs for each thread are stored here.
+_urlconfs = local()
+
+
+def resolve(path, urlconf=None):
+    if urlconf is None:
+        urlconf = get_urlconf()
+    return get_resolver(urlconf).resolve(path)
+
+
+def reverse(viewname, urlconf=None, args=None, kwargs=None, using_namespace=None):
+    if urlconf is None:
+        urlconf = get_urlconf()
+    resolver = get_resolver(urlconf)
+    args = args or []
+    kwargs = kwargs or {}
+
+    if not isinstance(viewname, str):
+        view = viewname
+    else:
+        *path, view = viewname.split(":")
+
+        if using_namespace:
+            current_path = using_namespace.split(":")
+            current_path.reverse()
+        else:
+            current_path = None
+
+        resolved_path = []
+        ns_pattern = ""
+        ns_converters = {}
+        for ns in path:
+            current_ns = current_path.pop() if current_path else None
+            # Lookup the name to see if it could be an app identifier.
+            try:
+                app_list = resolver.app_dict[ns]
+                # Yes! Path part matches an app in the current Resolver.
+                if current_ns and current_ns in app_list:
+                    # If we are reversing for a particular app, use that
+                    # namespace.
+                    ns = current_ns
+                elif ns not in app_list:
+                    # The name isn't shared by one of the instances (i.e.,
+                    # the default) so pick the first instance as the default.
+                    ns = app_list[0]
+            except KeyError:
+                pass
+
+            if ns != current_ns:
+                current_path = None
+
+            try:
+                extra, resolver = resolver.namespace_dict[ns]
+                resolved_path.append(ns)
+                ns_pattern += extra
+                ns_converters.update(resolver.pattern.converters)
+            except KeyError as key:
+                if resolved_path:
+                    raise NoReverseMatch(
+                        "{} is not a registered namespace inside '{}'".format(
+                            key, ":".join(resolved_path)
+                        )
+                    )
+                else:
+                    raise NoReverseMatch("%s is not a registered namespace" % key)
+        if ns_pattern:
+            resolver = get_ns_resolver(
+                ns_pattern, resolver, tuple(ns_converters.items())
+            )
+
+    return resolver.reverse(view, *args, **kwargs)
+
+
+reverse_lazy = lazy(reverse, str)
+
+
+def clear_url_caches():
+    _get_cached_resolver.cache_clear()
+    get_ns_resolver.cache_clear()
+
+
+def set_urlconf(urlconf_name):
+    """
+    Set the URLconf for the current thread (overriding the default one in
+    settings). If urlconf_name is None, revert back to the default.
+    """
+    if urlconf_name:
+        _urlconfs.value = urlconf_name
+    else:
+        if hasattr(_urlconfs, "value"):
+            del _urlconfs.value
+
+
+def get_urlconf(default=None):
+    """
+    Return the root URLconf to use for the current thread if it has been
+    changed from the default one.
+    """
+    return getattr(_urlconfs, "value", default)
+
+
+def is_valid_path(path, urlconf=None):
+    """
+    Return the ResolverMatch if the given path resolves against the default URL
+    resolver, False otherwise. This is a convenience method to make working
+    with "is this a match?" cases easier, avoiding try...except blocks.
+    """
+    try:
+        return resolve(path, urlconf)
+    except Resolver404:
+        return False

plain/urls/conf.py

@@ -0,0 +1,94 @@
+"""Functions for use in URLsconfs."""
+from functools import partial
+
+from plain.exceptions import ImproperlyConfigured
+
+from .resolvers import (
+    RegexPattern,
+    RoutePattern,
+    URLPattern,
+    URLResolver,
+)
+
+
+def include(arg, namespace=None):
+    default_namespace = None
+    if isinstance(arg, tuple):
+        # Callable returning a namespace hint.
+        try:
+            urlconf_module, default_namespace = arg
+        except ValueError:
+            if namespace:
+                raise ImproperlyConfigured(
+                    "Cannot override the namespace for a dynamic module that "
+                    "provides a namespace."
+                )
+            raise ImproperlyConfigured(
+                "Passing a %d-tuple to include() is not supported. Pass a "
+                "2-tuple containing the list of patterns and default_namespace, and "
+                "provide the namespace argument to include() instead." % len(arg)
+            )
+    else:
+        # No namespace hint - use manually provided namespace.
+        urlconf_module = arg
+
+    patterns = getattr(urlconf_module, "urlpatterns", urlconf_module)
+    default_namespace = getattr(urlconf_module, "default_namespace", default_namespace)
+    if namespace and not default_namespace:
+        raise ImproperlyConfigured(
+            "Specifying a namespace in include() without providing an default_namespace "
+            "is not supported. Set the default_namespace attribute in the included "
+            "module, or pass a 2-tuple containing the list of patterns and "
+            "default_namespace instead.",
+        )
+    namespace = namespace or default_namespace
+    # Make sure the patterns can be iterated through (without this, some
+    # testcases will break).
+    if isinstance(patterns, list | tuple):
+        for url_pattern in patterns:
+            getattr(url_pattern, "pattern", None)
+    return (urlconf_module, default_namespace, namespace)
+
+
+def _path(route, view, kwargs=None, name=None, Pattern=None):
+    from plain.views import View
+
+    if kwargs is not None and not isinstance(kwargs, dict):
+        raise TypeError(
+            f"kwargs argument must be a dict, but got {kwargs.__class__.__name__}."
+        )
+
+    if isinstance(view, list | tuple):
+        # For include(...) processing.
+        pattern = Pattern(route, is_endpoint=False)
+        urlconf_module, default_namespace, namespace = view
+        return URLResolver(
+            pattern,
+            urlconf_module,
+            kwargs,
+            default_namespace=default_namespace,
+            namespace=namespace,
+        )
+
+    if isinstance(view, View):
+        view_cls_name = view.__class__.__name__
+        raise TypeError(
+            f"view must be a callable, pass {view_cls_name} or {view_cls_name}.as_view(*args, **kwargs), not "
+            f"{view_cls_name}()."
+        )
+
+    # Automatically call view.as_view() for class-based views
+    if as_view := getattr(view, "as_view", None):
+        pattern = Pattern(route, name=name, is_endpoint=True)
+        return URLPattern(pattern, as_view(), kwargs, name)
+
+    # Function-based views or view_class.as_view() usage
+    if callable(view):
+        pattern = Pattern(route, name=name, is_endpoint=True)
+        return URLPattern(pattern, view, kwargs, name)
+
+    raise TypeError("view must be a callable or a list/tuple in the case of include().")
+
+
+path = partial(_path, Pattern=RoutePattern)
+re_path = partial(_path, Pattern=RegexPattern)

plain/urls/converters.py

@@ -0,0 +1,66 @@
+import functools
+import uuid
+
+
+class IntConverter:
+    regex = "[0-9]+"
+
+    def to_python(self, value):
+        return int(value)
+
+    def to_url(self, value):
+        return str(value)
+
+
+class StringConverter:
+    regex = "[^/]+"
+
+    def to_python(self, value):
+        return value
+
+    def to_url(self, value):
+        return value
+
+
+class UUIDConverter:
+    regex = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+
+    def to_python(self, value):
+        return uuid.UUID(value)
+
+    def to_url(self, value):
+        return str(value)
+
+
+class SlugConverter(StringConverter):
+    regex = "[-a-zA-Z0-9_]+"
+
+
+class PathConverter(StringConverter):
+    regex = ".+"
+
+
+DEFAULT_CONVERTERS = {
+    "int": IntConverter(),
+    "path": PathConverter(),
+    "slug": SlugConverter(),
+    "str": StringConverter(),
+    "uuid": UUIDConverter(),
+}
+
+
+REGISTERED_CONVERTERS = {}
+
+
+def register_converter(converter, type_name):
+    REGISTERED_CONVERTERS[type_name] = converter()
+    get_converters.cache_clear()
+
+
+@functools.cache
+def get_converters():
+    return {**DEFAULT_CONVERTERS, **REGISTERED_CONVERTERS}
+
+
+def get_converter(raw_converter):
+    return get_converters()[raw_converter]

plain/urls/exceptions.py

@@ -0,0 +1,9 @@
+from plain.http import Http404
+
+
+class Resolver404(Http404):
+    pass
+
+
+class NoReverseMatch(Exception):
+    pass