clear-skies 1.20.3__py3-none-any.whl → 1.21.1__py3-none-any.whl

{clear_skies-1.20.3.dist-info → clear_skies-1.21.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clear-skies
-Version: 1.20.3
+Version: 1.21.1
 Summary: A framework for building backends in the cloud
 Home-page: https://github.com/cmancone/clearskies
 License: MIT
@@ -25,6 +25,7 @@ Requires-Dist: jose (>=1.0.0,<2.0.0) ; extra == "jose"
 Requires-Dist: jwcrypto (>=1.5.6,<2.0.0) ; extra == "jwcrypto"
 Requires-Dist: pymysql (>=1.1.0,<2.0.0) ; extra == "mysql"
 Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: typing-extensions (>=4.12.0,<5.0.0) ; python_version >= "3.10" and python_version < "3.11"
 Project-URL: Repository, https://github.com/cmancone/clearskies
 Description-Content-Type: text/markdown
 

{clear_skies-1.20.3.dist-info → clear_skies-1.21.1.dist-info}/RECORD

@@ -61,15 +61,15 @@ clearskies/column_types/belongs_to.py,sha256=tH1tbTOfjifSNuVjO-KbMF7GiUIoLfcDItr
 clearskies/column_types/boolean.py,sha256=1yyM1CUfgD84pPE65c1OP1Qjf_J0Z45hjPrDR51AUkQ,1878
 clearskies/column_types/category_tree.py,sha256=PgNmzZPyqYS5NADH_QTCxLvDXZFxzv5ESKTkvPrrLXo,9140
 clearskies/column_types/column.py,sha256=ftuDFswjk-KE9Frxo1rhgkjr4sjSjnUc5ZtfNrnGLIc,15530
-clearskies/column_types/created.py,sha256=S78e1VuvvUPYiI79gWGqlPzMSLIbXMpaYQMw8as7l38,615
+clearskies/column_types/created.py,sha256=LIWSzPJ9rbHuk1u53pNvKtVCOG9y9XCn-mEEsSi97Zc,649
 clearskies/column_types/created_by_authorization_data.py,sha256=--1w1TOSo2CMwrpn6Y_iorl2RTqLgG8MbR8k27qreew,1108
 clearskies/column_types/created_by_header.py,sha256=5sY6vjtra-BrAgUE4zkuLhBtzCVWHNtJPwMozPw_7_s,520
 clearskies/column_types/created_by_ip.py,sha256=wwCUoEwHEVGN89x4xP7NJ6QR85Aum6v3JmxofoQrqtg,395
 clearskies/column_types/created_by_routing_data.py,sha256=EhVorRaGV2OhEb0YSPwPmrsK2NQycYgGEd4ab8-qI2I,569
 clearskies/column_types/created_by_user_agent.py,sha256=sSYDRrqSjsCwcYlhF_s9NO-iDww3PaH6aO2ATp_SKGQ,419
-clearskies/column_types/created_micro.py,sha256=EqeHB3ZHbi4nCa1rbrKy1TbooT9U3Kfw5z4jUvLi32U,636
-clearskies/column_types/datetime.py,sha256=OEy5eMfqWp6KOqEHQa3Ga_tl0oawtcMRBafI1SPYDFk,4275
-clearskies/column_types/datetime_micro.py,sha256=3DxtkeJZhWigdni7QEJFV3BJuCmXJMyFQjDZ9jyI144,328
+clearskies/column_types/created_micro.py,sha256=Y_YADPg-TYPfWCFuGbs1b7NeM1Ixi_oBP8OQfJgTI7s,670
+clearskies/column_types/datetime.py,sha256=VCVLDTxEN1yQ0h-BprejKWCYSOneQkvm7EeKy3c_T-Q,4339
+clearskies/column_types/datetime_micro.py,sha256=ewQSniCc2MmNIyX2XNuNcCIwh5Fpf1HcvpLfzB8lz8g,382
 clearskies/column_types/email.py,sha256=qq0Yo_C3KxUqT68q2HWXocBBR4xwMqjxcIdgZRv218U,584
 clearskies/column_types/float.py,sha256=j8jJeBueSOusPtAFCWgLHYBncfLnqT1U7bh1zcAkYiA,1332
 clearskies/column_types/has_many.py,sha256=Z4oM1g2dQx6H9171c52FLC41nLryCOKmh51I75mYmmY,5895
@@ -81,9 +81,9 @@ clearskies/column_types/many_to_many_with_data.py,sha256=NOYjZedeLIWVyDV4BTRyNmh
 clearskies/column_types/phone.py,sha256=aUKshuknqcklA0LhUAdIgCslmAXXnWtXln1q5js8Eh8,1611
 clearskies/column_types/select.py,sha256=1oBslTJ_7QCjlFeEcwJVRL-ED4sXwCESVFRAOonvG2I,297
 clearskies/column_types/string.py,sha256=XbHC31TmlW0k86cvdVJBDyowU8Xis6Te6R0rPLXgLpI,863
-clearskies/column_types/timestamp.py,sha256=XQ8SHKrvPbgaXWlGP_1dKn9sYOFbcGVuSmGjWnTVTl8,2820
-clearskies/column_types/updated.py,sha256=FNyRK-PS6lgFQ9QN2VrcIZP2g5EHGhll6pf-MgqMH7s,566
-clearskies/column_types/updated_micro.py,sha256=3geqsV4nsPB9xDKyvQDGniU-KMqM8WvoqHfUYcBqGJY,587
+clearskies/column_types/timestamp.py,sha256=q_9-zXm8AqJVFpSAvl0O2yqfxPFy4id4TxEh5qRQVmE,2866
+clearskies/column_types/updated.py,sha256=ZSaM97bjFK-vMkPBMo8WnVOgzS77K5mR6KAArC1CbhE,634
+clearskies/column_types/updated_micro.py,sha256=Z39_D574V6rY33UhY8Yruv-KeWw5PJw5yeuUQJfjE4A,655
 clearskies/column_types/uuid.py,sha256=pA6Cd-1QSRuUpz0PxWAGRdG01hW7bpIicOhhJvAvDkQ,711
 clearskies/columns.py,sha256=3PgLopL1l20vVWaUqOJkwXMr06a-gFHEsbExfOWVB4I,5925
 clearskies/condition_parser.py,sha256=IXl51-rDxws7-nAtTVu_m6gTegtpkDnoGAFX2MTPDIo,6589
@@ -120,7 +120,7 @@ clearskies/di/__init__.py,sha256=T7SgQNny2XAZQPeFkdmp1XxxmEVxtnpcRiGK8YflkwU,304
 clearskies/di/additional_config.py,sha256=jdoS_HWC0MAabori3WwLRAG1i5YKZmQfQ1o0hCoxsPs,526
 clearskies/di/additional_config_auto_import.py,sha256=m57IODPbnCAus9iDu3mDp42u4H87oPZvjAlBGoS8uRQ,111
 clearskies/di/di.py,sha256=g0U0PI73eNp0mkGH3KUN1fmqNic5eEUK-_IB8hQh-Kg,15511
-clearskies/di/standard_dependencies.py,sha256=vO2fbVQkuH7R-YqWu1eM2xcuR2SreFwcSeLmEVz2e8w,4396
+clearskies/di/standard_dependencies.py,sha256=fgD4GT4Z0bcGPBaPDrzCqCtblD0UP572XD5d0O_DJxE,4523
 clearskies/di/test_module/__init__.py,sha256=7YHQF7JHP0FdI7GdEGANSZ_t1EISQYhUNm1wqOg0NKw,88
 clearskies/di/test_module/another_module/__init__.py,sha256=8SRmHPDepLKGWTUSc1ucDF6U8mJPsNDsBDmBQCpzPWo,35
 clearskies/di/test_module/module_class.py,sha256=I_-wnMuHfbsvti-7d2Z4bXnr6deo__uvww9nds9qrlE,46
@@ -181,8 +181,8 @@ clearskies/input_requirements/unique.py,sha256=gpbm9uoXcy8WCHsuWqAotwockbjDfJOWi
 clearskies/mocks/__init__.py,sha256=T68OUB9gGCX0WoisGzsY3Bt2cCFX7ILHKPqi6XKTJM0,113
 clearskies/mocks/input_output.py,sha256=2wD5GbUyVSkXcBg1GTZ-Oz9VzcYxNHfTlmZAODW-7CI,3898
 clearskies/mocks/models.py,sha256=DCzsnMddBvPoBA8JwwbSOhzY7enQWrosgeYD4gx2deI,5124
-clearskies/model.py,sha256=6H6eGQqMBz22bWu20N4xy7XPa1qYgfvNWik5cXH2DZg,13137
-clearskies/models.py,sha256=WJUUPSJ1rhDvAv1DpNDw0igNmhpn7PlZGh0f_g9sl5E,12766
+clearskies/model.py,sha256=ZI75_1KP4J-PID2Aw9l_mNHCeY-HOZH887QKdxRoTdg,13511
+clearskies/models.py,sha256=1H5Vohv1U4avN5_YHqULzc7ynZDRytmZ56x775xWTIo,13038
 clearskies/secrets/__init__.py,sha256=ctTmA_etV9G_5U21APWENI1HvThrBS4DidGWRtEDHQs,1053
 clearskies/secrets/additional_configs/__init__.py,sha256=cFCrbtKF5nuR061S2y1iKZp349x-y8Srdwe3VZbfSFU,1119
 clearskies/secrets/additional_configs/mysql_connection_dynamic_producer.py,sha256=fOt2eOrVtQXhnK05XuSfWw9GoX6klxXLisJcFT0ycAE,2562
@@ -205,7 +205,7 @@ clearskies/tests/simple_api/models/__init__.py,sha256=nUA0W6fgXw_Bxa9CudkaDkC80t
 clearskies/tests/simple_api/models/status.py,sha256=PEhPbaQh5qdUNHp8O0gz91LOLENAEBtqSaHxUPXchaM,699
 clearskies/tests/simple_api/models/user.py,sha256=5_P4Tp1tTdX7PkMJ__epPM5MA7JAeVYGas69vcWloLc,819
 clearskies/tests/simple_api/users_api.py,sha256=KYXCgEofDxHeRdQK67txN5oYUPvxxmB8JTku7L-apk4,2344
-clear_skies-1.20.3.dist-info/LICENSE,sha256=3Ehd0g3YOpCj8sqj0Xjq5qbOtjjgk9qzhhD9YjRQgOA,1053
-clear_skies-1.20.3.dist-info/METADATA,sha256=zXR2NXaY80ulWCP4Jqavr4nu1NL5PkyIl11qvSOdPT0,1711
-clear_skies-1.20.3.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-clear_skies-1.20.3.dist-info/RECORD,,
+clear_skies-1.21.1.dist-info/LICENSE,sha256=3Ehd0g3YOpCj8sqj0Xjq5qbOtjjgk9qzhhD9YjRQgOA,1053
+clear_skies-1.21.1.dist-info/METADATA,sha256=gUmBHTE31EscgWpY1XRDst7EdoQlbySciQkEvh_fdoA,1817
+clear_skies-1.21.1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+clear_skies-1.21.1.dist-info/RECORD,,

clearskies/column_types/created.py

@@ -8,8 +8,8 @@ class Created(DateTime):
         "utc",
     ]
 
