plain.models 0.37.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

plain/models/query.py

@@ -24,10 +24,10 @@ from plain.models.db import (
 )
 from plain.models.expressions import Case, F, Value, When
 from plain.models.fields import (
-    AutoField,
     DateField,
     DateTimeField,
     Field,
+    PrimaryKeyField,
 )
 from plain.models.functions import Cast, Trunc
 from plain.models.query_utils import FilteredRelation, Q
@@ -82,14 +82,7 @@ class ModelIterable(BaseIterable):
             (
                 field,
                 related_objs,
-                operator.attrgetter(
-                    *[
-                        field.attname
-                        if from_field == "self"
-                        else queryset.model._meta.get_field(from_field).attname
-                        for from_field in field.from_fields
-                    ]
-                ),
+                operator.attrgetter(field.attname),
             )
             for field, related_objs in queryset._known_related_objects.items()
         ]
@@ -135,7 +128,7 @@ class RawModelIterable(BaseIterable):
                 annotation_fields,
             ) = self.queryset.resolve_model_init_order()
             model_cls = self.queryset.model
-            if model_cls._meta.pk.attname not in model_init_names:
+            if "id" not in model_init_names:
                 raise exceptions.FieldDoesNotExist(
                     "Raw query must include the primary key"
                 )
@@ -271,7 +264,7 @@ class QuerySet:
         self._for_write = False
         self._prefetch_related_lookups = ()
         self._prefetch_done = False
-        self._known_related_objects = {}  # {rel_field: {pk: rel_obj}}
+        self._known_related_objects = {}  # {rel_field: {id: rel_obj}}
         self._iterable_class = ModelIterable
         self._fields = None
         self._defer_next_filter = False
@@ -432,12 +425,12 @@ class QuerySet:
         query = (
             self
             if self.query.can_filter()
-            else self.model._base_manager.filter(pk__in=self.values("pk"))
+            else self.model._base_manager.filter(id__in=self.values("id"))
         )
         combined = query._chain()
         combined._merge_known_related_objects(other)
         if not other.query.can_filter():
-            other = other.model._base_manager.filter(pk__in=other.values("pk"))
+            other = other.model._base_manager.filter(id__in=other.values("id"))
         combined.query.combine(other.query, sql.OR)
         return combined
 
@@ -451,12 +444,12 @@ class QuerySet:
         query = (
             self
             if self.query.can_filter()
-            else self.model._base_manager.filter(pk__in=self.values("pk"))
+            else self.model._base_manager.filter(id__in=self.values("id"))
         )
         combined = query._chain()
         combined._merge_known_related_objects(other)
         if not other.query.can_filter():
-            other = other.model._base_manager.filter(pk__in=other.values("pk"))
+            other = other.model._base_manager.filter(id__in=other.values("id"))
         combined.query.combine(other.query, sql.XOR)
         return combined
 
@@ -570,6 +563,16 @@ class QuerySet:
             )
         )
 
