plain 0.40.0__tar.gz → 0.42.0__tar.gz

{plain-0.40.0 → plain-0.42.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain
-Version: 0.40.0
+Version: 0.42.0
 Summary: A web framework for building products with Python.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE

{plain-0.40.0 → plain-0.42.0}/plain/internal/handlers/base.py

@@ -80,12 +80,12 @@ class BaseHandler:
         """
         resolver_match = self.resolve_request(request)
 
-        response = resolver_match.func(
+        response = resolver_match.view(
             request, *resolver_match.args, **resolver_match.kwargs
         )
 
         # Complain if the view returned None (a common error).
-        self.check_response(response, resolver_match.func)
+        self.check_response(response, resolver_match.view)
 
         return response
 

{plain-0.40.0 → plain-0.42.0}/plain/templates/jinja/filters.py

@@ -19,6 +19,8 @@ default_filters = {
     # The standard Python ones
     "strftime": datetime.datetime.strftime,
     "strptime": datetime.datetime.strptime,
+    "fromtimestamp": datetime.datetime.fromtimestamp,
+    "fromisoformat": datetime.datetime.fromisoformat,
     # To convert to user time zone
     "localtime": localtime_filter,
     "timeuntil": timeuntil,

{plain-0.40.0 → plain-0.42.0}/plain/urls/patterns.py

@@ -1,13 +1,10 @@
-import functools
-import inspect
 import re
 import string
 
 from plain.exceptions import ImproperlyConfigured
 from plain.internal import internalcode
-from plain.preflight import Error, Warning
+from plain.preflight import Warning
 from plain.runtime import settings
-from plain.utils.functional import cached_property
 from plain.utils.regex_helper import _lazy_re_compile
 
 from .converters import get_converter
@@ -226,20 +223,6 @@ class URLPattern:
         else:
             return []
 
-    def _check_view(self):
-        from plain.views import View
-
-        view = self.view
-        if inspect.isclass(view) and issubclass(view, View):
-            return [
-                Error(
-                    f"Your URL pattern {self.pattern.describe()} has an invalid view, pass {view.__name__}.as_view() "
-                    f"instead of {view.__name__}.",
-                    id="urls.E009",
-                )
-            ]
-        return []
-
     def resolve(self, path):
         match = self.pattern.match(path)
         if match:
@@ -247,25 +230,9 @@ class URLPattern:
             from .resolvers import ResolverMatch
 
             return ResolverMatch(
-                self.view,
-                args,
-                captured_kwargs,
-                self.pattern.name,
+                view=self.view,
+                args=args,
+                kwargs=captured_kwargs,
+                url_name=self.pattern.name,
                 route=str(self.pattern),
-                captured_kwargs=captured_kwargs,
             )
-
-    @cached_property
-    def lookup_str(self):
-        """
-        A string that identifies the view (e.g. 'path.to.view_function' or
-        'path.to.ClassBasedView').
-        """
-        view = self.view
-        if isinstance(view, functools.partial):
-            view = view.func
-        if hasattr(view, "view_class"):
-            view = view.view_class
-        elif not hasattr(view, "__name__"):
-            return view.__module__ + "." + view.__class__.__name__
-        return view.__module__ + "." + view.__qualname__

{plain-0.40.0 → plain-0.42.0}/plain/urls/resolvers.py

@@ -8,7 +8,6 @@ attributes of the resolved URL match.
 
 import functools
 import re
-from pickle import PicklingError
 from threading import local
 from urllib.parse import quote
 
@@ -26,66 +25,29 @@ from .patterns import RegexPattern, URLPattern
 class ResolverMatch:
     def __init__(
         self,
-        func,
+        *,
+        view,
         args,
         kwargs,
         url_name=None,
         namespaces=None,
         route=None,
-        tried=None,
-        captured_kwargs=None,
-        extra_kwargs=None,
     ):
-        self.func = func
+        self.view = view
         self.args = args
         self.kwargs = kwargs
         self.url_name = url_name
         self.route = route
-        self.tried = tried
-        self.captured_kwargs = captured_kwargs
-        self.extra_kwargs = extra_kwargs
 
         # If a URLRegexResolver doesn't have a namespace or namespace, it passes
         # in an empty value.
         self.namespaces = [x for x in namespaces if x] if namespaces else []
         self.namespace = ":".join(self.namespaces)
 
-        if hasattr(func, "view_class"):
-            func = func.view_class
-        if not hasattr(func, "__name__"):
-            # A class-based view
-            self._func_path = func.__class__.__module__ + "." + func.__class__.__name__
-        else:
-            # A function-based view
-            self._func_path = func.__module__ + "." + func.__name__
-
-        view_path = url_name or self._func_path
-        self.view_name = ":".join(self.namespaces + [view_path])
-
-    def __repr__(self):
-        if isinstance(self.func, functools.partial):
-            func = repr(self.func)
-        else:
-            func = self._func_path
-        return (
-            "ResolverMatch(func={}, args={!r}, kwargs={!r}, url_name={!r}, "
-            "namespaces={!r}, route={!r}{}{})".format(
-                func,
-                self.args,
-                self.kwargs,
-                self.url_name,
-                self.namespaces,
-                self.route,
-                f", captured_kwargs={self.captured_kwargs!r}"
-                if self.captured_kwargs
-                else "",
-                f", extra_kwargs={self.extra_kwargs!r}" if self.extra_kwargs else "",
-            )
+        self.namespaced_url_name = (
+            ":".join(self.namespaces + [url_name]) if url_name else None
         )
 
-    def __reduce_ex__(self, protocol):
-        raise PicklingError(f"Cannot pickle {self.__class__.__qualname__}.")
-
 
 def get_resolver(router=None):
     if router is None:
@@ -257,13 +219,6 @@ class URLResolver:
             self._populate()
         return self._app_dict
 
-    @staticmethod
-    def _extend_tried(tried, pattern, sub_tried=None):
-        if sub_tried is None:
-            tried.append([pattern])
-        else:
-            tried.extend([pattern, *t] for t in sub_tried)
-
     @staticmethod
     def _join_route(route1, route2):
         """Join two routes, without the starting ^ in the second route."""
@@ -274,15 +229,14 @@ class URLResolver:
 
     def resolve(self, path):
         path = str(path)  # path may be a reverse_lazy object
-        tried = []
         match = self.pattern.match(path)
         if match:
             new_path, args, kwargs = match
             for pattern in self.url_patterns:
                 try:
                     sub_match = pattern.resolve(new_path)
-                except Resolver404 as e:
-                    self._extend_tried(tried, pattern, e.args[0].get("tried"))
+                except Resolver404:
+                    pass
                 else:
                     if sub_match:
                         # Merge captured arguments in match with submatch
@@ -299,20 +253,15 @@ class URLResolver:
                             if isinstance(pattern, URLPattern)
                             else str(pattern.pattern)
                         )
-                        self._extend_tried(tried, pattern, sub_match.tried)
                         return ResolverMatch(
-                            sub_match.func,
-                            sub_match_args,
-                            sub_match_dict,
-                            sub_match.url_name,
-                            [self.namespace] + sub_match.namespaces,
-                            self._join_route(current_route, sub_match.route),
-                            tried,
-                            captured_kwargs=sub_match.captured_kwargs,
-                            extra_kwargs=sub_match.extra_kwargs,
+                            view=sub_match.view,
+                            args=sub_match_args,
+                            kwargs=sub_match_dict,
+                            url_name=sub_match.url_name,
+                            namespaces=[self.namespace] + sub_match.namespaces,
+                            route=self._join_route(current_route, sub_match.route),
                         )
-                    tried.append([pattern])
-            raise Resolver404({"tried": tried, "path": new_path})
+            raise Resolver404({"path": new_path})
         raise Resolver404({"path": path})
 
     def reverse(self, lookup_view, *args, **kwargs):

{plain-0.40.0 → plain-0.42.0}/plain/views/templates.py

@@ -35,6 +35,7 @@ class TemplateView(View):
     def get_template_context(self) -> dict:
         return {
             "request": self.request,
+            "template_names": self.get_template_names(),
             "csrf_input": csrf_input_lazy(self.request),
             "csrf_token": csrf_token_lazy(self.request),
             "DEBUG": settings.DEBUG,

{plain-0.40.0 → plain-0.42.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "plain"
-version = "0.40.0"
+version = "0.42.0"
 description = "A web framework for building products with Python."
 authors = [{name = "Dave Gaeddert", email = "dave.gaeddert@dropseed.dev"}]
 readme = "README.md"