plain 0.1.0__py3-none-any.whl

plain/views/objects.py

@@ -0,0 +1,229 @@
+from plain.exceptions import ImproperlyConfigured, ObjectDoesNotExist
+from plain.http import Http404, Response, ResponseRedirect
+
+from .forms import FormView
+from .templates import TemplateView
+
+
+class ObjectTemplateViewMixin:
+    context_object_name = ""
+
+    def get(self) -> Response:
+        self.load_object()
+        return self.render_template()
+
+    def load_object(self) -> None:
+        try:
+            self.object = self.get_object()
+        except ObjectDoesNotExist:
+            raise Http404
+
+        if not self.object:
+            # Also raise 404 if the object is None
+            raise Http404
+
+    def get_object(self):  # Intentionally untyped... subclasses must override this.
+        raise NotImplementedError(
+            f"get_object() is not implemented on {self.__class__.__name__}"
+        )
+
+    def get_template_context(self) -> dict:
+        """Insert the single object into the context dict."""
+        context = super().get_template_context()  # type: ignore
+        context["object"] = self.object
+        if self.context_object_name:
+            context[self.context_object_name] = self.object
+        elif hasattr(self.object, "_meta"):
+            context[self.object._meta.model_name] = self.object
+        return context
+
+    def get_template_names(self) -> list[str]:
+        """
+        Return a list of template names to be used for the request. May not be
+        called if render_to_response() is overridden. Return the following list:
+
+        * the value of ``template_name`` on the view (if provided)
+          object instance that the view is operating upon (if available)
+        * ``<package_label>/<model_name><template_name_suffix>.html``
+        """
+        if self.template_name:  # type: ignore
+            return [self.template_name]  # type: ignore
+
+        # If template_name isn't specified, it's not a problem --
+        # we just start with an empty list.
+        names = []
+
+        # The least-specific option is the default <app>/<model>_detail.html;
+        # only use this if the object in question is a model.
+        if hasattr(self.object, "_meta"):
+            object_meta = self.object._meta
+            names.append(
+                f"{object_meta.package_label}/{object_meta.model_name}{self.template_name_suffix}.html"
+            )
+
+        return names
+
+
+class DetailView(ObjectTemplateViewMixin, TemplateView):
+    """
+    Render a "detail" view of an object.
+
+    By default this is a model instance looked up from `self.queryset`, but the
+    view will support display of *any* object by overriding `self.get_object()`.
+    """
+
+    template_name_suffix = "_detail"
+
+
+class CreateView(ObjectTemplateViewMixin, FormView):
+    """
+    View for creating a new object, with a response rendered by a template.
+    """
+
+    def post(self) -> Response:
+        """
+        Handle POST requests: instantiate a form instance with the passed
+        POST variables and then check if it's valid.
+        """
+        # Context expects self.object to exist
+        self.load_object()
+        return super().post()
+
+    def load_object(self) -> None:
+        self.object = None
+
+    # TODO? would rather you have to specify this...
+    def get_success_url(self):
+        """Return the URL to redirect to after processing a valid form."""
+        if self.success_url:
+            url = self.success_url.format(**self.object.__dict__)
+        else:
+            try:
+                url = self.object.get_absolute_url()
+            except AttributeError:
+                raise ImproperlyConfigured(
+                    "No URL to redirect to.  Either provide a url or define"
+                    " a get_absolute_url method on the Model."
+                )
+        return url
+
+    def form_valid(self, form):
+        """If the form is valid, save the associated model."""
+        self.object = form.save()
+        return super().form_valid(form)
+
+
+class UpdateView(ObjectTemplateViewMixin, FormView):
+    """View for updating an object, with a response rendered by a template."""
+
+    template_name_suffix = "_form"
+
+    def post(self) -> Response:
+        """
+        Handle POST requests: instantiate a form instance with the passed
+        POST variables and then check if it's valid.
+        """
+        self.load_object()
+        return super().post()
+
+    def get_success_url(self):
+        """Return the URL to redirect to after processing a valid form."""
+        if self.success_url:
+            url = self.success_url.format(**self.object.__dict__)
+        else:
+            try:
+                url = self.object.get_absolute_url()
+            except AttributeError:
+                raise ImproperlyConfigured(
+                    "No URL to redirect to.  Either provide a url or define"
+                    " a get_absolute_url method on the Model."
+                )
+        return url
+
+    def form_valid(self, form):
+        """If the form is valid, save the associated model."""
+        self.object = form.save()
+        return super().form_valid(form)
+
+    def get_form_kwargs(self):
+        """Return the keyword arguments for instantiating the form."""
+        kwargs = super().get_form_kwargs()
+        kwargs.update({"instance": self.object})
+        return kwargs
+
+
+class DeleteView(ObjectTemplateViewMixin, TemplateView):
+    """
+    View for deleting an object retrieved with self.get_object(), with a
+    response rendered by a template.
+    """
+
+    template_name_suffix = "_confirm_delete"
+
+    def get_form_kwargs(self):
+        """Return the keyword arguments for instantiating the form."""
+        kwargs = super().get_form_kwargs()
+        kwargs.update({"instance": self.object})
+        return kwargs
+
+    def get_success_url(self):
+        if self.success_url:
+            return self.success_url.format(**self.object.__dict__)
+        else:
+            raise ImproperlyConfigured("No URL to redirect to. Provide a success_url.")
+
+    def post(self):
+        self.load_object()
+        self.object.delete()
+        return ResponseRedirect(self.get_success_url())
+
+
+class ListView(TemplateView):
+    """
+    Render some list of objects, set by `self.get_queryset()`, with a response
+    rendered by a template.
+    """
+
+    template_name_suffix = "_list"
+    context_object_name = "objects"
+
+    def get(self) -> Response:
+        self.objects = self.get_objects()
+        return super().get()
+
+    def get_objects(self):
+        raise NotImplementedError(
+            f"get_objects() is not implemented on {self.__class__.__name__}"
+        )
+
+    def get_template_context(self) -> dict:
+        """Insert the single object into the context dict."""
+        context = super().get_template_context()  # type: ignore
+        context[self.context_object_name] = self.objects
+        return context
+
+    def get_template_names(self) -> list[str]:
+        """
+        Return a list of template names to be used for the request. May not be
+        called if render_to_response() is overridden. Return the following list:
+
+        * the value of ``template_name`` on the view (if provided)
+          object instance that the view is operating upon (if available)
+        * ``<package_label>/<model_name><template_name_suffix>.html``
+        """
+        if self.template_name:  # type: ignore
+            return [self.template_name]  # type: ignore
+
+        # If template_name isn't specified, it's not a problem --
+        # we just start with an empty list.
+        names = []
+
+        # The least-specific option is the default <app>/<model>_detail.html;
+        # only use this if the object in question is a model.
+        if hasattr(self.objects, "model") and hasattr(self.objects.model, "_meta"):
+            object_meta = self.objects.model._meta
+            names.append(
+                f"{object_meta.package_label}/{object_meta.model_name}{self.template_name_suffix}.html"
+            )
+
+        return names

