clear-skies 2.0.7__py3-none-any.whl → 2.0.9__py3-none-any.whl

clearskies/endpoints/advanced_search.py

@@ -1,19 +1,12 @@
 from __future__ import annotations
 
-import inspect
-from collections import OrderedDict
-from typing import TYPE_CHECKING, Any, Type
+from typing import TYPE_CHECKING, Any
 
-import clearskies.configs
-import clearskies.exceptions
-from clearskies import authentication, autodoc, typing
+from clearskies import exceptions
 from clearskies.endpoints.simple_search import SimpleSearch
-from clearskies.functional import string
-from clearskies.input_outputs import InputOutput
 
 if TYPE_CHECKING:
-    from clearskies import SecurityHeader
-    from clearskies.model import Model
+    from clearskies import Model, autodoc
 
 
 class AdvancedSearch(SimpleSearch):
@@ -350,12 +343,12 @@ class AdvancedSearch(SimpleSearch):
         if pagination_data:
             error = self.model.validate_pagination_data(pagination_data, self.auto_case_internal_column_name)
             if error:
-                raise clearskies.exceptions.ClientError(error)
+                raise exceptions.ClientError(error)
         if query_parameters:
-            raise clearskies.exceptions.ClientError("Query parameters were found but are not supported.")
+            raise exceptions.ClientError("Query parameters were found but are not supported.")
         for key in request_data.keys():
             if key not in self.allowed_request_keys:
-                raise clearskies.exceptions.ClientError(
+                raise exceptions.ClientError(
                     f"Invalid request parameter found in request body: '{key}'.  Expected parameters: "
                     + ", ".join([self.auto_case_internal_column_name(key) for key in self.allowed_request_keys])
                 )
@@ -363,7 +356,7 @@ class AdvancedSearch(SimpleSearch):
         sort_key_name = self.auto_case_internal_column_name("sort")
         sort = request_data.get(sort_key_name, [])
         if not isinstance(sort, list):
-            raise clearskies.exceptions.ClientError(
+            raise exceptions.ClientError(
                 f"'{sort_key_name}' property in request body should be a list, but I found a value of type "
                 + sort.__class__.__name
             )
@@ -372,25 +365,25 @@ class AdvancedSearch(SimpleSearch):
             direction_key_name = self.auto_case_internal_column_name("direction")
             for index, sort_entry in enumerate(sort):
                 if not isinstance(sort_entry, dict):
-                    raise clearskies.exceptions.ClientError(
+                    raise exceptions.ClientError(
                         f"'{sort_key_name}' should be a list of dictionaries, but entry #{index + 1} is a value of type '{sort_entry.__class__.__name}', not a dict"
                     )
                 for key_name in [column_key_name, direction_key_name]:
                     if not sort_entry.get(key_name):
-                        raise clearskies.exceptions.ClientError(
+                        raise exceptions.ClientError(
                             f"Each entry in the sort list should contain both '{column_key_name}' and '{direction_key_name}' but entry #{index + 1} is missing '{key_name}'"
                         )
                     if not isinstance(sort_entry[key_name], str):
-                        raise clearskies.exceptions.ClientError(
+                        raise exceptions.ClientError(
                             f"{key_name}' must be a string, but for entry #{index + 1} it is a value of type "
                             + sort_entry[key_name].__class__.__name__
                         )
                 if sort_entry[direction_key_name].lower() not in ["asc", "desc"]:
-                    raise clearskies.exceptions.ClientError(
+                    raise exceptions.ClientError(
                         f"{direction_key_name}' must be either 'ASC' or 'DESC', but a different value was found for entry #{index + 1}"
                     )
                 if self.auto_case_column_name(sort_entry[column_key_name], False) not in self.sortable_column_names:
-                    raise clearskies.exceptions.ClientError(
+                    raise exceptions.ClientError(
                         f"Invalid sort column for entry #{index + 1}.  Allowed values are: "
                         + ", ".join(
                             [
@@ -402,7 +395,7 @@ class AdvancedSearch(SimpleSearch):
         where_key_name = self.auto_case_internal_column_name("where")
         where = request_data.get(where_key_name, [])
         if not isinstance(where, list):
-            raise clearskies.exceptions.ClientError(
+            raise exceptions.ClientError(
                 f"'{where_key_name}' property in request body should be a list, but I found a value of type "
                 + where.__class__.__name
             )
@@ -412,21 +405,21 @@ class AdvancedSearch(SimpleSearch):
             value_key_name = self.auto_case_internal_column_name("value")
             for index, where_entry in enumerate(where):
                 if not isinstance(where_entry, dict):
-                    raise clearskies.exceptions.ClientError(
+                    raise exceptions.ClientError(
                         f"'{where_key_name}' should be a list of dictionaries, but entry #{index + 1} is a value of type '{where_entry.__class__.__name}', not a dict"
                     )
                 for key_name in [column_key_name, operator_key_name, value_key_name]:
                     if key_name not in where_entry:
-                        raise clearskies.exceptions.ClientError(
+                        raise exceptions.ClientError(
                             f"Each entry in the where list should contain '{column_key_name}', '{operator_key_name}', and '{value_key_name}', but entry #{index + 1} is missing '{key_name}'"
                         )
                     if key_name != value_key_name and not isinstance(where_entry[key_name], str):
-                        raise clearskies.exceptions.ClientError(
+                        raise exceptions.ClientError(
                             f"{key_name}' must be a string, but for entry #{index + 1} it is a value of type "
                             + sort_entry[key_name].__class__.__name__
                         )
                     if where_entry[column_key_name] not in self.searchable_column_names:
-                        raise clearskies.exceptions.ClientError(
+                        raise exceptions.ClientError(
                             f"Invalid where column for entry #{index + 1}.  Allowed values are: "
                             + ", ".join(
                                 [
@@ -462,12 +455,12 @@ class AdvancedSearch(SimpleSearch):
                                 value if operator != "in" else value[0], where_entry[operator_key_name]
                             )
                     if error_allowed_operators:
-                        raise clearskies.exceptions.ClientError(
+                        raise exceptions.ClientError(
                             f"Invalid operator for entry #{index + 1}.  Allowed operators are: "
                             + ", ".join(column.allowed_search_operators(relationship_reference=column_name))
                         )
                     if error:
-                        raise clearskies.exceptions.ClientError(f"Invalid search value for entry #{index + 1}: {error}")
+                        raise exceptions.ClientError(f"Invalid search value for entry #{index + 1}: {error}")
 
     def configure_model_from_request_data(
         self,

clearskies/endpoints/callable.py

@@ -1,22 +1,16 @@
 from __future__ import annotations
 
-import inspect
-from collections import OrderedDict
 from typing import TYPE_CHECKING, Any
 from typing import Callable as CallableType
 
-import clearskies.configs
-import clearskies.exceptions
-from clearskies import authentication, autodoc, typing
+from clearskies import authentication, autodoc, configs, decorators, exceptions
 from clearskies.endpoint import Endpoint
 from clearskies.functional import string
-from clearskies.input_outputs import InputOutput
 
 if TYPE_CHECKING:
-    from clearskies import Column, SecurityHeader
+    from clearskies import Column, Model, Schema, SecurityHeader
     from clearskies.authentication import Authentication, Authorization
-    from clearskies.model import Model
-    from clearskies.schema import Schema
+    from clearskies.input_outputs import InputOutput
 
 
 class Callable(Endpoint):
@@ -114,7 +108,7 @@ class Callable(Endpoint):
     """
     The callable to execute when the endpoint is invoked
     """
-    to_call = clearskies.configs.Callable(default=None)
+    to_call = configs.Callable(default=None)
 
     """
     A schema that describes the expected input from the client.
@@ -172,7 +166,7 @@ class Callable(Endpoint):
     ```
 
     """
-    input_schema = clearskies.configs.Schema(default=None)
+    input_schema = configs.Schema(default=None)
 
     """
     Whether or not the return value is meant to be wrapped up in the standard clearskies response schema.
@@ -232,20 +226,20 @@ class Callable(Endpoint):
     Note that you can also return strings this way instead of objects/JSON.
 
     """
-    return_standard_response = clearskies.configs.Boolean(default=True)
+    return_standard_response = configs.Boolean(default=True)
 
     """
     Set to true if the callable will be returning multiple records (used when building the auto-documentation)
     """
-    return_records = clearskies.configs.Boolean(default=False)
+    return_records = configs.Boolean(default=False)
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         to_call: CallableType,
         url: str = "",
         request_methods: list[str] = ["GET"],
-        model_class: type[clearskies.model.Model] | None = None,
+        model_class: type[Model] | None = None,
         readable_column_names: list[str] = [],
         writeable_column_names: list[str] = [],
         input_schema: type[Schema] | None = None,
@@ -281,7 +275,7 @@ class Callable(Endpoint):
         else:
             input_errors = self.find_input_errors_from_callable(input_output.request_data, input_output)
             if input_errors:
-                raise clearskies.exceptions.InputErrors(input_errors)
+                raise exceptions.InputErrors(input_errors)
         response = self.di.call_function(self.to_call, **input_output.get_context_for_callables())
 
         if not self.return_standard_response:

clearskies/endpoints/create.py

@@ -1,18 +1,14 @@
 from __future__ import annotations
 
-import inspect
-from collections import OrderedDict
 from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.configs
-import clearskies.exceptions
-from clearskies import authentication, autodoc, typing
+from clearskies import authentication, autodoc, decorators, exceptions
 from clearskies.endpoint import Endpoint
 from clearskies.functional import string
-from clearskies.input_outputs import InputOutput
 
 if TYPE_CHECKING:
-    from clearskies import Column, SecurityHeader
+    from clearskies import Column, Schema, SecurityHeader
+    from clearskies.input_outputs import InputOutput
     from clearskies.model import Model
 
 
@@ -102,7 +98,7 @@ class Create(Endpoint):
      5. We provided an extra column (`not_a_column`) that wasn't in the list of allowed columns.
     """
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         model_class: type[Model],
@@ -114,7 +110,7 @@ class Create(Endpoint):
         request_methods: list[str] = ["POST"],
         response_headers: list[str | Callable[..., list[str]]] = [],
         output_map: Callable[..., dict[str, Any]] | None = None,
-        output_schema: clearskies.Schema | None = None,
+        output_schema: Schema | None = None,
         column_overrides: dict[str, Column] = {},
         internal_casing: str = "snake_case",
         external_casing: str = "snake_case",
@@ -137,7 +133,7 @@ class Create(Endpoint):
     def handle(self, input_output: InputOutput) -> Any:
         request_data = self.get_request_data(input_output)
         if not request_data and input_output.has_body():
-            raise clearskies.exceptions.ClientError("Request body was not valid JSON")
+            raise exceptions.ClientError("Request body was not valid JSON")
         self.validate_input_against_schema(request_data, input_output, self.model_class)
         new_model = self.model.create(request_data, columns=self.columns)
         return self.success(input_output, self.model_as_json(new_model, input_output))

clearskies/endpoints/delete.py

@@ -1,19 +1,13 @@
 from __future__ import annotations
 
-import inspect
-from collections import OrderedDict
-from typing import TYPE_CHECKING, Any, Callable, Type
+from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.configs
-import clearskies.exceptions
-from clearskies import authentication, autodoc, typing
+from clearskies import authentication, autodoc, decorators
 from clearskies.endpoints.get import Get
-from clearskies.functional import routing, string
-from clearskies.input_outputs import InputOutput
 
 if TYPE_CHECKING:
-    from clearskies import SecurityHeader
-    from clearskies.model import Model, Schema
+    from clearskies import Model, SecurityHeader, typing
+    from clearskies.input_outputs import InputOutput
 
 
 class Delete(Get):
@@ -73,7 +67,7 @@ class Delete(Get):
     ```
     """
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         model_class: type[Model],

clearskies/endpoints/get.py

@@ -1,19 +1,15 @@
 from __future__ import annotations
 
-import inspect
-from collections import OrderedDict
-from typing import TYPE_CHECKING, Any, Callable, Type
-
-import clearskies.configs
-import clearskies.exceptions
-from clearskies import authentication, autodoc, typing
-from clearskies.authentication import Authentication, Authorization
+from typing import TYPE_CHECKING, Any, Callable
+
+from clearskies import autodoc, configs, decorators, exceptions
+from clearskies.authentication import Authentication, Authorization, Public
 from clearskies.endpoint import Endpoint
 from clearskies.functional import routing, string
-from clearskies.input_outputs import InputOutput
 
 if TYPE_CHECKING:
-    from clearskies import Column, Schema, SecurityHeader
+    from clearskies import Column, Schema, SecurityHeader, typing
+    from clearskies.input_outputs import InputOutput
     from clearskies.model import Model
 
 
@@ -157,9 +153,9 @@ class Get(Endpoint):
     }
     ```
     """
-    record_lookup_column_name = clearskies.configs.ReadableModelColumn("model_class", default=None)
+    record_lookup_column_name = configs.ReadableModelColumn("model_class", default=None)
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         model_class: type[Model],
@@ -177,8 +173,8 @@ class Get(Endpoint):
         description: str = "",
         where: typing.condition | list[typing.condition] = [],
         joins: typing.join | list[typing.join] = [],
-        authentication: Authentication = authentication.Public(),
-        authorization: Authorization = authentication.Authorization(),
+        authentication: Authentication = Public(),
+        authorization: Authorization = Authorization(),
     ):
         try:
             # we will set the value for this if it isn't already set, and the easiest way is to just fetch it and see if it blows up
@@ -211,7 +207,7 @@ class Get(Endpoint):
             self.record_lookup_column_name + "=" + lookup_column_value
         )
         if not model:
-            raise clearskies.exceptions.NotFound("Not Found")
+            raise exceptions.NotFound("Not Found")
         return model
 
     def handle(self, input_output: InputOutput) -> Any:

clearskies/endpoints/health_check.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
-import inspect
-from typing import Any, Callable, Type
+from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.configs
-import clearskies.exceptions
-from clearskies import autodoc, typing
+from clearskies import autodoc, configs, decorators
 from clearskies.endpoint import Endpoint
-from clearskies.functional import routing, string
-from clearskies.input_outputs import InputOutput
+
+if TYPE_CHECKING:
+    from clearskies.input_outputs import InputOutput
 
 
 class HealthCheck(Endpoint):
@@ -80,7 +78,7 @@ class HealthCheck(Endpoint):
     If any exceptions are raised when building the dependency injection parameters, the health check will return
     failure.
     """
-    dependency_injection_names = clearskies.configs.StringList(default=[])
+    dependency_injection_names = configs.StringList(default=[])
 
     """
     A list of classes to build with the dependency injection system.
@@ -104,7 +102,7 @@ class HealthCheck(Endpoint):
     wsgi()
     ```
     """
-    classes_to_build = clearskies.configs.Any(default=[])
+    classes_to_build = configs.Any(default=[])
 
     """
     A list of callables to invoke.
@@ -128,9 +126,9 @@ class HealthCheck(Endpoint):
     wsgi()
     ```
     """
-    callables = clearskies.configs.Any(default=[])
+    callables = configs.Any(default=[])
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         dependency_injection_names: list[str] = [],

clearskies/endpoints/list.py

@@ -1,20 +1,14 @@
 from __future__ import annotations
 
-import inspect
-from collections import OrderedDict
 from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.configs
-import clearskies.exceptions
-from clearskies import authentication, autodoc, typing
+from clearskies import authentication, autodoc, configs, decorators, exceptions
 from clearskies.endpoint import Endpoint
 from clearskies.functional import string
-from clearskies.input_outputs import InputOutput
 
 if TYPE_CHECKING:
-    from clearskies import Schema, SecurityHeader
-    from clearskies.column import Column
-    from clearskies.model import Model
+    from clearskies import Column, Model, Schema, SecurityHeader, typing
+    from clearskies.input_outputs import InputOutput
 
 
 class List(Endpoint):
@@ -35,6 +29,7 @@ class List(Endpoint):
     ```python
     import clearskies
 
+
     class User(clearskies.Model):
         id_column_name = "id"
         backend = clearskies.backends.MemoryBackend()
@@ -154,35 +149,33 @@ class List(Endpoint):
     """
     The default column to sort by.
     """
-    default_sort_column_name = clearskies.configs.ModelColumn("model_class")
+    default_sort_column_name = configs.ModelColumn("model_class")
 
     """
     The default sort direction (ASC or DESC).
     """
-    default_sort_direction = clearskies.configs.Select(["ASC", "DESC"], default="ASC")
+    default_sort_direction = configs.Select(["ASC", "DESC"], default="ASC")
 
     """
     The number of records returned if the client doesn't specify a different number of records (default: 50).
     """
-    default_limit = clearskies.configs.Integer(default=50)
+    default_limit = configs.Integer(default=50)
 
     """
     The maximum number of records the client is allowed to request (0 == no limit)
     """
-    maximum_limit = clearskies.configs.Integer(default=200)
+    maximum_limit = configs.Integer(default=200)
 
     """
     A column to group by.
     """
-    group_by_column_name = clearskies.configs.ModelColumn("model_class")
+    group_by_column_name = configs.ModelColumn("model_class")
 
-    readable_column_names = clearskies.configs.ReadableModelColumns("model_class")
-    sortable_column_names = clearskies.configs.ReadableModelColumns("model_class", allow_relationship_references=True)
-    searchable_column_names = clearskies.configs.SearchableModelColumns(
-        "model_class", allow_relationship_references=True
-    )
+    readable_column_names = configs.ReadableModelColumns("model_class")
+    sortable_column_names = configs.ReadableModelColumns("model_class", allow_relationship_references=True)
+    searchable_column_names = configs.SearchableModelColumns("model_class", allow_relationship_references=True)
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         model_class: type[Model],
@@ -236,16 +229,16 @@ class List(Endpoint):
     def handle(self, input_output: InputOutput):
         model = self.fetch_model_with_base_query(input_output)
         if not input_output.request_data and input_output.has_body():
-            raise clearskies.exceptions.ClientError("Request body was not valid JSON")
+            raise exceptions.ClientError("Request body was not valid JSON")
         if input_output.request_data and not isinstance(input_output.request_data, dict):
-            raise clearskies.exceptions.ClientError("When present, request body must be a JSON dictionary")
+            raise exceptions.ClientError("When present, request body must be a JSON dictionary")
         request_data = self.map_input_to_internal_names(input_output.request_data)  # type: ignore
         query_parameters = self.map_input_to_internal_names(input_output.query_parameters)
         pagination_data = {}
         for key in model.allowed_pagination_keys():
             if key in request_data and key in query_parameters:
                 original_name = self.auto_case_internal_column_name(key)
-                raise clearskies.exceptions.ClientError(
+                raise exceptions.ClientError(
                     f"Ambiguous request: key '{original_name}' is present in both the JSON body and URL data"
                 )
             if key in request_data:
@@ -340,49 +333,49 @@ class List(Endpoint):
         if pagination_data:
             error = self.model.validate_pagination_data(pagination_data, self.auto_case_internal_column_name)
             if error:
-                raise clearskies.exceptions.ClientError(error)
+                raise exceptions.ClientError(error)
         for key in request_data.keys():
             if key not in self.allowed_request_keys:
-                raise clearskies.exceptions.ClientError(f"Invalid request parameter found in request body: '{key}'")
+                raise exceptions.ClientError(f"Invalid request parameter found in request body: '{key}'")
         for key in query_parameters.keys():
             if key not in self.allowed_request_keys:
-                raise clearskies.exceptions.ClientError(f"Invalid request parameter found in URL data: '{key}'")
+                raise exceptions.ClientError(f"Invalid request parameter found in URL data: '{key}'")
             if key in request_data:
-                raise clearskies.exceptions.ClientError(
+                raise exceptions.ClientError(
                     f"Ambiguous request: '{key}' was found in both the request body and URL data"
                 )
         self.validate_limit(request_data, query_parameters)
         sort = self.from_either(request_data, query_parameters, "sort")
         direction = self.from_either(request_data, query_parameters, "direction")
         if sort and type(sort) != str:
-            raise clearskies.exceptions.ClientError("Invalid request: 'sort' should be a string")
+            raise exceptions.ClientError("Invalid request: 'sort' should be a string")
         if direction and type(direction) != str:
-            raise clearskies.exceptions.ClientError("Invalid request: 'direction' should be a string")
+            raise exceptions.ClientError("Invalid request: 'direction' should be a string")
         if sort or direction:
             if (sort and not direction) or (direction and not sort):
-                raise clearskies.exceptions.ClientError(
+                raise exceptions.ClientError(
                     "You must specify 'sort' and 'direction' together in the request - not just one of them"
                 )
             if sort not in self.sortable_column_names:
-                raise clearskies.exceptions.ClientError(f"Invalid request: invalid sort column")
+                raise exceptions.ClientError(f"Invalid request: invalid sort column")
             if direction.lower() not in ["asc", "desc"]:
-                raise clearskies.exceptions.ClientError("Invalid request: direction must be 'asc' or 'desc'")
+                raise exceptions.ClientError("Invalid request: direction must be 'asc' or 'desc'")
         self.check_search_in_request_data(request_data, query_parameters)
 
     def validate_limit(self, request_data: dict[str, Any], query_parameters: dict[str, Any]) -> None:
         limit = self.from_either(request_data, query_parameters, "limit")
         if limit is not None and type(limit) != int and type(limit) != float and type(limit) != str:
-            raise clearskies.exceptions.ClientError("Invalid request: 'limit' should be an integer")
+            raise exceptions.ClientError("Invalid request: 'limit' should be an integer")
         if limit:
             try:
                 limit = int(limit)
             except ValueError:
-                raise clearskies.exceptions.ClientError("Invalid request: 'limit' should be an integer")
+                raise exceptions.ClientError("Invalid request: 'limit' should be an integer")
         if limit:
             if limit > self.maximum_limit:
-                raise clearskies.exceptions.ClientError(f"Invalid request: 'limit' must be at most {self.max_limit}")
+                raise exceptions.ClientError(f"Invalid request: 'limit' must be at most {self.maximum_limit}")
             if limit < 0:
-                raise clearskies.exceptions.ClientError(f"Invalid request: 'limit' must be positive")
+                raise exceptions.ClientError(f"Invalid request: 'limit' must be positive")
 
     def check_search_in_request_data(self, request_data: dict[str, Any], query_parameters: dict[str, Any]):
         return None