clear-skies 1.18.3__tar.gz → 1.18.5__tar.gz

{clear_skies-1.18.3 → clear_skies-1.18.5}/PKG-INFO

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

{clear_skies-1.18.3 → clear_skies-1.18.5}/pyproject.toml

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

{clear_skies-1.18.3 → clear_skies-1.18.5}/src/clearskies/authentication/__init__.py

@@ -26,8 +26,12 @@ __all__ = [
     "Authorization",
     "BindingConfig",
     "public",
+    "Public",
     "secret_bearer",
+    "SecretBearer",
     "auth0_jwks",
+    "Auth0JWKS",
     "authorization",
     "jwks",
+    "JWKS",
 ]

{clear_skies-1.18.3 → clear_skies-1.18.5}/src/clearskies/authentication/auth0_jwks.py

@@ -15,7 +15,6 @@ class Auth0JWKS:
     _jwks_fetched = None
     _algorithms = None
     _audience = None
-    _jwt_claims = None
     _documentation_security_name = None
 
     def __init__(self, environment, requests, jose_jwt):

{clear_skies-1.18.3 → clear_skies-1.18.5}/src/clearskies/column_types/column.py

@@ -214,6 +214,12 @@ class Column(ABC):
         if on_change_actions and model.was_changed(self.name):
             self.execute_actions(on_change_actions, model)
 