plain/views/redirect.py

@@ -0,0 +1,72 @@
+import logging
+
+from plain.http import (
+    ResponseGone,
+    ResponsePermanentRedirect,
+    ResponseRedirect,
+)
+from plain.urls import reverse
+
+from .base import View
+
+logger = logging.getLogger("plain.request")
+
+
+class RedirectView(View):
+    """Provide a redirect on any GET request."""
+
+    permanent = False
+    url: str | None = None
+    pattern_name: str | None = None
+    query_string = False
+
+    def get_redirect_url(self):
+        """
+        Return the URL redirect to. Keyword arguments from the URL pattern
+        match generating the redirect request are provided as kwargs to this
+        method.
+        """
+        if self.url:
+            url = self.url % self.url_kwargs
+        elif self.pattern_name:
+            url = reverse(self.pattern_name, args=self.url_args, kwargs=self.url_kwargs)
+        else:
+            return None
+
+        args = self.request.META.get("QUERY_STRING", "")
+        if args and self.query_string:
+            url = f"{url}?{args}"
+        return url
+
+    def get(self):
+        url = self.get_redirect_url()
+        if url:
+            if self.permanent:
+                return ResponsePermanentRedirect(url)
+            else:
+                return ResponseRedirect(url)
+        else:
+            logger.warning(
+                "Gone: %s",
+                self.request.path,
+                extra={"status_code": 410, "request": self.request},
+            )
+            return ResponseGone()
+
+    def head(self):
+        return self.get()
+
+    def post(self):
+        return self.get()
+
+    def options(self):
+        return self.get()
+
+    def delete(self):
+        return self.get()
+
+    def put(self):
+        return self.get()
+
+    def patch(self):
+        return self.get()

plain/views/templates.py