-    def __init__(self, di, datetime):
-        super().__init__(di)
+    def __init__(self, di, datetime, timezone):
+        super().__init__(di, timezone)
         self.datetime = datetime
 
     @property
@@ -22,5 +22,5 @@ class Created(DateTime):
         if self.config("utc", silent=True):
             now = self.datetime.datetime.now(self.datetime.timezone.utc)
         else:
-            now = self.datetime.datetime.now()
+            now = self.datetime.datetime.now(self._timezone)
         return {**data, self.name: now}

clearskies/column_types/created_micro.py

@@ -8,8 +8,8 @@ class CreatedMicro(DateTimeMicro):
         "utc",
     ]
 
-    def __init__(self, di, datetime):
-        super().__init__(di)
+    def __init__(self, di, datetime, timezone):
+        super().__init__(di, timezone)
         self.datetime = datetime
 
     @property
@@ -22,5 +22,5 @@ class CreatedMicro(DateTimeMicro):
         if self.config("utc", silent=True):
             now = self.datetime.datetime.now(self.datetime.timezone.utc)
         else:
-            now = self.datetime.datetime.now()
+            now = self.datetime.datetime.now(self._timezone)
         return {**data, self.name: now}

clearskies/column_types/datetime.py

@@ -3,7 +3,6 @@ from datetime import datetime, timezone
 import dateparser
 from ..autodoc.schema import DateTime as AutoDocDateTime
 
