clear-skies 2.0.6__py3-none-any.whl → 2.0.8__py3-none-any.whl

clearskies/end.py

@@ -1,17 +1,22 @@
-# type: ignore
 from __future__ import annotations
 
 from abc import ABC
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
-    from clearskies.input_output import InputOutput
+    from clearskies import typing
+    from clearskies.input_outputs import InputOutput
 
-from clearskies import exceptions
+from clearskies import configs, configurable, di, exceptions
+from clearskies.authentication import Authorization, Public
 from clearskies.functional import string
 
 
-class End(ABC):
+class End(
+    ABC,
+    configurable.Configurable,
+    di.InjectableProperties,
+):
     """
     DRY for endpoint and endpoint groups.
 
@@ -20,6 +25,24 @@ class End(ABC):
     from the other.
     """
 
+    di = di.inject.Di()
+
+    url = configs.String(required=False, default="")
+
+    authentication = configs.Authentication(default=None)
+
+    authorization = configs.Authorization(default=None)
+
+    internal_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    external_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    response_headers = configs.StringListOrCallable(default=[])
+    authentication = configs.Authentication(default=Public())
+    authorization = configs.Authorization(default=Authorization())
+    security_headers = configs.SecurityHeaders(default=[])
+
+    cors_header: SecurityHeader = None  # type: ignore
+    has_cors: bool = False
+
     def add_url_prefix(self, prefix: str) -> None:
         self.url = (prefix.rstrip("/") + "/" + self.url.lstrip("/")).lstrip("/")
 
@@ -41,7 +64,7 @@ class End(ABC):
                 if not self.authorization.gate(input_output.authorization_data, input_output):
                     raise exceptions.Authorization("Not Authorized")
             except exceptions.ClientError as client_error:
-                raise exception.Authorization(str(client_error))
+                raise exceptions.Authorization(str(client_error))
 
     def __call__(self, input_output: InputOutput) -> Any:
         """
@@ -116,7 +139,7 @@ class End(ABC):
             for index, response_header in enumerate(response_headers):
                 if not isinstance(response_header, str):
                     raise TypeError(
-                        f"Invalid response header in entry #{index + 1}: the header should be a string, but I was given a type of '{header.__class__.__name__}' instead."
+                        f"Invalid response header in entry #{index + 1}: the header should be a string, but I was given a type of '{response_header.__class__.__name__}' instead."
                     )
                 parts = response_header.split(":", 1)
                 if len(parts) != 2:
@@ -127,7 +150,7 @@ class End(ABC):
         for security_header in self.security_headers:
             security_header.set_headers_for_input_output(input_output)
 
-    def respond(self, input_output: InputOutput, response: clearskies.typing.response, status_code: int) -> Any:
+    def respond(self, input_output: InputOutput, response: typing.response, status_code: int) -> Any:
         self.add_response_headers(input_output)
         return input_output.respond(response, status_code)
 
@@ -181,3 +204,18 @@ class End(ABC):
             self.external_casing,
             self.internal_casing,
         )
+
+    def error(self, input_output: InputOutput, message: str, status_code: int) -> Any:
+        """Return a client-side error (e.g. 400)."""
+        return self.respond_json(input_output, {"status": "client_error", "error": message}, status_code)
+
+    def input_errors(self, input_output: InputOutput, errors: dict[str, str], status_code: int = 200) -> Any:
+        """Return input errors to the client."""
+        return self.respond_json(input_output, {"status": "input_errors", "input_errors": errors}, status_code)
+
+    def redirect(self, input_output: InputOutput, location: str, status_code: int) -> Any:
+        """Return a redirect response (e.g. 302)."""
+        return self.respond_json(input_output, {"status": "redirect", "location": location}, status_code)
+
+    def handle(self, input_output: InputOutput) -> Any:
+        raise NotImplementedError()

clearskies/endpoint.py

@@ -3,16 +3,9 @@ from __future__ import annotations
 import inspect
 import urllib.parse
 from collections import OrderedDict
-from typing import TYPE_CHECKING, Any, Callable
-
-import clearskies.column
-import clearskies.configs
-import clearskies.configurable
-import clearskies.decorators
-import clearskies.di
-import clearskies.end
-import clearskies.typing
-from clearskies import autodoc, exceptions
+from typing import TYPE_CHECKING, Any, Callable, Optional
+
+from clearskies import autodoc, column, configs, configurable, decorators, di, end, exceptions
 from clearskies.authentication import Authentication, Authorization, Public
 from clearskies.autodoc import schema
 from clearskies.autodoc.request import Parameter, Request
@@ -27,12 +20,12 @@ if TYPE_CHECKING:
 
 
 class Endpoint(
-    clearskies.end.End,  # type: ignore
-    clearskies.configurable.Configurable,
-    clearskies.di.InjectableProperties,
+    end.End,  # type: ignore
+    configurable.Configurable,
+    di.InjectableProperties,
 ):
     """
