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

plain/models/migrations/utils.py

@@ -1,30 +1,39 @@
+from __future__ import annotations
+
 import datetime
 import re
 from collections import namedtuple
+from collections.abc import Generator
+from typing import TYPE_CHECKING, Any
 
 from plain.models.fields.related import RECURSIVE_RELATIONSHIP_CONSTANT
 
+if TYPE_CHECKING:
+    from plain.models.fields import Field
+
 FieldReference = namedtuple("FieldReference", "to through")
 
 COMPILED_REGEX_TYPE = type(re.compile(""))
 
 
 class RegexObject:
-    def __init__(self, obj):
+    def __init__(self, obj: Any) -> None:
         self.pattern = obj.pattern
         self.flags = obj.flags
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if not isinstance(other, RegexObject):
             return NotImplemented
         return self.pattern == other.pattern and self.flags == other.flags
 
 
-def get_migration_name_timestamp():
+def get_migration_name_timestamp() -> str:
     return datetime.datetime.now().strftime("%Y%m%d_%H%M")
 
 
-def resolve_relation(model, package_label=None, model_name=None):
+def resolve_relation(
+    model: str | Any, package_label: str | None = None, model_name: str | None = None
+) -> tuple[str, str]:
     """
     Turn a model class or model reference string and return a model tuple.
 
@@ -47,16 +56,16 @@ def resolve_relation(model, package_label=None, model_name=None):
                 "package_label must be provided to resolve unscoped model relationships."
             )
         return package_label, model.lower()
-    return model._meta.package_label, model._meta.model_name
+    return model.model_options.package_label, model.model_options.model_name
 
 
 def field_references(
-    model_tuple,
-    field,
-    reference_model_tuple,
-    reference_field_name=None,
-    reference_field=None,
-):
+    model_tuple: tuple[str, str],
+    field: Field,
+    reference_model_tuple: tuple[str, str],
+    reference_field_name: str | None = None,
+    reference_field: Field | None = None,
+) -> FieldReference | bool:
     """
     Return either False or a FieldReference if `field` references provided
     context.
@@ -97,7 +106,9 @@ def field_references(
     return FieldReference(references_to, references_through)
 
 
-def get_references(state, model_tuple, field_tuple=()):
+def get_references(
+    state: Any, model_tuple: tuple[str, str], field_tuple: tuple[Any, ...] = ()
+) -> Generator[tuple[Any, str, Field, FieldReference], None, None]:
     """
     Generator of (model_state, name, field, reference) referencing
     provided context.
@@ -108,12 +119,17 @@ def get_references(state, model_tuple, field_tuple=()):
     for state_model_tuple, model_state in state.models.items():
         for name, field in model_state.fields.items():
             reference = field_references(
-                state_model_tuple, field, model_tuple, *field_tuple
+                state_model_tuple,
+                field,
+                model_tuple,
+                *field_tuple,  # type: ignore[arg-type]
             )
             if reference:
                 yield model_state, name, field, reference
 
 
-def field_is_referenced(state, model_tuple, field_tuple):
+def field_is_referenced(
+    state: Any, model_tuple: tuple[str, str], field_tuple: tuple[Any, ...]
+) -> bool:
     """Return whether `field_tuple` is referenced by any state models."""
     return next(get_references(state, model_tuple, field_tuple), None) is not None

plain/models/migrations/writer.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
+
 import os
 import re
 from importlib import import_module
+from typing import Any
 
 from plain.models import migrations
 from plain.models.migrations.loader import MigrationLoader
@@ -14,13 +17,13 @@ from plain.utils.timezone import now
 
 
 class OperationWriter:
-    def __init__(self, operation, indentation=2):
+    def __init__(self, operation: Any, indentation: int = 2) -> None:
         self.operation = operation
-        self.buff = []
+        self.buff: list[str] = []
         self.indentation = indentation
 
-    def serialize(self):
-        def _write(_arg_name, _arg_value):
+    def serialize(self) -> tuple[str, set[str]]:
+        def _write(_arg_name: str, _arg_value: Any) -> None:
             if _arg_name in self.operation.serialization_expand_args and isinstance(
                 _arg_value, list | tuple | dict
             ):
@@ -100,16 +103,16 @@ class OperationWriter:
         self.feed("),")
         return self.render(), imports
 
-    def indent(self):
+    def indent(self) -> None:
         self.indentation += 1
 
-    def unindent(self):
+    def unindent(self) -> None:
         self.indentation -= 1
 
-    def feed(self, line):
+    def feed(self, line: str) -> None:
         self.buff.append(" " * (self.indentation * 4) + line)
 
-    def render(self):
+    def render(self) -> str:
         return "\n".join(self.buff)
 
 
@@ -119,12 +122,12 @@ class MigrationWriter:
     of the migration file from it.
     """
 
-    def __init__(self, migration, include_header=True):
+    def __init__(self, migration: Any, include_header: bool = True) -> None:
         self.migration = migration
         self.include_header = include_header
         self.needs_manual_porting = False
 
-    def as_string(self):
+    def as_string(self) -> str:
         """Return a string of the file contents."""
         items = {
             "replaces_str": "",
@@ -198,7 +201,7 @@ class MigrationWriter:
         return MIGRATION_TEMPLATE % items
 
     @property
-    def basedir(self):
+    def basedir(self) -> str:
         migrations_package_name, _ = MigrationLoader.migrations_module(
             self.migration.package_label
         )
@@ -266,15 +269,15 @@ class MigrationWriter:
         return final_dir
 
     @property
-    def filename(self):
+    def filename(self) -> str:
         return f"{self.migration.name}.py"
 
     @property
-    def path(self):
+    def path(self) -> str:
         return os.path.join(self.basedir, self.filename)
 
     @classmethod
-    def serialize(cls, value):
+    def serialize(cls, value: Any) -> tuple[str, set[str]]:
         return serializer_factory(value).serialize()