-
 class DateTime(Column):
     _auto_doc_class = AutoDocDateTime
     _date_format = "%Y-%m-%d %H:%M:%S"
@@ -14,8 +13,9 @@ class DateTime(Column):
         "default_date",
     ]
 
-    def __init__(self, di):
+    def __init__(self, di, timezone: datetime.tzinfo):
         super().__init__(di)
+        self._timezone = timezone
 
     def _finalize_configuration(self, configuration):
         return {
@@ -33,7 +33,7 @@ class DateTime(Column):
             date = dateparser.parse(value)
         else:
             date = value
-        return date.replace(tzinfo=timezone.utc) if date else None
+        return date.replace(tzinfo=self._timezone) if date else None
 
     def to_backend(self, data):
         if not self.name in data or type(data[self.name]) == str or data[self.name] == None:
@@ -47,7 +47,7 @@ class DateTime(Column):
         return {self.name: datetime.isoformat() if datetime else None}
 
     def build_condition(self, value, operator=None, column_prefix=""):
-        date = dateparser.parse(value).astimezone(timezone.utc).strftime(self.config("date_format"))
+        date = dateparser.parse(value).astimezone(self._timezone).strftime(self.config("date_format"))
         if not operator:
             operator = "="
         return f"{column_prefix}{self.name}{operator}{date}"

clearskies/column_types/datetime_micro.py

@@ -1,3 +1,4 @@
+from re import T
 from .datetime import DateTime
 from datetime import datetime, timezone
 import dateparser
@@ -8,5 +9,5 @@ class DateTimeMicro(DateTime):
     _date_format = "%Y-%m-%d %H:%M:%S.%f"
     _default_date = "0000-00-00 00:00:00.000000"
 
-    def __init__(self, di):
-        super().__init__(di)
+    def __init__(self, di, timezone: datetime.tzinfo):
+        super().__init__(di, timezone)

clearskies/column_types/timestamp.py

@@ -1,3 +1,4 @@
+import time
 from .datetime import DateTime
 from datetime import datetime, timezone
 import dateparser
@@ -28,16 +29,16 @@ class Timestamp(DateTime):
                 raise ValueError(
                     f"Invalid data was found in the backend for model {self.model_class.__name__} and column {self.name}: a string value was found that is not a timestamp.  It was '{value}'"
                 )
-            date = datetime.fromtimestamp(int(value) / mult)
+            date = datetime.fromtimestamp(int(value) / mult, self._timezone)
         elif isinstance(value, int):
-            date = datetime.fromtimestamp(value / mult)
+            date = datetime.fromtimestamp(value / mult, self._timezone)
         else:
             if not isinstance(value, datetime):
                 raise ValueError(
                     f"Invalid data was found in the backend for model {self.model_class.__name__} and column {self.name}: the value was neither an integer, a string, nor a datetime object"
                 )
             date = value
-        return date.replace(tzinfo=timezone.utc) if date else None
+        return date.replace(tzinfo=self._timezone) if date else None
 
     def to_backend(self, data):
         if not self.name in data or isinstance(data[self.name], int) or data[self.name] == None:

clearskies/column_types/updated.py

@@ -1,3 +1,5 @@
+import datetime
+
 from .datetime import DateTime
 
 
@@ -8,8 +10,8 @@ class Updated(DateTime):
         "utc",
     ]
 
