plain.models 0.49.2__py3-none-any.whl → 0.51.0__py3-none-any.whl

plain/models/backends/base/creation.py

@@ -1,8 +1,14 @@
+from __future__ import annotations
+
 import os
 import sys
+from typing import TYPE_CHECKING, Any
 
 from plain.runtime import settings
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+
 # The prefix to put on the default database name when creating
 # the test database.
 TEST_DATABASE_PREFIX = "test_"
@@ -14,16 +20,16 @@ class BaseDatabaseCreation:
     destruction of the test database.
     """
 
-    def __init__(self, connection):
+    def __init__(self, connection: BaseDatabaseWrapper):
         self.connection = connection
 
-    def _nodb_cursor(self):
+    def _nodb_cursor(self) -> Any:
         return self.connection._nodb_cursor()
 
-    def log(self, msg):
+    def log(self, msg: str) -> None:
         sys.stderr.write(msg + os.linesep)
 
-    def create_test_db(self, verbosity=1, prefix=""):
+    def create_test_db(self, verbosity: int = 1, prefix: str = "") -> str:
         """
         Create a test database, prompting the user for confirmation if the
         database already exists. Return the name of the test database created.
@@ -67,7 +73,7 @@ class BaseDatabaseCreation:
 
         return test_database_name
 
-    def set_as_test_mirror(self, primary_settings_dict):
+    def set_as_test_mirror(self, primary_settings_dict: dict[str, Any]) -> None:
         """
         Set this database up to be used in testing as a mirror of a primary
         database whose settings are given.
@@ -92,7 +98,7 @@ class BaseDatabaseCreation:
     #                 and package_config.package_label in loader.migrated_packages
     #             ):
     #                 for model in package_config.get_models():
-    #                     if model._meta.can_migrate(
+    #                     if model.model_options.can_migrate(
     #                         self.connection
     #                     ) and router.allow_migrate_model(self.connection.alias, model):
     #                         queryset = model._base_manager.using(
@@ -121,12 +127,12 @@ class BaseDatabaseCreation:
     #                 "json", data, using=self.connection.alias
     #             ):
     #                 obj.save()
-    #                 table_names.add(obj.object.__class__._meta.db_table)
+    #                 table_names.add(obj.object.model_options.db_table)
     #         # Manually check for any invalid keys that might have been added,
     #         # because constraint checks were disabled.
     #         self.connection.check_constraints(table_names=table_names)
 
-    def _get_test_db_name(self, prefix=""):
+    def _get_test_db_name(self, prefix: str = "") -> str:
         """
         Internal implementation - return the name of the test DB that will be
         created. Only useful when called from create_test_db() and
@@ -146,10 +152,12 @@ class BaseDatabaseCreation:
             return self.connection.settings_dict["TEST"]["NAME"]
         return TEST_DATABASE_PREFIX + self.connection.settings_dict["NAME"]
 
-    def _execute_create_test_db(self, cursor, parameters):
+    def _execute_create_test_db(self, cursor: Any, parameters: dict[str, str]) -> None:
         cursor.execute("CREATE DATABASE {dbname} {suffix}".format(**parameters))
 
-    def _create_test_db(self, *, test_database_name, verbosity, autoclobber):
+    def _create_test_db(
+        self, *, test_database_name: str, verbosity: int, autoclobber: bool
+    ) -> str:
         """
         Internal implementation - create the test db tables.
         """
@@ -187,7 +195,9 @@ class BaseDatabaseCreation:
 
         return test_database_name
 
-    def destroy_test_db(self, old_database_name=None, verbosity=1):
+    def destroy_test_db(
+        self, old_database_name: str | None = None, verbosity: int = 1
+    ) -> None:
         """
         Destroy a test database, prompting the user for confirmation if the
         database already exists.
@@ -205,7 +215,7 @@ class BaseDatabaseCreation:
             settings.DATABASE["NAME"] = old_database_name
             self.connection.settings_dict["NAME"] = old_database_name
 
-    def _destroy_test_db(self, test_database_name, verbosity):
+    def _destroy_test_db(self, test_database_name: str, verbosity: int) -> None:
         """
         Internal implementation - remove the test db tables.
         """
@@ -218,13 +228,13 @@ class BaseDatabaseCreation:
                 f"DROP DATABASE {self.connection.ops.quote_name(test_database_name)}"
             )
 
-    def sql_table_creation_suffix(self):
+    def sql_table_creation_suffix(self) -> str:
         """
         SQL to append to the end of the test table creation statements.
         """
         return ""
 
-    def test_db_signature(self, prefix=""):
+    def test_db_signature(self, prefix: str = "") -> tuple[str, str, str, str]:
         """
         Return a tuple with elements of self.connection.settings_dict (a
         DATABASE setting value) that uniquely identify a database

