plain 0.1.0__py3-none-any.whl

plain/exceptions.py

@@ -0,0 +1,242 @@
+"""
+Global Plain exception and warning classes.
+"""
+import operator
+
+from plain.utils.hashable import make_hashable
+
+
+class FieldDoesNotExist(Exception):
+    """The requested model field does not exist"""
+
+    pass
+
+
+class PackageRegistryNotReady(Exception):
+    """The plain.packages registry is not populated yet"""
+
+    pass
+
+
+class ObjectDoesNotExist(Exception):
+    """The requested object does not exist"""
+
+    silent_variable_failure = True
+
+
+class MultipleObjectsReturned(Exception):
+    """The query returned multiple objects when only one was expected."""
+
+    pass
+
+
+class SuspiciousOperation(Exception):
+    """The user did something suspicious"""
+
+
+class SuspiciousMultipartForm(SuspiciousOperation):
+    """Suspect MIME request in multipart form data"""
+
+    pass
+
+
+class SuspiciousFileOperation(SuspiciousOperation):
+    """A Suspicious filesystem operation was attempted"""
+
+    pass
+
+
+class DisallowedHost(SuspiciousOperation):
+    """HTTP_HOST header contains invalid value"""
+
+    pass
+
+
+class DisallowedRedirect(SuspiciousOperation):
+    """Redirect to scheme not in allowed list"""
+
+    pass
+
+
+class TooManyFieldsSent(SuspiciousOperation):
+    """
+    The number of fields in a GET or POST request exceeded
+    settings.DATA_UPLOAD_MAX_NUMBER_FIELDS.
+    """
+
+    pass
+
+
+class TooManyFilesSent(SuspiciousOperation):
+    """
+    The number of fields in a GET or POST request exceeded
+    settings.DATA_UPLOAD_MAX_NUMBER_FILES.
+    """
+
+    pass
+
+
+class RequestDataTooBig(SuspiciousOperation):
+    """
+    The size of the request (excluding any file uploads) exceeded
+    settings.DATA_UPLOAD_MAX_MEMORY_SIZE.
+    """
+
+    pass
+
+
+class RequestAborted(Exception):
+    """The request was closed before it was completed, or timed out."""
+
+    pass
+
+
+class BadRequest(Exception):
+    """The request is malformed and cannot be processed."""
+
+    pass
+
+
+class PermissionDenied(Exception):
+    """The user did not have permission to do that"""
+
+    pass
+
+
+class ViewDoesNotExist(Exception):
+    """The requested view does not exist"""
+
+    pass
+
+
+class ImproperlyConfigured(Exception):
+    """Plain is somehow improperly configured"""
+
+    pass
+
+
+class FieldError(Exception):
+    """Some kind of problem with a model field."""
+
+    pass
+
+
+NON_FIELD_ERRORS = "__all__"
+
+
+class ValidationError(Exception):
+    """An error while validating data."""
+
+    def __init__(self, message, code=None, params=None):
+        """
+        The `message` argument can be a single error, a list of errors, or a
+        dictionary that maps field names to lists of errors. What we define as
+        an "error" can be either a simple string or an instance of
+        ValidationError with its message attribute set, and what we define as
+        list or dictionary can be an actual `list` or `dict` or an instance
+        of ValidationError with its `error_list` or `error_dict` attribute set.
+        """
+        super().__init__(message, code, params)
+
+        if isinstance(message, ValidationError):
+            if hasattr(message, "error_dict"):
+                message = message.error_dict
+            elif not hasattr(message, "message"):
+                message = message.error_list
+            else:
+                message, code, params = message.message, message.code, message.params
+
+        if isinstance(message, dict):
+            self.error_dict = {}
+            for field, messages in message.items():
+                if not isinstance(messages, ValidationError):
+                    messages = ValidationError(messages)
+                self.error_dict[field] = messages.error_list
+
+        elif isinstance(message, list):
+            self.error_list = []
+            for message in message:
+                # Normalize plain strings to instances of ValidationError.
+                if not isinstance(message, ValidationError):
+                    message = ValidationError(message)
+                if hasattr(message, "error_dict"):
+                    self.error_list.extend(sum(message.error_dict.values(), []))
+                else:
+                    self.error_list.extend(message.error_list)
+
+        else:
+            self.message = message
+            self.code = code
+            self.params = params
+            self.error_list = [self]
+
+    @property
+    def message_dict(self):
+        # Trigger an AttributeError if this ValidationError
+        # doesn't have an error_dict.
+        getattr(self, "error_dict")
+
+        return dict(self)
+
+    @property
+    def messages(self):
+        if hasattr(self, "error_dict"):
+            return sum(dict(self).values(), [])
+        return list(self)
+
+    def update_error_dict(self, error_dict):
+        if hasattr(self, "error_dict"):
+            for field, error_list in self.error_dict.items():
+                error_dict.setdefault(field, []).extend(error_list)
+        else:
+            error_dict.setdefault(NON_FIELD_ERRORS, []).extend(self.error_list)
+        return error_dict
+
+    def __iter__(self):
+        if hasattr(self, "error_dict"):
+            for field, errors in self.error_dict.items():
+                yield field, list(ValidationError(errors))
+        else:
+            for error in self.error_list:
+                message = error.message
+                if error.params:
+                    message %= error.params
+                yield str(message)
+
+    def __str__(self):
+        if hasattr(self, "error_dict"):
+            return repr(dict(self))
+        return repr(list(self))
+
+    def __repr__(self):
+        return "ValidationError(%s)" % self
+
+    def __eq__(self, other):
+        if not isinstance(other, ValidationError):
+            return NotImplemented
+        return hash(self) == hash(other)
+
+    def __hash__(self):
+        if hasattr(self, "message"):
+            return hash(
+                (
+                    self.message,
+                    self.code,
+                    make_hashable(self.params),
+                )
+            )
+        if hasattr(self, "error_dict"):
+            return hash(make_hashable(self.error_dict))
+        return hash(tuple(sorted(self.error_list, key=operator.attrgetter("message"))))
+
+
+class EmptyResultSet(Exception):
+    """A database query predicate is impossible."""
+
+    pass
+
+
+class FullResultSet(Exception):
+    """A database query predicate is matches everything."""
+
+    pass

