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

plain/models/backends/sqlite3/base.py

@@ -2,12 +2,15 @@
 SQLite backend for the sqlite3 module in the standard library.
 """
 
+from __future__ import annotations
+
 import datetime
 import decimal
 import warnings
-from collections.abc import Mapping
+from collections.abc import Callable, Iterable, Mapping
 from itertools import chain, tee
 from sqlite3 import dbapi2 as Database
+from typing import Any
 
 from plain.exceptions import ImproperlyConfigured
 from plain.models.backends.base.base import BaseDatabaseWrapper
@@ -24,22 +27,22 @@ from .operations import DatabaseOperations
 from .schema import DatabaseSchemaEditor
 
 
-def decoder(conv_func):
+def decoder(conv_func: Callable[[str], Any]) -> Callable[[bytes], Any]:
     """
     Convert bytestrings from Python's sqlite3 interface to a regular string.
     """
     return lambda s: conv_func(s.decode())
 
 
-def adapt_date(val):
+def adapt_date(val: datetime.date) -> str:
     return val.isoformat()
 
 
-def adapt_datetime(val):
+def adapt_datetime(val: datetime.datetime) -> str:
     return val.isoformat(" ")
 
 
-def _get_varchar_column(data):
+def _get_varchar_column(data: dict[str, Any]) -> str:
     if data["max_length"] is None:
         return "varchar"
     return "varchar({max_length})".format(**data)
@@ -56,7 +59,7 @@ Database.register_adapter(datetime.date, adapt_date)
 Database.register_adapter(datetime.datetime, adapt_datetime)
 
 
-class DatabaseWrapper(BaseDatabaseWrapper):
+class SQLiteDatabaseWrapper(BaseDatabaseWrapper):
     vendor = "sqlite"
     display_name = "SQLite"
     # SQLite doesn't actually support most of these types, but it "does the right
@@ -140,7 +143,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
     introspection_class = DatabaseIntrospection
     ops_class = DatabaseOperations
 
-    def get_connection_params(self):
+    def get_connection_params(self) -> dict[str, Any]:
         settings_dict = self.settings_dict
         if not settings_dict["NAME"]:
             raise ImproperlyConfigured(
@@ -169,11 +172,11 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         kwargs.update({"check_same_thread": False, "uri": True})
         return kwargs
 
-    def get_database_version(self):
+    def get_database_version(self) -> tuple[int, ...]:
         return self.Database.sqlite_version_info
 
-    def get_new_connection(self, conn_params):
-        conn = Database.connect(**conn_params)
+    def get_new_connection(self, conn_params: dict[str, Any]) -> Any:
+        conn = Database.connect(**conn_params)  # type: ignore[call-overload]
         register_functions(conn)
 
         conn.execute("PRAGMA foreign_keys = ON")
@@ -182,18 +185,19 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         conn.execute("PRAGMA legacy_alter_table = OFF")
         return conn
 
-    def create_cursor(self, name=None):
+    def create_cursor(self, name: str | None = None) -> Any:
         return self.connection.cursor(factory=SQLiteCursorWrapper)
 
-    def close(self):
+    def close(self) -> None:
         self.validate_thread_sharing()
         # If database is in memory, closing the connection destroys the
         # database. To prevent accidental data loss, ignore close requests on
         # an in-memory db.
         if not self.is_in_memory_db():
             BaseDatabaseWrapper.close(self)
+        return None
 
-    def _savepoint_allowed(self):
+    def _savepoint_allowed(self) -> bool:
         # When 'isolation_level' is not None, sqlite3 commits before each
         # savepoint; it's a bug. When it is None, savepoints don't make sense
         # because autocommit is enabled. The only exception is inside 'atomic'
@@ -201,7 +205,7 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         # transaction explicitly rather than simply disable autocommit.
         return self.in_atomic_block
 
-    def _set_autocommit(self, autocommit):
+    def _set_autocommit(self, autocommit: bool) -> None:
         if autocommit:
             level = None
         else:
@@ -212,8 +216,9 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         # SQLite always runs at the SERIALIZABLE isolation level.
         with self.wrap_database_errors:
             self.connection.isolation_level = level
+        return None
 
-    def disable_constraint_checking(self):
+    def disable_constraint_checking(self) -> bool:
         with self.cursor() as cursor:
             cursor.execute("PRAGMA foreign_keys = OFF")
             # Foreign key constraints cannot be turned off while in a multi-
@@ -222,11 +227,12 @@ class DatabaseWrapper(BaseDatabaseWrapper):
             enabled = cursor.execute("PRAGMA foreign_keys").fetchone()[0]
         return not bool(enabled)
 
-    def enable_constraint_checking(self):
+    def enable_constraint_checking(self) -> None:
         with self.cursor() as cursor:
             cursor.execute("PRAGMA foreign_keys = ON")
+        return None
 
-    def check_constraints(self, table_names=None):
+    def check_constraints(self, table_names: list[str] | None = None) -> None:
         """
         Check each table name in `table_names` for rows with invalid foreign
         key references. This method is intended to be used in conjunction with