+    def values_match(self, value_1, value_2):
+        """
+        Compares two values to see if they are the same
+        """
+        return value_1 == value_2
+
     def pre_delete(self, model):
         """
         Make any changes needed to the data before starting the delete process

clear_skies-1.18.5/src/clearskies/column_types/datetime.py

@@ -0,0 +1,92 @@
+from .column import Column
+from datetime import datetime, timezone
+import dateparser
+from ..autodoc.schema import DateTime as AutoDocDateTime
+
+
+class DateTime(Column):
+    _auto_doc_class = AutoDocDateTime
+
+    def __init__(self, di):
+        super().__init__(di)
+
+    def from_backend(self, value):
+        if not value or value == "0000-00-00 00:00:00":
+            date = None
+        elif type(value) == str:
+            date = dateparser.parse(value)
+        else:
+            date = value
+        return date.replace(tzinfo=timezone.utc) 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:
+            return data
+
+        # hopefully this is a Python datetime object in UTC timezone...
+        return {**data, **{self.name: data[self.name].strftime("%Y-%m-%d %H:%M:%S")}}
+
+    def to_json(self, model):
+        datetime = model.get(self.name, silent=True)
+        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("%Y-%m-%d %H:%M:%S")
+        if not operator:
+            operator = "="
+        return f"{column_prefix}{self.name}{operator}{date}"
+
+    def is_allowed_operator(self, operator, relationship_reference=None):
+        """
+        This is called when processing user data to decide if the end-user is specifying an allowed operator
+        """
+        return operator in ["=", "<", ">", "<=", ">="]
+
+    def input_error_for_value(self, value, operator=None):
+        value = dateparser.parse(value)
+        if not value:
+            return "given value did not appear to be a valid date"
+        if not value.tzinfo:
+            return "date is missing timezone information"
+        return ""
+
+    def values_match(self, value_1, value_2):
+        """
+        Compares two values to see if they are the same
+        """
+        # in this function we deal with data directly out of the backend, so our date is likely
+        # to be string-ified and we want to look for default (e.g. null) values in string form.
+        if type(value_1) == str and "0000-00-00" in value_1:
+            value_1 = None
+        if type(value_2) == str and "0000-00-00" in value_2:
+            value_2 = None
+        number_values = 0
+        if value_1:
+            number_values += 1
+        if value_2:
+            number_values += 1
+        if number_values == 0:
+            return True
+        if number_values == 1:
+            return False
+
+        if type(value_1) == str:
+            value_1 = dateparser.parse(value_1)
+        if type(value_2) == str:
+            value_2 = dateparser.parse(value_2)
+
+        # we need to make sure we're comparing in the same timezones.  For our purposes, a difference in timezone
+        # is fine as long as they represent the same time (e.g. 16:00EST == 20:00UTC).  For python, same time in different
+        # timezones is treated as different datetime objects.
+        if value_1.tzinfo is not None and value_2.tzinfo is not None:
+            value_1 = value_1.astimezone(value_2.tzinfo)
+
+        # two times can be the same but if one is datetime-aware and one is not, python will treat them as not equal.
+        # we want to treat such times as being the same.  Therefore, check for equality but ignore the timezone.
+        for to_check in ["year", "month", "day", "hour", "minute", "second", "microsecond"]:
+            if getattr(value_1, to_check) != getattr(value_2, to_check):
+                return False
+
+        # and since we already converted the timezones to match (or one has a timezone and one doesn't), we're good to go.
+        # if we passed the above loop then the times are the same.
+        return True

{clear_skies-1.18.3 → clear_skies-1.18.5}/src/clearskies/columns.py

@@ -17,18 +17,23 @@ class Columns:
             if name in columns:
                 raise ValueError(f"Duplicate column '{name}' found for model '{model_class.__name__}'")
             column_overrides = overrides[name] if (overrides is not None and name in overrides) else {}
-            configuration = {
-                **configuration,
-                **column_overrides,
-                "input_requirements": self._resolve_input_requirements(
-                    self._merge_input_requirements(
-                        configuration.get("input_requirements"),
-                        column_overrides.get("input_requirements"),
+            # if the overrides changes the class then we need to completely replace the column definition
+            # with what is in the overrides.
+            if "class" in column_overrides and id(column_overrides["class"]) != id(configuration["class"]):
+                configuration = column_overrides
+            else:
+                configuration = {
+                    **configuration,
+                    **column_overrides,
+                    "input_requirements": self._resolve_input_requirements(
+                        self._merge_input_requirements(
+                            configuration.get("input_requirements"),
+                            column_overrides.get("input_requirements"),
+                        ),
+                        name,
+                        model_class.__name__,
                     ),
-                    name,
-                    model_class.__name__,
-                ),
-            }
+                }
             columns[name] = self.build_column(name, configuration, model_class)
 
         # overrides can add columns too - need to handle those separately

{clear_skies-1.18.3 → clear_skies-1.18.5}/src/clearskies/handlers/create.py

@@ -23,7 +23,7 @@ class Create(Write):
         if input_errors:
             self._logging.debug("Request rejected due to input errors: " + json.dumps(input_errors))
             raise InputError(input_errors)
-        model.save(input_data)
+        model.save(input_data, columns=self._columns)
 
         return self.success(input_output, self._model_as_json(model, input_output))
 

{clear_skies-1.18.3 → clear_skies-1.18.5}/src/clearskies/handlers/input_processing.py

@@ -9,11 +9,13 @@ class InputProcessing:
     def _get_writeable_columns(self):
         if self._writeable_columns is None:
             self._writeable_columns = self._get_rw_columns("writeable")
+            additional_columns = OrderedDict()
             for column in self._writeable_columns.values():
                 more_columns = column.additional_write_columns(is_create=self._is_create)
-                # do it one-at-a-time so we don't lose our OrderedDict
                 for additional_column_name, additional_column in more_columns.items():
-                    self._writeable_columns[additional_column_name] = additional_column
+                    additional_columns[additional_column_name] = additional_column
+            for additional_column_name, additional_column in additional_columns.items():
+                self._writeable_columns[additional_column_name] = additional_column
         return self._writeable_columns
 
     def _extra_column_errors(self, input_data):

{clear_skies-1.18.3 → clear_skies-1.18.5}/src/clearskies/handlers/update.py

@@ -58,7 +58,7 @@ class Update(Write):
         }
         if input_errors:
             raise InputError(input_errors)
-        model.save(input_data)
+        model.save(input_data, columns=self._columns)
 
         return self.success(input_output, self._model_as_json(model, input_output))
 

{clear_skies-1.18.3 → clear_skies-1.18.5}/src/clearskies/model.py

@@ -10,6 +10,7 @@ class Model(Models):
     _configured_columns = None
     _data = None
     _previous_data = None
+    _touched_columns = None
     _transformed = None
     id_column_name = "id"
 
@@ -18,6 +19,7 @@ class Model(Models):
         self._transformed = {}
         self._data = {}
         self._previous_data = None
+        self._touched_columns = None
 
     def model_class(self):
         """
