clear-skies 2.0.6__py3-none-any.whl → 2.0.8__py3-none-any.whl

clearskies/backends/memory_backend.py

@@ -1,15 +1,18 @@
-import inspect
+from __future__ import annotations
+
 from functools import cmp_to_key
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.model
-import clearskies.query
 from clearskies import functional
 from clearskies.autodoc.schema import Integer as AutoDocInteger
 from clearskies.autodoc.schema import Schema as AutoDocSchema
 from clearskies.backends.backend import Backend
 from clearskies.di import InjectableProperties, inject
 
+if TYPE_CHECKING:
+    from clearskies import Model
+    from clearskies.query import Condition, Join, Query, Sort
+
 
 class Null:
     def __lt__(self, other):
@@ -31,7 +34,7 @@ def gentle_float_conversion(value):
         return value
 
 
-def _sort(row_a: Any, row_b: Any, sorts: list[clearskies.query.Sort], default_table_name: str) -> int:
+def _sort(row_a: Any, row_b: Any, sorts: list[Sort], default_table_name: str) -> int:
     for sort in sorts:
         # so, if we've done a join then the rows will have data from all joined tables via a dict of dicts.
         # if there wasn't a join then we'll just have the data
@@ -92,7 +95,7 @@ class MemoryTable:
     _id_index: dict[int | str, int] = {}
     id_column_name: str = ""
     _next_id: int = 1
-    _model_class: type[clearskies.model.Model] = None  # type:  ignore
+    _model_class: type[Model] = None  # type:  ignore
 
     # here be dragons.  This is not a 100% drop-in replacement for the equivalent SQL operators
     # https://codereview.stackexchange.com/questions/259198/in-memory-table-filtering-in-python
@@ -124,7 +127,7 @@ class MemoryTable:
         "in": lambda column, values, null: lambda row: row.get(column, null) in values,
     }
 
-    def __init__(self, model_class: type[clearskies.model.Model]) -> None:
+    def __init__(self, model_class: type[Model]) -> None:
         self._rows = []
         self._id_index = {}
         self.id_column_name = model_class.id_column_name
@@ -193,13 +196,13 @@ class MemoryTable:
         self._rows[index] = None
         return True
 
-    def count(self, query: clearskies.query.Query):
+    def count(self, query: Query):
         return len(self.rows(query, query.conditions, filter_only=True))
 
     def rows(
         self,
-        query: clearskies.query.Query,
-        conditions: list[clearskies.query.Condition],
+        query: Query,
+        conditions: list[Condition],
         filter_only: bool = False,
         next_page_data: dict[str, Any] | None = None,
     ):
@@ -232,7 +235,7 @@ class MemoryTable:
         return rows
 
     @classmethod
-    def _condition_as_filter(cls, condition: clearskies.query.Condition) -> Callable:
+    def _condition_as_filter(cls, condition: Condition) -> Callable:
         column = condition.column_name
         values = condition.values
         return cls._operator_lambda_builders[condition.operator.lower()](column, values, cls.null)
@@ -469,19 +472,19 @@ class MemoryBackend(Backend, InjectableProperties):
     def silent_on_missing_tables(self, silent=True):
         self._silent_on_missing_tables = silent
 
-    def create_table(self, model_class: type[clearskies.model.Model]):
+    def create_table(self, model_class: type[Model]):
         self.load_default_data()
         table_name = model_class.destination_name()
         if table_name in self.__class__._tables:
             return
         self.__class__._tables[table_name] = MemoryTable(model_class)
 
-    def has_table(self, model_class: type[clearskies.model.Model]) -> bool:
+    def has_table(self, model_class: type[Model]) -> bool:
         self.load_default_data()
         table_name = model_class.destination_name()
         return table_name in self.__class__._tables
 
-    def get_table(self, model_class: type[clearskies.model.Model], create_if_missing=False) -> MemoryTable:
+    def get_table(self, model_class: type[Model], create_if_missing=False) -> MemoryTable:
         table_name = model_class.destination_name()
         if table_name not in self.__class__._tables:
             if create_if_missing:
@@ -492,25 +495,23 @@ class MemoryBackend(Backend, InjectableProperties):
                 )
         return self.__class__._tables[table_name]
 