-    def __init__(self, di, datetime):
-        super().__init__(di)
+    def __init__(self, di, datetime, timezone: datetime.tzinfo):
+        super().__init__(di, timezone)
         self.datetime = datetime
 
     @property
@@ -20,5 +22,5 @@ class Updated(DateTime):
         if self.config("utc", silent=True):
             now = self.datetime.datetime.now(self.datetime.timezone.utc)
         else:
-            now = self.datetime.datetime.now()
+            now = self.datetime.datetime.now(self._timezone)
         return {**data, self.name: now}

clearskies/column_types/updated_micro.py

@@ -1,3 +1,5 @@
+import datetime
+
 from .datetime_micro import DateTimeMicro
 
 
@@ -8,8 +10,8 @@ class UpdatedMicro(DateTimeMicro):
         "utc",
     ]
 
-    def __init__(self, di, datetime):
-        super().__init__(di)
+    def __init__(self, di, datetime, timezone: datetime.tzinfo):
+        super().__init__(di, timezone)
         self.datetime = datetime
 
     @property
@@ -20,5 +22,5 @@ class UpdatedMicro(DateTimeMicro):
         if self.config("utc", silent=True):
             now = self.datetime.datetime.now(self.datetime.timezone.utc)
         else:
-            now = self.datetime.datetime.now()
+            now = self.datetime.datetime.now(self._timezone)
         return {**data, self.name: now}

clearskies/di/standard_dependencies.py

@@ -138,3 +138,8 @@ class StandardDependencies(DI):
 
     def provide_uuid(self):
         return uuid
+  
+    def provide_timezone(self):
+        """Set the default timezone."""
+        import datetime
+        return datetime.UTC

clearskies/model.py

@@ -5,6 +5,10 @@ from .functional import string
 import re
 from .models import Models
 
+try:
+    from typing_extensions import Self
+except ModuleNotFoundError:
+    from typing import Self
 
 class Model(Models):
     _configured_columns = None
