clear-skies 1.20.1__tar.gz → 1.20.3__tar.gz

{clear_skies-1.20.1 → clear_skies-1.20.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clear-skies
-Version: 1.20.1
+Version: 1.20.3
 Summary: A framework for building backends in the cloud
 Home-page: https://github.com/cmancone/clearskies
 License: MIT

{clear_skies-1.20.1 → clear_skies-1.20.3}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [tool.poetry]
 name = "clear-skies"
-version = "1.20.1"
+version = "1.20.3"
 description = "A framework for building backends in the cloud"
 authors = [
     "Conor Mancone <cmancone@gmail.com>",

{clear_skies-1.20.1 → clear_skies-1.20.3}/src/clearskies/models.py

@@ -1,6 +1,11 @@
 from abc import ABC, abstractmethod
 from .condition_parser import ConditionParser
-from typing import Any, Callable, Dict, List, Tuple
+from typing import Any, Callable, Dict, List, Tuple, Iterator
+
+try:
+    from typing_extensions import Self
+except ModuleNotFoundError:
+    from typing import Self
 
 
 class Models(ABC, ConditionParser):
@@ -46,26 +51,26 @@ class Models(ABC, ConditionParser):
         """Return the model class that this models object will find/return instances of"""
         pass
 
-    def clone(self):
+    def clone(self) -> Self:
         clone = self.blank()
         clone.query_configuration = self.query_configuration
         return clone
 
-    def blank(self):
+    def blank(self) -> Self:
         return self._build_model()
 
-    def get_table_name(self):
+    def get_table_name(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):
+    def get_id_column_name(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):
+    def query_configuration(self) -> Dict[str, Any]:
         return {
             "wheres": [*self.query_wheres],
             "sorts": [*self.query_sorts],
@@ -80,7 +85,7 @@ class Models(ABC, ConditionParser):
         }
 
     @query_configuration.setter
-    def query_configuration(self, configuration):
+    def query_configuration(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,29 +102,29 @@ class Models(ABC, ConditionParser):
             self._model_columns = self.empty_model().columns()
         return self._model_columns
 
-    def select(self, selects):
+    def select(self, selects) -> Self:
         return self.clone().select_in_place(selects)
 
-    def select_in_place(self, selects):
+    def select_in_place(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):
+    def select_all(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):
+    def select_all_in_place(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):
+    def where(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):
+    def where_in_place(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"])
@@ -129,10 +134,10 @@ class Models(ABC, ConditionParser):
         self.must_recount = True
         return self
 
-    def join(self, join):
+    def join(self, join: str) -> Self:
         return self.clone().join_in_place(join)
 
-    def join_in_place(self, join):
+    def join_in_place(self, join: str) -> Self:
         self.query_joins.append(self.parse_join(join))
         self.must_rexecute = True
         self._next_page_data = None
@@ -150,10 +155,10 @@ class Models(ABC, ConditionParser):
             return join["alias"] if join["alias"] else join["table"]
         return False
 
-    def group_by(self, group_column):
+    def group_by(self, group_column: str) -> Self:
         return self.clone().group_by_in_place(group_column)
 
-    def group_by_in_place(self, group_column):
+    def group_by_in_place(self, group_column: str) -> Self:
         self._validate_column(group_column, "group")
         self.query_group_by_column = group_column
         self.must_rexecute = True
@@ -169,7 +174,7 @@ class Models(ABC, ConditionParser):
         secondary_column=None,
         secondary_direction=None,
         secondary_table=None,
-    ):
+    ) -> Self:
         return self.clone().sort_by_in_place(
             primary_column,
             primary_direction,
@@ -187,7 +192,7 @@ class Models(ABC, ConditionParser):
         secondary_column=None,
         secondary_direction=None,
         secondary_table=None,
-    ):
+    ) -> Self:
         sorts = [
             {"table": primary_table, "column": primary_column, "direction": primary_direction},
             {"table": secondary_table, "column": secondary_column, "direction": secondary_direction},
@@ -241,19 +246,19 @@ class Models(ABC, ConditionParser):
                 + "to your model definition"
             )
 
-    def limit(self, limit):
+    def limit(self, limit) -> Self:
         return self.clone().limit_in_place(limit)
 
-    def limit_in_place(self, limit):
+    def limit_in_place(self, limit) -> Self:
         self.query_limit = limit
         self.must_rexecute = True
         self._next_page_data = None
         return self
 
-    def pagination(self, **kwargs):
+    def pagination(self, **kwargs) -> Self:
         return self.clone().pagination_in_place(**kwargs)
 
-    def pagination_in_place(self, **kwargs):
+    def pagination_in_place(self, **kwargs) -> Self:
         error = self._backend.validate_pagination_kwargs(kwargs, str)
         if error:
             raise ValueError(
@@ -265,7 +270,7 @@ class Models(ABC, ConditionParser):
         self._next_page_data = None
         return self
 
-    def find(self, where):
+    def find(self, where: str) -> Self:
         """Returns the first model where condition"""
         return self.clone().where(where).first()
 
@@ -275,7 +280,7 @@ class Models(ABC, ConditionParser):
             self.must_recount = False
         return self.count
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Self]:
         self._next_page_data = {}
         raw_rows = self._backend.records(
             self.query_configuration,
@@ -285,7 +290,7 @@ class Models(ABC, ConditionParser):
         models = iter([self.model(row) for row in raw_rows])
         return models
 
-    def paginate_all(self):
+    def paginate_all(self) -> List[Self]:
         next_models = self.clone()
         results = list(next_models.__iter__())
         next_page_data = next_models.next_page_data()
@@ -295,24 +300,24 @@ class Models(ABC, ConditionParser):
             next_page_data = next_models.next_page_data()
         return results
 
-    def model(self, data):
+    def model(self, data) -> Self:
         model = self._build_model()
         model.data = data
         return model
 
-    def _build_model(self):
+    def _build_model(self) -> Self:
         model_class = self.model_class()
         return model_class(self._backend, self._columns)
 
-    def empty_model(self):
+    def empty_model(self) -> Self:
         return self.model({})
 
-    def create(self, data):
+    def create(self, data: Dict[str, Any]) -> Self:
         empty = self.empty_model()
         empty.save(data)
         return empty
 
-    def first(self):
+    def first(self) -> Self:
         iter = self.__iter__()
         try:
             return iter.__next__()