@@ -120,7 +122,7 @@ class Model(Models):
     def data(self, data):
         self._data = {} if data is None else data
 
-    def save(self, data):
+    def save(self, data, columns=None):
         """
         Save data to the database and update the model!
 
@@ -128,7 +130,8 @@ class Model(Models):
         """
         if not len(data):
             raise ValueError("You have to pass in something to save!")
-        columns = self.columns()
+        if columns is None:
+            columns = self.columns()
 
         old_data = self.data
         data = self.columns_pre_save(data, columns)
@@ -150,6 +153,7 @@ class Model(Models):
         self.data = new_data
         self._transformed = {}
         self._previous_data = old_data
+        self._touched_columns = list(data.keys())
 
         self.columns_save_finished(columns)
         self.save_finished()
@@ -190,9 +194,11 @@ class Model(Models):
         """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")
+        if key not in self._touched_columns:
+            return False
 
-        has_old_value = key in self._previous_data
-        has_new_value = key in self._data
+        has_old_value = bool(self._previous_data.get(key))
+        has_new_value = bool(self._data.get(key))
 
         if has_new_value != has_old_value:
             return True
@@ -200,7 +206,12 @@ class Model(Models):
         if not has_old_value:
             return False
 
-        return self.__getattr__(key) != self._previous_data[key]
+        columns = self.columns()
+        new_value = self.__getattr__(key)
+        old_value = self._previous_data[key]
+        if key not in columns:
+            return old_value != new_value
+        return not columns[key].values_match(old_value, new_value)
 
     def previous_value(self, key):
         return self.get_transformed_from_data(key, self._previous_data, cache=False, check_providers=False, silent=True)

clear_skies-1.18.3/src/clearskies/column_types/datetime.py

@@ -1,51 +0,0 @@
-from .column import Column
-from datetime import datetime, timezone
-import dateparser
-from ..autodoc.schema import DateTime as AutoDocDateTime
-
-
-class DateTime(Column):
-    _auto_doc_class = AutoDocDateTime
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    def from_backend(self, value):
-        if not value or value == "0000-00-00 00:00:00":
-            date = None
-        elif type(value) == str:
-            date = dateparser.parse(value)
-        else:
-            date = value
-        return date.replace(tzinfo=timezone.utc) 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:
-            return data
-
-        # hopefully this is a Python datetime object in UTC timezone...
-        return {**data, **{self.name: data[self.name].strftime("%Y-%m-%d %H:%M:%S")}}
-
-    def to_json(self, model):
-        datetime = model.get(self.name, silent=True)
-        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("%Y-%m-%d %H:%M:%S")
-        if not operator:
-            operator = "="
-        return f"{column_prefix}{self.name}{operator}{date}"
-
-    def is_allowed_operator(self, operator, relationship_reference=None):
-        """
-        This is called when processing user data to decide if the end-user is specifying an allowed operator
-        """
-        return operator in ["=", "<", ">", "<=", ">="]
-
-    def input_error_for_value(self, value, operator=None):
-        value = dateparser.parse(value)
-        if not value:
-            return "given value did not appear to be a valid date"
-        if not value.tzinfo:
-            return "date is missing timezone information"
-        return ""