-    def create_with_model_class(
-        self, data: dict[str, Any], model_class: type[clearskies.model.Model]
-    ) -> dict[str, Any]:
+    def create_with_model_class(self, data: dict[str, Any], model_class: type[Model]) -> dict[str, Any]:
         self.create_table(model_class)
         return self.get_table(model_class).create(data)
 
-    def update(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def update(self, id: int | str, data: dict[str, Any], model: Model) -> dict[str, Any]:
         self.create_table(model.__class__)
         return self.get_table(model.__class__).update(id, data)
 
-    def create(self, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def create(self, data: dict[str, Any], model: Model) -> dict[str, Any]:
         self.create_table(model.__class__)
         return self.get_table(model.__class__).create(data)
 
-    def delete(self, id: int | str, model: clearskies.model.Model) -> bool:
+    def delete(self, id: int | str, model: Model) -> bool:
         self.create_table(model.__class__)
         return self.get_table(model.__class__).delete(id)
 
-    def count(self, query: clearskies.query.Query) -> int:
+    def count(self, query: Query) -> int:
         self.check_query(query)
         if not self.has_table(query.model_class):
             if self._silent_on_missing_tables:
@@ -528,9 +529,7 @@ class MemoryBackend(Backend, InjectableProperties):
         query.joins = [join for join in query.joins if join.join_type != "LEFT"]
         return len(self.rows_with_joins(query))
 
-    def records(
-        self, query: clearskies.query.Query, next_page_data: dict[str, str | int] | None = None
-    ) -> list[dict[str, Any]]:
+    def records(self, query: Query, next_page_data: dict[str, str | int] | None = None) -> list[dict[str, Any]]:
         self.check_query(query)
         if not self.has_table(query.model_class):
             if self._silent_on_missing_tables:
@@ -568,7 +567,7 @@ class MemoryBackend(Backend, InjectableProperties):
                 next_page_data["start"] = start + query.limit
         return rows
 
-    def rows_with_joins(self, query: clearskies.query.Query) -> list[dict[str, Any]]:
+    def rows_with_joins(self, query: Query) -> list[dict[str, Any]]:
         joins = [*query.joins]
         conditions = [*query.conditions]
         # quick sanity check
@@ -642,15 +641,13 @@ class MemoryBackend(Backend, InjectableProperties):
             raise ValueError(f"Cannot return rows for unknown table '{table_name}'")
         return list(filter(None, self.__class__._tables[table_name]._rows))
 
-    def check_query(self, query: clearskies.query.Query) -> None:
+    def check_query(self, query: Query) -> None:
         if query.group_by:
             raise KeyError(
                 f"MemoryBackend does not support group_by clauses in queries. You may be using the wrong backend."
             )
 
-    def conditions_for_table(
-        self, table_name: str, conditions: list[clearskies.query.Condition], is_left=False
-    ) -> list[clearskies.query.Condition]:
+    def conditions_for_table(self, table_name: str, conditions: list[Condition], is_left=False) -> list[Condition]:
         """
         Return only the conditions for the given table.
 
@@ -667,7 +664,7 @@ class MemoryBackend(Backend, InjectableProperties):
         self,
         rows: list[dict[str, Any]],
         join_rows: list[dict[str, Any]],
-        join: clearskies.query.Join,
+        join: Join,
         joined_tables: list[str],
     ) -> list[dict[str, Any]]:
         """

clearskies/backends/secrets_backend.py

@@ -1,12 +1,13 @@
-from typing import Any, Callable
+from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies
-from clearskies.autodoc.schema import Integer as AutoDocInteger
 from clearskies.autodoc.schema import Schema as AutoDocSchema
-from clearskies.autodoc.schema import String as AutoDocString
 from clearskies.backends.backend import Backend
-from clearskies.di import InjectableProperties, inject
-from clearskies.functional import routing, string
+from clearskies.di import inject
+from clearskies.query import Condition, Query
+
+if TYPE_CHECKING:
+    from clearskies import Model
+    from clearskies.authentication import Authentication
 
 
 class SecretsBackend(Backend):
@@ -31,11 +32,11 @@ class SecretsBackend(Backend):
     def __init__(self):
         pass
 
-    def check_query(self, query: clearskies.query.Query) -> None:
+    def check_query(self, query: Query) -> None:
         if not query.conditions:
             raise KeyError(f"You must search by an id when using the secrets backend.")
 
-    def update(self, id: str, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:  # type: ignore[override]
+    def update(self, id: str, data: dict[str, Any], model: Model) -> dict[str, Any]:  # type: ignore[override]
         """Update the record with the given id with the information from the data dictionary."""
         folder_path = self._make_folder_path(model, id)
         for key, value in data.items():
@@ -44,20 +45,16 @@ class SecretsBackend(Backend):
             self.secrets.update(f"{folder_path}{key}", value)
 
         # and now query again to fetch the updated record.
-        return self.records(
-            clearskies.query.Query(
-                model.__class__, conditions=[clearskies.query.Condition(f"{model.id_column_name}={id}")]
-            )
-        )[0]
+        return self.records(Query(model.__class__, conditions=[Condition(f"{model.id_column_name}={id}")]))[0]
 
-    def create(self, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def create(self, data: dict[str, Any], model: Model) -> dict[str, Any]:
         if not model.id_column_name in data:
             raise ValueError(
                 f"You must provide '{model.id_column_name}' when creating a record with the secrets backend"
             )
         return self.update(data[model.id_column_name], data, model)
 
-    def delete(self, id: str, model: clearskies.model.Model) -> bool:  # type: ignore[override]
+    def delete(self, id: str, model: Model) -> bool:  # type: ignore[override]
         """
         Delete the record with the given id.
 
@@ -65,9 +62,7 @@ class SecretsBackend(Backend):
         """
         return True
 
-    def records(
-        self, query: clearskies.query.Query, next_page_data: dict[str, str | int] | None = None
-    ) -> list[dict[str, Any]]:
+    def records(self, query: Query, next_page_data: dict[str, str | int] | None = None) -> list[dict[str, Any]]:
         """Return a list of records that match the given query configuration."""
         self.check_query(query)
         for condition in query.conditions:

clearskies/column.py

@@ -1,30 +1,22 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, Self, Type, overload
-
-import clearskies.configs.actions
-import clearskies.configs.boolean
-import clearskies.configs.select
-import clearskies.configs.string
-import clearskies.configs.string_or_callable
-import clearskies.configs.validators
-import clearskies.configurable
-import clearskies.decorators
-import clearskies.di
-import clearskies.model
-import clearskies.typing
-from clearskies.autodoc.schema import Schema as AutoDocSchema
+from typing import TYPE_CHECKING, Any, Callable, Self, overload
+
+from clearskies import configs, configurable, decorators
 from clearskies.autodoc.schema import String as AutoDocString
-from clearskies.query.condition import Condition, ParsedCondition
+from clearskies.di import InjectableProperties, inject
+from clearskies.query.condition import ParsedCondition
 from clearskies.validator import Validator
 
 if TYPE_CHECKING:
-    from clearskies import Model, Schema
+    from clearskies import Model, Schema, typing
+    from clearskies.autodoc.schema import Schema as AutoDocSchema
+    from clearskies.query.condition import Condition
 
 
-class Column(clearskies.configurable.Configurable, clearskies.di.InjectableProperties):
+class Column(configurable.Configurable, InjectableProperties):
     """
-    Columns are used to build schemes and enable a variety of levels of automation with clearskies.
+    Columns are used to build schemes and enable a variety of levels of automation with.
 
     Columns are used to define your schemas in clearskies, especially via models.  The column definitions are then used by endpoints
     and other aspects of the clearskies framework to automate things like input validation, front-end/backend-transformations, and more.
@@ -33,7 +25,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     """
     The column class gets the full DI container, because it does a lot of object building itself
     """
-    di = clearskies.di.inject.Di()
+    di = inject.Di()
 
     """
     A default value to set for this column.
@@ -79,7 +71,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     }
     ```
     """
-    default = clearskies.configs.string.String(default=None)
+    default = configs.string.String(default=None)
 
     """
     A value to set for this column during a save operation.
@@ -143,7 +135,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     e.g., `date_of_birth` is `age` years behind the current time (as recorded in the `created` timestamp).
 
     """
-    setable = clearskies.configs.string_or_callable.StringOrCallable(default=None)
+    setable = configs.string_or_callable.StringOrCallable(default=None)
 
     """
     Whether or not this column can be converted to JSON and included in an API response.
@@ -151,7 +143,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     If this is set to False for a column and you attempt to set that column as a readable_column in an endpoint,
     clearskies will throw an exception.
     """
-    is_readable = clearskies.configs.boolean.Boolean(default=True)
+    is_readable = configs.boolean.Boolean(default=True)
 
     """
     Whether or not this column can be set via an API call.
@@ -159,7 +151,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     If this is set to False for a column and you attempt to set the column as a writeable column in an endpoint,
     clearskies will throw an exception.
     """
-    is_writeable = clearskies.configs.boolean.Boolean(default=True)
+    is_writeable = configs.boolean.Boolean(default=True)
 
     """
     Whether or not it is possible to search by this column
@@ -167,7 +159,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     If this is set to False for a column and you attempt to set the column as a searchable column in an endpoint,
     clearskies will throw an exception.
     """
-    is_searchable = clearskies.configs.boolean.Boolean(default=True)
+    is_searchable = configs.boolean.Boolean(default=True)
 
     """
     Whether or not this column is temporary.  A temporary column is not persisted to the backend.
@@ -228,7 +220,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     If you were using an SQL database, you would not have to put a `date_of_birth` column in your table.
 
     """
-    is_temporary = clearskies.configs.boolean.Boolean(default=False)
+    is_temporary = configs.boolean.Boolean(default=False)
 
     """
     Validators to use when checking the input for this column during write operations from the API.
@@ -319,7 +311,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     }
     ```
     """
-    validators = clearskies.configs.validators.Validators(default=[])
+    validators = configs.validators.Validators(default=[])
 
     """
     Actions to take during the pre-save step of the save process if the column has changed during the active save operation.
@@ -403,7 +395,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     ```
 
     """
-    on_change_pre_save = clearskies.configs.actions.Actions(default=[])
+    on_change_pre_save = configs.actions.Actions(default=[])
 
     """
     Actions to take during the post-save step of the process if the column has changed during the active save.
@@ -521,7 +513,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     ```
 
     """
-    on_change_post_save = clearskies.configs.actions.Actions(default=[])
+    on_change_post_save = configs.actions.Actions(default=[])
 
     """
     Actions to take during the save-finished step of the save process if the column has changed in the save.
@@ -538,7 +530,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     Unlike pre_save and post_save, `data` is not provided because this data has already been merged into the
     model.  If you need some context from the completed save operation, use methods like `was_changed` and `previous_value`.
     """
-    on_change_save_finished = clearskies.configs.actions.Actions(default=[])
+    on_change_save_finished = configs.actions.Actions(default=[])
 
     """
     Use in conjunction with `created_by_source_type` to have this column automatically populated by data from an HTTP request.
@@ -554,7 +546,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
 
     See created_by_source_type for usage examples.
     """
-    created_by_source_key = clearskies.configs.string.String(default="")
+    created_by_source_key = configs.string.String(default="")
 
     """
     Use in conjunction with `created_by_source_key` to have this column automatically populated by data from ann HTTP request.
@@ -614,20 +606,20 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     ```
 
     """
-    created_by_source_type = clearskies.configs.select.Select(
+    created_by_source_type = configs.select.Select(
         ["authorization_data", "http_header", "routing_data", ""], default=""
     )
 
     """
     If True, and the key requested via created_by_source_key doesn't exist in the designated source, an error will be raised.
     """
-    created_by_source_strict = clearskies.configs.boolean.Boolean(default=True)
+    created_by_source_strict = configs.boolean.Boolean(default=True)
 
     """ The model class this column is associated with. """
-    model_class = clearskies.configs.Schema()
+    model_class = configs.Schema()
 
     """ The name of this column. """
-    name = clearskies.configs.string.String()
+    name = configs.string.String()
 
     """
     Simple flag to denote if the column is unique or not.
@@ -669,7 +661,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
     """
     auto_doc_class: type[AutoDocSchema] = AutoDocString
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         default: str | None = None,
@@ -678,10 +670,10 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
         is_writeable: bool = True,
         is_searchable: bool = True,
         is_temporary: bool = False,
-        validators: clearskies.typing.validator | list[clearskies.typing.validator] = [],
-        on_change_pre_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_post_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_save_finished: clearskies.typing.action | list[clearskies.typing.action] = [],
+        validators: typing.validator | list[typing.validator] = [],
+        on_change_pre_save: typing.action | list[typing.action] = [],
+        on_change_post_save: typing.action | list[typing.action] = [],
+        on_change_save_finished: typing.action | list[typing.action] = [],
         created_by_source_type: str = "",
         created_by_source_key: str = "",
         created_by_source_strict: bool = True,
@@ -810,11 +802,11 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
             }
         return additional_write_columns
 
-    def to_json(self, model: clearskies.model.Model) -> dict[str, Any]:
+    def to_json(self, model: Model) -> dict[str, Any]:
         """Grabs the column out of the model and converts it into a representation that can be turned into JSON."""
         return {self.name: self.__get__(model, model.__class__)}
 
-    def input_errors(self, model: clearskies.model.Model, data: dict[str, Any]) -> dict[str, Any]:
+    def input_errors(self, model: Model, data: dict[str, Any]) -> dict[str, Any]:
         """
         Check the given dictionary of data for any possible input errors.
 
@@ -885,7 +877,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
         """
         return ""
 
-    def pre_save(self, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def pre_save(self, data: dict[str, Any], model: Model) -> dict[str, Any]:
         """
         Make any necessary changes to the data before starting the save process.
 
@@ -914,7 +906,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
             data = self.execute_actions_with_data(self.on_change_pre_save, model, data)
         return data
 
-    def post_save(self, data: dict[str, Any], model: clearskies.model.Model, id: int | str) -> None:
+    def post_save(self, data: dict[str, Any], model: Model, id: int | str) -> None:
         """
         Make any changes needed after persisting data to the backend.
 
@@ -940,7 +932,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
                 require_dict_return_value=False,
             )
 
-    def save_finished(self, model: clearskies.model.Model) -> None:
+    def save_finished(self, model: Model) -> None:
         """
         Make any necessary changes needed after a save has completely finished.
 
@@ -980,8 +972,8 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
 
     def execute_actions_with_data(
         self,
-        actions: list[clearskies.typing.action],
-        model: clearskies.model.Model,
+        actions: list[typing.action],
+        model: Model,
         data: dict[str, Any],
         id: int | str | None = None,
         context: str = "on_change_pre_save",
@@ -1016,8 +1008,8 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
 
     def execute_actions(
         self,
-        actions: list[clearskies.typing.action],
-        model: clearskies.model.Model,
+        actions: list[typing.action],
+        model: Model,
     ) -> None:
         """Execute a given set of actions."""
         input_output = self.di.build("input_output", cache=True)
@@ -1036,9 +1028,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
         """
         return value_1 == value_2
 
-    def add_search(
-        self, model: clearskies.model.Model, value: str, operator: str = "", relationship_reference: str = ""
-    ) -> clearskies.model.Model:
+    def add_search(self, model: Model, value: str, operator: str = "", relationship_reference: str = "") -> Model:
         return model.where(self.condition(operator, value))
 
     def build_condition(self, value: str, operator: str = "", column_prefix: str = ""):
@@ -1068,9 +1058,7 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
         """Process user data to decide if the end-user is specifying an allowed operator."""
         return operator.lower() in self._allowed_search_operators
 
-    def n_plus_one_add_joins(
-        self, model: clearskies.model.Model, column_names: list[str] = []
-    ) -> clearskies.model.Model:
+    def n_plus_one_add_joins(self, model: Model, column_names: list[str] = []) -> Model:
         """Add any additional joins to solve the N+1 problem."""
         return model
 
@@ -1096,11 +1084,11 @@ class Column(clearskies.configurable.Configurable, clearskies.di.InjectablePrope
 
     def where_for_request(
         self,
-        model: clearskies.model.Model,
+        model: Model,
         routing_data: dict[str, str],
         authorization_data: dict[str, Any],
         input_output,
-    ) -> clearskies.model.Model:
+    ) -> Model:
         """
         Create a hook to automatically apply filtering whenever the column makes an appearance in a get/update/list/search handler.
 

clearskies/columns/audit.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
-import clearskies.decorators
-import clearskies.typing
-from clearskies import configs
+from clearskies import configs, decorators
 from clearskies.column import Column
 from clearskies.columns.has_many import HasMany
 
+if TYPE_CHECKING:
+    from clearskies import Model, typing
+
 
 class Audit(HasMany):
     """
@@ -66,7 +67,7 @@ class Audit(HasMany):
     _descriptor_config_map = None
     _parent_columns: dict[str, Column] | None
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         audit_model_class,
@@ -74,17 +75,17 @@ class Audit(HasMany):
         mask_columns: list[str] = [],
         foreign_column_name: str | None = None,
         readable_child_columns: list[str] = [],
-        where: clearskies.typing.condition | list[clearskies.typing.condition] = [],
+        where: typing.condition | list[typing.condition] = [],
         default: str | None = None,
         is_readable: bool = True,
         is_temporary: bool = False,
-        on_change_pre_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_post_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_save_finished: clearskies.typing.action | list[clearskies.typing.action] = [],
+        on_change_pre_save: typing.action | list[typing.action] = [],
+        on_change_post_save: typing.action | list[typing.action] = [],
+        on_change_save_finished: typing.action | list[typing.action] = [],
     ):
         self.child_model_class = self.audit_model_class
 
-    def save_finished(self, model):
+    def save_finished(self, model: Model):
         super().save_finished(model)
         old_data: dict[str, Any] = model._previous_data
         new_data: dict[str, Any] = model.get_raw_data()
@@ -114,8 +115,8 @@ class Audit(HasMany):
         # note that this is fairly simple logic to get started.  It's not going to detect changes that happen
         # in other "tables".  For instance, disconnecting a record by deleting an entry in a many-to-many relationship
         # won't be picked up by this.
-        old_model = model.empty_model()
-        old_model.data = old_data
+        old_model = model.empty()
+        old_model._data = old_data
         from_data: dict[str, Any] = {}
         to_data: dict[str, Any] = {}
         for column, new_value in new_data.items():
@@ -187,7 +188,7 @@ class Audit(HasMany):
     def parent_columns(self) -> dict[str, Column]:
         if self._parent_columns == None:
             self._parent_columns = self.di.build(self.model_class, cache=True).columns()
-        return self._parent_columns
+        return self._parent_columns  # type: ignore[return-value]
 
     def record(self, model, action, data=None, record_data=None):
         audit_data = {

clearskies/columns/belongs_to_id.py

@@ -1,11 +1,8 @@
 from __future__ import annotations
 
-from collections import OrderedDict
 from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.decorators
-import clearskies.typing
-from clearskies import configs
+from clearskies import configs, decorators
 from clearskies.autodoc.schema import Object as AutoDocObject
 from clearskies.autodoc.schema import Schema as AutoDocSchema
 from clearskies.autodoc.schema import String as AutoDocString
@@ -14,7 +11,7 @@ from clearskies.di.inject import InputOutput
 from clearskies.functional import validations
 
 if TYPE_CHECKING:
-    from clearskies import Column, Model
+    from clearskies import Model, typing
 
 
 class BelongsToId(String):
@@ -144,7 +141,7 @@ class BelongsToId(String):
     import models.category_reference
 
 
-    class Product(clearskies.model.Model):
+    class Product(clearskies.Model):
         id_column_name = "id"
         backend = clearskies.backends.MemoryBackend()
 
@@ -299,23 +296,23 @@ class BelongsToId(String):
     _allowed_search_operators = ["="]
     _descriptor_config_map = None
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         parent_model_class,
         readable_parent_columns: list[str] = [],
         join_type: str | None = None,
-        where: clearskies.typing.condition | list[clearskies.typing.condition] = [],
+        where: typing.condition | list[typing.condition] = [],
         default: str | None = None,
         setable: str | Callable | None = None,
         is_readable: bool = True,
         is_writeable: bool = True,
         is_searchable: bool = True,
         is_temporary: bool = False,
-        validators: clearskies.typing.validator | list[clearskies.typing.validator] = [],
-        on_change_pre_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_post_save: clearskies.typing.action | list[clearskies.typing.action] = [],
-        on_change_save_finished: clearskies.typing.action | list[clearskies.typing.action] = [],
+        validators: typing.validator | list[typing.validator] = [],
+        on_change_pre_save: typing.action | list[typing.action] = [],
+        on_change_post_save: typing.action | list[typing.action] = [],
+        on_change_save_finished: typing.action | list[typing.action] = [],
         created_by_source_type: str = "",
         created_by_source_key: str = "",
         created_by_source_strict: bool = True,
@@ -441,9 +438,7 @@ class BelongsToId(String):
             )
         return self.parent_columns[relationship_reference].allowed_search_operators()
 
-    def add_search(
-        self, model: clearskies.model.Model, value: str, operator: str = "", relationship_reference: str = ""
-    ) -> clearskies.model.Model:
+    def add_search(self, model: Model, value: str, operator: str = "", relationship_reference: str = "") -> Model:
         if not relationship_reference:
             return super().add_search(model, value, operator=operator)