clear-skies 1.22.4__tar.gz → 1.22.6__tar.gz

{clear_skies-1.22.4 → clear_skies-1.22.6}/PKG-INFO

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

{clear_skies-1.22.4 → clear_skies-1.22.6}/pyproject.toml

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

{clear_skies-1.22.4 → clear_skies-1.22.6}/src/clearskies/backends/__init__.py

@@ -1,5 +1,6 @@
 from .. import binding_config
 from .api_backend import ApiBackend
+from .api_get_only_backend import ApiGetOnlyBackend
 from .backend import Backend
 from .cursor_backend import CursorBackend
 from .example_backend import ExampleBackend
@@ -16,6 +17,7 @@ def example_backend(data):
 
 __all__ = [
     "ApiBackend",
+    "ApiGetOnlyBackend",
     "Backend",
     "CursorBackend",
     "ExampleBackend",

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

@@ -0,0 +1,48 @@
+from .api_backend import ApiBackend
+from typing import Any, Dict
+
+
+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="", id_column_name="id"):
+        self._auth = auth
+        self._origin = origin
+        self._id_column_name = id_column_name
+
+    def records_url(self, configuration):
+        if not len(configuration["wheres"]):
+            raise ValueError(
+                f"When using the {self.__class__.__name__} backend, you must search the model by the id column.  A records request was executed but no search conditions were found."
+            )
+        record_id = None
+        for where in configuration["wheres"]:
+            if where["column"] == self._id_column_name:
+                record_id = where["values"][0]
+        if not record_id:
+            raise ValueError(
+                f"When using  the {self.__class__.__name__} backend, you must search by the id column ('{self._id_column_name}').  A records request was executed but there was no condition set for the '{self._id_column_name}' column"
+            )
+
+        return self._origin + configuration["table_name"].strip("/") + f"/{record_id}"
+
+    def records_method(self, configuration: Dict[str, Any]) -> str:
+        return "GET"
+
+    def _map_records_response(self, json):
+        response = super()._map_records_response(json)
+        if isinstance(response, dict):
+            return [response]
+        return response

{clear_skies-1.22.4 → clear_skies-1.22.6}/src/clearskies/column_types/audit.py

@@ -49,6 +49,7 @@ class Audit(has_many.HasMany):
         "readable_child_columns",
         "parent_class_name",
         "parent_id_column_name",
+        "where",
     ]
 
     def __init__(self, di):

{clear_skies-1.22.4 → clear_skies-1.22.6}/src/clearskies/column_types/has_many.py

@@ -143,7 +143,11 @@ class HasMany(Column):
     @property
     def child_models(self):
         children = self.di.build(self.config("child_models_class"), cache=True)
-        for index, where in enumerate(self.config("where")):
+        wheres = self.config("where", silent=True)
+        if not wheres:
+            return children
+
+        for index, where in enumerate(wheres):
             if callable(where):
                 children = self.di.call_function(where, model=children)
                 if not children:

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

@@ -1,101 +0,0 @@
-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