clear-skies 1.22.1__tar.gz → 1.22.3__tar.gz

{clear_skies-1.22.1 → clear_skies-1.22.3}/PKG-INFO

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

{clear_skies-1.22.1 → clear_skies-1.22.3}/pyproject.toml

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

clear_skies-1.22.3/src/clearskies/backends/api_get_only_backend.py

@@ -0,0 +1,101 @@
+from .api_backend import ApiBackend
+from typing import Any, Callable, Dict, List, Tuple
+from .. import model
+
+
+class ApiGetOnlyBackend(ApiBackend):
+    _requests = None
+    _auth = None
+    _id_column_name = None
+
+    _allowed_configs = [
+        "wheres",
+        "table_name",
+        "model_columns",
+        "select_all",
+    ]
+
+    def __init__(self, requests):
+        self._requests = requests
+
+    def configure(self, auth=None, origin=None, id_column_name="id"):
+        self._auth = auth
+        self._origin = origin
+        self._id_column_name = id_column_name
+
+    def records_url(self, configuration):
+        record_id = None
+        for where in configuration["wheres"]:
+            if where["column"] == "id":
+                record_id = where["values"][0]
+        if record_id:
+            return self.auth_origin + configuration["table_name"].strip("/") + f"/{record_id}"
+        return self.auth_origin + configuration["table_name"].strip("/") + "/search"
+
+    def delete_url(self, id: str, model: model.Model) -> str:
+        table_name = model.table_name().rstrip("/")
+        return f"{table_name}/{id}"
+
+    def update_url(self, id: str, model: model.Model) -> str:
+        table_name = model.table_name().rstrip("/")
+        return f"{table_name}/{id}"
+
+    def create_url(self, data: Dict[str, Any], model: model.Model) -> str:
+        return model.table_name().rstrip("/")
+
+    def records_method(self, configuration: Dict[str, Any]) -> str:
+        return "POST"
+
+    def count_method(self, configuration: Dict[str, Any]) -> str:
+        return "POST"
+
+    def _build_delete_request(self, id, model):
+        data = model.data
+        (url, data) = self._finalize_url_and_data(self.delete_url(id, model), data)
+        return [url, self.delete_method(id, model), {}, {}]
+
+    def _build_count_request(self, configuration):
+        [url, method, json_data, headers] = super()._build_count_request(configuration)
+        json_data["count_only"] = True
+        return [url, method, json_data, headers]
+
+    def records(self, configuration, model, next_page_data={}):
+        configuration = self._check_query_configuration(configuration)
+        [url, method, json_data, headers] = self._build_records_request(configuration)
+        response = self._execute_request(url, method, json=json_data, headers=headers).json()
+        records = self._map_records_response(response)
+        for next_page_key in ["nextPage", "NextPage", "next_page"]:
+            if response.get("pagination", {}).get(next_page_key):
+                for key, value in response["pagination"][next_page_key].items():
+                    next_page_data[key] = value
+        return records
+
+    def _as_post_data(self, configuration):
+        data = {
+            "where": list(
+                map(lambda where: self._where_for_post(where, configuration["model_columns"]), configuration["wheres"])
+            ),
+            "sort": configuration["sorts"],
+            "start": configuration["pagination"].get("start", 0),
+            "limit": configuration["limit"],
+        }
+        return {key: value for (key, value) in data.items() if value}
+
+    def _where_for_post(self, where, columns):
+        prefix = ""
+        if where.get("table"):
+            prefix = where["table"] + "."
+        return {
+            "column": prefix + where["column"],
+            "operator": where["operator"],
+            "value": self.normalize_outgoing_value(where, columns, where["values"][0]),
+        }
+
+    def normalize_outgoing_value(self, where, columns, value):
+        column_name = where["column"]
+        if where.get("table") or column_name not in columns:
+            return value
+        normalized_data = self.column_to_backend(columns[column_name], {column_name: value})
+        if column_name in normalized_data:
+            return normalized_data[column_name]
+        return value

{clear_skies-1.22.1 → clear_skies-1.22.3}/src/clearskies/column_types/belongs_to.py

@@ -34,6 +34,7 @@ class BelongsTo(String):
         "model_column_name",
         "readable_parent_columns",
         "join_type",
+        "where",
     ]
 
     def __init__(self, di):
@@ -43,6 +44,7 @@ class BelongsTo(String):
         super()._check_configuration(configuration)
         self.validate_models_class(configuration["parent_models_class"])
 
+        error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
         if not configuration.get("model_column_name") and self.name[-3:] != "_id":
             raise ValueError(
                 f"Invalid name for column '{self.name}' in '{self.model_class.__name__}' - "
@@ -50,19 +52,14 @@ class BelongsTo(String):
                 + "that the parent model can be fetched from."
             )
         if configuration.get("model_column_name") and type(configuration.get("model_column_name")) != str:
-            raise ValueError(
-                f"Configuration error for '{self.name}' in '{self.model_class.__name__}': 'model_column_name' must be a string."
-            )
+            raise ValueError(f"{error_prefix} 'model_column_name' must be a string.")
 
         join_type = configuration.get("join_type")
         if join_type and join_type.upper() not in ["LEFT", "INNER"]:
-            raise ValueError(
-                f"Configuration error for '{self.name}' in '{self.model_class.__name__}': join_type must be INNER or LEFT"
-            )
+            raise ValueError(f"{error_prefix} join_type must be INNER or LEFT")
 
         if configuration.get("readable_parent_columns"):
             parent_columns = self.di.build(configuration["parent_models_class"], cache=True).raw_columns_configuration()
-            error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
             readable_parent_columns = configuration["readable_parent_columns"]
             if not hasattr(readable_parent_columns, "__iter__"):
                 raise ValueError(
@@ -81,6 +78,19 @@ class BelongsTo(String):
                         + "column does not exist in the model class."
                     )
 
+        wheres = configuration.get("where")
+        if wheres:
+            if not isinstance(wheres, list):
+                raise ValueError(
+                    f"{error_prefix} 'where' must be a list of where conditions or callables that return where conditions"
+                )
+            for index, where in enumerate(wheres):
+                if callable(where) or isinstance(where, str):
+                    continue
+                raise ValueError(
+                    f"{error_prefix} 'where' must be a list of where conditions or callables that return where conditions, but the item in entry #${index+1} was neither a string nor a callable"
+                )
+
     def _finalize_configuration(self, configuration):
         return {
             **super()._finalize_configuration(configuration),
@@ -89,6 +99,7 @@ class BelongsTo(String):
                 if configuration.get("model_column_name")
                 else self.name[:-3],
                 "join_type": configuration.get("join_type", "INNER").upper(),
+                "where": configuration.get("where", []),
             },
         }
 
@@ -149,7 +160,17 @@ class BelongsTo(String):
 
     @property
     def parent_models(self):
-        return self.di.build(self.config("parent_models_class"), cache=True)
+        parents = self.di.build(self.config("parent_models_class"), cache=True)
+        for where in self.config("where"):
+            if callable(where):
+                parents = self.di.call_function(where, model=parents)
+                if not parents:
+                    raise ValueError(
+                        f"Configuration error for column '{self.name}' in model '{self.model_class.__name__}': when 'where' is a callable, it must return a models class, but when the callable in where entry #{index+1} was called, it did not return the models class"
+                    )
+            else:
+                parents = parents.where(where)
+        return parents
 
     @property
     def parent_columns(self):

{clear_skies-1.22.1 → clear_skies-1.22.3}/src/clearskies/column_types/has_many.py

@@ -27,6 +27,7 @@ class HasMany(Column):
         "is_readable",
         "readable_child_columns",
         "parent_id_column_name",
+        "where",
     ]
 
     def __init__(self, di):
@@ -63,9 +64,10 @@ class HasMany(Column):
 
     def _check_configuration(self, configuration):
         super()._check_configuration(configuration)
+        error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
+
         if configuration.get("is_readable"):
             child_columns = self.di.build(configuration["child_models_class"], cache=True).raw_columns_configuration()
-            error_prefix = f"Configuration error for '{self.name}' in '{self.model_class.__name__}':"
             if not "readable_child_columns" in configuration:
                 raise ValueError(f"{error_prefix} must provide 'readable_child_columns' if is_readable is set")
             readable_child_columns = configuration["readable_child_columns"]
@@ -86,6 +88,27 @@ class HasMany(Column):
                         + "column does not exist in the model class."
                     )
 
+        wheres = configuration.get("where")
+        if wheres:
+            if not isinstance(wheres, list):
+                raise ValueError(
+                    f"{error_prefix} 'where' must be a list of where conditions or callables that return where conditions"
+                )
+            for index, where in enumerate(wheres):
+                if callable(where) or isinstance(where, str):
+                    continue
+                raise ValueError(
+                    f"{error_prefix} 'where' must be a list of where conditions or callables that return where conditions, but the item in entry #${index+1} was neither a string nor a callable"
+                )
+
+    def _finalize_configuration(self, configuration):
+        return {
+            **super()._finalize_configuration(configuration),
+            **{
+                "where": configuration.get("where", []),
+            },
+        }
+
     def get_child_columns(self):
         if "child_columns" not in self.configuration:
             self.configuration["child_columns"] = self.child_models.columns()
@@ -119,7 +142,17 @@ class HasMany(Column):
 
     @property
     def child_models(self):
-        return self.di.build(self.config("child_models_class"), cache=True)
+        children = self.di.build(self.config("child_models_class"), cache=True)
+        for index, where in enumerate(self.config("where")):
+            if callable(where):
+                children = self.di.call_function(where, model=children)
+                if not children:
+                    raise ValueError(
+                        f"Configuration error for column '{self.name}' in model '{self.model_class.__name__}': when 'where' is a callable, it must return a models class, but when the callable in where entry #{index+1} was called, it did not return the models class"
+                    )
+            else:
+                children = children.where(where)
+        return children
 
     def documentation(self, name=None, example=None, value=None):
         columns = self.get_child_columns()