@@ -14,14 +18,14 @@ class Model(Models):
     _transformed = None
     id_column_name = "id"
 
-    def __init__(self, backend, columns):
+    def __init__(self: Self, backend, columns):
         super().__init__(backend, columns)
         self._transformed = {}
         self._data = {}
         self._previous_data = None
         self._touched_columns = None
 
-    def model_class(self):
+    def model_class(self: Self) -> type[Self]:
         """
         Return the model class that this models object will find/return instances of
 
@@ -30,7 +34,7 @@ class Model(Models):
         return self.__class__
 
     @classmethod
-    def table_name(cls):
+    def table_name(cls: type[Self]) -> str:
         """Return the name of the table that the model uses for data storage"""
         singular = string.camel_case_to_snake_case(cls.__name__)
         if singular[-1] == "y":
@@ -40,16 +44,16 @@ class Model(Models):
         return f"{singular}s"
 
     @abstractmethod
-    def columns_configuration(self):
+    def columns_configuration(self: Self):
         """Returns an ordered dictionary with the configuration for the columns"""
         pass
 
-    def all_columns(self):
+    def all_columns(self: Self):
         default = OrderedDict([(self.id_column_name, {"class": UUID})])
         default.update(self.columns_configuration())
         return default
 
-    def columns(self, overrides=None):
+    def columns(self: Self, overrides=None):
         # no caching if we have overrides
         if overrides is not None:
             return self._columns.configure(self.all_columns(), self.__class__, overrides=overrides)
@@ -58,13 +62,13 @@ class Model(Models):
             self._configured_columns = self._columns.configure(self.all_columns(), self.__class__)
         return self._configured_columns
 
-    def supports_n_plus_one(self):
+    def supports_n_plus_one(self: Self):
         return self._backend.supports_n_plus_one
 
-    def __getitem__(self, column_name):
+    def __getitem__(self: Self, column_name):
         return self.__getattr__(column_name)
 
-    def __getattr__(self, column_name):
+    def __getattr__(self: Self, column_name):
         # this should be adjusted to only return None for empty records if the column name corresponds
         # to an actual column in the table.
         if not self.exists:
@@ -72,13 +76,13 @@ class Model(Models):
 
         return self.get_transformed_from_data(column_name, self._data)
 
-    def get(self, column_name, silent=False):
+    def get(self: Self, column_name, silent=False):
         if not self.exists:
             return None
 
         return self.get_transformed_from_data(column_name, self._data, silent=silent)
 
-    def get_transformed_from_data(self, column_name, data, cache=True, check_providers=True, silent=False):
+    def get_transformed_from_data(self: Self, column_name, data, cache=True, check_providers=True, silent=False):
         if cache and column_name in self._transformed:
             return self._transformed[column_name]
 
@@ -111,18 +115,18 @@ class Model(Models):
         return value
 
     @property
-    def exists(self):
+    def exists(self: Self) -> bool:
         return True if (self.id_column_name in self._data and self._data[self.id_column_name]) else False
 
     @property
-    def data(self):
+    def data(self: Self):
         return self._data
 
     @data.setter
-    def data(self, data):
+    def data(self: Self, data) -> None:
         self._data = {} if data is None else data
 
-    def save(self, data, columns=None):
+    def save(self: Self, data, columns=None) -> bool:
         """
         Save data to the database and update the model!
 
@@ -168,7 +172,7 @@ class Model(Models):
 
         return True
 
-    def is_changing(self, key, data):
+    def is_changing(self: Self, key, data) -> bool:
         """
         Returns True/False to denote if the given column is being modified by the active save operation
 
@@ -184,7 +188,7 @@ class Model(Models):
 
         return self.__getattr__(key) != data[key]
 
-    def latest(self, key, data):
+    def latest(self: Self, key, data):
         """
         Returns the 'latest' value for a column during the save operation
 
@@ -198,7 +202,7 @@ class Model(Models):
             return data[key]
         return self.__getattr__(key)
 
-    def was_changed(self, key):
+    def was_changed(self: Self, key) -> bool: 
         """Returns True/False to denote if a column was changed in the last save"""
         if self._previous_data is None:
             raise ValueError("was_changed was called before a save was finished - you must save something first")
@@ -221,10 +225,10 @@ class Model(Models):
             return old_value != new_value
         return not columns[key].values_match(old_value, new_value)
 
-    def previous_value(self, key):
+    def previous_value(self: Self, key):
         return self.get_transformed_from_data(key, self._previous_data, cache=False, check_providers=False, silent=True)
 