@@ -0,0 +1,66 @@
+from plain.csrf.middleware import get_token
+from plain.exceptions import ImproperlyConfigured
+from plain.runtime import settings
+from plain.templates import Template, TemplateFileMissing
+from plain.utils.functional import lazy
+from plain.utils.html import format_html
+from plain.utils.safestring import SafeString
+
+from .base import View
+
+
+def csrf_input(request):
+    return format_html(
+        '<input type="hidden" name="csrfmiddlewaretoken" value="{}">',
+        get_token(request),
+    )
+
+
+csrf_input_lazy = lazy(csrf_input, SafeString, str)
+csrf_token_lazy = lazy(get_token, str)
+
+
+class TemplateView(View):
+    """
+    Render a template. Pass keyword arguments from the URLconf to the context.
+    """
+
+    template_name: str | None = None
+
+    def get_template_context(self) -> dict:
+        return {
+            "request": self.request,
+            "csrf_input": csrf_input_lazy(self.request),
+            "csrf_token": csrf_token_lazy(self.request),
+            "DEBUG": settings.DEBUG,
+        }
+
+    def get_template_names(self) -> list[str]:
+        """
+        Return a list of template names to be used for the request. Must return
+        a list. May not be called if render_to_response() is overridden.
+        """
+        if self.template_name is None:
+            raise ImproperlyConfigured(
+                "TemplateView requires either a definition of "
+                "'template_name' or an implementation of 'get_template_names()'"
+            )
+        else:
+            return [self.template_name]
+
+    def get_template(self) -> Template:
+        template_names = self.get_template_names()
+
+        for template_name in template_names:
+            try:
+                return Template(template_name)
+            except TemplateFileMissing:
+                pass
+
+        raise TemplateFileMissing(template_names)
+
+    def render_template(self) -> str:
+        return self.get_template().render(self.get_template_context())
+
+    def get(self):
+        return self.render_template()

plain/wsgi.py

@@ -0,0 +1,11 @@
+import plain.runtime
+from plain.internal.handlers.wsgi import WSGIHandler
+
+
+def _get_wsgi_application():
+    plain.runtime.setup()
+    return WSGIHandler()
+
+
+# The default `plain.wsgi:app` WSGI application
+app = _get_wsgi_application()

plain-0.1.0.dist-info/LICENSE

@@ -0,0 +1,85 @@
+## Plain is released under the BSD 3-Clause License
+
+BSD 3-Clause License
+
+Copyright (c) 2023, Dropseed, LLC
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+## This package contains code forked from github.com/django/django
+
+Copyright (c) Django Software Foundation and individual contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+    3. Neither the name of Django nor the names of its contributors may be used
+       to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+## This package contains code forked from github.com/evansd/whitenoise
+
+The MIT License (MIT)
+
+Copyright (c) 2013 David Evans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

plain-0.1.0.dist-info/METADATA

@@ -0,0 +1,51 @@
+Metadata-Version: 2.1
+Name: plain
+Version: 0.1.0
+Summary: A web framework for building products with Python.
+Author: Dave Gaeddert
+Author-email: dave.gaeddert@dropseed.dev
+Requires-Python: >=3.11,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: click (>=8.0.0)
+Requires-Dist: jinja2 (>=3.1.2,<4.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Description-Content-Type: text/markdown
+
+<!-- This file is compiled from plain/plain/README.md. Do not edit this file directly. -->
+
+# Plain
+
+Plain is a web framework for building products with Python.
+
+With the core `plain` package you can build an app that:
+
+- Matches [URL patterns](https://plainframework.com/docs/plain/plain/urls) to Python [views](https://plainframework.com/docs/plain/plain/views)
+- Handles [HTTP requests and responses](https://plainframework.com/docs/plain/plain/http)
+- Renders [HTML templates](https://plainframework.com/docs/plain/plain/templates) with Jinja
+- Processes user input via [forms](https://plainframework.com/docs/plain/plain/forms)
+- Has a [CLI interface](https://plainframework.com/docs/plain/plain/cli)
+- Serves static [assets](https://plainframework.com/docs/plain/plain/assets) (CSS, JS, images)
+- Can be modified with [middleware](https://plainframework.com/docs/plain/plain/middleware)
+- Integrates first-party and third-party [packages](https://plainframework.com/docs/plain/plain/packages)
+- Has a [preflight check system](https://plainframework.com/docs/plain/plain/preflight)
+
+With the official Plain ecosystem packages you can:
+
+- Integrate a full-featured [database ORM](https://plainframework.com/docs/plain-models/)
+- Use a built-in [user authentication](https://plainframework.com/docs/plain-auth/) system
+- [Lint and format code](https://plainframework.com/docs/plain-code/)
+- Run a [database-backed cache](https://plainframework.com/docs/plain-cache/)
+- [Send emails](https://plainframework.com/docs/plain-mail/)
+- Streamline [local development](https://plainframework.com/docs/plain-dev/)
+- Manage [feature flags](https://plainframework.com/docs/plain-flags/)
+- Integrate [HTMX](https://plainframework.com/docs/plain-htmx/)
+- Style with [Tailwind CSS](https://plainframework.com/docs/plain-tailwind/)
+- Add [OAuth login](https://plainframework.com/docs/plain-oauth/) and API access
+- Run tests with [pytest](https://plainframework.com/docs/plain-test/)
+- Run a [background job worker](https://plainframework.com/docs/plain-worker/)
+- Build [staff tooling and admin dashboards](https://plainframework.com/docs/plain-staff/)
+
+Learn more at [plainframework.com](https://plainframework.com).
+