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

clearskies/backends/api_backend.py

@@ -5,13 +5,7 @@ from typing import TYPE_CHECKING, Any, Callable
 
 import requests
 
-import clearskies.columns.datetime
-import clearskies.columns.json
-import clearskies.configs
-import clearskies.configurable
-import clearskies.decorators
-import clearskies.model
-import clearskies.query
+from clearskies import columns, configs, configurable, decorators
 from clearskies.autodoc.schema import Integer as AutoDocInteger
 from clearskies.autodoc.schema import Schema as AutoDocSchema
 from clearskies.autodoc.schema import String as AutoDocString
@@ -20,10 +14,12 @@ from clearskies.di import InjectableProperties, inject
 from clearskies.functional import routing, string
 
 if TYPE_CHECKING:
-    import clearskies.column
+    from clearskies import Column, Model
+    from clearskies.authentication import Authentication
+    from clearskies.query import Query
 
 
-class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProperties):
+class ApiBackend(configurable.Configurable, Backend, InjectableProperties):
     """
     Fetch and store data from an API endpoint.
 
@@ -314,14 +310,14 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
 
     Note: this is treated as a 'folder' path: if set, it becomes the URL prefix and is followed with a '/'
     """
-    base_url = clearskies.configs.String(default="")
+    base_url = configs.String(default="")
 
     """
     A suffix to append to the end of the URL.
 
     Note: this is treated as a 'folder' path: if set, it becomes the URL suffix and is prefixed with a '/'
     """
-    url_suffix = clearskies.configs.String(default="")
+    url_suffix = configs.String(default="")
 
     """
     An instance of clearskies.authentication.Authentication that handles authentication to the API.
@@ -392,12 +388,12 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
 
     ```
     """
-    authentication = clearskies.configs.Authentication(default=None)
+    authentication = configs.Authentication(default=None)
 
     """
     A dictionary of headers to attach to all outgoing API requests
     """
-    headers = clearskies.configs.StringDict(default={})
+    headers = configs.StringDict(default={})
 
     """
     The casing used in the model (snake_case, camelCase, TitleCase)
@@ -478,14 +474,14 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
     }
     ```
     """
-    model_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    model_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
 
     """
     The casing used by the API response (snake_case, camelCase, TitleCase)
 
     See model_casing for details and usage.
     """
-    api_casing = clearskies.configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
+    api_casing = configs.Select(["snake_case", "camelCase", "TitleCase"], default="snake_case")
 
     """
     A mapping from the data keys returned by the API to the data keys expected in the model
@@ -554,24 +550,24 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
     }
     ```
     """
-    api_to_model_map = clearskies.configs.StringDict(default={})
+    api_to_model_map = configs.StringDict(default={})
 
     """
     The name of the pagination parameter
     """
-    pagination_parameter_name = clearskies.configs.String(default="start")
+    pagination_parameter_name = configs.String(default="start")
 
     """
     The expected 'type' of the pagination parameter: must be either 'int' or 'str'
 
     Note: this is set as a literal string, not as a type.
     """
-    pagination_parameter_type = clearskies.configs.Select(["int", "str"], default="str")
+    pagination_parameter_type = configs.Select(["int", "str"], default="str")
 
     """
     The name of the parameter that sets the number of records per page (if empty, setting the page size will not be allowed)
     """
-    limit_parameter_name = clearskies.configs.String(default="limit")
+    limit_parameter_name = configs.String(default="limit")
 
     """
     The requests instance.
@@ -586,11 +582,11 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
     _auth_injected = False
     _response_to_model_map: dict[str, str] = None  # type: ignore
 
-    @clearskies.decorators.parameters_to_properties
+    @decorators.parameters_to_properties
     def __init__(
         self,
         base_url: str,
-        authentication: clearskies.authentication.Authentication | None = None,
+        authentication: Authentication | None = None,
         model_casing: str = "snake_case",
         api_casing: str = "snake_case",
         api_to_model_map: dict[str, str] = {},
@@ -658,7 +654,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         """
         return self.finalize_url(url, data, operation)
 
-    def finalize_url_from_query(self, query: clearskies.query.Query, operation: str) -> tuple[str, list[str]]:
+    def finalize_url_from_query(self, query: Query, operation: str) -> tuple[str, list[str]]:
         """
         Create the URL using a query to fill in any URL parameters.
 
@@ -671,7 +667,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
             available_routing_data[condition.column_name] = condition.values[0]
         return self.finalize_url(query.model_class.destination_name(), available_routing_data, operation)
 
-    def create_url(self, data: dict[str, Any], model: clearskies.model.Model) -> tuple[str, list[str]]:
+    def create_url(self, data: dict[str, Any], model: Model) -> tuple[str, list[str]]:
         """
         Calculate the URL to use for a create requst.  Also, return the list of ay data parameters used to construct the URL.
 
@@ -679,11 +675,11 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         """
         return self.finalize_url_from_data(model.destination_name(), data, "create")
 
-    def create_method(self, data: dict[str, Any], model: clearskies.model.Model) -> str:
+    def create_method(self, data: dict[str, Any], model: Model) -> str:
         """Return the request method to use with a create request."""
         return "POST"
 
-    def records_url(self, query: clearskies.query.Query) -> tuple[str, list[str]]:
+    def records_url(self, query: Query) -> tuple[str, list[str]]:
         """
         Calculate the URL to use for a records request.  Also, return the list of any query parameters used to construct the URL.
 
@@ -691,11 +687,11 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         """
         return self.finalize_url_from_query(query, "records")
 
-    def records_method(self, query: clearskies.query.Query) -> str:
+    def records_method(self, query: Query) -> str:
         """Return the request method to use when fetching records from the API."""
         return "GET"
 
-    def count_url(self, query: clearskies.query.Query) -> tuple[str, list[str]]:
+    def count_url(self, query: Query) -> tuple[str, list[str]]:
         """
         Calculate the URL to use for a request to get a record count..  Also, return the list of any query parameters used to construct the URL.
 
@@ -703,11 +699,11 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         """
         return self.records_url(query)
 
-    def count_method(self, query: clearskies.query.Query) -> str:
+    def count_method(self, query: Query) -> str:
         """Return the request method to use when making a request for a record count."""
         return self.records_method(query)
 
-    def delete_url(self, id: int | str, model: clearskies.model.Model) -> tuple[str, list[str]]:
+    def delete_url(self, id: int | str, model: Model) -> tuple[str, list[str]]:
         """
         Calculate the URL to use for a delete request.  Also, return the list of any query parameters used to construct the URL.
 
@@ -716,11 +712,11 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         model_base_url = model.destination_name().strip("/") + "/" if model.destination_name() else ""
         return self.finalize_url_from_data(f"{model_base_url}{id}", model.get_raw_data(), "delete")
 
-    def delete_method(self, id: int | str, model: clearskies.model.Model) -> str:
+    def delete_method(self, id: int | str, model: Model) -> str:
         """Return the request method to use when deleting records via the API."""
         return "DELETE"
 