plain/models/backends/base/features.py

@@ -1,4 +1,10 @@
+from __future__ import annotations
+
 from functools import cached_property
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
 
 
 class BaseDatabaseFeatures:
@@ -185,16 +191,16 @@ class BaseDatabaseFeatures:
     # Does the backend support unlimited character columns?
     supports_unlimited_charfield = False
 
-    def __init__(self, connection):
+    def __init__(self, connection: BaseDatabaseWrapper):
         self.connection = connection
 
     @cached_property
-    def supports_explaining_query_execution(self):
+    def supports_explaining_query_execution(self) -> bool:
         """Does this backend support explaining query execution?"""
         return self.connection.ops.explain_prefix is not None
 
     @cached_property
-    def supports_transactions(self):
+    def supports_transactions(self) -> bool:
         """Confirm support for transactions."""
         with self.connection.cursor() as cursor:
             cursor.execute("CREATE TABLE ROLLBACK_TEST (X INT)")
@@ -207,7 +213,7 @@ class BaseDatabaseFeatures:
             cursor.execute("DROP TABLE ROLLBACK_TEST")
         return count == 0
 
-    def allows_group_by_selected_pks_on_model(self, model):
+    def allows_group_by_selected_pks_on_model(self, model: Any) -> bool:
         if not self.allows_group_by_selected_pks:
             return False
         return True

plain/models/backends/base/introspection.py

@@ -1,4 +1,11 @@
+from __future__ import annotations
+
 from collections import namedtuple
+from collections.abc import Generator
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
 
 # Structure returned by DatabaseIntrospection.get_table_list()
 TableInfo = namedtuple("TableInfo", ["name", "type"])
@@ -14,12 +21,12 @@ FieldInfo = namedtuple(
 class BaseDatabaseIntrospection:
     """Encapsulate backend-specific introspection utilities."""
 
-    data_types_reverse = {}
+    data_types_reverse: dict[Any, str] = {}
 
-    def __init__(self, connection):
+    def __init__(self, connection: BaseDatabaseWrapper) -> None:
         self.connection = connection
 
-    def get_field_type(self, data_type, description):
+    def get_field_type(self, data_type: Any, description: Any) -> str:
         """
         Hook for a database backend to use the cursor description to
         match a Plain field type to a database column.
@@ -29,7 +36,7 @@ class BaseDatabaseIntrospection:
         """
         return self.data_types_reverse[data_type]
 
-    def identifier_converter(self, name):
+    def identifier_converter(self, name: str) -> str:
         """
         Apply a conversion to the identifier for the purposes of comparison.
 
@@ -37,7 +44,7 @@ class BaseDatabaseIntrospection:
         """
         return name
 
-    def table_names(self, cursor=None, include_views=False):
+    def table_names(self, cursor: Any = None, include_views: bool = False) -> list[str]:
         """
         Return a list of names of all tables that exist in the database.
         Sort the returned table list by Python's default sorting. Do NOT use
@@ -45,7 +52,7 @@ class BaseDatabaseIntrospection:
         order between databases.
         """
 
-        def get_names(cursor):
+        def get_names(cursor: Any) -> list[str]:
             return sorted(
                 ti.name
                 for ti in self.get_table_list(cursor)
@@ -57,7 +64,7 @@ class BaseDatabaseIntrospection:
                 return get_names(cursor)
         return get_names(cursor)
 
-    def get_table_list(self, cursor):
+    def get_table_list(self, cursor: Any) -> list[TableInfo]:
         """
         Return an unsorted list of TableInfo named tuples of all tables and
         views that exist in the database.
@@ -67,7 +74,7 @@ class BaseDatabaseIntrospection:
             "method"
         )
 
-    def get_table_description(self, cursor, table_name):
+    def get_table_description(self, cursor: Any, table_name: str) -> list[FieldInfo]:
         """
         Return a description of the table with the DB-API cursor.description
         interface.
@@ -77,7 +84,7 @@ class BaseDatabaseIntrospection:
             "get_table_description() method."
         )
 
-    def get_migratable_models(self):
+    def get_migratable_models(self) -> Generator[Any, None, None]:
         from plain.models import models_registry
         from plain.packages import packages_registry
 
@@ -87,10 +94,12 @@ class BaseDatabaseIntrospection:
             for model in models_registry.get_models(
                 package_label=package_config.package_label
             )
-            if model._meta.can_migrate(self.connection)
+            if model.model_options.can_migrate(self.connection)
         )
 