-    Automating drudgery!
+    Automating drudgery.
 
     With clearskies, endpoints exist to offload some drudgery and make your life easier, but they can also
     get out of your way when you don't need them.  Think of them as pre-built endpoints that can execute
@@ -47,7 +40,7 @@ class Endpoint(
     """
     The dependency injection container
     """
-    di = clearskies.di.inject.Di()
+    di = di.inject.Di()
 
     """
     Whether or not this endpoint can handle CORS
@@ -57,7 +50,7 @@ class Endpoint(
     """
     The actual CORS header
     """
-    cors_header: Cors | None = None
+    cors_header: Optional[Cors] = None
 
     """
     Set some response headers that should be returned for this endpoint.
@@ -82,7 +75,7 @@ class Endpoint(
     wsgi()
     ```
     """
-    response_headers = clearskies.configs.StringListOrCallable(default=[])
+    response_headers = configs.StringListOrCallable(default=[])
 
     """
     Set the URL for the endpoint
@@ -161,7 +154,7 @@ class Endpoint(
     ```
 
     """
-    url = clearskies.configs.Url(default="")
+    url = configs.Url(default="")
 
     """
     The allowed request methods for this endpoint.
@@ -204,7 +197,7 @@ class Endpoint(
     }
     ```
     """
-    request_methods = clearskies.configs.SelectList(
+    request_methods = configs.SelectList(
         allowed_values=["GET", "POST", "PUT", "DELETE", "PATCH", "QUERY"], default=["GET"]
     )
 
@@ -214,7 +207,7 @@ class Endpoint(
     Use this to attach an instance of `clearskies.authentication.Authentication` to an endpoint, which enforces authentication.
     For more details, see the dedicated documentation section on authentication and authorization. By default, all endpoints are public.
     """
-    authentication = clearskies.configs.Authentication(default=Public())
+    authentication = configs.Authentication(default=Public())
 
     """
     The authorization rules for this endpoint
@@ -222,7 +215,7 @@ class Endpoint(
     Use this to attach an instance of `clearskies.authentication.Authorization` to an endpoint, which enforces authorization.
     For more details, see the dedicated documentation section on authentication and authorization. By default, no authorization is enforced.
     """
-    authorization = clearskies.configs.Authorization(default=Authorization())
+    authorization = configs.Authorization(default=Authorization())
 
     """
     An override of the default model-to-json mapping for endpoints that auto-convert models to json.
@@ -329,7 +322,7 @@ class Endpoint(
     ```
 
     """
-    output_map = clearskies.configs.Callable(default=None)
+    output_map = configs.Callable(default=None)
 
     """
     A schema that describes the expected output to the client.
@@ -338,14 +331,14 @@ class Endpoint(
     Note that this is typically not required - when returning models and relying on clearskies to auto-convert to JSON,
     it will also automatically generate your documentation.
     """
-    output_schema = clearskies.configs.Schema(default=None)
+    output_schema = configs.Schema(default=None)
 
     """
     The model class used by this endpoint.
 
     The endpoint will use this to fetch/save/validate incoming data as needed.
     """
-    model_class = clearskies.configs.ModelClass(default=None)
+    model_class = configs.ModelClass(default=None)
 
     """
     Columns from the model class that should be returned to the client.
@@ -421,7 +414,7 @@ class Endpoint(
 
     ```
     """
-    readable_column_names = clearskies.configs.ReadableModelColumns("model_class", default=[])
+    readable_column_names = configs.ReadableModelColumns("model_class", default=[])
 
     """
     Specifies which columns from a model class can be set by the client.
@@ -486,14 +479,14 @@ class Endpoint(
     ```
 
     """
-    writeable_column_names = clearskies.configs.WriteableModelColumns("model_class", default=[])
+    writeable_column_names = configs.WriteableModelColumns("model_class", default=[])
 
     """
     Columns from the model class that can be searched by the client.
 
     Sets which columns the client is allowed to search (for endpoints that support searching).
     """
-    searchable_column_names = clearskies.configs.SearchableModelColumns("model_class", default=[])
+    searchable_column_names = configs.SearchableModelColumns("model_class", default=[])
 
     """
     A function to call to add custom input validation logic.
@@ -557,7 +550,7 @@ class Endpoint(
     ```
 
     """
-    input_validation_callable = clearskies.configs.Callable(default=None)
+    input_validation_callable = configs.Callable(default=None)
 
     """
     A dictionary with columns that should override columns in the model.
@@ -579,7 +572,7 @@ class Endpoint(
     )
     ```
     """
-    column_overrides = clearskies.configs.Columns(default={})
+    column_overrides = configs.Columns(default={})
 
     """
     Used in conjunction with external_casing to change the casing of the key names in the outputted JSON of the endpoint.
@@ -638,14 +631,14 @@ class Endpoint(
     }
     ```
     """
-    internal_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    internal_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
 
     """
     Used in conjunction with internal_casing to change the casing of the key names in the outputted JSON of the endpoint.
 
     See the docs for `internal_casing` for more details and usage examples.
     """
-    external_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    external_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
 
     """
     Configure standard security headers to be sent along in the response from this endpoint.
@@ -689,19 +682,19 @@ class Endpoint(
     ```
 
     """
-    security_headers = clearskies.configs.SecurityHeaders(default=[])
+    security_headers = configs.SecurityHeaders(default=[])
 
     """
     A description for this endpoint.  This is added to any auto-documentation
     """
-    description = clearskies.configs.String(default="")
+    description = configs.String(default="")
 
     """
     Whether or not the routing data should also be persisted to the model.  Defaults to False.
 
     Note: this is only relevant for handlers that accept request data
     """
-    include_routing_data_in_request_data = clearskies.configs.Boolean(default=False)
+    include_routing_data_in_request_data = configs.Boolean(default=False)
 
     """
     Additional conditions to always add to the results.
@@ -783,7 +776,7 @@ class Endpoint(
     and note that neither Greg nor Ann are returned.  Ann because she doesn't make the grade criteria, and Greg because
     he won't graduate.
     """
-    where = clearskies.configs.Conditions(default=[])
+    where = configs.Conditions(default=[])
 
     """
     Additional joins to always add to the query.
@@ -868,18 +861,18 @@ class Endpoint(
     e.g., the inner join reomves all the students that don't have an entry in the PastRecord model.
 
     """
-    joins = clearskies.configs.Joins(default=[])
+    joins = configs.Joins(default=[])
 
     cors_header: Cors = None  # type: ignore
-    _model: clearskies.model.Model = None  # type: ignore
-    _columns: dict[str, clearskies.column.Column] = None  # type: ignore
-    _readable_columns: dict[str, clearskies.column.Column] = None  # type: ignore
-    _writeable_columns: dict[str, clearskies.column.Column] = None  # type: ignore
-    _searchable_columns: dict[str, clearskies.column.Column] = None  # type: ignore
-    _sortable_columns: dict[str, clearskies.column.Column] = None  # type: ignore
-    _as_json_map: dict[str, clearskies.column.Column] = None  # type: ignore
-
-    @clearskies.decorators.parameters_to_properties
+    _model: Model = None  # type: ignore
+    _columns: dict[str, column.Column] = None  # type: ignore
+    _readable_columns: dict[str, column.Column] = None  # type: ignore
+    _writeable_columns: dict[str, column.Column] = None  # type: ignore
+    _searchable_columns: dict[str, column.Column] = None  # type: ignore
+    _sortable_columns: dict[str, column.Column] = None  # type: ignore
+    _as_json_map: dict[str, column.Column] = None  # type: ignore
+
+    @decorators.parameters_to_properties
     def __init__(
         self,
         url: str = "",
@@ -972,9 +965,6 @@ class Endpoint(
         )
         return self.authorization.filter_model(model, input_output.authorization_data, input_output)
 
-    def handle(self, input_output: InputOutput) -> Any:
-        raise NotImplementedError()
-
     def matches_request(self, input_output: InputOutput, allow_partial=False) -> bool:
         """Whether or not we can handle an incoming request based on URL and request method."""
         # soo..... this excessively duplicates the logic in __call__, but I'm being lazy right now
@@ -1012,20 +1002,14 @@ class Endpoint(
     def failure(self, input_output: InputOutput) -> Any:
         return self.respond_json(input_output, {"status": "failure"}, 500)
 
-    def input_errors(self, input_output: InputOutput, errors: dict[str, str], status_code: int = 200) -> Any:
-        """Return input errors to the client."""
-        return self.respond_json(input_output, {"status": "input_errors", "input_errors": errors}, status_code)
-
-    def error(self, input_output: InputOutput, message: str, status_code: int) -> Any:
-        """Return a client-side error (e.g. 400)."""
-        return self.respond_json(input_output, {"status": "client_error", "error": message}, status_code)
-
     def redirect(self, input_output: InputOutput, location: str, status_code: int) -> Any:
         """Return a redirect."""
         input_output.response_headers.add("content-type", "text/html")
         input_output.response_headers.add("location", location)
         return self.respond(
-            '<meta http-equiv="refresh" content="0; url=' + urllib.parse.quote(location) + '">Redirecting', status_code
+            input_output,
+            '<meta http-equiv="refresh" content="0; url=' + urllib.parse.quote(location) + '">Redirecting',
+            status_code,
         )
 
     def success(
@@ -1053,7 +1037,7 @@ class Endpoint(
 
         return self.respond_json(input_output, response_data, 200)
 
-    def model_as_json(self, model: clearskies.model.Model, input_output: InputOutput) -> dict[str, Any]:
+    def model_as_json(self, model: Model, input_output: InputOutput) -> dict[str, Any]:
         if self.output_map:
             return self.di.call_function(self.output_map, model=model, **input_output.get_context_for_callables())
 
@@ -1070,7 +1054,7 @@ class Endpoint(
                     json[self.auto_case_column_name(key, True)] = value
         return json
 
-    def _build_as_json_map(self, model: clearskies.model.Model) -> dict[str, clearskies.column.Column]:
+    def _build_as_json_map(self, model: Model) -> dict[str, column.Column]:
         conversion_map = {}
         if not self.readable_column_names:
             raise ValueError(

clearskies/endpoint_group.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Callable, Self
 
-import clearskies.configurable
-import clearskies.di
-import clearskies.end
-from clearskies import exceptions
+from clearskies import configs, configurable, decorators, di, end
 from clearskies.authentication import Authentication, Authorization, Public
 from clearskies.endpoint import Endpoint
 from clearskies.functional import routing
@@ -16,9 +13,9 @@ if TYPE_CHECKING:
 
 
 class EndpointGroup(
-    clearskies.end.End,  # type: ignore
-    clearskies.configurable.Configurable,
-    clearskies.di.InjectableProperties,
+    end.End,  # type: ignore
+    configurable.Configurable,
+    di.InjectableProperties,
 ):
     """
     An endpoint group brings endpoints together: it basically handles routing.
@@ -216,32 +213,32 @@ class EndpointGroup(
     """
     The dependency injection container
     """
-    di = clearskies.di.inject.Di()
+    di = di.inject.Di()
 
     """
     The base URL for the endpoint group.
 
     This URL is added as a prefix to all endpoints attached to the group.  This includes any named URL parameters:
     """
-    url = clearskies.configs.String(default="")
+    url = configs.String(default="")
 
     """
     The list of endpoints connected to this endpoint group
     """
-    endpoints = clearskies.configs.EndpointList()
+    endpoints = configs.EndpointList()
 
-    internal_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
-    external_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
-    response_headers = clearskies.configs.StringListOrCallable(default=[])
-    authentication = clearskies.configs.Authentication(default=Public())
-    authorization = clearskies.configs.Authorization(default=Authorization())
-    security_headers = clearskies.configs.SecurityHeaders(default=[])
+    internal_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    external_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    response_headers = configs.StringListOrCallable(default=[])
+    authentication = configs.Authentication(default=Public())
+    authorization = configs.Authorization(default=Authorization())
+    security_headers = configs.SecurityHeaders(default=[])
 
     cors_header: SecurityHeader = None  # type: ignore
     has_cors: bool = False
     endpoints_initialized = False
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         endpoints: list[Endpoint | Self],
@@ -325,7 +322,7 @@ class EndpointGroup(
         return self.respond_json(input_output, {"status": "client_error", "error": message}, status_code)
 
     def all_endpoints(self) -> list[Endpoint]:
-        """Returns the full (recursive) list of all endpoints associated with this endpoint group"""
+        """Return the full (recursive) list of all endpoints associated with this endpoint group."""
         all_endpoints: list[Endpoint] = []
         for endpoint in self.endpoints:
             if hasattr(endpoint, "all_endpoints"):

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: