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

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

clearskies/endpoints/restful_api.py

@@ -1,27 +1,19 @@
 from __future__ import annotations
 
 import inspect
-from collections import OrderedDict
 from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.configs
-import clearskies.decorators
-import clearskies.exceptions
-from clearskies import authentication, autodoc, typing
+from clearskies import configs, decorators
 from clearskies.authentication import Authentication, Authorization, Public
-from clearskies.endpoint import Endpoint
 from clearskies.endpoint_group import EndpointGroup
 from clearskies.endpoints.create import Create
 from clearskies.endpoints.delete import Delete
 from clearskies.endpoints.get import Get
 from clearskies.endpoints.simple_search import SimpleSearch
 from clearskies.endpoints.update import Update
-from clearskies.functional import string
-from clearskies.input_outputs import InputOutput
 
 if TYPE_CHECKING:
-    from clearskies import SecurityHeader
-    from clearskies.model import Column, Model, Schema
+    from clearskies import Column, Endpoint, Model, Schema, SecurityHeader
 
 
 class RestfulApi(EndpointGroup):
@@ -190,7 +182,7 @@ class RestfulApi(EndpointGroup):
     This defaults to `clearskies.endpoints.Create`.  To disable the create operation all together,
     set this to None.
     """
-    create_endpoint = clearskies.configs.Endpoint(default=Create)
+    create_endpoint = configs.Endpoint(default=Create)
 
     """
     The endpoint class to use for managing the delete operation.
@@ -198,7 +190,7 @@ class RestfulApi(EndpointGroup):
     This defaults to `clearskies.endpoints.Delete`.  To disable the delete operation all together,
     set this to None.
     """
-    delete_endpoint = clearskies.configs.Endpoint(default=Delete)
+    delete_endpoint = configs.Endpoint(default=Delete)
 
     """
     The endpoint class to use for managing the update operation.
@@ -206,7 +198,7 @@ class RestfulApi(EndpointGroup):
     This defaults to `clearskies.endpoints.Update`.  To disable the update operation all together,
     set this to None.
     """
-    update_endpoint = clearskies.configs.Endpoint(default=Update)
+    update_endpoint = configs.Endpoint(default=Update)
 
     """
     The endpoint class to use to fetch individual records.
@@ -214,7 +206,7 @@ class RestfulApi(EndpointGroup):
     This defaults to `clearskies.endpoints.Get`.  To disable the get operation all together,
     set this to None.
     """
-    get_endpoint = clearskies.configs.Endpoint(default=Get)
+    get_endpoint = configs.Endpoint(default=Get)
 
     """
     The endpoint class to use to list records.
