clear-skies 1.21.4__tar.gz → 1.22.0__tar.gz

{clear_skies-1.21.4 → clear_skies-1.22.0}/PKG-INFO

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

{clear_skies-1.21.4 → clear_skies-1.22.0}/pyproject.toml

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

{clear_skies-1.21.4 → clear_skies-1.22.0}/src/clearskies/backends/api_backend.py

@@ -3,6 +3,7 @@ from typing import Any, Callable, Dict, List, Tuple
 from ..autodoc.schema import Integer as AutoDocInteger
 from .. import model
 from ..column_types import JSON, DateTime
+import re
 
 
 class ApiBackend(Backend):
@@ -34,6 +35,36 @@ class ApiBackend(Backend):
         self.url = url
         self._auth = auth
 
+    def records_url(self, configuration: Dict[str, Any]) -> str:
+        return self.url
+
+    def count_url(self, configuration: Dict[str, Any]) -> str:
+        return self.records_url(configuration)
+
+    def delete_url(self, id: str, model: model.Model) -> str:
+        return self.url
+
+    def update_url(self, id: str, model: model.Model) -> str:
+        return self.url
+
+    def create_url(self, data: Dict[str, Any], model: model.Model) -> str:
+        return self.url
+
+    def records_method(self, configuration: Dict[str, Any]) -> str:
+        return "GET"
+
+    def count_method(self, configuration: Dict[str, Any]) -> str:
+        return "GET"
+
+    def delete_method(self, id: str, model: model.Model) -> str:
+        return "DELETE"
+
+    def update_method(self, id: str, model: model.Model) -> str:
+        return "PATCH"
+
+    def create_method(self, data: Dict[str, Any], model: model.Model) -> str:
+        return "POST"
+
     def update(self, id, data, model):
         [url, method, json_data, headers] = self._build_update_request(id, data, model)
         response = self._execute_request(url, method, json=json_data, headers=headers)
@@ -42,7 +73,8 @@ class ApiBackend(Backend):
         return self._map_update_response(response.json())
 
     def _build_update_request(self, id, data, model):
-        return [self.url, "PATCH", data, {}]
+        (url, data) = self._finalize_url_and_data(self.update_url(id, model), data)
+        return [url, self.update_method(id, model), data, {}]
 
     def _map_update_response(self, json):
         if not "data" in json:
@@ -55,7 +87,8 @@ class ApiBackend(Backend):
         return self._map_create_response(response.json())
 
     def _build_create_request(self, data, model):
-        return [self.url, "POST", data, {}]
+        (url, data) = self._finalize_url_and_data(self.create_url(data, model), data)
+        return [url, self.create_method(data, model), data, {}]
 
     def _map_create_response(self, json):
         if not "data" in json:
@@ -68,7 +101,9 @@ class ApiBackend(Backend):
         return self._validate_delete_response(response.json())
 
     def _build_delete_request(self, id, model):
-        return [self.url, "DELETE", {model.id_column_name: id}, {}]
+        data = model.data
+        (url, data) = self._finalize_url_and_data(self.delete_url(id, model), data)
+        return [url, self.delete_method(id, model), {model.id_column_name: id}, {}]
 
     def _validate_delete_response(self, json):
         if "status" not in json:
@@ -82,7 +117,13 @@ class ApiBackend(Backend):
         return self._map_count_response(response.json())
 
     def _build_count_request(self, configuration):
-        return [self.url, "GET", {**{"count_only": True}, **self._as_post_data(configuration)}, {}]
+        (url, configuration) = self._finalize_url_and_configuration(self.count_url(configuration), configuration)
+        return [
+            url,
+            self.count_method(configuration),
+            {**{"count_only": True}, **self._as_post_data(configuration)},
+            {},
+        ]
 
     def _map_count_response(self, json):
         if not "total_matches" in json:
@@ -102,7 +143,8 @@ class ApiBackend(Backend):
         return records
 
     def _build_records_request(self, configuration):
-        return [self.url, "GET", self._as_post_data(configuration), {}]
+        (url, configuration) = self._finalize_url_and_configuration(self.records_url(configuration), configuration)
+        return [url, self.records_method(configuration), self._as_post_data(configuration), {}]
 
     def _map_records_response(self, json):
         if not "data" in json:
@@ -224,3 +266,85 @@ class ApiBackend(Backend):
             )
             return {**backend_data, **{column.name: as_date}}
         return column.to_backend(backend_data)
