sqlspec 0.24.1__py3-none-any.whl → 0.26.0__py3-none-any.whl

sqlspec/driver/_common.py

@@ -1,13 +1,15 @@
 """Common driver attributes and utilities."""
 
-from typing import TYPE_CHECKING, Any, Final, NamedTuple, Optional, Union, cast
+import re
+from contextlib import suppress
+from typing import TYPE_CHECKING, Any, Final, NamedTuple, Optional, TypeVar, Union, cast
 
 from mypy_extensions import trait
 from sqlglot import exp
 
 from sqlspec.builder import QueryBuilder
 from sqlspec.core import SQL, ParameterStyle, SQLResult, Statement, StatementConfig, TypedParameter
-from sqlspec.core.cache import get_cache_config, sql_cache
+from sqlspec.core.cache import CachedStatement, get_cache, get_cache_config
 from sqlspec.core.splitter import split_sql_script
 from sqlspec.exceptions import ImproperConfigurationError
 from sqlspec.utils.logging import get_logger
@@ -25,13 +27,158 @@ __all__ = (
     "EXEC_ROWCOUNT_OVERRIDE",
     "EXEC_SPECIAL_DATA",
     "CommonDriverAttributesMixin",
+    "DataDictionaryMixin",
     "ExecutionResult",
     "ScriptExecutionResult",
+    "VersionInfo",
 )
 
 
 logger = get_logger("driver")
 
+DriverT = TypeVar("DriverT")
+VERSION_GROUPS_MIN_FOR_MINOR = 1
+VERSION_GROUPS_MIN_FOR_PATCH = 2
+
+
+class VersionInfo:
+    """Database version information."""
+
+    def __init__(self, major: int, minor: int = 0, patch: int = 0) -> None:
+        """Initialize version info.
+
+        Args:
+            major: Major version number
+            minor: Minor version number
+            patch: Patch version number
+        """
+        self.major = major
+        self.minor = minor
+        self.patch = patch
+
+    @property
+    def version_tuple(self) -> "tuple[int, int, int]":
+        """Get version as tuple for comparison."""
+        return (self.major, self.minor, self.patch)
+
+    def __str__(self) -> str:
+        """String representation of version info."""
+        return f"{self.major}.{self.minor}.{self.patch}"
+
+    def __repr__(self) -> str:
+        """Detailed string representation."""
+        return f"VersionInfo({self.major}, {self.minor}, {self.patch})"
+
+    def __eq__(self, other: object) -> bool:
+        """Check version equality."""
+        if not isinstance(other, VersionInfo):
+            return NotImplemented
+        return self.version_tuple == other.version_tuple
+
+    def __lt__(self, other: "VersionInfo") -> bool:
+        """Check if this version is less than another."""
+        return self.version_tuple < other.version_tuple
+
+    def __le__(self, other: "VersionInfo") -> bool:
+        """Check if this version is less than or equal to another."""
+        return self.version_tuple <= other.version_tuple
+
+    def __gt__(self, other: "VersionInfo") -> bool:
+        """Check if this version is greater than another."""
+        return self.version_tuple > other.version_tuple
+
+    def __ge__(self, other: "VersionInfo") -> bool:
+        """Check if this version is greater than or equal to another."""
+        return self.version_tuple >= other.version_tuple
+
+    def __hash__(self) -> int:
+        """Make VersionInfo hashable based on version tuple."""
+        return hash(self.version_tuple)
+
+
+@trait
+class DataDictionaryMixin:
+    """Mixin providing common data dictionary functionality."""
+
+    def parse_version_string(self, version_str: str) -> "Optional[VersionInfo]":
+        """Parse version string into VersionInfo.
+
+        Args:
+            version_str: Raw version string from database
+
+        Returns:
+            VersionInfo instance or None if parsing fails
+        """
+        # Try common version patterns
+        patterns = [
+            r"(\d+)\.(\d+)\.(\d+)",  # x.y.z
+            r"(\d+)\.(\d+)",  # x.y
+            r"(\d+)",  # x
+        ]
+
+        for pattern in patterns:
+            match = re.search(pattern, version_str)
+            if match:
+                groups = match.groups()
+
+                major = int(groups[0])
+                minor = int(groups[1]) if len(groups) > VERSION_GROUPS_MIN_FOR_MINOR else 0
+                patch = int(groups[2]) if len(groups) > VERSION_GROUPS_MIN_FOR_PATCH else 0
+                return VersionInfo(major, minor, patch)
+
+        return None
+
+    def detect_version_with_queries(self, driver: Any, queries: "list[str]") -> "Optional[VersionInfo]":
+        """Try multiple version queries to detect database version.
+
+        Args:
+            driver: Database driver instance
+            queries: List of SQL queries to try
+
+        Returns:
+            Version information or None if detection fails
+        """
+        for query in queries:
+            with suppress(Exception):
+                result = driver.execute(query)
+                if result.data:
+                    version_str = str(result.data[0])
+                    if isinstance(result.data[0], dict):
+                        version_str = str(next(iter(result.data[0].values())))
+                    elif isinstance(result.data[0], (list, tuple)):
+                        version_str = str(result.data[0][0])
+
+                    parsed_version = self.parse_version_string(version_str)
+                    if parsed_version:
+                        logger.debug("Detected database version: %s", parsed_version)
+                        return parsed_version
+
+        logger.warning("Could not detect database version")
+        return None
+
+    def get_default_type_mapping(self) -> "dict[str, str]":
+        """Get default type mappings for common categories.
+
+        Returns:
+            Dictionary mapping type categories to generic SQL types
+        """
+        return {
+            "json": "TEXT",
+            "uuid": "VARCHAR(36)",
+            "boolean": "INTEGER",
+            "timestamp": "TIMESTAMP",
+            "text": "TEXT",
+            "blob": "BLOB",
+        }
+
+    def get_default_features(self) -> "list[str]":
+        """Get default feature flags supported by most databases.
+
+        Returns:
+            List of commonly supported feature names
+        """
+        return ["supports_transactions", "supports_prepared_statements"]
+
 
 class ScriptExecutionResult(NamedTuple):
     """Result from script execution with statement count information."""
@@ -206,16 +353,16 @@ class CommonDriverAttributesMixin:
             sql_statement = statement.to_statement(statement_config)
             if parameters or kwargs:
                 merged_parameters = (
-                    (*sql_statement._positional_parameters, *parameters)
+                    (*sql_statement.positional_parameters, *parameters)
                     if parameters
-                    else sql_statement._positional_parameters
+                    else sql_statement.positional_parameters
                 )
                 return SQL(sql_statement.sql, *merged_parameters, statement_config=statement_config, **kwargs)
             return sql_statement
         if isinstance(statement, SQL):
             if parameters or kwargs:
                 merged_parameters = (
-                    (*statement._positional_parameters, *parameters) if parameters else statement._positional_parameters
+                    (*statement.positional_parameters, *parameters) if parameters else statement.positional_parameters
                 )
                 return SQL(statement.sql, *merged_parameters, statement_config=statement_config, **kwargs)
             needs_rebuild = False
@@ -232,14 +379,14 @@ class CommonDriverAttributesMixin:
                 needs_rebuild = True
 
             if needs_rebuild:
-                sql_text = statement._raw_sql or statement.sql
+                sql_text = statement.raw_sql or statement.sql
 
                 if statement.is_many and statement.parameters:
                     new_sql = SQL(sql_text, statement.parameters, statement_config=statement_config, is_many=True)
-                elif statement._named_parameters:
-                    new_sql = SQL(sql_text, statement_config=statement_config, **statement._named_parameters)
+                elif statement.named_parameters:
+                    new_sql = SQL(sql_text, statement_config=statement_config, **statement.named_parameters)
                 else:
-                    new_sql = SQL(sql_text, *statement._positional_parameters, statement_config=statement_config)
+                    new_sql = SQL(sql_text, *statement.positional_parameters, statement_config=statement_config)
 
                 return new_sql
             return statement
@@ -270,7 +417,11 @@ class CommonDriverAttributesMixin:
         ]
 
     def prepare_driver_parameters(
-        self, parameters: Any, statement_config: "StatementConfig", is_many: bool = False
+        self,
+        parameters: Any,
+        statement_config: "StatementConfig",
+        is_many: bool = False,
+        prepared_statement: Optional[Any] = None,  # pyright: ignore[reportUnusedParameter]
     ) -> Any:
         """Prepare parameters for database driver consumption.
 
@@ -281,6 +432,7 @@ class CommonDriverAttributesMixin:
             parameters: Parameters in any format (dict, list, tuple, scalar, TypedParameter)
             statement_config: Statement configuration for parameter style detection
             is_many: If True, handle as executemany parameter sequence
+            prepared_statement: Optional prepared statement containing metadata for parameter processing
 
         Returns:
             Parameters with TypedParameter objects unwrapped to primitive values
@@ -413,15 +565,16 @@ class CommonDriverAttributesMixin:
         cache_key = None
         if cache_config.compiled_cache_enabled and statement_config.enable_caching:
             cache_key = self._generate_compilation_cache_key(statement, statement_config, flatten_single_parameters)
-            cached_result = sql_cache.get(cache_key)
-            if cached_result is not None:
-                return cached_result
+            cache = get_cache()
+            cached_result = cache.get("statement", cache_key, str(statement.dialect) if statement.dialect else None)
+            if cached_result is not None and isinstance(cached_result, CachedStatement):
+                return cached_result.compiled_sql, cached_result.parameters
 
         prepared_statement = self.prepare_statement(statement, statement_config=statement_config)
         compiled_sql, execution_parameters = prepared_statement.compile()
 
         prepared_parameters = self.prepare_driver_parameters(
-            execution_parameters, statement_config, is_many=statement.is_many
+            execution_parameters, statement_config, is_many=statement.is_many, prepared_statement=statement
         )
 
         if statement_config.parameter_config.output_transformer:
@@ -430,7 +583,23 @@ class CommonDriverAttributesMixin:
             )
 
         if cache_key is not None:
-            sql_cache.set(cache_key, (compiled_sql, prepared_parameters))
+            cache = get_cache()
+            cached_statement = CachedStatement(
+                compiled_sql=compiled_sql,
+                parameters=tuple(prepared_parameters)
+                if isinstance(prepared_parameters, list)
+                else (
+                    prepared_parameters
+                    if prepared_parameters is None or isinstance(prepared_parameters, dict)
+                    else (
+                        tuple(prepared_parameters)
+                        if not isinstance(prepared_parameters, tuple)
+                        else prepared_parameters
+                    )
+                ),
+                expression=statement.expression,
+            )
+            cache.put("statement", cache_key, cached_statement, str(statement.dialect) if statement.dialect else None)
 
         return compiled_sql, prepared_parameters
 
@@ -562,8 +731,8 @@ class CommonDriverAttributesMixin:
             count_expr.set("limit", None)
             count_expr.set("offset", None)
 
-            return SQL(count_expr, *original_sql._positional_parameters, statement_config=original_sql.statement_config)
+            return SQL(count_expr, *original_sql.positional_parameters, statement_config=original_sql.statement_config)
 
         subquery = cast("exp.Select", expr).subquery(alias="total_query")
         count_expr = exp.select(exp.Count(this=exp.Star())).from_(subquery)
-        return SQL(count_expr, *original_sql._positional_parameters, statement_config=original_sql.statement_config)
+        return SQL(count_expr, *original_sql.positional_parameters, statement_config=original_sql.statement_config)

sqlspec/driver/_sync.py

@@ -1,10 +1,10 @@
 """Synchronous driver protocol implementation."""
 
 from abc import abstractmethod
-from typing import TYPE_CHECKING, Any, Final, NoReturn, Optional, Union, cast, overload
+from typing import TYPE_CHECKING, Any, Final, NoReturn, Optional, TypeVar, Union, cast, overload
 
 from sqlspec.core import SQL
-from sqlspec.driver._common import CommonDriverAttributesMixin, ExecutionResult
+from sqlspec.driver._common import CommonDriverAttributesMixin, DataDictionaryMixin, ExecutionResult, VersionInfo
 from sqlspec.driver.mixins import SQLTranslatorMixin, ToSchemaMixin
 from sqlspec.exceptions import NotFoundError
 from sqlspec.utils.logging import get_logger
@@ -21,17 +21,28 @@ if TYPE_CHECKING:
 _LOGGER_NAME: Final[str] = "sqlspec"
 logger = get_logger(_LOGGER_NAME)
 
-__all__ = ("SyncDriverAdapterBase",)
+__all__ = ("SyncDataDictionaryBase", "SyncDriverAdapterBase", "SyncDriverT")
 
 
 EMPTY_FILTERS: Final["list[StatementFilter]"] = []
 
+SyncDriverT = TypeVar("SyncDriverT", bound="SyncDriverAdapterBase")
+
 
 class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToSchemaMixin):
     """Base class for synchronous database drivers."""
 
     __slots__ = ()
 
+    @property
+    @abstractmethod
+    def data_dictionary(self) -> "SyncDataDictionaryBase":
+        """Get the data dictionary for this driver.
+
+        Returns:
+            Data dictionary instance for metadata queries
+        """
+
     def dispatch_statement_execution(self, statement: "SQL", connection: "Any") -> "SQLResult":
         """Central execution dispatcher using the Template Method Pattern.
 
@@ -186,10 +197,10 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
         config = statement_config or self.statement_config
 
         if isinstance(statement, SQL):
-            sql_statement = SQL(statement._raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
+            sql_statement = SQL(statement.raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
         else:
             base_statement = self.prepare_statement(statement, filters, statement_config=config, kwargs=kwargs)
-            sql_statement = SQL(base_statement._raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
+            sql_statement = SQL(base_statement.raw_sql, parameters, statement_config=config, is_many=True, **kwargs)
 
         return self.dispatch_statement_execution(statement=sql_statement, connection=self.connection)
 
@@ -488,3 +499,95 @@ class SyncDriverAdapterBase(CommonDriverAttributesMixin, SQLTranslatorMixin, ToS
     def _raise_cannot_extract_value_from_row_type(self, type_name: str) -> NoReturn:
         msg = f"Cannot extract value from row type {type_name}"
         raise TypeError(msg)
+
+
+class SyncDataDictionaryBase(DataDictionaryMixin):
+    """Base class for synchronous data dictionary implementations."""
+
+    @abstractmethod
+    def get_version(self, driver: "SyncDriverAdapterBase") -> "Optional[VersionInfo]":
+        """Get database version information.
+
+        Args:
+            driver: Sync database driver instance
+
+        Returns:
+            Version information or None if detection fails
+        """
+
+    @abstractmethod
+    def get_feature_flag(self, driver: "SyncDriverAdapterBase", feature: str) -> bool:
+        """Check if database supports a specific feature.
+
+        Args:
+            driver: Sync database driver instance
+            feature: Feature name to check
+
+        Returns:
+            True if feature is supported, False otherwise
+        """
+
+    @abstractmethod
+    def get_optimal_type(self, driver: "SyncDriverAdapterBase", type_category: str) -> str:
+        """Get optimal database type for a category.
+
+        Args:
+            driver: Sync database driver instance
+            type_category: Type category (e.g., 'json', 'uuid', 'boolean')
+
+        Returns:
+            Database-specific type name
+        """
+
+    def get_tables(self, driver: "SyncDriverAdapterBase", schema: "Optional[str]" = None) -> "list[str]":
+        """Get list of tables in schema.
+
+        Args:
+            driver: Sync database driver instance
+            schema: Schema name (None for default)
+
+        Returns:
+            List of table names
+        """
+        _ = driver, schema
+        return []
+
+    def get_columns(
+        self, driver: "SyncDriverAdapterBase", table: str, schema: "Optional[str]" = None
+    ) -> "list[dict[str, Any]]":
+        """Get column information for a table.
+
+        Args:
+            driver: Sync database driver instance
+            table: Table name
+            schema: Schema name (None for default)
+
+        Returns:
+            List of column metadata dictionaries
+        """
+        _ = driver, table, schema
+        return []
+
+    def get_indexes(
+        self, driver: "SyncDriverAdapterBase", table: str, schema: "Optional[str]" = None
+    ) -> "list[dict[str, Any]]":
+        """Get index information for a table.
+
+        Args:
+            driver: Sync database driver instance
+            table: Table name
+            schema: Schema name (None for default)
+
+        Returns:
+            List of index metadata dictionaries
+        """
+        _ = driver, table, schema
+        return []
+
+    def list_available_features(self) -> "list[str]":
+        """List all features that can be checked via get_feature_flag.
+
+        Returns:
+            List of feature names this data dictionary supports
+        """
+        return self.get_default_features()

sqlspec/driver/mixins/_result_tools.py

@@ -15,6 +15,7 @@ from mypy_extensions import trait
 from sqlspec.exceptions import SQLSpecError
 from sqlspec.typing import (
     CATTRS_INSTALLED,
+    NUMPY_INSTALLED,
     ModelDTOT,
     ModelT,
     attrs_asdict,
@@ -41,12 +42,36 @@ logger = logging.getLogger(__name__)
 
 
 _DATETIME_TYPES: Final[set[type]] = {datetime.datetime, datetime.date, datetime.time}
+
+
+def _is_list_type_target(target_type: Any) -> bool:
+    """Check if target type is a list type (e.g., list[float])."""
+    try:
+        return hasattr(target_type, "__origin__") and target_type.__origin__ is list
+    except (AttributeError, TypeError):
+        return False
+
+
+def _convert_numpy_to_list(target_type: Any, value: Any) -> Any:
+    """Convert numpy array to list if target is a list type."""
+    if not NUMPY_INSTALLED:
+        return value
+
+    import numpy as np
+
+    if isinstance(value, np.ndarray) and _is_list_type_target(target_type):
+        return value.tolist()
+
+    return value
+
+
 _DEFAULT_TYPE_DECODERS: Final[list[tuple[Callable[[Any], bool], Callable[[Any, Any], Any]]]] = [
     (lambda x: x is UUID, lambda t, v: t(v.hex)),
     (lambda x: x is datetime.datetime, lambda t, v: t(v.isoformat())),
     (lambda x: x is datetime.date, lambda t, v: t(v.isoformat())),
     (lambda x: x is datetime.time, lambda t, v: t(v.isoformat())),
     (lambda x: x is Enum, lambda t, v: t(v.value)),
+    (_is_list_type_target, _convert_numpy_to_list),
 ]
 
 
@@ -63,6 +88,13 @@ def _default_msgspec_deserializer(
     Returns:
         Converted value or original value if conversion not applicable
     """
+    # Handle numpy arrays first for list types
+    if NUMPY_INSTALLED:
+        import numpy as np
+
+        if isinstance(value, np.ndarray) and _is_list_type_target(target_type):
+            return value.tolist()
+
     if type_decoders:
         for predicate, decoder in type_decoders:
             if predicate(target_type):
@@ -71,17 +103,19 @@ def _default_msgspec_deserializer(
     if target_type is UUID and isinstance(value, UUID):
         return value.hex
 
-    if target_type in _DATETIME_TYPES:
-        try:
-            return value.isoformat()
-        except AttributeError:
-            pass
+    if target_type in _DATETIME_TYPES and hasattr(value, "isoformat"):
+        return value.isoformat()  # pyright: ignore
 
     if isinstance(target_type, type) and issubclass(target_type, Enum) and isinstance(value, Enum):
         return value.value
 
-    if isinstance(value, target_type):
-        return value
+    # Check if value is already the correct type (but avoid parameterized generics)
+    try:
+        if isinstance(target_type, type) and isinstance(value, target_type):
+            return value
+    except TypeError:
+        # Handle parameterized generics like list[int] which can't be used with isinstance
+        pass
 
     if isinstance(target_type, type):
         try:
@@ -190,6 +224,25 @@ class ToSchemaMixin:
                     logger.debug("Field name transformation failed for msgspec schema: %s", e)
                     transformed_data = data
 
+            # Pre-process numpy arrays to lists before msgspec conversion
+            if NUMPY_INSTALLED:
+                try:
+                    import numpy as np
+
+                    def _convert_numpy_arrays_in_data(obj: Any) -> Any:
+                        """Recursively convert numpy arrays to lists in data structures."""
+                        if isinstance(obj, np.ndarray):
+                            return obj.tolist()
+                        if isinstance(obj, dict):
+                            return {k: _convert_numpy_arrays_in_data(v) for k, v in obj.items()}
+                        if isinstance(obj, (list, tuple)):
+                            return type(obj)(_convert_numpy_arrays_in_data(item) for item in obj)
+                        return obj
+
+                    transformed_data = _convert_numpy_arrays_in_data(transformed_data)
+                except ImportError:
+                    pass
+
             if not isinstance(transformed_data, Sequence):
                 return convert(obj=transformed_data, type=schema_type, from_attributes=True, dec_hook=deserializer)
             return convert(obj=transformed_data, type=list[schema_type], from_attributes=True, dec_hook=deserializer)  # type: ignore[valid-type]

sqlspec/exceptions.py

@@ -3,6 +3,7 @@ from contextlib import contextmanager
 from typing import Any, Optional, Union
 
 __all__ = (
+    "ConfigResolverError",
     "FileNotFoundInStorageError",
     "ImproperConfigurationError",
     "IntegrityError",
@@ -69,6 +70,10 @@ class BackendNotRegisteredError(SQLSpecError):
         super().__init__(f"Storage backend '{backend_key}' is not registered. Please register it before use.")
 
 
+class ConfigResolverError(SQLSpecError):
+    """Exception raised when config resolution fails."""
+
+
 class SQLParsingError(SQLSpecError):
     """Issues parsing SQL statements."""
 

sqlspec/loader.py

@@ -12,7 +12,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Final, Optional, Union
 from urllib.parse import unquote, urlparse
 
-from sqlspec.core.cache import CacheKey, get_cache_config, get_default_cache
+from sqlspec.core.cache import get_cache, get_cache_config
 from sqlspec.core.statement import SQL
 from sqlspec.exceptions import SQLFileNotFoundError, SQLFileParseError, StorageOperationFailedError
 from sqlspec.storage.registry import storage_registry as default_storage_registry
@@ -438,9 +438,8 @@ class SQLFileLoader:
             return
 
         cache_key_str = self._generate_file_cache_key(file_path)
-        cache_key = CacheKey((cache_key_str,))
-        unified_cache = get_default_cache()
-        cached_file = unified_cache.get(cache_key)
+        cache = get_cache()
+        cached_file = cache.get("file", cache_key_str)
 
         if (
             cached_file is not None
@@ -475,7 +474,7 @@ class SQLFileLoader:
                     file_statements[stored_name] = self._queries[query_name]
 
             cached_file_data = CachedSQLFile(sql_file=sql_file, parsed_statements=file_statements)
-            unified_cache.put(cache_key, cached_file_data)
+            cache.put("file", cache_key_str, cached_file_data)
 
     def _load_file_without_cache(self, file_path: Union[str, Path], namespace: Optional[str]) -> None:
         """Load a single SQL file without using cache.
@@ -592,15 +591,15 @@ class SQLFileLoader:
 
         cache_config = get_cache_config()
         if cache_config.compiled_cache_enabled:
-            unified_cache = get_default_cache()
-            unified_cache.clear()
+            cache = get_cache()
+            cache.clear()
 
     def clear_file_cache(self) -> None:
         """Clear the file cache only, keeping loaded queries."""
         cache_config = get_cache_config()
         if cache_config.compiled_cache_enabled:
-            unified_cache = get_default_cache()
-            unified_cache.clear()
+            cache = get_cache()
+            cache.clear()
 
     def get_query_text(self, name: str) -> str:
         """Get raw SQL text for a query.

sqlspec/migrations/__init__.py

@@ -4,7 +4,7 @@ A native migration system for SQLSpec that leverages the SQLFileLoader
 and driver system for database versioning.
 """
 
-from sqlspec.migrations.commands import AsyncMigrationCommands, MigrationCommands, SyncMigrationCommands
+from sqlspec.migrations.commands import AsyncMigrationCommands, SyncMigrationCommands, create_migration_commands
 from sqlspec.migrations.loaders import (
     BaseMigrationLoader,
     MigrationLoadError,
@@ -12,7 +12,7 @@ from sqlspec.migrations.loaders import (
     SQLFileLoader,
     get_migration_loader,
 )
-from sqlspec.migrations.runner import AsyncMigrationRunner, SyncMigrationRunner
+from sqlspec.migrations.runner import AsyncMigrationRunner, SyncMigrationRunner, create_migration_runner
 from sqlspec.migrations.tracker import AsyncMigrationTracker, SyncMigrationTracker
 from sqlspec.migrations.utils import create_migration_file, drop_all, get_author
 
@@ -21,14 +21,15 @@ __all__ = (
     "AsyncMigrationRunner",
     "AsyncMigrationTracker",
     "BaseMigrationLoader",
-    "MigrationCommands",
     "MigrationLoadError",
     "PythonFileLoader",
     "SQLFileLoader",
     "SyncMigrationCommands",
     "SyncMigrationRunner",
     "SyncMigrationTracker",
+    "create_migration_commands",
     "create_migration_file",
+    "create_migration_runner",
     "drop_all",
     "get_author",
     "get_migration_loader",