-    def plain_table_names(self, only_existing=False, include_views=True):
+    def plain_table_names(
+        self, only_existing: bool = False, include_views: bool = True
+    ) -> list[str]:
         """
         Return a list of all table names that have associated Plain models and
         are in INSTALLED_PACKAGES.
@@ -99,8 +108,10 @@ class BaseDatabaseIntrospection:
         """
         tables = set()
         for model in self.get_migratable_models():
-            tables.add(model._meta.db_table)
-            tables.update(f.m2m_db_table() for f in model._meta.local_many_to_many)
+            tables.add(model.model_options.db_table)
+            tables.update(
+                f.m2m_db_table() for f in model._model_meta.local_many_to_many
+            )
         tables = list(tables)
         if only_existing:
             existing_tables = set(self.table_names(include_views=include_views))
@@ -109,7 +120,7 @@ class BaseDatabaseIntrospection:
             ]
         return tables
 
-    def sequence_list(self):
+    def sequence_list(self) -> list[dict[str, Any]]:
         """
         Return a list of information about all DB sequences for all models in
         all packages.
@@ -119,12 +130,16 @@ class BaseDatabaseIntrospection:
             for model in self.get_migratable_models():
                 sequence_list.extend(
                     self.get_sequences(
-                        cursor, model._meta.db_table, model._meta.local_fields
+                        cursor,
+                        model.model_options.db_table,
+                        model._model_meta.local_fields,
                     )
                 )
         return sequence_list
 
-    def get_sequences(self, cursor, table_name, table_fields=()):
+    def get_sequences(
+        self, cursor: Any, table_name: str, table_fields: tuple[Any, ...] = ()
+    ) -> list[dict[str, Any]]:
         """
         Return a list of introspected sequences for table_name. Each sequence
         is a dict: {'table': <table_name>, 'column': <column_name>}. An optional
@@ -135,7 +150,7 @@ class BaseDatabaseIntrospection:
             "method"
         )
 
-    def get_relations(self, cursor, table_name):
+    def get_relations(self, cursor: Any, table_name: str) -> dict[str, tuple[str, str]]:
         """
         Return a dictionary of {field_name: (field_name_other_table, other_table)}
         representing all foreign keys in the given table.
@@ -145,21 +160,23 @@ class BaseDatabaseIntrospection:
             "get_relations() method."
         )
 
-    def get_primary_key_column(self, cursor, table_name):
+    def get_primary_key_column(self, cursor: Any, table_name: str) -> str | None:
         """
         Return the name of the primary key column for the given table.
         """
         columns = self.get_primary_key_columns(cursor, table_name)
         return columns[0] if columns else None
 
-    def get_primary_key_columns(self, cursor, table_name):
+    def get_primary_key_columns(self, cursor: Any, table_name: str) -> list[str] | None:
         """Return a list of primary key columns for the given table."""
         for constraint in self.get_constraints(cursor, table_name).values():
             if constraint["primary_key"]:
                 return constraint["columns"]
         return None
 
-    def get_constraints(self, cursor, table_name):
+    def get_constraints(
+        self, cursor: Any, table_name: str
+    ) -> dict[str, dict[str, Any]]:
         """
         Retrieve any constraints or keys (unique, pk, fk, check, index)
         across one or more columns.