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

plain/models/sql/datastructures.py

@@ -3,9 +3,18 @@ Useful auxiliary data structures for query construction. Not useful outside
 the SQL domain.
 """
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
 from plain.models.exceptions import FullResultSet
 from plain.models.sql.constants import INNER, LOUTER
 
+if TYPE_CHECKING:
+    from plain.models.backends.base.base import BaseDatabaseWrapper
+    from plain.models.fields import Field
+    from plain.models.sql.compiler import SQLCompiler
+
 
 class MultiJoin(Exception):
     """
@@ -14,7 +23,7 @@ class MultiJoin(Exception):
     exceptionally).
     """
 
-    def __init__(self, names_pos, path_with_names):
+    def __init__(self, names_pos: int, path_with_names: list[str]) -> None:
         self.level = names_pos
         # The path travelled, this includes the path to the multijoin.
         self.names_with_path = path_with_names
@@ -45,14 +54,14 @@ class Join:
 
     def __init__(
         self,
-        table_name,
-        parent_alias,
-        table_alias,
-        join_type,
-        join_field,
-        nullable,
-        filtered_relation=None,
-    ):
+        table_name: str,
+        parent_alias: str,
+        table_alias: str,
+        join_type: str,
+        join_field: Field,
+        nullable: bool,
+        filtered_relation: Any = None,
+    ) -> None:
         # Join table
         self.table_name = table_name
         self.parent_alias = parent_alias
@@ -62,14 +71,16 @@ class Join:
         self.join_type = join_type
         # A list of 2-tuples to use in the ON clause of the JOIN.
         # Each 2-tuple will create one join condition in the ON clause.
-        self.join_cols = join_field.get_joining_columns()
+        self.join_cols = join_field.get_joining_columns()  # type: ignore[attr-defined]
         # Along which field (or ForeignObjectRel in the reverse join case)
         self.join_field = join_field
         # Is this join nullabled?
         self.nullable = nullable
         self.filtered_relation = filtered_relation
 
-    def as_sql(self, compiler, connection):
+    def as_sql(
+        self, compiler: SQLCompiler, connection: BaseDatabaseWrapper
+    ) -> tuple[str, list[Any]]:
         """
         Generate the full
            LEFT OUTER JOIN sometable ON sometable.somecol = othertable.othercol, params
@@ -117,7 +128,7 @@ class Join:
         sql = f"{self.join_type} {qn(self.table_name)}{alias_str} ON ({on_clause_sql})"
         return sql, params
 
-    def relabeled_clone(self, change_map):
+    def relabeled_clone(self, change_map: dict[str, str]) -> Join:
         new_parent_alias = change_map.get(self.parent_alias, self.parent_alias)
         new_table_alias = change_map.get(self.table_alias, self.table_alias)
         if self.filtered_relation is not None:
@@ -138,7 +149,7 @@ class Join:
         )
 
     @property
-    def identity(self):
+    def identity(self) -> tuple[type[Join], str, str, Any, Any]:
         return (
             self.__class__,
             self.table_name,
@@ -147,24 +158,24 @@ class Join:
             self.filtered_relation,
         )
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, Join):
             return NotImplemented
         return self.identity == other.identity
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.identity)
 
-    def equals(self, other):
+    def equals(self, other: Join) -> bool:
         # Ignore filtered_relation in equality check.
         return self.identity[:-1] == other.identity[:-1]
 
-    def demote(self):
+    def demote(self) -> Join:
         new = self.relabeled_clone({})
         new.join_type = INNER
         return new
 
-    def promote(self):
+    def promote(self) -> Join:
         new = self.relabeled_clone({})
         new.join_type = LOUTER
         return new
@@ -182,33 +193,35 @@ class BaseTable:
     parent_alias = None
     filtered_relation = None
 
-    def __init__(self, table_name, alias):
+    def __init__(self, table_name: str, alias: str) -> None:
         self.table_name = table_name
         self.table_alias = alias
 
-    def as_sql(self, compiler, connection):
+    def as_sql(
+        self, compiler: SQLCompiler, connection: BaseDatabaseWrapper
+    ) -> tuple[str, list[Any]]:
         alias_str = (
             "" if self.table_alias == self.table_name else (f" {self.table_alias}")
         )
         base_sql = compiler.quote_name_unless_alias(self.table_name)
         return base_sql + alias_str, []
 
-    def relabeled_clone(self, change_map):
+    def relabeled_clone(self, change_map: dict[str, str]) -> BaseTable:
         return self.__class__(
             self.table_name, change_map.get(self.table_alias, self.table_alias)
         )
 
     @property
-    def identity(self):
+    def identity(self) -> tuple[type[BaseTable], str, str]:
         return self.__class__, self.table_name, self.table_alias
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if not isinstance(other, BaseTable):
             return NotImplemented
         return self.identity == other.identity
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.identity)
 
-    def equals(self, other):
+    def equals(self, other: BaseTable) -> bool:
         return self.identity == other.identity