-    def delete(self, except_if_not_exists=True):
+    def delete(self: Self, except_if_not_exists=True) -> bool:
         if not self.exists:
             if except_if_not_exists:
                 raise ValueError("Cannot delete model that already exists")
@@ -240,7 +244,7 @@ class Model(Models):
         self.post_delete()
         return True
 
-    def columns_pre_save(self, data, columns):
+    def columns_pre_save(self: Self, data, columns):
         """Uses the column information present in the model to make any necessary changes before saving"""
         for column in columns.values():
             data = column.pre_save(data, self)
@@ -258,7 +262,7 @@ class Model(Models):
         """
         return data
 
-    def columns_to_backend(self, data, columns):
+    def columns_to_backend(self: Self, data, columns):
         backend_data = {**data}
         temporary_data = {}
         for column in columns.values():
@@ -275,10 +279,10 @@ class Model(Models):
 
         return [backend_data, temporary_data]
 
-    def to_backend(self, data, columns):
+    def to_backend(self: Self, data, columns):
         return data
 
-    def columns_post_save(self, data, id, columns):
+    def columns_post_save(self: Self, data, id, columns):
         """Uses the column information present in the model to make additional changes as needed after saving"""
         for column in columns.values():
             data = column.post_save(data, self, id)
@@ -288,12 +292,12 @@ class Model(Models):
                 )
         return data
 
-    def columns_save_finished(self, columns):
+    def columns_save_finished(self: Self, columns):
         """Calls the save_finished method on all of our columns"""
         for column in columns.values():
             column.save_finished(self)
 
-    def post_save(self, data, id):
+    def post_save(self: Self, data, id):
         """
         A hook to extend so you can provide additional pre-save logic as needed
 
@@ -302,7 +306,7 @@ class Model(Models):
         """
         pass
 
-    def pre_save(self, data):
+    def pre_save(self: Self, data):
         """
         A hook to extend so you can provide additional pre-save logic as needed
 
@@ -310,7 +314,7 @@ class Model(Models):
         """
         return data
 
-    def save_finished(self):
+    def save_finished(self: Self):
         """
         A hook to extend so you can provide additional logic after a save operation has fully completed
 