-    def update_url(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> tuple[str, list[str]]:
+    def update_url(self, id: int | str, data: dict[str, Any], model: Model) -> tuple[str, list[str]]:
         """
         Calculate the URL to use for an update request.  Also, return the list of any query parameters used to construct the URL.
 
@@ -729,11 +725,11 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         model_base_url = model.destination_name().strip("/") + "/" if model.destination_name() else ""
         return self.finalize_url_from_data(f"{model_base_url}{id}", {**model.get_raw_data(), **data}, "update")
 
-    def update_method(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> str:
+    def update_method(self, id: int | str, data: dict[str, Any], model: Model) -> str:
         """Return the request method to use for an update request."""
         return "PATCH"
 
-    def update(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def update(self, id: int | str, data: dict[str, Any], model: Model) -> dict[str, Any]:
         """Update a record."""
         data = {**data}
         (url, used_routing_parameters) = self.update_url(id, data, model)
@@ -748,7 +744,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
             new_record = {**new_record, **self.map_update_response(response.json(), model)}
         return new_record
 
-    def map_update_response(self, response_data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def map_update_response(self, response_data: dict[str, Any], model: Model) -> dict[str, Any]:
         """
         Take the response from the API endpoint for an update request and figure out where the data lives/return it to build a new model.
 
@@ -756,7 +752,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         """
         return self.map_record_response(response_data, model.get_columns(), "update")
 
-    def create(self, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def create(self, data: dict[str, Any], model: Model) -> dict[str, Any]:
         """Create a record."""
         data = {**data}
         (url, used_routing_parameters) = self.create_url(data, model)
@@ -770,19 +766,17 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
             return self.map_create_response(response.json(), model)
         return {}
 
-    def map_create_response(self, response_data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def map_create_response(self, response_data: dict[str, Any], model: Model) -> dict[str, Any]:
         return self.map_record_response(response_data, model.get_columns(), "create")
 
-    def delete(self, id: int | str, model: clearskies.model.Model) -> bool:
+    def delete(self, id: int | str, model: Model) -> bool:
         (url, used_routing_parameters) = self.delete_url(id, model)
         request_method = self.delete_method(id, model)
 
         response = self.execute_request(url, request_method)
         return True
 
-    def records(
-        self, query: clearskies.query.Query, next_page_data: dict[str, str | int] | None = None
-    ) -> list[dict[str, Any]]:
+    def records(self, query: Query, next_page_data: dict[str, str | int] | None = None) -> list[dict[str, Any]]:
         self.check_query(query)
         (url, method, body, headers) = self.build_records_request(query)
         response = self.execute_request(url, method, json=body, headers=headers)
@@ -791,7 +785,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
             self.set_next_page_data_from_response(next_page_data, query, response)
         return records
 
-    def build_records_request(self, query: clearskies.query.Query) -> tuple[str, str, dict[str, Any], dict[str, str]]:
+    def build_records_request(self, query: Query) -> tuple[str, str, dict[str, Any], dict[str, str]]:
         (url, used_routing_parameters) = self.records_url(query)
 
         (condition_route_id, condition_url_parameters, condition_body_parameters) = (
@@ -825,7 +819,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         )
 
     def conditions_to_request_parameters(
-        self, query: clearskies.query.Query, used_routing_parameters: list[str]
+        self, query: Query, used_routing_parameters: list[str]
     ) -> tuple[str, dict[str, str], dict[str, Any]]:
         route_id = ""
 
@@ -844,7 +838,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
 
         return (route_id, url_parameters, {})
 
-    def pagination_to_request_parameters(self, query: clearskies.query.Query) -> tuple[dict[str, str], dict[str, Any]]:
+    def pagination_to_request_parameters(self, query: Query) -> tuple[dict[str, str], dict[str, Any]]:
         url_parameters = {}
         if query.limit:
             if not self.limit_parameter_name:
@@ -858,7 +852,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
 
         return (url_parameters, {})
 
-    def sorts_to_request_parameters(self, query: clearskies.query.Query) -> tuple[dict[str, str], dict[str, Any]]:
+    def sorts_to_request_parameters(self, query: Query) -> tuple[dict[str, str], dict[str, Any]]:
         if not query.sorts:
             return ({}, {})
 
@@ -873,7 +867,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         )
 
     def map_records_response(
-        self, response_data: Any, query: clearskies.query.Query, query_data: dict[str, Any] | None = None
+        self, response_data: Any, query: Query, query_data: dict[str, Any] | None = None
     ) -> list[dict[str, Any]]:
         """Take the response from an API endpoint that returns a list of records and find the actual list of records."""
         columns = query.model_class.get_columns()
@@ -918,7 +912,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
         )
 
     def map_record_response(
-        self, response_data: dict[str, Any], columns: dict[str, clearskies.column.Column], operation: str
+        self, response_data: dict[str, Any], columns: dict[str, Column], operation: str
     ) -> dict[str, Any]:
         """
         Take the response from an API endpoint that returns a single record (typically update and create requests) and return the data for a new model.
@@ -948,7 +942,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
     def check_dict_and_map_to_model(
         self,
         response_data: dict[str, Any],
-        columns: dict[str, clearskies.column.Column],
+        columns: dict[str, Column],
         query_data: dict[str, Any] = {},
     ) -> dict[str, Any] | None:
         """
@@ -987,7 +981,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
 
         return {**query_data, **mapped}
 
-    def build_response_to_model_map(self, columns: dict[str, clearskies.column.Column]) -> dict[str, str]:
+    def build_response_to_model_map(self, columns: dict[str, Column]) -> dict[str, str]:
         if self._response_to_model_map is not None:
             return self._response_to_model_map
 
@@ -1003,7 +997,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
     def set_next_page_data_from_response(
         self,
         next_page_data: dict[str, Any],
-        query: clearskies.query.Query,
+        query: Query,
         response: requests.Response,  # type: ignore
     ) -> None:
         """
@@ -1042,7 +1036,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
             )
         next_page_data[self.pagination_parameter_name] = query_parameters[self.pagination_parameter_name][0]
 
-    def count(self, query: clearskies.query.Query) -> int:
+    def count(self, query: Query) -> int:
         raise NotImplementedError(
             f"The {self.__class__.__name__} backend does not support count operations, so you can't use the `len` or `bool` function for any models using it."
         )
