clear-skies 1.18.6__tar.gz → 1.18.8__tar.gz

{clear_skies-1.18.6 → clear_skies-1.18.8}/PKG-INFO

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

{clear_skies-1.18.6 → clear_skies-1.18.8}/pyproject.toml

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

clear_skies-1.18.8/src/clearskies/column_types/created_by_authorization_data.py

@@ -0,0 +1,26 @@
+from .string import String
+
+
+class CreatedByAuthorizationData(String):
+    required_configs = [
+        "authorization_data_key_name",
+    ]
+
+    def __init__(self, di):
+        super().__init__(di)
+
+    @property
+    def is_writeable(self):
+        return False
+
+    def pre_save(self, data, model):
+        if model.exists:
+            return data
+
+        authorization_data = self.di.build("input_output", cache=True).get_authorization_data()
+        # data comes last so that it can override the info in the authorization data.  This seems counter-intuitive,
+        # but is important.  You would think that you *don't* want the data from the authorization data to be
+        # overridden (since this is mainly used for logging), but the trouble is that there are a variety of use-cases
+        # where the application must provide the audit data.  Examples include registration and login.  In these
+        # cases, authorization data will be empty, and must be provided by the applicaiton.
+        return {self.name: authorization_data.get(self.config("authorization_data_key_name"), "N/A"), **data}

{clear_skies-1.18.6 → clear_skies-1.18.8}/src/clearskies/handlers/base.py

@@ -48,7 +48,7 @@ class Base(ABC):
                 raise KeyError(f"Attempt to set unknown configuration setting '{key}' for handler '{class_name}'")
 
         self._check_configuration(configuration)
-        self._configuration = self._finalize_configuration(self.apply_default_configuation(configuration))
+        self._configuration = self._finalize_configuration(self.apply_default_configuration(configuration))
 
     def _check_configuration(self, configuration):
         if not "authentication" in configuration:
@@ -113,7 +113,7 @@ class Base(ABC):
                 f"Configuration error for handler '{self.__class__.__name__}': if provided, base_url must be a string"
             )
 