@@ -320,29 +324,29 @@ class Model(Models):
         """
         pass
 
-    def columns_pre_delete(self, columns):
+    def columns_pre_delete(self: Self, columns):
         """Uses the column information present in the model to make any necessary changes before deleting"""
         for column in columns.values():
             column.pre_delete(self)
 
-    def pre_delete(self):
+    def pre_delete(self: Self):
         """
         A hook to extend so you can provide additional pre-delete logic as needed
         """
         pass
 
-    def columns_post_delete(self, columns):
+    def columns_post_delete(self: Self, columns):
         """Uses the column information present in the model to make any necessary changes after deleting"""
         for column in columns.values():
             column.post_delete(self)
 
-    def post_delete(self):
+    def post_delete(self: Self):
         """
         A hook to extend so you can provide additional post-delete logic as needed
         """
         pass
 
-    def where_for_request(self, models, routing_data, authorization_data, input_output, overrides=None):
+    def where_for_request(self: Self, models, routing_data, authorization_data, input_output, overrides=None):
         """
         A hook to automatically apply filtering whenever the model makes an appearance in a get/update/list/search handler.
         """

clearskies/models.py

@@ -47,30 +47,30 @@ class Models(ABC, ConditionParser):
         self.query_select_all = True
 
     @abstractmethod
-    def model_class(self):
+    def model_class(self: Self) -> type[Self]:
         """Return the model class that this models object will find/return instances of"""
         pass
 
-    def clone(self) -> Self:
+    def clone(self: Self) -> Self:
         clone = self.blank()
         clone.query_configuration = self.query_configuration
         return clone
 
-    def blank(self) -> Self:
+    def blank(self: Self) -> Self:
         return self._build_model()
 
-    def get_table_name(self) -> str:
+    def get_table_name(self: Self) -> str:
         if self._table_name is None:
             self._table_name = self.model_class().table_name()
         return self._table_name
 
-    def get_id_column_name(self) -> str:
+    def get_id_column_name(self: Self) -> str:
         if self._id_column_name is None:
             self._id_column_name = self.empty_model().id_column_name
         return self._id_column_name
 
     @property
-    def query_configuration(self) -> Dict[str, Any]:
+    def query_configuration(self: Self) -> Dict[str, Any]:
         return {
             "wheres": [*self.query_wheres],
             "sorts": [*self.query_sorts],
@@ -85,7 +85,7 @@ class Models(ABC, ConditionParser):
         }
 
     @query_configuration.setter
-    def query_configuration(self, configuration: Dict[str, Any]):
+    def query_configuration(self: Self, configuration: Dict[str, Any]):
         self.query_wheres = configuration["wheres"]
         self.query_sorts = configuration["sorts"]
         self.query_group_by_column = configuration["group_by_column"]
@@ -97,34 +97,34 @@ class Models(ABC, ConditionParser):
         self._model_columns = configuration["model_columns"]
 
     @property
-    def model_columns(self):
+    def model_columns(self: Self):
         if self._model_columns is None:
             self._model_columns = self.empty_model().columns()
         return self._model_columns
 
-    def select(self, selects) -> Self:
+    def select(self: Self, selects) -> Self:
         return self.clone().select_in_place(selects)
 
-    def select_in_place(self, selects) -> Self:
+    def select_in_place(self: Self, selects) -> Self:
         self.query_selects.append(selects)
         self.must_rexecute = True
         self._next_page_data = None
         return self
 
-    def select_all(self, select_all=True) -> Self:
+    def select_all(self: Self, select_all=True) -> Self:
         return self.clone().select_all_in_place(select_all=select_all)
 
-    def select_all_in_place(self, select_all=True) -> Self:
+    def select_all_in_place(self: Self, select_all=True) -> Self:
         self.query_select_all = select_all
         self.must_rexecute = True
         self._next_page_data = None
         return self
 
-    def where(self, where: str) -> Self:
+    def where(self: Self, where: str) -> Self:
         """Adds the given condition to the query and returns a new Models object"""
         return self.clone().where_in_place(where)
 
-    def where_in_place(self, where: str) -> Self:
+    def where_in_place(self: Self, where: str) -> Self:
         """Adds the given condition to the query for the current Models object"""
         condition = self.parse_condition(where)
         self._validate_column(condition["column"], "filter", table=condition["table"])
@@ -134,17 +134,17 @@ class Models(ABC, ConditionParser):
         self.must_recount = True
         return self
 
-    def join(self, join: str) -> Self:
+    def join(self: Self, join: str) -> Self:
         return self.clone().join_in_place(join)
 
-    def join_in_place(self, join: str) -> Self:
+    def join_in_place(self: Self, join: str) -> Self:
         self.query_joins.append(self.parse_join(join))
         self.must_rexecute = True
         self._next_page_data = None
         self.must_recount = True
         return self
 
-    def is_joined(self, table_name, alias=None):
+    def is_joined(self: Self, table_name, alias=None):
         for join in self.query_joins:
             if join["table"] != table_name:
                 continue
@@ -155,10 +155,10 @@ class Models(ABC, ConditionParser):
             return join["alias"] if join["alias"] else join["table"]
         return False
 
-    def group_by(self, group_column: str) -> Self:
+    def group_by(self: Self, group_column: str) -> Self:
         return self.clone().group_by_in_place(group_column)
 
-    def group_by_in_place(self, group_column: str) -> Self:
+    def group_by_in_place(self: Self, group_column: str) -> Self:
         self._validate_column(group_column, "group")
         self.query_group_by_column = group_column
         self.must_rexecute = True
@@ -167,7 +167,7 @@ class Models(ABC, ConditionParser):
         return self
 
     def sort_by(
-        self,
+        self: Self,
         primary_column,
         primary_direction,
         primary_table=None,
@@ -185,7 +185,7 @@ class Models(ABC, ConditionParser):
         )
 
     def sort_by_in_place(
-        self,
+        self: Self,
         primary_column,
         primary_direction,
         primary_table=None,
@@ -205,7 +205,7 @@ class Models(ABC, ConditionParser):
         self._next_page_data = None
         return self
 
-    def _normalize_and_validate_sort(self, sort):
+    def _normalize_and_validate_sort(self: Self, sort):
         if "column" not in sort or not sort["column"]:
             raise ValueError("Missing 'column' for sort")
         if "direction" not in sort or not sort["direction"]:
@@ -218,7 +218,7 @@ class Models(ABC, ConditionParser):
         # down the line we may ask the model class what columns we can sort on, but we're good for now
         return {"column": sort["column"], "direction": sort["direction"], "table": sort.get("table")}
 
-    def _validate_column(self, column_name, action, table=None):
+    def _validate_column(self: Self, column_name, action, table=None):
         """
         Down the line we may use the model configuration to check what columns are valid sort/group/search targets
         """
@@ -246,19 +246,19 @@ class Models(ABC, ConditionParser):
                 + "to your model definition"
             )
 
-    def limit(self, limit) -> Self:
+    def limit(self: Self, limit) -> Self:
         return self.clone().limit_in_place(limit)
 
-    def limit_in_place(self, limit) -> Self:
+    def limit_in_place(self: Self, limit) -> Self:
         self.query_limit = limit
         self.must_rexecute = True
         self._next_page_data = None
         return self
 
-    def pagination(self, **kwargs) -> Self:
+    def pagination(self: Self, **kwargs) -> Self:
         return self.clone().pagination_in_place(**kwargs)
 
-    def pagination_in_place(self, **kwargs) -> Self:
+    def pagination_in_place(self: Self, **kwargs) -> Self:
         error = self._backend.validate_pagination_kwargs(kwargs, str)
         if error:
             raise ValueError(
@@ -270,17 +270,17 @@ class Models(ABC, ConditionParser):
         self._next_page_data = None
         return self
 
-    def find(self, where: str) -> Self:
+    def find(self: Self, where: str) -> Self:
         """Returns the first model where condition"""
         return self.clone().where(where).first()
 
-    def __len__(self):
+    def __len__(self: Self):
         if self.must_recount:
             self.count = self._backend.count(self.query_configuration, self.empty_model())
             self.must_recount = False
         return self.count
 
-    def __iter__(self) -> Iterator[Self]:
+    def __iter__(self: Self) -> Iterator[Self]:
         self._next_page_data = {}
         raw_rows = self._backend.records(
             self.query_configuration,
@@ -290,7 +290,7 @@ class Models(ABC, ConditionParser):
         models = iter([self.model(row) for row in raw_rows])
         return models
 
-    def paginate_all(self) -> List[Self]:
+    def paginate_all(self: Self) -> List[Self]:
         next_models = self.clone()
         results = list(next_models.__iter__())
         next_page_data = next_models.next_page_data()
@@ -300,51 +300,51 @@ class Models(ABC, ConditionParser):
             next_page_data = next_models.next_page_data()
         return results
 
-    def model(self, data) -> Self:
+    def model(self: Self, data) -> Self:
         model = self._build_model()
         model.data = data
         return model
 
-    def _build_model(self) -> Self:
+    def _build_model(self: Self) -> Self:
         model_class = self.model_class()
         return model_class(self._backend, self._columns)
 
-    def empty_model(self) -> Self:
+    def empty_model(self: Self) -> Self:
         return self.model({})
 
-    def create(self, data: Dict[str, Any]) -> Self:
+    def create(self: Self, data: Dict[str, Any]) -> Self:
         empty = self.empty_model()
         empty.save(data)
         return empty
 
-    def first(self) -> Self:
+    def first(self: Self) -> Self:
         iter = self.__iter__()
         try:
             return iter.__next__()
         except StopIteration:
             return self.empty_model()
 
-    def columns(self, overrides=None):
+    def columns(self: Self, overrides=None):
         model = self.model({})
         return model.columns(overrides=None)
 
-    def raw_columns_configuration(self):
+    def raw_columns_configuration(self: Self):
         return self.model({}).all_columns()
 
-    def allowed_pagination_keys(self) -> List[str]:
+    def allowed_pagination_keys(self: Self) -> List[str]:
         return self._backend.allowed_pagination_keys()
 
     def validate_pagination_kwargs(self, kwargs: Dict[str, Any], case_mapping: Callable) -> str:
         return self._backend.validate_pagination_kwargs(kwargs, case_mapping)
 
-    def next_page_data(self):
+    def next_page_data(self: Self):
         return self._next_page_data
 
-    def documentation_pagination_next_page_response(self, case_mapping: Callable) -> List[Any]:
+    def documentation_pagination_next_page_response(self: Self, case_mapping: Callable) -> List[Any]:
         return self._backend.documentation_pagination_next_page_response(case_mapping)
 
-    def documentation_pagination_next_page_example(self, case_mapping: Callable) -> Dict[str, Any]:
+    def documentation_pagination_next_page_example(self: Self, case_mapping: Callable) -> Dict[str, Any]:
         return self._backend.documentation_pagination_next_page_example(case_mapping)
 
-    def documentation_pagination_parameters(self, case_mapping: Callable) -> List[Tuple[Any]]:
+    def documentation_pagination_parameters(self: Self, case_mapping: Callable) -> List[Tuple[Any]]:
         return self._backend.documentation_pagination_parameters(case_mapping)