+
+    def _finalize_url_and_data(self, url: str, data: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+        (url, used_columns) = self._finalize_url(url, data, model)
+        for used_column in used_columns:
+            del data[used_column]
+        return (url, data)
+
+    def _finalize_url_and_configuration(self, url: str, configuration: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+        # we need to convert the wheres in the configuration to a dictionary of key/values, but
+        # *only* for cases where we have performed an equals search.
+        filters_by_equals = {}
+        index_lookup = {}
+        for index, where in enumerate(configuration["wheres"]):
+            if where["operator"] != "=":
+                continue
+            filters_by_equals[where["column"]] = where["values"][0]
+            index_lookup[where["column"]] = index
+
+        # always call _finalize_url, even if we don't have any search columns,
+        # because if there are placeholders in the URL but we don't have any values,
+        # then we need to throw an exception.
+        (url, used_columns) = self._finalize_url(url, filters_by_equals, model)
+        # we need to remove the used entries from the wheres but in doing so we start at the end
+        # of the array so our indexes stay valid.
+        to_delete = [index_lookup[used_column] for used_column in used_columns]
+        to_delete.sort(reverse=True)
+        for index_to_delete in to_delete:
+            del configuration["wheres"][index_to_delete]
+
+        return (url, configuration)
+
+    def _finalize_url(self, url: str, data: Dict[str, Any], model: model.Models) -> Tuple[str, List[str]]:
+        """
+        This function is what gives support for placeholders in URLs.  We support two formats:
+
+         1. /some/path/{some_field}/blah
+         2. /some/path/:some_field/blah
+
+        The url comes from the `my_url` function, which (by default) is just self.url.  You can
+        always extend `my_url` to pull the URL from something else (the `model.table_name()` for instance).
+
+        You would then:
+
+        ```
+        models.where("some_field=some_value")
+        ```
+
+        and when the API backend makes the call it will then build the appropriate URL.  Naturally,
+        you'll want to add a corresponding column to your model, otherwise the model will complain
+        that "some_field is not an allowed column in model class 'BLAH'" (since all search columns
+        used in a `where` query go through strict input validation).
+        """
+        # many Snyk API calls require a resource id in the URL.  Let's check if that is the case here,
+        # and if so, get  it out of the query configuration
+        used_columns = []
+        resource_references = self._find_resource_references_in_url(url)
+        for resource_reference in resource_references:
+            resource_name = resource_reference["name"]
+            placeholder = resource_reference["placeholder"]
+            if not data.get(resource_name):
+                raise ValueError(
+                    f"Error building a request with {self.__class__.__name__}: my url, '{url}', has a URL resource named '{resource_name}' but a request was made without providing a value for this resource.  All URL parameters are implicitly required.  Also note that only where clauses with an 'equals' operator will be used when providing search terms for the URL.  So, make sure you add an appropriate: `models.where('{resource_name}=some_value')` search when using the corresponding models class.  Alternatively, if executing a create/delete/update operation, make sure the model and/or save has a value for this column"
+                )
+
+            url = url.replace(placeholder, str(data.get(resource_name)))
+            used_columns.append(resource_name)
+        return (url, used_columns)
+
+    def _find_resource_references_in_url(self, url: str) -> list[str]:
+        if not url:
+            return []
+        # To help with the regexp matching, it helps if the URL both starts and ends with a "/".
+        # We don't need to modify the URL at all - we just need it for our matching, so it's fine
+        # that our changes aren't propogated back to the calling function.
+        if url[-1] != "/":
+            url += "/"
+        if url[0] != "/":
+            url = f"/{url}"
+        return [
+            *[{"name": reference, "placeholder": "{" + reference + "}"} for reference in re.findall(r"{(\w+)}", url)],
+            *[{"name": reference, "placeholder": f":{reference}"} for reference in re.findall(r"/:([^/]+)/", url)],
+        ]

clear_skies-1.22.0/src/clearskies/backends/restful_api_advanced_search_backend.py

@@ -0,0 +1,103 @@
+from .api_backend import ApiBackend
+from typing import Any, Callable, Dict, List, Tuple
+from .. import model
+from ..autodoc.schema import Integer as AutoDocInteger
+
+
+class RestfulApiAdvancedSearchBackend(ApiBackend):
+    _requests = None
+    _auth = None
+    _records = None
+
+    _allowed_configs = [
+        "wheres",
+        "sorts",
+        "limit",
+        "pagination",
+        "table_name",
+        "model_columns",
+        "select_all",
+    ]
+
+    _empty_configs = [
+        "group_by_column",
+        "selects",
+        "joins",
+    ]
+
+    def __init__(self, requests):
+        self._requests = requests
+
+    def configure(self, auth=None):
+        self._auth = auth
+
+    def records_url(self, configuration: Dict[str, Any]) -> str:
+        return configuration["table_name"].rstrip("/") + "/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.21.4 → clear_skies-1.22.0}/src/clearskies/models.py

@@ -81,7 +81,7 @@ class Models(ABC, ConditionParser):
             "selects": self.query_selects,
             "select_all": self.query_select_all,
             "table_name": self.get_table_name(),
-            "model_columns": self._model_columns,
+            "model_columns": self.model_columns,
         }
 
     @query_configuration.setter

clear_skies-1.21.4/src/clearskies/backends/restful_api_advanced_search_backend.py

@@ -1,138 +0,0 @@
-from .api_backend import ApiBackend
-from typing import Any, Callable, Dict, List, Tuple
-from ..autodoc.schema import Integer as AutoDocInteger
-
-
-class RestfulApiAdvancedSearchBackend(ApiBackend):
-    _requests = None
-    _auth = None
-    _records = None
-
-    _allowed_configs = [
-        "wheres",
-        "sorts",
-        "limit",
-        "pagination",
-        "table_name",
-        "model_columns",
-        "select_all",
-    ]
-
-    _empty_configs = [
-        "group_by_column",
-        "selects",
-        "joins",
-    ]
-
-    def __init__(self, requests):
-        self._requests = requests
-
-    def configure(self, auth=None):
-        self._auth = auth
-
-    def update(self, id, data, model):
-        [url, method, json_data, headers] = self._build_update_request(id, data, model)
-        response = self._execute_request(url, method, json=json_data, headers=headers)
-        if not response.content:
-            return {**model.data, **data}
-        return self._map_update_response(response.json())
-
-    def _build_update_request(self, id, data, model):
-        url = model.table_name().rstrip("/")
-        return [f"{url}/{id}", "PATCH", data, {}]
-
-    def _map_update_response(self, json):
-        if not "data" in json:
-            raise ValueError("Unexpected API response to update request")
-        return json["data"]
-
-    def create(self, data, model):
-        [url, method, json_data, headers] = self._build_create_request(data, model)
-        response = self._execute_request(url, method, json=json_data, headers=headers)
-        return self._map_create_response(response.json())
-
-    def _build_create_request(self, data, model):
-        return [model.table_name().rstrip("/"), "POST", data, {}]
-
-    def _map_create_response(self, json):
-        if not "data" in json:
-            raise ValueError("Unexpected API response to create request")
-        return json["data"]
-
-    def delete(self, id, model):
-        [url, method, json_data, headers] = self._build_delete_request(id, model)
-        response = self._execute_request(url, method, json=json_data, headers=headers)
-        return self._validate_delete_response(response.json())
-
-    def _build_delete_request(self, id, model):
-        url = model.table_name().rstrip("/")
-        return [f"{url}/{id}", "DELETE", {}, {}]
-
-    def _validate_delete_response(self, json):
-        if "status" not in json:
-            raise ValueError("Unexpected response to delete API request")
-        return json["status"] == "success"
-
-    def count(self, configuration, model):
-        configuration = self._check_query_configuration(configuration)
-        [url, method, json_data, headers] = self._build_count_request(configuration, model)
-        response = self._execute_request(url, method, json=json_data, headers=headers)
-        return self._map_count_response(response.json())
-
-    def _build_count_request(self, configuration, model):
-        url = model.table_name().rstrip("/") + "/search"
-        return [url, "POST", {**{"count_only": True}, **self._as_post_data(configuration, model)}, {}]
-
-    def _map_count_response(self, json):
-        if not "total_matches" in json:
-            raise ValueError("Unexpected API response when executing count request")
-        return json["total_matches"]
-
-    def records(self, configuration, model, next_page_data={}):
-        configuration = self._check_query_configuration(configuration)
-        [url, method, json_data, headers] = self._build_records_request(configuration, model)
-        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 _build_records_request(self, configuration, model):
-        url = model.table_name().rstrip("/") + "/search"
-        return [url, "POST", self._as_post_data(configuration, model), {}]
-
-    def _map_records_response(self, json):
-        if not "data" in json:
-            raise ValueError("Unexpected response from records request")
-        return json["data"]
-
-    def _as_post_data(self, configuration, model):
-        data = {
-            "where": list(map(lambda where: self._where_for_post(where, model), 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, model):
-        prefix = ""
-        if where.get("table"):
-            prefix = where["table"] + "."
-        return {
-            "column": prefix + where["column"],
-            "operator": where["operator"],
-            "value": self.normalize_outgoing_value(where, model, where["values"][0]),
-        }
-
-    def normalize_outgoing_value(self, where, model, value):
-        column_name = where["column"]
-        columns = model.columns()
-        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