-    def apply_default_configuation(self, configuration):
+    def apply_default_configuration(self, configuration):
         return {
             **self._global_configuration_defaults,
             **self._configuration_defaults,

{clear_skies-1.18.6 → clear_skies-1.18.8}/src/clearskies/handlers/routing.py

@@ -56,7 +56,7 @@ class Routing(Base):
                 raise KeyError(f"Attempt to set unknown configuration setting '{key}' for handler '{class_name}'")
 
         self._check_configuration(configuration)
-        self._configuration = self._finalize_configuration(self.apply_default_configuation(configuration))
+        self._configuration = self._finalize_configuration(self.apply_default_configuration(configuration))
 
     def _check_configuration(self, configuration):
         super()._check_configuration(configuration)

{clear_skies-1.18.6 → clear_skies-1.18.8}/src/clearskies/handlers/simple_routing_route.py

@@ -1,9 +1,13 @@
+import logging
 import urllib.parse
 import re
+import json
 from ..autodoc.request import URLPath
 from ..autodoc.schema import String
 from . import simple_routing
 
+logger = logging.getLogger(__name__)
+
 
 class SimpleRoutingRoute:
     _di = None
@@ -91,26 +95,45 @@ class SimpleRoutingRoute:
         to understand if there was no route match at all.
         """
         # if we're routing to a simple router then defer to it
+        incoming = f"Incoming request: [{request_method}] {full_path}.  Check against route with url '{self._path}' "
+        if not self._methods:
+            incoming += " configured for any method except OPTIONS"
+        elif isinstance(self._methods, str):
+            incoming += f" with method '{self._methods}'"
+        else:
+            incoming += " with any of the following methods: " + ", ".join(self._methods)
         if self._routes_to_simple_routing:
             return self._handler.can_handle(full_path, request_method, is_cors=is_cors)
         # If we're routing for CORS then ignore the request method (since it won't match)
         if not is_cors and self._methods is not None and request_method not in self._methods:
+            logger.debug(
+                f"{incoming} Skipped because this route is not specifically configured for CORS, and this is an OPTIONS request."
+            )
             return None
         if self._resource_paths:
-            return self._resource_path_match(full_path, self._path_parts, self._resource_paths)
+            results = self._resource_path_match(full_path, self._path_parts, self._resource_paths)
+            if not results:
+                logger.debug(f"{incoming} Not a match.")
+            else:
+                logger.debug(f"{incoming} Matched and extracted route data: " + json.dumps(results))
+            return results
         if self._path is not None:
             full_path = full_path.strip("/")
             my_path = self._path.strip("/")
             my_path_length = len(my_path)
             full_path_length = len(full_path)
             if my_path_length > full_path_length:
+                logger.debug(f"{incoming} Not a match. I'm too long to bother checking.")
                 return None
             if full_path[:my_path_length] != my_path:
+                logger.debug(f"{incoming} Not a match.  Our prefixes just don't match.")
                 return None
             # make sure we don't get confused by partial matches.  `user` should match `user/` and `user/5`,
             # but it shouldn't match `users/`
             if full_path_length > my_path_length and full_path[my_path_length] != "/":
+                logger.debug(f"{incoming} Not a match.  I only partially matched the URL but not as a sub-directory.")
                 return None
+        logger.debug(f"{incoming} Match!")
         return {}
 
     def _resource_path_match(self, requested_path, path_parts, resource_paths):

{clear_skies-1.18.6 → clear_skies-1.18.8}/src/clearskies/handlers/update.py

@@ -12,6 +12,7 @@ class Update(Write):
         "model": None,
         "model_class": None,
         "columns": None,
+        "column_overrides": None,
         "writeable_columns": None,
         "readable_columns": None,
         "where": [],
@@ -19,15 +20,19 @@ class Update(Write):
         "include_id_in_path": False,
     }
 
-    def handle(self, input_output):
-        input_data = self.request_data(input_output)
+    def get_model_id(self, input_output, input_data):
         routing_data = input_output.routing_data()
         if self.id_column_name in routing_data:
-            model_id = routing_data[self.id_column_name]
-        elif "id" in routing_data:
-            model_id = routing_data["id"]
-        else:
-            raise ValueError("I didn't receive the ID in my routing data.  I am probably misconfigured.")
+            return routing_data[self.id_column_name]
+        if "id" in routing_data:
+            return routing_data["id"]
+        raise ValueError("I didn't receive the ID in my routing data.  I am probably misconfigured.")
+
+    def handle(self, input_output):
+        input_data = self.request_data(input_output)
+        model_id = self.get_model_id(input_output, input_data)
+        if not model_id:
+            return self.error(input_output, "Not Found", 404)
         id_column_name = self.id_column_name
         models = self._model.where(f"{id_column_name}={model_id}")
         for where in self.configuration("where"):
@@ -42,6 +47,7 @@ class Update(Write):
             input_output.routing_data(),
             input_output.get_authorization_data(),
             input_output,
+            overrides=self.configuration("column_overrides"),
         )
         authorization = self._configuration.get("authorization", None)
         if authorization and hasattr(authorization, "filter_models"):
@@ -58,7 +64,7 @@ class Update(Write):
         }
         if input_errors:
             raise InputError(input_errors)
-        model.save(input_data, columns=self._columns)
+        model.save(input_data, columns=self._get_writeable_columns())
 
         return self.success(input_output, self._model_as_json(model, input_output))
 

{clear_skies-1.18.6 → clear_skies-1.18.8}/src/clearskies/model.py

@@ -130,24 +130,26 @@ class Model(Models):
         """
         if not len(data):
             raise ValueError("You have to pass in something to save!")
-        if columns is None:
-            columns = self.columns()
+        save_columns = self.columns()
+        if columns is not None:
+            for column in columns.values():
+                save_columns[column.name] = column
 
         old_data = self.data
-        data = self.columns_pre_save(data, columns)
+        data = self.columns_pre_save(data, save_columns)
         data = self.pre_save(data)
         if data is None:
             raise ValueError("pre_save forgot to return the data array!")
 
-        to_save = self.columns_to_backend(data, columns)
-        to_save = self.to_backend(to_save, columns)
+        to_save = self.columns_to_backend(data, save_columns)
+        to_save = self.to_backend(to_save, save_columns)
         if self.exists:
             new_data = self._backend.update(self._data[self.id_column_name], to_save, self)
         else:
             new_data = self._backend.create(to_save, self)
-        id = self._backend.column_from_backend(columns[self.id_column_name], new_data[self.id_column_name])
+        id = self._backend.column_from_backend(save_columns[self.id_column_name], new_data[self.id_column_name])
 
-        data = self.columns_post_save(data, id, columns)
+        data = self.columns_post_save(data, id, save_columns)
         self.post_save(data, id)
 
         self.data = new_data
@@ -155,7 +157,7 @@ class Model(Models):
         self._previous_data = old_data
         self._touched_columns = list(data.keys())
 
-        self.columns_save_finished(columns)
+        self.columns_save_finished(save_columns)
         self.save_finished()
 
         return True
@@ -332,10 +334,10 @@ class Model(Models):
         """
         pass
 
-    def where_for_request(self, models, routing_data, authorization_data, input_output):
+    def where_for_request(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.
         """
-        for column in self.columns().values():
+        for column in self.columns(overrides=overrides).values():
             models = column.where_for_request(models, routing_data, authorization_data, input_output)
         return models

clear_skies-1.18.6/src/clearskies/column_types/created_by_authorization_data.py

@@ -1,21 +0,0 @@
-from .string import String
-
-
-class CreatedByAuthorizationData(String):
-    required_configs = [
-        "authorization_data_key_name",
-    ]
-
-    def __init__(self, di):
-        super().__init__(di)
-
-    @property
-    def is_writeable(self):
-        return False
-
-    def pre_save(self, data, model):
-        if model.exists:
-            return data
-
-        authorization_data = self.di.build("input_output", cache=True).get_authorization_data()
-        return {**data, self.name: authorization_data.get(self.config("authorization_data_key_name"), "N/A")}