@@ -1104,7 +1098,7 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
 
         return response
 
-    def check_query(self, query: clearskies.query.Query) -> None:
+    def check_query(self, query: Query) -> None:
         for key in ["joins", "group_by", "selects"]:
             if getattr(query, key):
                 raise ValueError(f"{self.__class__.__name__} does not support queries with {key}")
@@ -1155,20 +1149,20 @@ class ApiBackend(clearskies.configurable.Configurable, Backend, InjectableProper
             )
         ]
 
-    def column_from_backend(self, column: clearskies.column.Column, value: Any) -> Any:
+    def column_from_backend(self, column: Column, value: Any) -> Any:
         """We have a couple columns we want to override transformations for."""
         # most importantly, there's no need to transform a JSON column in either direction
-        if isinstance(column, clearskies.columns.json.Json):
+        if isinstance(column, columns.json.Json):
             return value
         return super().column_from_backend(column, value)
 
-    def column_to_backend(self, column: clearskies.column.Column, backend_data: dict[str, Any]) -> dict[str, Any]:
+    def column_to_backend(self, column: Column, backend_data: dict[str, Any]) -> dict[str, Any]:
         """We have a couple columns we want to override transformations for."""
         # most importantly, there's no need to transform a JSON column in either direction
-        if isinstance(column, clearskies.columns.json.Json):
+        if isinstance(column, columns.json.Json):
             return backend_data
         # also, APIs tend to have a different format for dates than SQL
-        if isinstance(column, clearskies.columns.datetime.Datetime) and column.name in backend_data:
+        if isinstance(column, columns.datetime.Datetime) and column.name in backend_data:
             as_date = (
                 backend_data[column.name].isoformat()
                 if type(backend_data[column.name]) != str

clearskies/backends/backend.py

@@ -1,12 +1,14 @@
-import inspect
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Type
+from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.column
-import clearskies.model
-import clearskies.query
 from clearskies.autodoc.schema import Schema as AutoDocSchema
 
+if TYPE_CHECKING:
+    from clearskies import Column, Model
+    from clearskies.query import Query
+
 
 class Backend(ABC):
     """
@@ -26,29 +28,27 @@ class Backend(ABC):
     can_count = True
 
     @abstractmethod
-    def update(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def update(self, id: int | str, data: dict[str, Any], model: Model) -> dict[str, Any]:
         """Update the record with the given id with the information from the data dictionary."""
         pass
 
     @abstractmethod
-    def create(self, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def create(self, data: dict[str, Any], model: Model) -> dict[str, Any]:
         """Create a record with the information from the data dictionary."""
         pass
 
     @abstractmethod
-    def delete(self, id: int | str, model: clearskies.model.Model) -> bool:
+    def delete(self, id: int | str, model: Model) -> bool:
         """Delete the record with the given id."""
         pass
 
     @abstractmethod
-    def count(self, query: clearskies.query.Query) -> int:
+    def count(self, query: Query) -> int:
         """Return the number of records which match the given query configuration."""
         pass
 
     @abstractmethod
-    def records(
-        self, query: clearskies.query.Query, next_page_data: dict[str, str | int] | None = None
-    ) -> list[dict[str, Any]]:
+    def records(self, query: Query, next_page_data: dict[str, str | int] | None = None) -> list[dict[str, Any]]:
         """
         Return a list of records that match the given query configuration.
 
@@ -107,7 +107,7 @@ class Backend(ABC):
         """
         pass
 
-    def column_from_backend(self, column: clearskies.column.Column, value: Any) -> Any:
+    def column_from_backend(self, column: Column, value: Any) -> Any:
         """
         Manage transformations from the backend.
 
@@ -121,7 +121,7 @@ class Backend(ABC):
         """
         return column.from_backend(value)
 
-    def column_to_backend(self, column: clearskies.column.Column, backend_data: dict[str, Any]) -> dict[str, Any]:
+    def column_to_backend(self, column: Column, backend_data: dict[str, Any]) -> dict[str, Any]:
         """
         Manage transformations to the backend.
 

clearskies/backends/cursor_backend.py

@@ -1,11 +1,15 @@
-from typing import Any, Callable
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable
 
-import clearskies.model
-import clearskies.query
 from clearskies.autodoc.schema import Integer as AutoDocInteger
 from clearskies.autodoc.schema import Schema as AutoDocSchema
 from clearskies.backends.backend import Backend
 from clearskies.di import InjectableProperties, inject
+from clearskies.query import Condition, Query
+
+if TYPE_CHECKING:
+    from clearskies import Model
 
 
 class CursorBackend(Backend, InjectableProperties):
@@ -133,7 +137,7 @@ class CursorBackend(Backend, InjectableProperties):
             + self.table_escape_character
         )
 
-    def update(self, id: int | str, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def update(self, id: int | str, data: dict[str, Any], model: Model) -> dict[str, Any]:
         query_parts = []
         parameters = []
         escape = self.column_escape_character
@@ -149,13 +153,9 @@ class CursorBackend(Backend, InjectableProperties):
         )
 
         # and now query again to fetch the updated record.
-        return self.records(
-            clearskies.query.Query(
-                model.__class__, conditions=[clearskies.query.Condition(f"{model.id_column_name}={id}")]
-            )
-        )[0]
+        return self.records(Query(model.__class__, conditions=[Condition(f"{model.id_column_name}={id}")]))[0]
 
-    def create(self, data: dict[str, Any], model: clearskies.model.Model) -> dict[str, Any]:
+    def create(self, data: dict[str, Any], model: Model) -> dict[str, Any]:
         escape = self.column_escape_character
         columns = escape + f"{escape}, {escape}".join(data.keys()) + escape
         placeholders = ", ".join(["%s" for i in range(len(data))])
@@ -168,27 +168,21 @@ class CursorBackend(Backend, InjectableProperties):
         if not new_id:
             raise ValueError("I can't figure out what the id is for a newly created record :(")
 
-        return self.records(
-            clearskies.query.Query(
-                model.__class__, conditions=[clearskies.query.Condition(f"{model.id_column_name}={new_id}")]
-            )
-        )[0]
+        return self.records(Query(model.__class__, conditions=[Condition(f"{model.id_column_name}={new_id}")]))[0]
 
-    def delete(self, id: int | str, model: clearskies.model.Model) -> bool:
+    def delete(self, id: int | str, model: Model) -> bool:
         table_name = self._finalize_table_name(model.destination_name())
         self.cursor.execute(f"DELETE FROM {table_name} WHERE {model.id_column_name}=%s", (id,))
         return True
 
-    def count(self, query: clearskies.query.Query) -> int:
+    def count(self, query: Query) -> int:
         (sql, parameters) = self.as_count_sql(query)
         self.cursor.execute(sql, parameters)
         for row in self.cursor:
             return row[0] if type(row) == tuple else row["count"]
         return 0
 
-    def records(
-        self, query: clearskies.query.Query, next_page_data: dict[str, str | int] | None = None
-    ) -> list[dict[str, Any]]:
+    def records(self, query: Query, next_page_data: dict[str, str | int] | None = None) -> list[dict[str, Any]]:
         # I was going to get fancy and have this return an iterator, but since I'm going to load up
         # everything into a list anyway, I may as well just return the list, right?
         (sql, parameters) = self.as_sql(query)
@@ -201,7 +195,7 @@ class CursorBackend(Backend, InjectableProperties):
                 next_page_data["start"] = int(start) + int(limit)
         return records
 
-    def as_sql(self, query: clearskies.query.Query) -> tuple[str, tuple[Any]]:
+    def as_sql(self, query: Query) -> tuple[str, tuple[Any]]:
         escape = self.column_escape_character
         table_name = query.model_class.destination_name()
         (wheres, parameters) = self.conditions_as_wheres_and_parameters(
@@ -243,7 +237,7 @@ class CursorBackend(Backend, InjectableProperties):
             parameters,
         )
 
-    def as_count_sql(self, query: clearskies.query.Query) -> tuple[str, tuple[Any]]:
+    def as_count_sql(self, query: Query) -> tuple[str, tuple[Any]]:
         escape = self.column_escape_character
         # note that this won't work if we start including a HAVING clause
         (wheres, parameters) = self.conditions_as_wheres_and_parameters(
@@ -267,7 +261,7 @@ class CursorBackend(Backend, InjectableProperties):
         return (query_string, parameters)
 
     def conditions_as_wheres_and_parameters(
-        self, conditions: list[clearskies.query.Condition], default_table_name: str
+        self, conditions: list[Condition], default_table_name: str
     ) -> tuple[str, tuple[Any]]:
         if not conditions:
             return ("", ())  # type: ignore