clear-skies 1.21.0__tar.gz → 1.21.2__tar.gz

{clear_skies-1.21.0 → clear_skies-1.21.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: clear-skies
-Version: 1.21.0
+Version: 1.21.2
 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.21.0 → clear_skies-1.21.2}/pyproject.toml

@@ -2,7 +2,7 @@
 
 [tool.poetry]
 name = "clear-skies"
-version = "1.21.0"
+version = "1.21.2"
 description = "A framework for building backends in the cloud"
 authors = [
     "Conor Mancone <cmancone@gmail.com>",
@@ -34,6 +34,7 @@ akeyless-cloud-id = {version = "^0.2.3", optional = true}
 pymysql = {version = "^1.1.0", optional = true}
 jose = {version = "^1.0.0", optional = true}
 jwcrypto = {version = "^1.5.6", optional = true}
+typing-extensions = {version = "^4.12.0", python = ">=3.10,<3.11"}
 
 [[tool.poetry.source]]
 name = "PyPI"

{clear_skies-1.21.0 → clear_skies-1.21.2}/src/clearskies/column_types/category_tree.py

@@ -119,6 +119,10 @@ class CategoryTree(BelongsTo):
         "tree_level_column_name",
         "max_iterations",
         "parent_models_class",
+        "children_column_name",
+        "descendents_column_name",
+        "ancestors_column_name",
+        "load_relatives_strategy",
     ]
 
     def __init__(self, di):
@@ -137,6 +141,11 @@ class CategoryTree(BelongsTo):
             configuration["tree_models_class"],
             config_name="tree_models_class",
         )
+        load_relatives_strategy = configuration.get("load_relatives_strategy", None)
+        if load_relatives_strategy and load_relatives_strategy not in ["join", "where_in", "individual"]:
+            raise ValueError(
+                f"Configuration error for category_tree column '{self.name} in model class '{self.model_class.__name__}': load_relatives_strategy must be one of ['join', 'where_in', or 'individual']"
+            )
 
     def _finalize_configuration(self, configuration):
         return {
@@ -152,6 +161,10 @@ class CategoryTree(BelongsTo):
                 "tree_is_parent_column_name": configuration.get("tree_is_parent_column_name", "is_parent"),
                 "tree_level_column_name": configuration.get("tree_level_column_name", "level"),
                 "max_iterations": configuration.get("max_iterations", 100),
+                "children_column_name": configuration.get("children_column_name", "children"),
+                "descendents_column_name": configuration.get("descendents_column_name", "descendents"),
+                "ancestors_column_name": configuration.get("ancestors_column_name", "ancestors"),
+                "load_relatives_strategy": configuration.get("load_relatives_strategy", "join"),
             },
         }
 
@@ -167,7 +180,7 @@ class CategoryTree(BelongsTo):
         return data
 
     def force_tree_update(self, model):
-        self.update_tree_table(model, model.id, model.__getattr__(self.name))
+        self.update_tree_table(model, model.get(self.id_column_name), model.__getattr__(self.name))
 
     def update_tree_table(self, model, child_id, direct_parent_id):
         tree_models = self.tree_models
@@ -224,3 +237,68 @@ class CategoryTree(BelongsTo):
             + "You may have accidentally created a circular cateogry tree.  If not, and your category tree "
             + "really _is_ that deep, then adjust the 'max_iterations' configuration for this column accordingly. "
         )
+
+    def can_provide(self, column_name):
+        return column_name in [
+            self.config("model_column_name"),
+            self.config("children_column_name"),
+            self.config("descendents_column_name"),
+            self.config("ancestors_column_name"),
+        ]
+
+    def provide(self, data, column_name):
+        if column_name == self.config("model_column_name"):
+            return super().provide(data, column_name)
+
+        if column_name == self.config("children_column_name"):
+            return self.relatives(data)
+
+        if column_name == self.config("descendents_column_name"):
+            return self.relatives(data, include_all=True)
+
+        if column_name == self.config("ancestors_column_name"):
+            return self.relatives(data, find_parents=True)
+
+    def relatives(self, data, include_all=False, find_parents=False):
+        id_column_name = self.model_class.id_column_name
+        model_id = data[self.model_class.id_column_name]
+        model_table_name = self.model_class.table_name()
+        tree_table_name = self.config("tree_models_class").table_name()
+        parent_id_column_name = self.config("tree_parent_id_column_name")
+        child_id_column_name = self.config("tree_child_id_column_name")
+        is_parent_column_name = self.config("is_parent_column_name")
+        level_column_name = self.config("tree_level_column_name")
+
+        if find_parents:
+            join_on = parent_id_column_name
+            search_on = child_id_column_name
+        else:
+            join_on = child_id_column_name
+            search_on = parent_id_column_name
+
+        # if we can join then use a join.
+        if self.config("load_relatives_strategy") == "join":
+            relatives = self.parent_models.join(
+                f"{tree_table_name} as tree on tree.{join_on}={model_table_name}.{id_column_name}"
+            )
+            relatives = relatives.where(f"tree.{search_on}={model_id}")
+            if not include_all:
+                relatives = relatives.where(f"tree.{is_parent_column_name}=1")
+            if find_parents:
+                relatives = relatives.sort_by(level_column_name, "asc")
+            return relatives
+
+        # joins only work for SQL-like backends.  Otherwise, we have to pull out our list of ids
+        branches = self.tree_models.where(f"{search_on}={model_id}")
+        if not include_all:
+            branches = branches.where(f"tree.{is_parent_column_name}=1")
+        if find_parents:
+            branches = branches.sort_by(level_column_name, "asc")
+        ids = [str(branch.get(child_id_column_name)) for branch in branches]
+
+        # Can we search with a WHERE IN() clause?  If the backend supports it, it is probably faster
+        if self.config("load_relatives_strategy") == "where_in":
+            return self.parent_models.where(f"{id_column_name} IN ('" + "','".join(ids) + "')")
+
+        # otherwise we have to load each model individually which is SLOW....
+        return [self.parent_models.find(f"{id_column_name}={id}") for id in ids]

{clear_skies-1.21.0 → clear_skies-1.21.2}/src/clearskies/column_types/datetime.py

@@ -3,6 +3,7 @@ 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"

{clear_skies-1.21.0 → clear_skies-1.21.2}/src/clearskies/di/standard_dependencies.py

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

{clear_skies-1.21.0 → clear_skies-1.21.2}/src/clearskies/model.py

@@ -5,6 +5,11 @@ 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 +19,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 +35,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 +45,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 +63,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 +77,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 +116,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 +173,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 +189,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 +203,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 +226,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 +245,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 +263,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 +280,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 +293,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 +307,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 +315,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 +325,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.
         """