+    def get_or_none(self, *args, **kwargs):
+        """
+        Perform the query and return a single object matching the given
+        keyword arguments, or None if no object is found.
+        """
+        try:
+            return self.get(*args, **kwargs)
+        except self.model.DoesNotExist:
+            return None
+
     def create(self, **kwargs):
         """
         Create a new object with the given kwargs, saving it to the database
@@ -581,10 +584,11 @@ class QuerySet:
         return obj
 
     def _prepare_for_bulk_create(self, objs):
+        id_field = self.model._meta.get_field("id")
         for obj in objs:
-            if obj.pk is None:
-                # Populate new PK values.
-                obj.pk = obj._meta.pk.get_pk_value_on_save(obj)
+            if obj.id is None:
+                # Populate new primary key values.
+                obj.id = id_field.get_id_value_on_save(obj)
             obj._prepare_related_fields_for_save(operation_name="bulk_create")
 
     def _check_bulk_create_options(
@@ -663,11 +667,7 @@ class QuerySet:
             return objs
         opts = self.model._meta
         if unique_fields:
-            # Primary key is allowed in unique_fields.
-            unique_fields = [
-                self.model._meta.get_field(opts.pk.name if name == "pk" else name)
-                for name in unique_fields
-            ]
+            unique_fields = [self.model._meta.get_field(name) for name in unique_fields]
         if update_fields:
             update_fields = [self.model._meta.get_field(name) for name in update_fields]
         on_conflict = self._check_bulk_create_options(
@@ -680,26 +680,27 @@ class QuerySet:
         objs = list(objs)
         self._prepare_for_bulk_create(objs)
         with transaction.atomic(savepoint=False):
-            objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)
-            if objs_with_pk:
+            objs_with_id, objs_without_id = partition(lambda o: o.id is None, objs)
+            if objs_with_id:
                 returned_columns = self._batched_insert(
-                    objs_with_pk,
+                    objs_with_id,
                     fields,
                     batch_size,
                     on_conflict=on_conflict,
                     update_fields=update_fields,
                     unique_fields=unique_fields,
                 )
-                for obj_with_pk, results in zip(objs_with_pk, returned_columns):
+                id_field = opts.get_field("id")
+                for obj_with_id, results in zip(objs_with_id, returned_columns):
                     for result, field in zip(results, opts.db_returning_fields):
-                        if field != opts.pk:
-                            setattr(obj_with_pk, field.attname, result)
-                for obj_with_pk in objs_with_pk:
-                    obj_with_pk._state.adding = False
-            if objs_without_pk:
-                fields = [f for f in fields if not isinstance(f, AutoField)]
+                        if field != id_field:
+                            setattr(obj_with_id, field.attname, result)
+                for obj_with_id in objs_with_id:
+                    obj_with_id._state.adding = False
+            if objs_without_id:
+                fields = [f for f in fields if not isinstance(f, PrimaryKeyField)]
                 returned_columns = self._batched_insert(
-                    objs_without_pk,
+                    objs_without_id,
                     fields,
                     batch_size,
                     on_conflict=on_conflict,
@@ -710,11 +711,11 @@ class QuerySet:
                     db_connection.features.can_return_rows_from_bulk_insert
                     and on_conflict is None
                 ):
-                    assert len(returned_columns) == len(objs_without_pk)
-                for obj_without_pk, results in zip(objs_without_pk, returned_columns):
+                    assert len(returned_columns) == len(objs_without_id)
+                for obj_without_id, results in zip(objs_without_id, returned_columns):
                     for result, field in zip(results, opts.db_returning_fields):
-                        setattr(obj_without_pk, field.attname, result)
-                    obj_without_pk._state.adding = False
+                        setattr(obj_without_id, field.attname, result)
+                    obj_without_id._state.adding = False
 
         return objs
 
@@ -727,7 +728,7 @@ class QuerySet:
         if not fields:
             raise ValueError("Field names must be given to bulk_update().")
         objs = tuple(objs)
-        if any(obj.pk is None for obj in objs):
+        if any(obj.id is None for obj in objs):
             raise ValueError("All bulk_update() objects must have a primary key set.")
         fields = [self.model._meta.get_field(name) for name in fields]
         if any(not f.concrete or f.many_to_many for f in fields):
@@ -743,7 +744,7 @@ class QuerySet:
         # PK is used twice in the resulting update query, once in the filter
         # and once in the WHEN. Each field will also have one CAST.
         self._for_write = True
-        max_batch_size = db_connection.ops.bulk_batch_size(["pk", "pk"] + fields, objs)
+        max_batch_size = db_connection.ops.bulk_batch_size(["id", "id"] + fields, objs)
         batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size
         requires_casting = db_connection.features.requires_casted_case_in_updates
         batches = (objs[i : i + batch_size] for i in range(0, len(objs), batch_size))
@@ -756,17 +757,17 @@ class QuerySet:
                     attr = getattr(obj, field.attname)
                     if not hasattr(attr, "resolve_expression"):
                         attr = Value(attr, output_field=field)
-                    when_statements.append(When(pk=obj.pk, then=attr))
+                    when_statements.append(When(id=obj.id, then=attr))
                 case_statement = Case(*when_statements, output_field=field)
                 if requires_casting:
                     case_statement = Cast(case_statement, output_field=field)
                 update_kwargs[field.attname] = case_statement
-            updates.append(([obj.pk for obj in batch_objs], update_kwargs))
+            updates.append(([obj.id for obj in batch_objs], update_kwargs))
         rows_updated = 0
         queryset = self._chain()
         with transaction.atomic(savepoint=False):
-            for pks, update_kwargs in updates:
-                rows_updated += queryset.filter(pk__in=pks).update(**update_kwargs)
+            for ids, update_kwargs in updates:
+                rows_updated += queryset.filter(id__in=ids).update(**update_kwargs)
         return rows_updated
 
     def get_or_create(self, defaults=None, **kwargs):
@@ -914,7 +915,7 @@ class QuerySet:
             queryset = self
         else:
             self._check_ordering_first_last_queryset_aggregation(method="first")
-            queryset = self.order_by("pk")
+            queryset = self.order_by("id")
         for obj in queryset[:1]:
             return obj
 
@@ -924,11 +925,11 @@ class QuerySet:
             queryset = self.reverse()
         else:
             self._check_ordering_first_last_queryset_aggregation(method="last")
-            queryset = self.order_by("-pk")
+            queryset = self.order_by("-id")
         for obj in queryset[:1]:
             return obj
 
-    def in_bulk(self, id_list=None, *, field_name="pk"):
+    def in_bulk(self, id_list=None, *, field_name="id"):
         """
         Return a dictionary mapping each of the given IDs to the object with
         that ID. If `id_list` isn't provided, evaluate the entire QuerySet.
