plain 0.39.0__py3-none-any.whl → 0.40.0__py3-none-any.whl

plain/chores/README.md

@@ -0,0 +1,64 @@
+# Chores
+
+**Routine maintenance tasks.**
+
+Chores are registered functions that can be run at any time to keep an app in a desirable state.
+
+![](https://assets.plainframework.com/docs/plain-chores-run.png)
+
+A good example is the clearing of expired sessions in [`plain.sessions`](/plain-sessions/plain/sessions/chores.py) — since the sessions are stored in the database, occasionally you will want to delete any sessions that are expired and no longer in use.
+
+```python
+# plain/sessions/chores.py
+from plain.chores import register_chore
+from plain.utils import timezone
+
+from .models import Session
+
+
+@register_chore("sessions")
+def clear_expired():
+    """
+    Delete sessions that have expired.
+    """
+    result = Session.objects.filter(expires_at__lt=timezone.now()).delete()
+    return f"{result[0]} expired sessions deleted"
+```
+
+## Running chores
+
+The `plain chores run` command will execute all registered chores. When and how to run this is up to the user, but running them hourly is a safe assumption in most cases (assuming you have any chores — `plain chores list`).
+
+There are several ways you can run chores depending on your needs:
+
+- on deploy
+- as a [`plain.worker` scheduled job](/plain-worker/plain/worker/README.md#scheduled-jobs)
+- as a cron job (using any cron-like system where your app is hosted)
+- manually as needed
+
+## Writing chores
+
+A chore is a function decorated with `@register_chore(chore_group_name)`. It can write a description as a docstring, and it can return a value that will be printed when the chore is run.
+
+```python
+# app/chores.py
+from plain.chores import register_chore
+
+
+@register_chore("app")
+def chore_name():
+    """
+    A chore description can go here
+    """
+    # Do a thing!
+    return "We did it!"
+```
+
+A good chore is:
+
+- Fast
+- Idempotent
+- Recurring
+- Stateless
+
+If chores are written in `app/chores.py` or `{pkg}/chores.py`, then they will be imported automatically and registered.

plain/csrf/middleware.py

@@ -74,9 +74,9 @@ def _unmask_cipher_token(token):
 
 
 def _add_new_csrf_cookie(request):
-    """Generate a new random CSRF_COOKIE value, and add it to request.META."""
+    """Generate a new random CSRF_COOKIE value, and add it to request.meta."""
     csrf_secret = _get_new_csrf_string()
-    request.META.update(
+    request.meta.update(
         {
             "CSRF_COOKIE": csrf_secret,
             "CSRF_COOKIE_NEEDS_UPDATE": True,
@@ -95,12 +95,12 @@ def get_token(request):
     header to the outgoing response.  For this reason, you may need to use this
     function lazily, as is done by the csrf context processor.
     """
-    if "CSRF_COOKIE" in request.META:
-        csrf_secret = request.META["CSRF_COOKIE"]
+    if "CSRF_COOKIE" in request.meta:
+        csrf_secret = request.meta["CSRF_COOKIE"]
         # Since the cookie is being used, flag to send the cookie in
         # process_response() (even if the client already has it) in order to
         # renew the expiry timer.
-        request.META["CSRF_COOKIE_NEEDS_UPDATE"] = True
+        request.meta["CSRF_COOKIE_NEEDS_UPDATE"] = True
     else:
         csrf_secret = _add_new_csrf_cookie(request)
     return _mask_cipher_secret(csrf_secret)
@@ -177,14 +177,14 @@ class CsrfViewMiddleware:
                 # masked, this also causes it to be replaced with the unmasked
                 # form, but only in cases where the secret is already getting
                 # saved anyways.
-                request.META["CSRF_COOKIE"] = csrf_secret
+                request.meta["CSRF_COOKIE"] = csrf_secret
 
         if csrf_response := self._get_csrf_response(request):
             return csrf_response
 
         response = self.get_response(request)
 
-        if request.META.get("CSRF_COOKIE_NEEDS_UPDATE"):
+        if request.meta.get("CSRF_COOKIE_NEEDS_UPDATE"):
             self._set_csrf_cookie(request, response)
             # Unset the flag to prevent _set_csrf_cookie() from being
             # unnecessarily called again in process_response() by other
@@ -193,7 +193,7 @@ class CsrfViewMiddleware:
             # CSRF_COOKIE_NEEDS_UPDATE is still respected in subsequent calls
             # e.g. in case rotate_token() is called in process_response() later
             # by custom middleware but before those subsequent calls.
-            request.META["CSRF_COOKIE_NEEDS_UPDATE"] = False
+            request.meta["CSRF_COOKIE_NEEDS_UPDATE"] = False
 
         return response
 
@@ -246,7 +246,7 @@ class CsrfViewMiddleware:
         the request's secret has invalid characters or an invalid length.
         """
         try:
-            csrf_secret = request.COOKIES[settings.CSRF_COOKIE_NAME]
+            csrf_secret = request.cookies[settings.CSRF_COOKIE_NAME]
         except KeyError:
             csrf_secret = None
         else:
@@ -260,7 +260,7 @@ class CsrfViewMiddleware:
     def _set_csrf_cookie(self, request, response):
         response.set_cookie(
             settings.CSRF_COOKIE_NAME,
-            request.META["CSRF_COOKIE"],
+            request.meta["CSRF_COOKIE"],
             max_age=settings.CSRF_COOKIE_AGE,
             domain=settings.CSRF_COOKIE_DOMAIN,
             path=settings.CSRF_COOKIE_PATH,
@@ -272,7 +272,7 @@ class CsrfViewMiddleware:
         patch_vary_headers(response, ("Cookie",))
 
     def _origin_verified(self, request):
-        request_origin = request.META["HTTP_ORIGIN"]
+        request_origin = request.meta["HTTP_ORIGIN"]
         try:
             good_host = request.get_host()
         except DisallowedHost:
@@ -298,7 +298,7 @@ class CsrfViewMiddleware:
         )
 
     def _check_referer(self, request):
-        referer = request.META.get("HTTP_REFERER")
+        referer = request.meta.get("HTTP_REFERER")
         if referer is None:
             raise RejectRequest(REASON_NO_REFERER)
 
@@ -364,7 +364,7 @@ class CsrfViewMiddleware:
         request_csrf_token = ""
         if request.method == "POST":
             try:
-                request_csrf_token = request.POST.get(settings.CSRF_POST_NAME, "")
+                request_csrf_token = request.data.get(settings.CSRF_FIELD_NAME, "")
             except UnreadablePostError:
                 # Handle a broken connection before we've completed reading the
                 # POST data. process_view shouldn't raise any exceptions, so
@@ -398,7 +398,7 @@ class CsrfViewMiddleware:
             raise RejectRequest(reason)
 
     def _get_csrf_response(self, request):
-        # Wait until request.META["CSRF_COOKIE"] has been manipulated before
+        # Wait until request.meta["CSRF_COOKIE"] has been manipulated before
         # bailing out, so that get_token still works
         if getattr(request, "csrf_exempt", True):
             return None
@@ -409,10 +409,10 @@ class CsrfViewMiddleware:
 
         # Reject the request if the Origin header doesn't match an allowed
         # value.
-        if "HTTP_ORIGIN" in request.META:
+        if "HTTP_ORIGIN" in request.meta:
             if not self._origin_verified(request):
                 return self._reject(
-                    request, REASON_BAD_ORIGIN % request.META["HTTP_ORIGIN"]
+                    request, REASON_BAD_ORIGIN % request.meta["HTTP_ORIGIN"]
                 )
         elif request.is_https():
             # If the Origin header wasn't provided, reject HTTPS requests if

plain/forms/forms.py

@@ -3,10 +3,8 @@ Form classes
 """
 
 import copy
-import json
 
 from plain.exceptions import NON_FIELD_ERRORS
-from plain.utils.datastructures import MultiValueDict
 from plain.utils.functional import cached_property
 
 from .exceptions import ValidationError
@@ -64,27 +62,12 @@ class BaseForm:
         prefix=None,
         initial=None,
     ):
-        if request.method in ("POST", "PUT", "PATCH"):
-            if request.headers.get("Content-Type") == "application/json":
-                self.data = json.loads(request.body)
-                self.is_json_request = True
-            elif request.headers.get("Content-Type") in [
-                "application/x-www-form-urlencoded",
-                "multipart/form-data",
-            ]:
-                self.data = request.POST
-                self.is_json_request = False
-            else:
-                raise ValueError(
-                    "Unsupported Content-Type. Supported types are "
-                    "'application/json', 'application/x-www-form-urlencoded', "
-                    "and 'multipart/form-data'."
-                )
-        else:
-            self.data = MultiValueDict()
-            self.is_json_request = False
+        self.data = request.data
+        self.files = request.files
 
-        self.files = request.FILES
+        self.is_json_request = request.headers.get("Content-Type", "").startswith(
+            "application/json"
+        )
 
         self.is_bound = bool(self.data or self.files)
 

plain/http/README.md

@@ -14,7 +14,7 @@ class ExampleView(View):
         print(self.request.headers.get("Example-Header"))
 
         # Accessing a query parameter
-        print(self.request.GET.get("example"))
+        print(self.request.query_params.get("example"))
 
         # Creating a response
         response = Response("Hello, world!", status_code=200)

plain/http/multipartparser.py

@@ -54,12 +54,12 @@ class MultiPartParser:
 
     boundary_re = _lazy_re_compile(r"[ -~]{0,200}[!-~]")
 
-    def __init__(self, META, input_data, upload_handlers, encoding=None):
+    def __init__(self, meta, input_data, upload_handlers, encoding=None):
         """
         Initialize the MultiPartParser object.
 
-        :META:
-            The standard ``META`` dictionary in Plain request objects.
+        :meta:
+            The standard ``meta`` dictionary in Plain request objects.
         :input_data:
             The raw post data, as a file-like object.
         :upload_handlers:
@@ -69,7 +69,7 @@ class MultiPartParser:
             The encoding with which to treat the incoming data.
         """
         # Content-Type should contain multipart and the boundary information.
-        content_type = META.get("CONTENT_TYPE", "")
+        content_type = meta.get("CONTENT_TYPE", "")
         if not content_type.startswith("multipart/"):
             raise MultiPartParserError(f"Invalid Content-Type: {content_type}")
 
@@ -91,7 +91,7 @@ class MultiPartParser:
         # Content-Length should contain the length of the body we are about
         # to receive.
         try:
-            content_length = int(META.get("CONTENT_LENGTH", 0))
+            content_length = int(meta.get("CONTENT_LENGTH", 0))
         except (ValueError, TypeError):
             content_length = 0
 
@@ -107,7 +107,7 @@ class MultiPartParser:
         possible_sizes = [x.chunk_size for x in upload_handlers if x.chunk_size]
         self._chunk_size = min([2**31 - 4] + possible_sizes)
 
-        self._meta = META
+        self._meta = meta
         self._encoding = encoding or settings.DEFAULT_CHARSET
         self._content_length = content_length
         self._upload_handlers = upload_handlers

plain/http/request.py

@@ -1,5 +1,6 @@
 import codecs
 import copy
+import json
 import uuid
 from io import BytesIO
 from itertools import chain
@@ -64,11 +65,11 @@ class HttpRequest:
         # A unique ID we can use to trace this request
         self.unique_id = str(uuid.uuid4())
 
-        self.GET = QueryDict(mutable=True)
-        self.POST = QueryDict(mutable=True)
-        self.COOKIES = {}
-        self.META = {}
-        self.FILES = MultiValueDict()
+        self.query_params = QueryDict(mutable=True)
+        self.data = QueryDict(mutable=True)
+        self.cookies = {}
+        self.meta = {}
+        self.files = MultiValueDict()
 
         self.path = ""
         self.path_info = ""
@@ -99,7 +100,7 @@ class HttpRequest:
 
     @cached_property
     def headers(self):
-        return HttpHeaders(self.META)
+        return HttpHeaders(self.meta)
 
     @cached_property
     def accepted_types(self):
@@ -130,13 +131,13 @@ class HttpRequest:
         allowed hosts protection, so may return an insecure host.
         """
         # We try three options, in order of decreasing preference.
-        if settings.USE_X_FORWARDED_HOST and ("HTTP_X_FORWARDED_HOST" in self.META):
-            host = self.META["HTTP_X_FORWARDED_HOST"]
-        elif "HTTP_HOST" in self.META:
-            host = self.META["HTTP_HOST"]
+        if settings.USE_X_FORWARDED_HOST and ("HTTP_X_FORWARDED_HOST" in self.meta):
+            host = self.meta["HTTP_X_FORWARDED_HOST"]
+        elif "HTTP_HOST" in self.meta:
+            host = self.meta["HTTP_HOST"]
         else:
             # Reconstruct the host using the algorithm from PEP 333.
-            host = self.META["SERVER_NAME"]
+            host = self.meta["SERVER_NAME"]
             server_port = self.get_port()
             if server_port != ("443" if self.is_https() else "80"):
                 host = f"{host}:{server_port}"
@@ -166,10 +167,10 @@ class HttpRequest:
 
     def get_port(self):
         """Return the port number for the request as a string."""
-        if settings.USE_X_FORWARDED_PORT and "HTTP_X_FORWARDED_PORT" in self.META:
-            port = self.META["HTTP_X_FORWARDED_PORT"]
+        if settings.USE_X_FORWARDED_PORT and "HTTP_X_FORWARDED_PORT" in self.meta:
+            port = self.meta["HTTP_X_FORWARDED_PORT"]
         else:
-            port = self.META["SERVER_PORT"]
+            port = self.meta["SERVER_PORT"]
         return str(port)
 
     def get_full_path(self, force_append_slash=False):
@@ -198,8 +199,8 @@ class HttpRequest:
         return "{}{}{}".format(
             escape_uri_path(path),
             "/" if force_append_slash and not path.endswith("/") else "",
-            ("?" + iri_to_uri(self.META.get("QUERY_STRING", "")))
-            if self.META.get("QUERY_STRING", "")
+            ("?" + iri_to_uri(self.meta.get("QUERY_STRING", "")))
+            if self.meta.get("QUERY_STRING", "")
             else "",
         )
 
@@ -263,7 +264,7 @@ class HttpRequest:
                     "The HTTPS_PROXY_HEADER setting must be a tuple containing "
                     "two values."
                 )
-            header_value = self.META.get(header)
+            header_value = self.meta.get(header)
             if header_value is not None:
                 header_value, *_ = header_value.split(",", 1)
                 return "https" if header_value.strip() == secure_value else "http"
@@ -279,15 +280,15 @@ class HttpRequest:
     @encoding.setter
     def encoding(self, val):
         """
-        Set the encoding used for GET/POST accesses. If the GET or POST
+        Set the encoding used for query_params/data accesses. If the query_params or data
         dictionary has already been created, remove and recreate it on the
         next access (so that it is decoded correctly).
         """
         self._encoding = val
-        if hasattr(self, "GET"):
-            del self.GET
-        if hasattr(self, "_post"):
-            del self._post
+        if hasattr(self, "query_params"):
+            del self.query_params
+        if hasattr(self, "_data"):
+            del self._data
 
     def _initialize_handlers(self):
         self._upload_handlers = [
@@ -311,15 +312,15 @@ class HttpRequest:
             )
         self._upload_handlers = upload_handlers
 
-    def parse_file_upload(self, META, post_data):
-        """Return a tuple of (POST QueryDict, FILES MultiValueDict)."""
+    def parse_file_upload(self, meta, post_data):
+        """Return a tuple of (data QueryDict, files MultiValueDict)."""
         self.upload_handlers = ImmutableList(
             self.upload_handlers,
             warning=(
                 "You cannot alter upload handlers after the upload has been processed."
             ),
         )
-        parser = MultiPartParser(META, post_data, self.upload_handlers, self.encoding)
+        parser = MultiPartParser(meta, post_data, self.upload_handlers, self.encoding)
         return parser.parse()
 
     @property
@@ -333,7 +334,7 @@ class HttpRequest:
             # Limit the maximum request data size that will be handled in-memory.
             if (
                 settings.DATA_UPLOAD_MAX_MEMORY_SIZE is not None
-                and int(self.META.get("CONTENT_LENGTH") or 0)
+                and int(self.meta.get("CONTENT_LENGTH") or 0)
                 > settings.DATA_UPLOAD_MAX_MEMORY_SIZE
             ):
                 raise RequestDataTooBig(
@@ -350,29 +351,31 @@ class HttpRequest:
         return self._body
 
     def _mark_post_parse_error(self):
-        self._post = QueryDict()
+        self._data = QueryDict()
         self._files = MultiValueDict()
 
-    def _load_post_and_files(self):
-        """Populate self._post and self._files if the content-type is a form type"""
-        if self.method != "POST":
-            self._post, self._files = (
-                QueryDict(encoding=self._encoding),
-                MultiValueDict(),
-            )
-            return
+    def _load_data_and_files(self):
+        """Populate self._data and self._files"""
+
         if self._read_started and not hasattr(self, "_body"):
             self._mark_post_parse_error()
             return
 
-        if self.content_type == "multipart/form-data":
+        if self.content_type.startswith("application/json"):
+            try:
+                self._data = json.loads(self.body)
+                self._files = MultiValueDict()
+            except json.JSONDecodeError:
+                self._mark_post_parse_error()
+                raise
+        elif self.content_type == "multipart/form-data":
             if hasattr(self, "_body"):
                 # Use already read data
                 data = BytesIO(self._body)
             else:
                 data = self
             try:
-                self._post, self._files = self.parse_file_upload(self.META, data)
+                self._data, self._files = self.parse_file_upload(self.meta, data)
             except (MultiPartParserError, TooManyFilesSent):
                 # An error occurred while parsing POST data. Since when
                 # formatting the error the request handler might access
@@ -381,12 +384,12 @@ class HttpRequest:
                 self._mark_post_parse_error()
                 raise
         elif self.content_type == "application/x-www-form-urlencoded":
-            self._post, self._files = (
+            self._data, self._files = (
                 QueryDict(self.body, encoding=self._encoding),
                 MultiValueDict(),
             )
         else:
-            self._post, self._files = (
+            self._data, self._files = (
                 QueryDict(encoding=self._encoding),
                 MultiValueDict(),
             )
@@ -400,7 +403,7 @@ class HttpRequest:
     #
     # Expects self._stream to be set to an appropriate source of bytes by
     # a corresponding request subclass (e.g. WSGIRequest).
-    # Also when request data has already been read by request.POST or
+    # Also when request data has already been read by request.data or
     # request.body, self._stream points to a BytesIO instance
     # containing that data.
 

plain/internal/files/uploadhandler.py

@@ -85,7 +85,7 @@ class FileUploadHandler:
         self.request = request
 
     def handle_raw_input(
-        self, input_data, META, content_length, boundary, encoding=None
+        self, input_data, meta, content_length, boundary, encoding=None
     ):
         """
         Handle the raw input from the client.
@@ -94,8 +94,8 @@ class FileUploadHandler:
 
             :input_data:
                 An object that supports reading via .read().
-            :META:
-                ``request.META``.
+            :meta:
+                ``request.meta``.
             :content_length:
                 The (integer) value of the Content-Length header from the
                 client.
@@ -199,7 +199,7 @@ class MemoryFileUploadHandler(FileUploadHandler):
     """
 
     def handle_raw_input(
-        self, input_data, META, content_length, boundary, encoding=None
+        self, input_data, meta, content_length, boundary, encoding=None
     ):
         """
         Use the content_length to signal whether or not this handler should be

plain/internal/handlers/wsgi.py

@@ -72,9 +72,9 @@ class WSGIRequest(HttpRequest):
         self.path = "{}/{}".format(
             script_name.rstrip("/"), path_info.replace("/", "", 1)
         )
-        self.META = environ
-        self.META["PATH_INFO"] = path_info
-        self.META["SCRIPT_NAME"] = script_name
+        self.meta = environ
+        self.meta["PATH_INFO"] = path_info
+        self.meta["SCRIPT_NAME"] = script_name
         self.method = environ["REQUEST_METHOD"].upper()
         # Set content_type, content_params, and encoding.
         self._set_content_type_params(environ)
@@ -89,39 +89,39 @@ class WSGIRequest(HttpRequest):
     def __getstate__(self):
         state = super().__getstate__()
         for attr in self.meta_non_picklable_attrs:
-            if attr in state["META"]:
-                del state["META"][attr]
+            if attr in state["meta"]:
+                del state["meta"][attr]
         return state
 
     def _get_scheme(self):
         return self.environ.get("wsgi.url_scheme")
 
     @cached_property
-    def GET(self):
+    def query_params(self):
         # The WSGI spec says 'QUERY_STRING' may be absent.
         raw_query_string = get_bytes_from_wsgi(self.environ, "QUERY_STRING", "")
         return QueryDict(raw_query_string, encoding=self._encoding)
 
-    def _get_post(self):
-        if not hasattr(self, "_post"):
-            self._load_post_and_files()
-        return self._post
+    def _get_data(self):
+        if not hasattr(self, "_data"):
+            self._load_data_and_files()
+        return self._data
 
-    def _set_post(self, post):
-        self._post = post
+    def _set_data(self, data):
+        self._data = data
 
     @cached_property
-    def COOKIES(self):
+    def cookies(self):
         raw_cookie = get_str_from_wsgi(self.environ, "HTTP_COOKIE", "")
         return parse_cookie(raw_cookie)
 
     @property
-    def FILES(self):
+    def files(self):
         if not hasattr(self, "_files"):
-            self._load_post_and_files()
+            self._load_data_and_files()
         return self._files
 
-    POST = property(_get_post, _set_post)
+    data = property(_get_data, _set_data)
 
 
 class WSGIHandler(base.BaseHandler):

plain/runtime/global_settings.py

@@ -134,7 +134,7 @@ CSRF_COOKIE_SECURE = True
 CSRF_COOKIE_HTTPONLY = False
 CSRF_COOKIE_SAMESITE = "Lax"
 CSRF_HEADER_NAME = "CSRF-Token"
-CSRF_POST_NAME = "_csrftoken"
+CSRF_FIELD_NAME = "_csrftoken"
 CSRF_TRUSTED_ORIGINS: list[str] = []
 
 ###########

plain/views/redirect.py

@@ -38,7 +38,7 @@ class RedirectView(View):
         else:
             return None
 
-        args = self.request.META.get("QUERY_STRING", "")
+        args = self.request.meta.get("QUERY_STRING", "")
         if args and self.query_string:
             url = f"{url}?{args}"
         return url

plain/views/templates.py

@@ -12,7 +12,7 @@ from .base import View
 def csrf_input(request):
     return format_html(
         '<input type="hidden" name="{}" value="{}">',
-        settings.CSRF_POST_NAME,
+        settings.CSRF_FIELD_NAME,
         get_token(request),
     )
 

{plain-0.39.0.dist-info → plain-0.40.0.dist-info}/METADATA

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

{plain-0.39.0.dist-info → plain-0.40.0.dist-info}/RECORD

@@ -14,6 +14,7 @@ plain/assets/finders.py,sha256=2k8QZAbfUbc1LykxbzdazTSB6xNxJZnsZaGhWbSFZZs,1452
 plain/assets/fingerprints.py,sha256=2LPHLUkoITMseLDmemTpBtMRDWCR2H5GAHjC6AN4gz0,1367
 plain/assets/urls.py,sha256=zQUA8bAlh9qVqskPJJrqWd9DjvetOi5jPSqy4vUX0J4,1161
 plain/assets/views.py,sha256=T_0Qh6v9qBerEBYbhToigwOzsij-x1z_R-1zETQcIh0,9447
+plain/chores/README.md,sha256=Da8Nw8ZF7PlAE_iVb0AqJGbLOu0F6HC0cj1K451KBak,1946
 plain/chores/__init__.py,sha256=r9TXtQCH-VbvfnIJ5F8FxgQC35GRWFOfmMZN3q9niLg,67
 plain/chores/registry.py,sha256=V3WjuekRI22LFvJbqSkUXQtiOtuE2ZK8gKV1TRvxRUI,1866
 plain/cli/README.md,sha256=ompPcgzY2Fdpm579ITmCpFIaZIsiXYbfD61mqkq312M,1860
@@ -33,19 +34,19 @@ plain/cli/startup.py,sha256=wLaFuyUb4ewWhtehBCGicrRCXIIGCRbeCT3ce9hUv-A,1022
 plain/cli/urls.py,sha256=CS9NFpwZBWveAR8F3YsoUNySDEK_PwF73oSgLDfkOdI,3776
 plain/cli/utils.py,sha256=VwlIh0z7XxzVV8I3qM2kZo07fkJFPoeeVZa1ODG616k,258
 plain/csrf/README.md,sha256=nxCpPk1HF5eAM-7paxg9D-9RVCU9jXsSPAVHkJvA_DU,717
-plain/csrf/middleware.py,sha256=bn8KOE45aucSam0m3F9g8FVfnmjjt-6jxS6iSNwHamU,17413
+plain/csrf/middleware.py,sha256=MJusxqfa_SVpzHchfkTOCzccCl8twT8Cr_ymxLb5EvY,17414
 plain/csrf/views.py,sha256=HwQqfI6KPelHP9gSXhjfZaTLQic71PKsoZ6DPhr1rKI,572
 plain/forms/README.md,sha256=TawBdy1jP0-8HUsfUzd7vvgkwl3EJGejDxFhWR8F-80,2242
 plain/forms/__init__.py,sha256=UxqPwB8CiYPCQdHmUc59jadqaXqDmXBH8y4bt9vTPms,226
 plain/forms/boundfield.py,sha256=LhydhCVR0okrli0-QBMjGjAJ8-06gTCXVEaBZhBouQk,1741
 plain/forms/exceptions.py,sha256=NYk1wjYDkk-lA_XMJQDItOebQcL_m_r2eNRc2mkLQkg,315
 plain/forms/fields.py,sha256=C71ed7m8VBnsgS-eIC6Xsmz7ruNSkdGa1BuSo7V3QKc,34574
-plain/forms/forms.py,sha256=Zcl5euWWxuE-CTcOHsOVYixWESdVk7no2Sz40AxmudY,11204
-plain/http/README.md,sha256=G662f56feQWiEHw9tTncZqK8kNB_nbR1HTGeOR1ygNM,713
+plain/forms/forms.py,sha256=gyDUrl7wh7n3fqKMB6eH0-AvCmWXST3oc-jBWUf9rmU,10454
+plain/http/README.md,sha256=F9wbahgSU3jIDEG14gJjdPJRem4weUNvwnwhb7o3cu0,722
 plain/http/__init__.py,sha256=DIsDRbBsCGa4qZgq-fUuQS0kkxfbTU_3KpIM9VvH04w,1067
 plain/http/cookie.py,sha256=11FnSG3Plo6T3jZDbPoCw7SKh9ExdBio3pTmIO03URg,597
-plain/http/multipartparser.py,sha256=Cyk_UZhxf8JwNza_Yl4_nKCYkmnG7xY9PSVcf9Us57U,27266
-plain/http/request.py,sha256=kq3AuM0EWyAD_kqMlorTccm5mzIQ6ZefkCa-jXUntnI,25514
+plain/http/multipartparser.py,sha256=Z1dFJNAd8N5RHUuF67jh1jBfZOFepORsre_3ee6CgOQ,27266
+plain/http/request.py,sha256=Xlolhpp2ZfZIi0TOz960U16CdqGi8jMhmHsBtxpkR_4,25631
 plain/http/response.py,sha256=IGSg22ioob6kSRkKGQsQF_exb2Lch8RKiZr_Xoi1_xA,23644
 plain/internal/__init__.py,sha256=fVBaYLCXEQc-7riHMSlw3vMTTuF7-0Bj2I8aGzv0o0w,171
 plain/internal/files/__init__.py,sha256=VctFgox4Q1AWF3klPaoCC5GIw5KeLafYjY5JmN8mAVw,63
@@ -54,12 +55,12 @@ plain/internal/files/locks.py,sha256=z03q7IZD4tPMK3s1HKF3w_uetkFj6w6FTheLUxZsfB0
 plain/internal/files/move.py,sha256=jfdD29QhamxZjXRgqmZS4dJoJ4sK6M7QK1Km-69jWeo,3238
 plain/internal/files/temp.py,sha256=UJJnCI8dqPIC8XXHU3-jG2-0svbkrgGlBs4yhciLm4c,2506
 plain/internal/files/uploadedfile.py,sha256=JRB7T3quQjg-1y3l1ASPxywtSQZhaeMc45uFPIxvl7c,4192
-plain/internal/files/uploadhandler.py,sha256=eEnd5onstypjHYtg367PnVWwCaF1kAPlLPSV7goIf_E,7198
+plain/internal/files/uploadhandler.py,sha256=63_QUwAwfq3bevw79i0S7zt2EB2UBoO7MaauvezaVMY,7198
 plain/internal/files/utils.py,sha256=xN4HTJXDRdcoNyrL1dFd528MBwodRlHZM8DGTD_oBIg,2646
 plain/internal/handlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plain/internal/handlers/base.py,sha256=oRKni79ATI_u7sywGFExrzKvP5dpJTqIp1m521A90Ew,4169
 plain/internal/handlers/exception.py,sha256=vfha_6-fz6S6VYCP1PMBfue2Gw-_th6jqaTE372fGlw,4809
-plain/internal/handlers/wsgi.py,sha256=aOGCd9hJEMTVMGfgIDlSFvevd8_XCzZa2dtlR4peqZg,8253
+plain/internal/handlers/wsgi.py,sha256=sOgqnE4fNzKD2a5EMubiEpHEK9Mi69FWx3BVWxGgMw0,8262
 plain/internal/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 plain/internal/middleware/headers.py,sha256=ENIW1Gwat54hv-ejgp2R8QTZm-PlaI7k44WU01YQrNk,964
 plain/internal/middleware/https.py,sha256=XpuQK8HicYX1jNanQHqNgyQ9rqe4NLUOZO3ZzKdsP8k,1203
@@ -82,7 +83,7 @@ plain/preflight/security.py,sha256=oxUZBp2M0bpBfUoLYepIxoex2Y90nyjlrL8XU8UTHYY,2
 plain/preflight/urls.py,sha256=cQ-WnFa_5oztpKdtwhuIGb7pXEml__bHsjs1SWO2YNI,1468
 plain/runtime/README.md,sha256=S_FIOmSq8LkVQHh9Xm6s3EJWKTVdlSr5A_bNXgh02X8,4740
 plain/runtime/__init__.py,sha256=o2RVETiL8U0lMFBpbtfnxflhw_4MFllMV6CEpX3RqZs,1965
-plain/runtime/global_settings.py,sha256=gg9XhMJmzbQqfxzst5JaI0hDIzPvTwX5M0AonJk2ISY,5579
+plain/runtime/global_settings.py,sha256=Vi7jabMF-SBolkP5qx1nLnGoDt_kD1KT_wgtbjNlPHw,5580
 plain/runtime/user_settings.py,sha256=uRHHVfzUvHon91_fOKj7K2WaBYwJ1gCPLfeXqKj5CTs,10902
 plain/signals/README.md,sha256=FInfJXdVQkb7u93PvD8XgPbz_f6m0l2xIu_4PyttV1E,234
 plain/signals/__init__.py,sha256=eAs0kLqptuP6I31dWXeAqRNji3svplpAV4Ez6ktjwXM,131
@@ -143,10 +144,10 @@ plain/views/errors.py,sha256=jbNCJIzowwCsEvqyJ3opMeZpPDqTyhtrbqb0VnAm2HE,1263
 plain/views/exceptions.py,sha256=b4euI49ZUKS9O8AGAcFfiDpstzkRAuuj_uYQXzWNHME,138
 plain/views/forms.py,sha256=ESZOXuo6IeYixp1RZvPb94KplkowRiwO2eGJCM6zJI0,2400
 plain/views/objects.py,sha256=GGbcfg_9fPZ-PiaBwIHG2e__8GfWDR7JQtQ15wTyiHg,5970
-plain/views/redirect.py,sha256=vMXx8430FtyKcT0V0gyY92SkLtyULBX52KhX4eu4gEA,1985
-plain/views/templates.py,sha256=kMcHKkKNvucF91SFGkaq-ugjrCwn4zJBpFV1JkwA544,2027
-plain-0.39.0.dist-info/METADATA,sha256=DlIAs31jS4S87R0UhAlZlYdgxZGKOebjo3IcgK5yas4,4297
-plain-0.39.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-plain-0.39.0.dist-info/entry_points.txt,sha256=1Ys2lsSeMepD1vz8RSrJopna0RQfUd951vYvCRsvl6A,45
-plain-0.39.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
-plain-0.39.0.dist-info/RECORD,,
+plain/views/redirect.py,sha256=daq2cQIkdDF78bt43sjuZxRAyJm_t_SKw6tyPmiXPIc,1985
+plain/views/templates.py,sha256=ORBabNc9p2QbW_rTfq2650yJtzUuUJoPXoHogrhYLCo,2028
+plain-0.40.0.dist-info/METADATA,sha256=WccAr8tpVrNh7gYPQXG7gCS3dUtm1zv9Nn8IkHTQpFI,4297
+plain-0.40.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+plain-0.40.0.dist-info/entry_points.txt,sha256=1Ys2lsSeMepD1vz8RSrJopna0RQfUd951vYvCRsvl6A,45
+plain-0.40.0.dist-info/licenses/LICENSE,sha256=m0D5O7QoH9l5Vz_rrX_9r-C8d9UNr_ciK6Qwac7o6yo,3175
+plain-0.40.0.dist-info/RECORD,,