@@ -267,11 +273,12 @@ class DatabaseWrapper(BaseDatabaseWrapper):
                     f"invalid foreign key: {table_name}.{column_name} contains a value '{bad_value}' that "
                     f"does not have a corresponding value in {referenced_table_name}.{referenced_column_name}."
                 )
+        return None
 
-    def is_usable(self):
+    def is_usable(self) -> bool:
         return True
 
-    def _start_transaction_under_autocommit(self):
+    def _start_transaction_under_autocommit(self) -> None:
         """
         Start a transaction explicitly in autocommit mode.
 
@@ -279,8 +286,9 @@ class DatabaseWrapper(BaseDatabaseWrapper):
         savepoints when autocommit is disabled.
         """
         self.cursor().execute("BEGIN")
+        return None
 
-    def is_in_memory_db(self):
+    def is_in_memory_db(self) -> bool:
         return self.creation.is_in_memory_db(self.settings_dict["NAME"])
 
 
@@ -300,7 +308,9 @@ class SQLiteCursorWrapper(Database.Cursor):
     In both cases, if you want to use a literal "%s", you'll need to use "%%s".
     """
 
-    def execute(self, query, params=None):
+    def execute(  # type: ignore[override]
+        self, query: str, params: Iterable[Any] | Mapping[str, Any] | None = None
+    ) -> Any:
         if params is None:
             return super().execute(query)
         # Extract names if params is a mapping, i.e. "pyformat" style is used.
@@ -308,7 +318,11 @@ class SQLiteCursorWrapper(Database.Cursor):
         query = self.convert_query(query, param_names=param_names)
         return super().execute(query, params)
 
-    def executemany(self, query, param_list):
+    def executemany(  # type: ignore[override]
+        self,
+        query: str,
+        param_list: Iterable[Iterable[Any] | Mapping[str, Any]],
+    ) -> Any:
         # Extract names if params is a mapping, i.e. "pyformat" style is used.
         # Peek carefully as a generator can be passed instead of a list/tuple.
         peekable, param_list = tee(iter(param_list))
@@ -319,7 +333,7 @@ class SQLiteCursorWrapper(Database.Cursor):
         query = self.convert_query(query, param_names=param_names)
         return super().executemany(query, param_list)
 
-    def convert_query(self, query, *, param_names=None):
+    def convert_query(self, query: str, *, param_names: list[str] | None = None) -> str:
         if param_names is None:
             # Convert from "format" style to "qmark" style.
             return FORMAT_QMARK_REGEX.sub("?", query).replace("%%", "%")

plain/models/backends/sqlite3/client.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+from typing import Any
+
 from plain.models.backends.base.client import BaseDatabaseClient
 
 
@@ -5,6 +9,8 @@ class DatabaseClient(BaseDatabaseClient):
     executable_name = "sqlite3"
 
     @classmethod
-    def settings_to_cmd_args_env(cls, settings_dict, parameters):
+    def settings_to_cmd_args_env(
+        cls, settings_dict: dict[str, Any], parameters: list[str]
+    ) -> tuple[list[str], None]:
         args = [cls.executable_name, settings_dict["NAME"], *parameters]
         return args, None

plain/models/backends/sqlite3/creation.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import sys
 from pathlib import Path
@@ -7,12 +9,12 @@ from plain.models.backends.base.creation import BaseDatabaseCreation
 
 class DatabaseCreation(BaseDatabaseCreation):
     @staticmethod
-    def is_in_memory_db(database_name):
+    def is_in_memory_db(database_name: str | Path) -> bool:
         return not isinstance(database_name, Path) and (
             database_name == ":memory:" or "mode=memory" in database_name
         )
 
-    def _get_test_db_name(self, prefix=""):
+    def _get_test_db_name(self, prefix: str = "") -> str:
         raw_name = self.connection.settings_dict["TEST"]["NAME"] or ":memory:"
         # Special in-memory case
         if raw_name == ":memory:":
@@ -25,7 +27,9 @@ class DatabaseCreation(BaseDatabaseCreation):
 
         return test_database_name
 
-    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 - delete existing SQLite test DB file if needed.
         """