@@ -942,7 +943,7 @@ class QuerySet:
             if len(constraint.fields) == 1
         ]
         if (
-            field_name != "pk"
+            field_name != "id"
             and not opts.get_field(field_name).primary_key
             and field_name not in unique_fields
             and self.query.distinct_fields != (field_name,)
@@ -1096,11 +1097,11 @@ class QuerySet:
                 return False
         except AttributeError:
             raise TypeError("'obj' must be a model instance.")
-        if obj.pk is None:
+        if obj.id is None:
             raise ValueError("QuerySet.contains() cannot be used on unsaved objects.")
         if self._result_cache is not None:
             return obj in self._result_cache
-        return self.filter(pk=obj.pk).exists()
+        return self.filter(id=obj.id).exists()
 
     def _prefetch_related_objects(self):
         # This method can only be called once the result cache has been filled.
@@ -1764,7 +1765,8 @@ class QuerySet:
 
     def _check_ordering_first_last_queryset_aggregation(self, method):
         if isinstance(self.query.group_by, tuple) and not any(
-            col.output_field is self.model._meta.pk for col in self.query.group_by
+            col.output_field is self.model._meta.get_field("id")
+            for col in self.query.group_by
         ):
             raise TypeError(
                 f"Cannot use QuerySet.{method}() on an unordered queryset performing "
@@ -2327,7 +2329,7 @@ class RelatedPopulator:
         #      we have to reorder the parent data. The reorder_for_init
         #      attribute contains a function used to reorder the field data
         #      in the order __init__ expects it.
-        #  - pk_idx: the index of the primary key field in the reordered
+        #  - id_idx: the index of the primary key field in the reordered
         #    model data. Used to check if a related object exists at all.
         #  - init_list: the field attnames fetched from the database. For
         #    deferred models this isn't the same as all attnames of the
@@ -2347,7 +2349,7 @@ class RelatedPopulator:
         self.reorder_for_init = None
 
         self.model_cls = klass_info["model"]
-        self.pk_idx = self.init_list.index(self.model_cls._meta.pk.attname)
+        self.id_idx = self.init_list.index("id")
         self.related_populators = get_related_populators(klass_info, select)
         self.local_setter = klass_info["local_setter"]
         self.remote_setter = klass_info["remote_setter"]
@@ -2357,7 +2359,7 @@ class RelatedPopulator:
             obj_data = self.reorder_for_init(row)
         else:
             obj_data = row[self.cols_start : self.cols_end]
-        if obj_data[self.pk_idx] is None:
+        if obj_data[self.id_idx] is None:
             obj = None
         else:
             obj = self.model_cls.from_db(self.init_list, obj_data)

plain/models/query_utils.py

@@ -313,8 +313,6 @@ def select_related_descend(field, restricted, requested, select_mask, reverse=Fa
     """
     if not field.remote_field:
         return False
-    if field.remote_field.parent_link and not reverse:
-        return False
     if restricted:
         if reverse and field.related_query_name() not in requested:
             return False
@@ -363,11 +361,11 @@ def check_rel_lookup_compatibility(model, target_opts, field):
     # model is ok, too. Consider the case:
     # class Restaurant(models.Model):
     #     place = OneToOneField(Place, primary_key=True):
-    # Restaurant.objects.filter(pk__in=Restaurant.objects.all()).
-    # If we didn't have the primary key check, then pk__in (== place__in) would
+    # Restaurant.objects.filter(id__in=Restaurant.objects.all()).
+    # If we didn't have the primary key check, then id__in (== place__in) would
     # give Place's opts as the target opts, but Restaurant isn't compatible
     # with that. This logic applies only to primary keys, as when doing __in=qs,
-    # we are going to turn this into __in=qs.values('pk') later on.
+    # we are going to turn this into __in=qs.values('id') later on.
     return check(target_opts) or (
         getattr(field, "primary_key", False) and check(field.model._meta)
     )

plain/models/sql/compiler.py

@@ -107,12 +107,12 @@ class SQLCompiler:
         #    SomeModel.objects.annotate(Count('somecol')).values('name')
         #    GROUP BY: all cols of the model
         #
-        #    SomeModel.objects.values('name', 'pk')
-        #    .annotate(Count('somecol')).values('pk')
-        #    GROUP BY: name, pk
+        #    SomeModel.objects.values('name', 'id')
+        #    .annotate(Count('somecol')).values('id')
+        #    GROUP BY: name, id
         #
-        #    SomeModel.objects.values('name').annotate(Count('somecol')).values('pk')
-        #    GROUP BY: name, pk
+        #    SomeModel.objects.values('name').annotate(Count('somecol')).values('id')
+        #    GROUP BY: name, id
         #
         # In fact, the self.query.group_by is the minimal set to GROUP BY. It
         # can't be ever restricted to a smaller set, but additional columns in
@@ -1000,14 +1000,13 @@ class SQLCompiler:
         ) = self._setup_joins(pieces, opts, alias)
 
         # If we get to this point and the field is a relation to another model,
-        # append the default ordering for that model unless it is the pk
-        # shortcut or the attribute name of the field that is specified or
+        # append the default ordering for that model unless it is the
+        # attribute name of the field that is specified or
         # there are transforms to process.
         if (
             field.is_relation
             and opts.ordering
             and getattr(field, "attname", None) != pieces[-1]
-            and name != "pk"
             and not getattr(transform_function, "has_transforms", False)
         ):
             # Firstly, avoid infinite loops.
@@ -1654,7 +1653,7 @@ class SQLInsertCompiler(SQLCompiler):
             on_conflict=self.query.on_conflict,
         )
         result = [f"{insert_statement} {qn(opts.db_table)}"]
-        fields = self.query.fields or [opts.pk]
+        fields = self.query.fields or [opts.get_field("id")]
         result.append("({})".format(", ".join(qn(f.column) for f in fields)))
 
         if self.query.fields:
@@ -1757,7 +1756,7 @@ class SQLInsertCompiler(SQLCompiler):
                         self.connection.ops.last_insert_id(
                             cursor,
                             opts.db_table,
-                            opts.pk.column,
+                            opts.get_field("id").column,
                         ),
                     )
                 ]
@@ -1813,15 +1812,15 @@ class SQLDeleteCompiler(SQLCompiler):
         innerq = self.query.clone()
         innerq.__class__ = Query
         innerq.clear_select_clause()
-        pk = self.query.model._meta.pk
-        innerq.select = [pk.get_col(self.query.get_initial_alias())]
+        id_field = self.query.model._meta.get_field("id")
+        innerq.select = [id_field.get_col(self.query.get_initial_alias())]
         outerq = Query(self.query.model)
         if not self.connection.features.update_can_self_select:
             # Force the materialization of the inner query to allow reference
             # to the target table on MySQL.
             sql, params = innerq.get_compiler().as_sql()
             innerq = RawSQL(f"SELECT * FROM ({sql}) subquery", params)
-        outerq.add_filter("pk__in", innerq)
+        outerq.add_filter("id__in", innerq)
         return self._as_sql(outerq)
 
 
@@ -1930,12 +1929,11 @@ class SQLUpdateCompiler(SQLCompiler):
         query.clear_ordering(force=True)
         query.extra = {}
         query.select = []
-        meta = query.get_meta()
-        fields = [meta.pk.name]
+        fields = ["id"]
         related_ids_index = []
         for related in self.query.related_updates:
             # If a primary key chain exists to the targeted related update,
-            # then the meta.pk value can be used for it.
+            # then the primary key value can be used for it.
             related_ids_index.append((related, 0))
 
         query.add_fields(fields)
@@ -1958,11 +1956,11 @@ class SQLUpdateCompiler(SQLCompiler):
                 idents.extend(r[0] for r in rows)
                 for parent, index in related_ids_index:
                     related_ids[parent].extend(r[index] for r in rows)
-            self.query.add_filter("pk__in", idents)
+            self.query.add_filter("id__in", idents)
             self.query.related_ids = related_ids
         else:
             # The fast path. Filters and updates in one query.
-            self.query.add_filter("pk__in", query)
+            self.query.add_filter("id__in", query)
         self.query.reset_refcounts(refcounts_before)
 
 

plain/models/sql/query.py

@@ -438,7 +438,9 @@ class Query(BaseExpression):
                 # used.
                 if inner_query.default_cols and has_existing_aggregation:
                     inner_query.group_by = (
-                        self.model._meta.pk.get_col(inner_query.get_initial_alias()),
+                        self.model._meta.get_field("id").get_col(
+                            inner_query.get_initial_alias()
+                        ),
                     )
                 inner_query.default_cols = False
                 if not qualify:
@@ -480,7 +482,9 @@ class Query(BaseExpression):
                 # field selected in the inner query, yet we must use a subquery.
                 # So, make sure at least one field is selected.
                 inner_query.select = (
-                    self.model._meta.pk.get_col(inner_query.get_initial_alias()),
+                    self.model._meta.get_field("id").get_col(
+                        inner_query.get_initial_alias()
+                    ),
                 )
         else:
             outer_query = self
@@ -689,7 +693,7 @@ class Query(BaseExpression):
     def _get_defer_select_mask(self, opts, mask, select_mask=None):
         if select_mask is None:
             select_mask = {}
-        select_mask[opts.pk] = {}
+        select_mask[opts.get_field("id")] = {}
         # All concrete fields that are not part of the defer mask must be
         # loaded. If a relational field is encountered it gets added to the
         # mask for it be considered if `select_related` and the cycle continues
@@ -726,7 +730,7 @@ class Query(BaseExpression):
     def _get_only_select_mask(self, opts, mask, select_mask=None):
         if select_mask is None:
             select_mask = {}
-        select_mask[opts.pk] = {}
+        select_mask[opts.get_field("id")] = {}
         # Only include fields mentioned in the mask.
         for field_name, field_mask in mask.items():
             field = opts.get_field(field_name)
@@ -1567,8 +1571,6 @@ class Query(BaseExpression):
         path, names_with_path = [], []
         for pos, name in enumerate(names):
             cur_names_with_path = (name, [])
-            if name == "pk":
-                name = opts.pk.name
 
             field = None
             filtered_relation = None
@@ -1917,14 +1919,16 @@ class Query(BaseExpression):
         select_field = col.target
         alias = col.alias
         if alias in can_reuse:
-            pk = select_field.model._meta.pk
+            id_field = select_field.model._meta.get_field("id")
             # Need to add a restriction so that outer query's filters are in effect for
             # the subquery, too.
             query.bump_prefix(self)
             lookup_class = select_field.get_lookup("exact")
             # Note that the query.select[0].alias is different from alias
             # due to bump_prefix above.
-            lookup = lookup_class(pk.get_col(query.select[0].alias), pk.get_col(alias))
+            lookup = lookup_class(
+                id_field.get_col(query.select[0].alias), id_field.get_col(alias)
+            )
             query.where.add(lookup, AND)
             query.external_aliases[alias] = True
 
@@ -2257,9 +2261,6 @@ class Query(BaseExpression):
         """
         existing, defer = self.deferred_loading
         field_names = set(field_names)
-        if "pk" in field_names:
-            field_names.remove("pk")
-            field_names.add(self.get_meta().pk.name)
 
         if defer:
             # Remove any existing deferred names from the current set before

plain/models/sql/subqueries.py

@@ -23,21 +23,21 @@ class DeleteQuery(Query):
                 return cursor.rowcount
         return 0
 
-    def delete_batch(self, pk_list):
+    def delete_batch(self, id_list):
         """
-        Set up and execute delete queries for all the objects in pk_list.
+        Set up and execute delete queries for all the objects in id_list.
 
         More than one physical query may be executed if there are a
-        lot of values in pk_list.
+        lot of values in id_list.
         """
         # number of objects deleted
         num_deleted = 0
-        field = self.get_meta().pk
-        for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
+        field = self.get_meta().get_field("id")
+        for offset in range(0, len(id_list), GET_ITERATOR_CHUNK_SIZE):
             self.clear_where()
             self.add_filter(
                 f"{field.attname}__in",
-                pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE],
+                id_list[offset : offset + GET_ITERATOR_CHUNK_SIZE],
             )
             num_deleted += self.do_query(self.get_meta().db_table, self.where)
         return num_deleted
@@ -66,12 +66,12 @@ class UpdateQuery(Query):
         obj.related_updates = self.related_updates.copy()
         return obj
 
-    def update_batch(self, pk_list, values):
+    def update_batch(self, id_list, values):
         self.add_update_values(values)
-        for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):
+        for offset in range(0, len(id_list), GET_ITERATOR_CHUNK_SIZE):
             self.clear_where()
             self.add_filter(
-                "pk__in", pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]
+                "id__in", id_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]
             )
             self.get_compiler().execute_sql(NO_RESULTS)
 
@@ -132,7 +132,7 @@ class UpdateQuery(Query):
             query = UpdateQuery(model)
             query.values = values
             if self.related_ids is not None:
-                query.add_filter("pk__in", self.related_ids[model])
+                query.add_filter("id__in", self.related_ids[model])
             result.append(query)
         return result
 

{plain_models-0.37.0.dist-info → plain_models-0.39.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plain.models
-Version: 0.37.0
+Version: 0.39.0
 Summary: Database models for Plain.
 Author-email: Dave Gaeddert <dave.gaeddert@dropseed.dev>
 License-File: LICENSE
@@ -30,6 +30,9 @@ class User(models.Model):
         return self.email
 ```
 
+Every model automatically includes an `id` field which serves as the primary
+key. The name `id` is reserved and can't be used for other fields.
+
 Create, update, and delete instances of your models:
 
 ```python