plain/forms/README.md

@@ -0,0 +1,14 @@
+# Forms
+
+Handle user input.
+
+- forms don't render themselves
+- registered scripts vs media?
+- move model save logic into form.save() - disconnect them
+- Form: validates input from request, saves it
+- Form field: validates field, knows how to parse from html data ?
+- starter includes form components - no markup in python
+
+## Re-using input styles
+
+plain-elements, or includes

plain/forms/__init__.py

@@ -0,0 +1,8 @@
+"""
+Plain validation and HTML form handling.
+"""
+
+from .boundfield import BoundField  # NOQA
+from .exceptions import FormFieldMissingError, ValidationError  # NOQA
+from .fields import *  # NOQA
+from .forms import Form  # NOQA

plain/forms/boundfield.py

@@ -0,0 +1,58 @@
+from functools import cached_property
+
+__all__ = ("BoundField",)
+
+
+class BoundField:
+    "A Field plus data"
+
+    def __init__(self, form, field, name):
+        self._form = form
+        self.field = field
+        self.name = name
+        self.html_name = form.add_prefix(name)
+        self.html_id = form.add_prefix(self._auto_id)
+
+    def __repr__(self):
+        return f'<{self.__class__.__name__} "{self.html_name}">'
+
+    @property
+    def errors(self):
+        """
+        Return an error list (empty if there are no errors) for this field.
+        """
+        return self._form.errors.get(self.name, [])
+
+    def value(self):
+        """
+        Return the value for this BoundField, using the initial value if
+        the form is not bound or the data otherwise.
+        """
+        data = self.initial
+        if self._form.is_bound:
+            data = self.field.bound_data(
+                self._form._field_data_value(self.field, self.html_name), data
+            )
+        return self.field.prepare_value(data)
+
+    @cached_property
+    def initial(self):
+        return self._form.get_initial_for_field(self.field, self.name)
+
+    def _has_changed(self):
+        return self.field.has_changed(
+            self.initial, self._form._field_data_value(self.field, self.html_name)
+        )
+
+    @property
+    def _auto_id(self):
+        """
+        Calculate and return the ID attribute for this BoundField, if the
+        associated Form has specified auto_id. Return an empty string otherwise.
+        """
+        auto_id = self._form._auto_id  # Boolean or string
+        if auto_id and "%s" in str(auto_id):
+            return auto_id % self.html_name
+        elif auto_id:
+            return self.html_name
+        return ""

plain/forms/exceptions.py

@@ -0,0 +1,11 @@
+from plain.exceptions import ValidationError
+
+
+class FormFieldMissingError(Exception):
+    pass
+
+
+__all__ = [
+    "ValidationError",
+    "FormFieldMissingError",
+]