@@ -50,12 +54,12 @@ class DatabaseCreation(BaseDatabaseCreation):
                     sys.exit(1)
         return test_database_name
 
-    def _destroy_test_db(self, test_database_name, verbosity):
+    def _destroy_test_db(self, test_database_name: str, verbosity: int) -> None:
         if test_database_name and not self.is_in_memory_db(test_database_name):
             # Remove the SQLite database file
             os.remove(test_database_name)
 
-    def test_db_signature(self, prefix=""):
+    def test_db_signature(self, prefix: str = "") -> tuple[str, str]:
         """
         Return a tuple that uniquely identifies a test database.
 

plain/models/backends/sqlite3/features.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import operator
 from functools import cached_property
 
@@ -34,11 +36,11 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     supports_unlimited_charfield = True
 
     @cached_property
-    def supports_atomic_references_rename(self):
+    def supports_atomic_references_rename(self) -> bool:
         return Database.sqlite_version_info >= (3, 26, 0)
 
     @cached_property
-    def supports_json_field(self):
+    def supports_json_field(self) -> bool:
         with self.connection.cursor() as cursor:
             try:
                 with transaction.atomic():
@@ -51,7 +53,7 @@ class DatabaseFeatures(BaseDatabaseFeatures):
     has_json_object_function = property(operator.attrgetter("supports_json_field"))
 
     @cached_property
-    def can_return_columns_from_insert(self):
+    def can_return_columns_from_insert(self) -> bool:
         return Database.sqlite_version_info >= (3, 35)
 
     can_return_rows_from_bulk_insert = property(

plain/models/backends/sqlite3/introspection.py

@@ -1,6 +1,12 @@
+from __future__ import annotations
+
 from collections import namedtuple
+from collections.abc import Generator
+from typing import Any
 
 import sqlparse
+import sqlparse.sql
+import sqlparse.tokens
 
 from plain.models import Index
 from plain.models.backends.base.introspection import (
@@ -18,7 +24,7 @@ FieldInfo = namedtuple(
 field_size_re = _lazy_re_compile(r"^\s*(?:var)?char\s*\(\s*(\d+)\s*\)\s*$")
 
 
-def get_field_size(name):
+def get_field_size(name: str) -> int | None:
     """Extract the size number from a "varchar(11)" type name"""
     m = field_size_re.search(name)
     return int(m[1]) if m else None
@@ -53,7 +59,7 @@ class FlexibleFieldLookupDict:
         "time": "TimeField",
     }
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: str) -> str:
         key = key.lower().split("(", 1)[0].strip()
         return self.base_data_types_reverse[key]
 
@@ -61,7 +67,7 @@ class FlexibleFieldLookupDict:
 class DatabaseIntrospection(BaseDatabaseIntrospection):
     data_types_reverse = FlexibleFieldLookupDict()
 
-    def get_field_type(self, data_type, description):
+    def get_field_type(self, data_type: Any, description: Any) -> str:
         field_type = super().get_field_type(data_type, description)
         if description.pk and field_type == "BigIntegerField":
             return "PrimaryKeyField"
@@ -69,7 +75,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             return "JSONField"
         return field_type
 
-    def get_table_list(self, cursor):
+    def get_table_list(self, cursor: Any) -> list[TableInfo]:
         """Return a list of table and view names in the current database."""
         # Skip the sqlite_sequence system table used for autoincrement key
         # generation.
@@ -81,7 +87,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
         )
         return [TableInfo(row[0], row[1][0]) for row in cursor.fetchall()]
 
-    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.
@@ -128,11 +134,13 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             for cid, name, data_type, notnull, default, pk in table_info
         ]
 
-    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]]:
         pk_col = self.get_primary_key_column(cursor, table_name)
         return [{"table": table_name, "column": pk_col}]
 
-    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 {column_name: (ref_column_name, ref_table_name)}
         representing all foreign keys in the given table.
@@ -152,13 +160,15 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
             ) in cursor.fetchall()
         }
 
-    def get_primary_key_columns(self, cursor, table_name):
+    def get_primary_key_columns(self, cursor: Any, table_name: str) -> list[str]:
         cursor.execute(
             f"PRAGMA table_info({self.connection.ops.quote_name(table_name)})"
         )
         return [name for _, name, *_, pk in cursor.fetchall() if pk]
 
-    def _parse_column_or_constraint_definition(self, tokens, columns):
+    def _parse_column_or_constraint_definition(
+        self, tokens: Generator[Any, None, None], columns: set[str]
+    ) -> tuple[str | None, dict[str, Any] | None, dict[str, Any] | None, Any]:
         token = None
         is_constraint_definition = None
         field_name = None
@@ -258,11 +268,13 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
         )
         return constraint_name, unique_constraint, check_constraint, token
 
-    def _parse_table_constraints(self, sql, columns):
+    def _parse_table_constraints(
+        self, sql: str, columns: set[str]
+    ) -> dict[str, dict[str, Any]]:
         # Check constraint parsing is based of SQLite syntax diagram.
         # https://www.sqlite.org/syntaxdiagrams.html#table-constraint
         statement = sqlparse.parse(sql)[0]
-        constraints = {}
+        constraints: dict[str, dict[str, Any]] = {}
         unnamed_constrains_index = 0
         tokens = (token for token in statement.flatten() if not token.is_whitespace)
         # Go to columns and constraint definition
@@ -297,12 +309,14 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
                 break
         return constraints
 
-    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.
         """
-        constraints = {}
+        constraints: dict[str, dict[str, Any]] = {}
         # Find inline check constraints.
         try:
             table_schema = cursor.execute(
@@ -393,7 +407,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
         )
         return constraints
 
-    def _get_index_columns_orders(self, sql):
+    def _get_index_columns_orders(self, sql: str) -> list[str] | None:
         tokens = sqlparse.parse(sql)[0]
         for token in tokens:
             if isinstance(token, sqlparse.sql.Parenthesis):
@@ -401,7 +415,9 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
                 return ["DESC" if info.endswith("DESC") else "ASC" for info in columns]
         return None
 
-    def _get_column_collations(self, cursor, table_name):
+    def _get_column_collations(
+        self, cursor: Any, table_name: str
+    ) -> dict[str, str | None]:
         row = cursor.execute(
             """
             SELECT sql
@@ -415,7 +431,7 @@ class DatabaseIntrospection(BaseDatabaseIntrospection):
 
         sql = row[0]
         columns = str(sqlparse.parse(sql)[0][-1]).strip("()").split(", ")
-        collations = {}
+        collations: dict[str, str | None] = {}
         for column in columns:
             tokens = column[1:].split()
             column_name = tokens[0].strip('"')