@@ -222,78 +214,76 @@ class RestfulApi(EndpointGroup):
     This defaults to `clearskies.endpoints.SimpleSearch`.  To disable the list operation all together,
     set this to None.
     """
-    list_endpoint = clearskies.configs.Endpoint(default=SimpleSearch)
+    list_endpoint = configs.Endpoint(default=SimpleSearch)
 
     """
     The request method(s) to use to route to the create operation.  Default is ["POST"].
     """
-    create_request_methods = clearskies.configs.SelectList(
+    create_request_methods = configs.SelectList(
         allowed_values=["GET", "POST", "PUT", "DELETE", "PATCH"], default=["POST"]
     )
 
     """
     The request method(s) to use to route to the update operation.  Default is ["PATCH"].
     """
-    update_request_methods = clearskies.configs.SelectList(
+    update_request_methods = configs.SelectList(
         allowed_values=["GET", "POST", "PUT", "DELETE", "PATCH"], default=["PATCH"]
     )
 
     """
     The request method(s) to use to route to the delete operation.  Default is ["DELETE"].
     """
-    delete_request_methods = clearskies.configs.SelectList(
+    delete_request_methods = configs.SelectList(
         allowed_values=["GET", "POST", "PUT", "DELETE", "PATCH"], default=["DELETE"]
     )
 
     """
     The request method(s) to use to route to the get operation.  Default is ["GET"].
     """
-    get_request_methods = clearskies.configs.SelectList(
-        allowed_values=["GET", "POST", "PUT", "DELETE", "PATCH"], default=["GET"]
-    )
+    get_request_methods = configs.SelectList(allowed_values=["GET", "POST", "PUT", "DELETE", "PATCH"], default=["GET"])
 
     """
     The request method(s) to use to route to the create operation.  Default is ["GET"].
     """
-    list_request_methods = clearskies.configs.SelectList(
+    list_request_methods = configs.SelectList(
         allowed_values=["GET", "POST", "PUT", "DELETE", "PATCH", "QUERY"], default=["GET", "POST", "QUERY"]
     )
 
     """
     The request method(s) to use to route to the create operation.  Default is ["POST"].
     """
-    id_column_name = clearskies.configs.ModelColumn("model_class", default=None)
+    id_column_name = configs.ModelColumn("model_class", default=None)
 
     """
     The base URL to be used for all the endpoints.
     """
-    url = clearskies.configs.String(default="")
-
-    authentication = clearskies.configs.Authentication(default=Public())
-    authorization = clearskies.configs.Authorization(default=Authorization())
-    output_map = clearskies.configs.Callable(default=None)
-    output_schema = clearskies.configs.Schema(default=None)
-    model_class = clearskies.configs.ModelClass(default=None)
-    readable_column_names = clearskies.configs.ReadableModelColumns("model_class", default=[])
-    writeable_column_names = clearskies.configs.WriteableModelColumns("model_class", default=[])
-    searchable_column_names = clearskies.configs.SearchableModelColumns("model_class", default=[])
-    sortable_column_names = clearskies.configs.ReadableModelColumns("model_class", default=[])
-    default_sort_column_name = clearskies.configs.ModelColumn("model_class", required=True)
-    default_sort_direction = clearskies.configs.Select(["ASC", "DESC"], default="ASC")
-    default_limit = clearskies.configs.Integer(default=50)
-    maximum_limit = clearskies.configs.Integer(default=200)
-    group_by_column_name = clearskies.configs.ModelColumn("model_class")
-    input_validation_callable = clearskies.configs.Callable(default=None)
-    include_routing_data_in_request_data = clearskies.configs.Boolean(default=False)
-    column_overrides = clearskies.configs.Columns(default={})
-    internal_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
-    external_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
-    security_headers = clearskies.configs.SecurityHeaders(default=[])
-    description = clearskies.configs.String(default="")
-    where = clearskies.configs.Conditions(default=[])
+    url = configs.String(default="")
+
+    authentication = configs.Authentication(default=Public())
+    authorization = configs.Authorization(default=Authorization())
+    output_map = configs.Callable(default=None)
+    output_schema = configs.Schema(default=None)
+    model_class = configs.ModelClass(default=None)
+    readable_column_names = configs.ReadableModelColumns("model_class", default=[])
+    writeable_column_names = configs.WriteableModelColumns("model_class", default=[])
+    searchable_column_names = configs.SearchableModelColumns("model_class", default=[])
+    sortable_column_names = configs.ReadableModelColumns("model_class", default=[])
+    default_sort_column_name = configs.ModelColumn("model_class", required=True)
+    default_sort_direction = configs.Select(["ASC", "DESC"], default="ASC")
+    default_limit = configs.Integer(default=50)
+    maximum_limit = configs.Integer(default=200)
+    group_by_column_name = configs.ModelColumn("model_class")
+    input_validation_callable = configs.Callable(default=None)
+    include_routing_data_in_request_data = configs.Boolean(default=False)
+    column_overrides = configs.Columns(default={})
+    internal_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    external_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    security_headers = configs.SecurityHeaders(default=[])
+    description = configs.String(default="")
+    where = configs.Conditions(default=[])
     _descriptor_config_map = None
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         model_class: type[Model],
@@ -303,11 +293,11 @@ class RestfulApi(EndpointGroup):
         sortable_column_names: list[str],
         default_sort_column_name: str,
         read_only: bool = False,
-        create_endpoint: Endpoint | None = Create,
-        delete_endpoint: Endpoint | None = Delete,
-        update_endpoint: Endpoint | None = Update,
-        get_endpoint: Endpoint | None = Get,
-        list_endpoint: Endpoint | None = SimpleSearch,
+        create_endpoint: type[Endpoint] | None = Create,
+        delete_endpoint: type[Endpoint] | None = Delete,
+        update_endpoint: type[Endpoint] | None = Update,
+        get_endpoint: type[Endpoint] | None = Get,
+        list_endpoint: type[Endpoint] | None = SimpleSearch,
         create_request_methods: list[str] = ["POST"],
         update_request_methods: list[str] = ["PATCH"],
         delete_request_methods: list[str] = ["DELETE"],

clearskies/endpoints/schema.py

@@ -1,25 +1,19 @@
 from __future__ import annotations
 
-import inspect
-from collections import OrderedDict
-from typing import TYPE_CHECKING, Any, Callable, Type
-
-import clearskies.autodoc
-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 authentication, autodoc, configs, decorators
 from clearskies.endpoint import Endpoint
-from clearskies.input_outputs import InputOutput
 
 if TYPE_CHECKING:
-    from clearskies import Column, SecurityHeader
-    from clearskies.model import Model
+    from clearskies import SecurityHeader
+    from clearskies.authentication import Authentication
+    from clearskies.input_outputs import InputOutput
 
 
 class Schema(Endpoint):
     """
-    An endpoint that automatically creates a swagger doc for the application
+    An endpoint that automatically creates a swagger doc for the application.
 
     The schema endpoint must always be attached to an endpoint group.  It will document all endpoints
     attached to its parent endpoint group.
@@ -74,11 +68,12 @@ class Schema(Endpoint):
                 sortable_column_names=readable_column_names,
                 searchable_column_names=readable_column_names,
                 default_sort_column_name="name",
-            )
+            ),
         ],
         url="/users",
     )
 
+
     class SomeThing(clearskies.Model):
         id_column_name = "id"
         backend = clearskies.backends.MemoryBackend()
@@ -87,6 +82,7 @@ class Schema(Endpoint):
         thing_1 = clearskies.columns.String(validators=[Required()])
         thing_2 = clearskies.columns.String(validators=[Unique()])
 
+
     more_endpoints = clearskies.EndpointGroup(
         [
             clearskies.endpoints.HealthCheck(url="health"),
@@ -130,7 +126,7 @@ class Schema(Endpoint):
     """
     The doc builder class/format to use
     """
-    schema_format = clearskies.configs.Any(default=clearskies.autodoc.formats.oai3_json.Oai3Json)
+    schema_format = configs.Any(default=autodoc.formats.oai3_json.Oai3Json)
 
     """
     Addiional data to inject into the schema doc.
@@ -138,13 +134,13 @@ class Schema(Endpoint):
     This is typically used for setting info/server settings in the resultant swagger doc.  Anything
     in this dictionary is injected into the "root" of the generated documentation file.
     """
-    schema_configuration = clearskies.configs.AnyDict(default={})
+    schema_configuration = configs.AnyDict(default={})
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         url: str,
-        schema_format=clearskies.autodoc.formats.oai3_json.Oai3Json,
+        schema_format=autodoc.formats.oai3_json.Oai3Json,
         request_methods: list[str] = ["GET"],
         response_headers: list[str | Callable[..., list[str]]] = [],
         security_headers: list[SecurityHeader] = [],