plain.models 0.0.0__tar.gz

plain_models-0.0.0/LICENSE

@@ -0,0 +1,61 @@
+## 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.

plain_models-0.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: plain.models
+Version: 0.0.0
+Summary: 
+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: sqlparse (>=0.3.1)

plain_models-0.0.0/plain/models/README.md

@@ -0,0 +1,94 @@
+# plain-models
+
+Model your data and store it in a database.
+
+```python
+# app/users/models.py
+from plain import models
+from plain.passwords.models import PasswordField
+
+
+class User(models.Model):
+    email = models.EmailField(unique=True)
+    password = PasswordField()
+    is_staff = models.BooleanField(default=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    def __str__(self):
+        return self.email
+```
+
+Create, update, and delete instances of your models:
+
+```python
+from .models import User
+
+
+# Create a new user
+user = User.objects.create(
+    email="test@example.com",
+    password="password",
+)
+
+# Update a user
+user.email = "new@example.com"
+user.save()
+
+# Delete a user
+user.delete()
+
+# Query for users
+staff_users = User.objects.filter(is_staff=True)
+```
+
+## Installation
+
+```python
+# app/settings.py
+INSTALLED_PACKAGES = [
+    ...
+    "plain.models",
+]
+```
+
+To connect to a database, you can provide a `DATABASE_URL` environment variable.
+
+```sh
+DATABASE_URL=postgresql://user:password@localhost:5432/dbname
+```
+
+Or you can manually define the `DATABASES` setting.
+
+```python
+# app/settings.py
+DATABASES = {
+    "default": {
+        "ENGINE": "plain.models.backends.postgresql",
+        "NAME": "dbname",
+        "USER": "user",
+        "PASSWORD": "password",
+        "HOST": "localhost",
+        "PORT": "5432",
+    }
+}
+```
+
+[Multiple backends are supported, including Postgres, MySQL, and SQLite.](./backends/README.md)
+
+## Querying
+
+## Migrations
+
+[Migration docs](./migrations/README.md)
+
+## Fields
+
+[Field docs](./fields/README.md)
+
+## Validation
+
+## Indexes and constraints
+
+## Managers
+
+## Forms

plain_models-0.0.0/plain/models/__init__.py

@@ -0,0 +1,152 @@
+from plain.exceptions import ObjectDoesNotExist
+
+from . import (
+    preflight,  # noqa
+)
+from .aggregates import *  # NOQA
+from .aggregates import __all__ as aggregates_all
+from .constraints import *  # NOQA
+from .constraints import __all__ as constraints_all
+from .db import (
+    DEFAULT_DB_ALIAS,
+    PLAIN_VERSION_PICKLE_KEY,
+    DatabaseError,
+    DataError,
+    Error,
+    IntegrityError,
+    InterfaceError,
+    InternalError,
+    NotSupportedError,
+    OperationalError,
+    ProgrammingError,
+    close_old_connections,
+    connection,
+    connections,
+    reset_queries,
+    router,
+)
+from .deletion import (
+    CASCADE,
+    DO_NOTHING,
+    PROTECT,
+    RESTRICT,
+    SET,
+    SET_DEFAULT,
+    SET_NULL,
+    ProtectedError,
+    RestrictedError,
+)
+from .enums import *  # NOQA
+from .enums import __all__ as enums_all
+from .expressions import (
+    Case,
+    Exists,
+    Expression,
+    ExpressionList,
+    ExpressionWrapper,
+    F,
+    Func,
+    OrderBy,
+    OuterRef,
+    RowRange,
+    Subquery,
+    Value,
+    ValueRange,
+    When,
+    Window,
+    WindowFrame,
+)
+from .fields import *  # NOQA
+from .fields import __all__ as fields_all
+from .fields.json import JSONField
+from .fields.proxy import OrderWrt
+from .indexes import *  # NOQA
+from .indexes import __all__ as indexes_all
+from .lookups import Lookup, Transform
+from .manager import Manager
+from .query import Prefetch, QuerySet, prefetch_related_objects
+from .query_utils import FilteredRelation, Q
+
+# Imports that would create circular imports if sorted
+from .base import DEFERRED, Model  # isort:skip
+from .fields.related import (  # isort:skip
+    ForeignKey,
+    ForeignObject,
+    OneToOneField,
+    ManyToManyField,
+    ForeignObjectRel,
+    ManyToOneRel,
+    ManyToManyRel,
+    OneToOneRel,
+)
+
+
+__all__ = aggregates_all + constraints_all + enums_all + fields_all + indexes_all
+__all__ += [
+    "ObjectDoesNotExist",
+    "CASCADE",
+    "DO_NOTHING",
+    "PROTECT",
+    "RESTRICT",
+    "SET",
+    "SET_DEFAULT",
+    "SET_NULL",
+    "ProtectedError",
+    "RestrictedError",
+    "Case",
+    "Exists",
+    "Expression",
+    "ExpressionList",
+    "ExpressionWrapper",
+    "F",
+    "Func",
+    "OrderBy",
+    "OuterRef",
+    "RowRange",
+    "Subquery",
+    "Value",
+    "ValueRange",
+    "When",
+    "Window",
+    "WindowFrame",
+    "JSONField",
+    "OrderWrt",
+    "Lookup",
+    "Transform",
+    "Manager",
+    "Prefetch",
+    "Q",
+    "QuerySet",
+    "prefetch_related_objects",
+    "DEFERRED",
+    "Model",
+    "FilteredRelation",
+    "ForeignKey",
+    "ForeignObject",
+    "OneToOneField",
+    "ManyToManyField",
+    "ForeignObjectRel",
+    "ManyToOneRel",
+    "ManyToManyRel",
+    "OneToOneRel",
+]
+
+# DB-related exports
+__all__ += [
+    "connection",
+    "connections",
+    "router",
+    "reset_queries",
+    "close_old_connections",
+    "DatabaseError",
+    "IntegrityError",
+    "InternalError",
+    "ProgrammingError",
+    "DataError",
+    "NotSupportedError",
+    "Error",
+    "InterfaceError",
+    "OperationalError",
+    "DEFAULT_DB_ALIAS",
+    "PLAIN_VERSION_PICKLE_KEY",
+]

plain_models-0.0.0/plain/models/aggregates.py

@@ -0,0 +1,202 @@
+"""
+Classes to represent the definitions of aggregate functions.
+"""
+from plain.exceptions import FieldError, FullResultSet
+from plain.models.expressions import Case, Func, Star, Value, When
+from plain.models.fields import IntegerField
+from plain.models.functions.comparison import Coalesce
+from plain.models.functions.mixins import (
+    FixDurationInputMixin,
+    NumericOutputFieldMixin,
+)
+
+__all__ = [
+    "Aggregate",
+    "Avg",
+    "Count",
+    "Max",
+    "Min",
+    "StdDev",
+    "Sum",
+    "Variance",
+]
+
+
+class Aggregate(Func):
+    template = "%(function)s(%(distinct)s%(expressions)s)"
+    contains_aggregate = True
+    name = None
+    filter_template = "%s FILTER (WHERE %%(filter)s)"
+    window_compatible = True
+    allow_distinct = False
+    empty_result_set_value = None
+
+    def __init__(
+        self, *expressions, distinct=False, filter=None, default=None, **extra
+    ):
+        if distinct and not self.allow_distinct:
+            raise TypeError("%s does not allow distinct." % self.__class__.__name__)
+        if default is not None and self.empty_result_set_value is not None:
+            raise TypeError(f"{self.__class__.__name__} does not allow default.")
+        self.distinct = distinct
+        self.filter = filter
+        self.default = default
+        super().__init__(*expressions, **extra)
+
+    def get_source_fields(self):
+        # Don't return the filter expression since it's not a source field.
+        return [e._output_field_or_none for e in super().get_source_expressions()]
+
+    def get_source_expressions(self):
+        source_expressions = super().get_source_expressions()
+        if self.filter:
+            return source_expressions + [self.filter]
+        return source_expressions
+
+    def set_source_expressions(self, exprs):
+        self.filter = self.filter and exprs.pop()
+        return super().set_source_expressions(exprs)
+
+    def resolve_expression(
+        self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False
+    ):
+        # Aggregates are not allowed in UPDATE queries, so ignore for_save
+        c = super().resolve_expression(query, allow_joins, reuse, summarize)
+        c.filter = c.filter and c.filter.resolve_expression(
+            query, allow_joins, reuse, summarize
+        )
+        if not summarize:
+            # Call Aggregate.get_source_expressions() to avoid
+            # returning self.filter and including that in this loop.
+            expressions = super(Aggregate, c).get_source_expressions()
+            for index, expr in enumerate(expressions):
+                if expr.contains_aggregate:
+                    before_resolved = self.get_source_expressions()[index]
+                    name = (
+                        before_resolved.name
+                        if hasattr(before_resolved, "name")
+                        else repr(before_resolved)
+                    )
+                    raise FieldError(
+                        f"Cannot compute {c.name}('{name}'): '{name}' is an aggregate"
+                    )
+        if (default := c.default) is None:
+            return c
+        if hasattr(default, "resolve_expression"):
+            default = default.resolve_expression(query, allow_joins, reuse, summarize)
+            if default._output_field_or_none is None:
+                default.output_field = c._output_field_or_none
+        else:
+            default = Value(default, c._output_field_or_none)
+        c.default = None  # Reset the default argument before wrapping.
+        coalesce = Coalesce(c, default, output_field=c._output_field_or_none)
+        coalesce.is_summary = c.is_summary
+        return coalesce
+
+    @property
+    def default_alias(self):
+        expressions = self.get_source_expressions()
+        if len(expressions) == 1 and hasattr(expressions[0], "name"):
+            return f"{expressions[0].name}__{self.name.lower()}"
+        raise TypeError("Complex expressions require an alias")
+
+    def get_group_by_cols(self):
+        return []
+
+    def as_sql(self, compiler, connection, **extra_context):
+        extra_context["distinct"] = "DISTINCT " if self.distinct else ""
+        if self.filter:
+            if connection.features.supports_aggregate_filter_clause:
+                try:
+                    filter_sql, filter_params = self.filter.as_sql(compiler, connection)
+                except FullResultSet:
+                    pass
+                else:
+                    template = self.filter_template % extra_context.get(
+                        "template", self.template
+                    )
+                    sql, params = super().as_sql(
+                        compiler,
+                        connection,
+                        template=template,
+                        filter=filter_sql,
+                        **extra_context,
+                    )
+                    return sql, (*params, *filter_params)
+            else:
+                copy = self.copy()
+                copy.filter = None
+                source_expressions = copy.get_source_expressions()
+                condition = When(self.filter, then=source_expressions[0])
+                copy.set_source_expressions([Case(condition)] + source_expressions[1:])
+                return super(Aggregate, copy).as_sql(
+                    compiler, connection, **extra_context
+                )
+        return super().as_sql(compiler, connection, **extra_context)
+
+    def _get_repr_options(self):
+        options = super()._get_repr_options()
+        if self.distinct:
+            options["distinct"] = self.distinct
+        if self.filter:
+            options["filter"] = self.filter
+        return options
+
+
+class Avg(FixDurationInputMixin, NumericOutputFieldMixin, Aggregate):
+    function = "AVG"
+    name = "Avg"
+    allow_distinct = True
+
+
+class Count(Aggregate):
+    function = "COUNT"
+    name = "Count"
+    output_field = IntegerField()
+    allow_distinct = True
+    empty_result_set_value = 0
+
+    def __init__(self, expression, filter=None, **extra):
+        if expression == "*":
+            expression = Star()
+        if isinstance(expression, Star) and filter is not None:
+            raise ValueError("Star cannot be used with filter. Please specify a field.")
+        super().__init__(expression, filter=filter, **extra)
+
+
+class Max(Aggregate):
+    function = "MAX"
+    name = "Max"
+
+
+class Min(Aggregate):
+    function = "MIN"
+    name = "Min"
+
+
+class StdDev(NumericOutputFieldMixin, Aggregate):
+    name = "StdDev"
+
+    def __init__(self, expression, sample=False, **extra):
+        self.function = "STDDEV_SAMP" if sample else "STDDEV_POP"
+        super().__init__(expression, **extra)
+
+    def _get_repr_options(self):
+        return {**super()._get_repr_options(), "sample": self.function == "STDDEV_SAMP"}
+
+
+class Sum(FixDurationInputMixin, Aggregate):
+    function = "SUM"
+    name = "Sum"
+    allow_distinct = True
+
+
+class Variance(NumericOutputFieldMixin, Aggregate):
+    name = "Variance"
+
+    def __init__(self, expression, sample=False, **extra):
+        self.function = "VAR_SAMP" if sample else "VAR_POP"
+        super().__init__(expression, **extra)
+
+    def _get_repr_options(self):
+        return {**super()._get_repr_options(), "sample": self.function == "VAR_SAMP"}

plain_models-0.0.0/plain/models/backends/README.md

@@ -0,0 +1 @@
+# Backends