benchbox 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

benchbox/platforms/__init__.py

@@ -8,6 +8,7 @@ Copyright 2026 Joe Harris / BenchBox Project
 Licensed under the MIT License. See LICENSE file in the project root for details.
 """
 
+import importlib
 from typing import Optional, Type
 
 from benchbox.core.platform_registry import PlatformRegistry
@@ -15,170 +16,215 @@ from benchbox.utils.runtime_env import ensure_driver_version
 
 from .base import BenchmarkResults, ConnectionConfig, PlatformAdapter
 
-# Import local platform adapters
-try:
-    from .duckdb import DuckDBAdapter
-except ImportError:
-    DuckDBAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
-
-try:
-    from .motherduck import MotherDuckAdapter
-except ImportError:
-    MotherDuckAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
-
-try:
-    from .sqlite import SQLiteAdapter
-except ImportError:
-    SQLiteAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+# ============================================================================
+# Lazy Import System for Cloud Platform Adapters
+# ============================================================================
+# Cloud platform SDKs (databricks, snowflake, google-cloud-bigquery, etc.) have
+# heavy import chains that add 300+ seconds to pytest collection time even when
+# wrapped in try/except blocks. The import statement itself executes even if
+# immediately caught.
+#
+# This lazy loading pattern defers the actual import until the adapter is first
+# accessed, dramatically reducing test suite startup time.
+#
+# Adapters loaded lazily (heavy SDK dependencies):
+#   - DatabricksAdapter (databricks-sql-connector, databricks-sdk)
+#   - BigQueryAdapter (google-cloud-bigquery, google-cloud-storage)
+#   - SnowflakeAdapter (snowflake-connector-python)
+#   - RedshiftAdapter (redshift-connector, boto3)
+#   - ClickHouseAdapter (clickhouse-driver or chdb)
+#   - TrinoAdapter (trino)
+#   - AthenaAdapter (pyathena, boto3)
+#   - SparkAdapter (pyspark)
+#   - PySparkSQLAdapter (pyspark)
+#   - FireboltAdapter (firebolt-sdk)
+#   - InfluxDBAdapter (influxdb3-python)
+#   - PrestoAdapter (presto-python-client)
+#   - AzureSynapseAdapter (pyodbc, azure-identity)
+#   - FabricWarehouseAdapter (pyodbc, azure-identity)
+#
+# Adapters loaded eagerly (light dependencies or core):
+#   - DuckDBAdapter (duckdb - core dependency, always available)
+#   - MotherDuckAdapter (duckdb - shares core dependency)
+#   - SQLiteAdapter (stdlib sqlite3)
+#   - DataFusionAdapter (datafusion - lightweight)
+#   - PolarsAdapter (polars - lightweight)
+#   - PostgreSQLAdapter (psycopg2 - core dependency)
+#   - TimescaleDBAdapter (psycopg2 - shares core dependency)
+# ============================================================================
 
-try:
-    from .datafusion import DataFusionAdapter
-except ImportError:
-    DataFusionAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+# Cache for lazily loaded adapters and constants
+_lazy_adapter_cache: dict[str, Optional[Type[PlatformAdapter]]] = {}
+_lazy_constant_cache: dict[str, bool] = {}
+
+# Mapping of lazy adapter names to their module paths
+_LAZY_ADAPTERS = {
+    # Cloud SQL platforms with heavy SDK dependencies
+    "DatabricksAdapter": ".databricks",
+    "BigQueryAdapter": ".bigquery",
+    "SnowflakeAdapter": ".snowflake",
+    "RedshiftAdapter": ".redshift",
+    "ClickHouseAdapter": ".clickhouse",
+    "ClickHouseCloudAdapter": ".clickhouse_cloud",
+    "TrinoAdapter": ".trino",
+    "AthenaAdapter": ".athena",
+    "SparkAdapter": ".spark",
+    "PySparkSQLAdapter": ".pyspark",
+    "FireboltAdapter": ".firebolt",
+    "InfluxDBAdapter": ".influxdb",
+    "PrestoAdapter": ".presto",
+    "AzureSynapseAdapter": ".azure_synapse",
+    "FabricWarehouseAdapter": ".fabric_warehouse",
+    "MicrosoftFabricAdapter": ".fabric_warehouse",  # Backward compatibility alias
+    "QuantonAdapter": ".onehouse",
+    # DataFrame adapters (have their own lazy loading but need module-level deferral)
+    "PolarsDataFrameAdapter": ".dataframe",
+    "PandasDataFrameAdapter": ".dataframe",
+    "ModinDataFrameAdapter": ".dataframe",
+    "CuDFDataFrameAdapter": ".dataframe",
+    "DaskDataFrameAdapter": ".dataframe",
+    "DataFusionDataFrameAdapter": ".dataframe",
+    "PySparkDataFrameAdapter": ".dataframe",
+    "DataFramePlatformChecker": ".dataframe",
+}
+
+# Mapping of lazy constants to their module paths and default values
+_LAZY_CONSTANTS = {
+    "POLARS_AVAILABLE": (".dataframe", False),
+    "PANDAS_AVAILABLE": (".dataframe", False),
+    "MODIN_AVAILABLE": (".dataframe", False),
+    "CUDF_AVAILABLE": (".dataframe", False),
+    "DASK_AVAILABLE": (".dataframe", False),
+    "DATAFUSION_DF_AVAILABLE": (".dataframe", False),
+    "PYSPARK_AVAILABLE": (".dataframe", False),
+}
+
+# Cache for clickhouse module (special case - needs module reference)
+_clickhouse_module_cache = None
+
+
+def _load_lazy_adapter(name: str) -> Optional[Type[PlatformAdapter]]:
+    """Load a lazily-imported adapter class.
 
-try:
-    from .polars_platform import PolarsAdapter
-except ImportError:
-    PolarsAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    Args:
+        name: Adapter class name (e.g., 'DatabricksAdapter')
 
-# Import cloud platform adapters with graceful fallback
-# ClickHouse is optional and may not be included in pip-installed packages
-try:
-    from . import clickhouse as _clickhouse_module
-    from .clickhouse import ClickHouseAdapter
+    Returns:
+        Adapter class if available, None if import fails
+    """
+    if name in _lazy_adapter_cache:
+        return _lazy_adapter_cache[name]
 
-    # Provide module access for legacy patches/tests (only if clickhouse is available)
-    clickhouse = _clickhouse_module
-except ImportError:
-    _clickhouse_module = None  # type: ignore[assignment]
-    clickhouse = None  # type: ignore[assignment]
-    ClickHouseAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    module_path = _LAZY_ADAPTERS.get(name)
+    if module_path is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
-try:
-    from .databricks import DatabricksAdapter
-except ImportError:
-    DatabricksAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    try:
+        module = importlib.import_module(module_path, __package__)
+        adapter_class = getattr(module, name, None)
+        _lazy_adapter_cache[name] = adapter_class
+        return adapter_class
+    except ImportError:
+        _lazy_adapter_cache[name] = None
+        return None
 
-try:
-    from .bigquery import BigQueryAdapter
-except ImportError:
-    BigQueryAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
-try:
-    from .redshift import RedshiftAdapter
-except ImportError:
-    RedshiftAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+def _load_lazy_constant(name: str) -> bool:
+    """Load a lazily-imported availability constant.
 
-try:
-    from .snowflake import SnowflakeAdapter
-except ImportError:
-    SnowflakeAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    Args:
+        name: Constant name (e.g., 'POLARS_AVAILABLE')
 
-try:
-    from .trino import TrinoAdapter
-except ImportError:
-    TrinoAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    Returns:
+        Constant value (True/False), defaults to False on import failure
+    """
+    if name in _lazy_constant_cache:
+        return _lazy_constant_cache[name]
 
-try:
-    from .athena import AthenaAdapter
-except ImportError:
-    AthenaAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    module_path, default = _LAZY_CONSTANTS.get(name, (None, False))
+    if module_path is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
-try:
-    from .spark import SparkAdapter
-except ImportError:
-    SparkAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    try:
+        module = importlib.import_module(module_path, __package__)
+        value = getattr(module, name, default)
+        _lazy_constant_cache[name] = value
+        return value
+    except ImportError:
+        _lazy_constant_cache[name] = default
+        return default
 
-try:
-    from .pyspark import PySparkSQLAdapter
-except ImportError:
-    PySparkSQLAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
-try:
-    from .firebolt import FireboltAdapter
-except ImportError:
-    FireboltAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+def __getattr__(name: str):
+    """Lazy load cloud platform adapters and DataFrame components on first access.
 
-try:
-    from .influxdb import InfluxDBAdapter
-except ImportError:
-    InfluxDBAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    This function is called when an attribute is not found in the module's namespace.
+    It enables deferred loading of heavy cloud SDK dependencies until they're actually
+    needed, dramatically reducing test collection time.
+    """
+    global _clickhouse_module_cache
 
-try:
-    from .presto import PrestoAdapter
-except ImportError:
-    PrestoAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    # Handle adapter classes
+    if name in _LAZY_ADAPTERS:
+        return _load_lazy_adapter(name)
 
-try:
-    from .postgresql import PostgreSQLAdapter
-except ImportError:
-    PostgreSQLAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    # Handle availability constants
+    if name in _LAZY_CONSTANTS:
+        return _load_lazy_constant(name)
 
-try:
-    from .timescaledb import TimescaleDBAdapter
-except ImportError:
-    TimescaleDBAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    # Special case: clickhouse module reference (for legacy patches/tests)
+    if name == "clickhouse":
+        if _clickhouse_module_cache is None:
+            try:
+                _clickhouse_module_cache = importlib.import_module(".clickhouse", __package__)
+            except ImportError:
+                pass  # Keep as None
+        return _clickhouse_module_cache
 
-try:
-    from .azure_synapse import AzureSynapseAdapter
-except ImportError:
-    AzureSynapseAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
-try:
-    from .fabric_warehouse import FabricWarehouseAdapter, MicrosoftFabricAdapter
-except ImportError:
-    FabricWarehouseAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
-    MicrosoftFabricAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
-# DataFrame platform adapters - these use a different interface (DataFrame API instead of SQL)
-# Import availability flags and adapters with graceful fallback
-try:
-    from .dataframe import POLARS_AVAILABLE, PolarsDataFrameAdapter
-except ImportError:
-    POLARS_AVAILABLE = False
-    PolarsDataFrameAdapter = None  # type: ignore[assignment,misc]
+# ============================================================================
+# Eagerly Loaded Adapters (light dependencies or core)
+# ============================================================================
+# These adapters have lightweight dependencies that don't impact startup time
+# significantly, so they're loaded eagerly for simpler access patterns.
 
+# Import local platform adapters (core/light dependencies)
 try:
-    from .dataframe import PANDAS_AVAILABLE, PandasDataFrameAdapter
+    from .duckdb import DuckDBAdapter
 except ImportError:
-    PANDAS_AVAILABLE = False
-    PandasDataFrameAdapter = None  # type: ignore[assignment,misc]
+    DuckDBAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
 try:
-    from .dataframe import MODIN_AVAILABLE, ModinDataFrameAdapter
+    from .motherduck import MotherDuckAdapter
 except ImportError:
-    MODIN_AVAILABLE = False
-    ModinDataFrameAdapter = None  # type: ignore[assignment,misc]
+    MotherDuckAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
 try:
-    from .dataframe import CUDF_AVAILABLE, CuDFDataFrameAdapter
+    from .sqlite import SQLiteAdapter
 except ImportError:
-    CUDF_AVAILABLE = False
-    CuDFDataFrameAdapter = None  # type: ignore[assignment,misc]
+    SQLiteAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
 try:
-    from .dataframe import DASK_AVAILABLE, DaskDataFrameAdapter
+    from .datafusion import DataFusionAdapter
 except ImportError:
-    DASK_AVAILABLE = False
-    DaskDataFrameAdapter = None  # type: ignore[assignment,misc]
+    DataFusionAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
 try:
-    from .dataframe import DATAFUSION_DF_AVAILABLE, DataFusionDataFrameAdapter
+    from .polars_platform import PolarsAdapter
 except ImportError:
-    DATAFUSION_DF_AVAILABLE = False
-    DataFusionDataFrameAdapter = None  # type: ignore[assignment,misc]
+    PolarsAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
-# Import platform checker for DataFrame platform status
 try:
-    from .dataframe import DataFramePlatformChecker
+    from .postgresql import PostgreSQLAdapter
 except ImportError:
-    DataFramePlatformChecker = None  # type: ignore[assignment,misc]
+    PostgreSQLAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
 try:
-    from .dataframe import PYSPARK_AVAILABLE, PySparkDataFrameAdapter
+    from .timescaledb import TimescaleDBAdapter
 except ImportError:
-    PYSPARK_AVAILABLE = False
-    PySparkDataFrameAdapter = None  # type: ignore[assignment,misc]
+    TimescaleDBAdapter: Optional[Type[PlatformAdapter]] = None  # type: ignore[assignment,misc]
 
 __all__ = [
     "PlatformAdapter",
@@ -189,6 +235,7 @@ __all__ = [
     "DataFusionAdapter",
     "PolarsAdapter",
     "ClickHouseAdapter",
+    "ClickHouseCloudAdapter",
     "DatabricksAdapter",
     "BigQueryAdapter",
     "RedshiftAdapter",
@@ -204,6 +251,7 @@ __all__ = [
     "AzureSynapseAdapter",
     "FabricWarehouseAdapter",
     "MicrosoftFabricAdapter",  # Backward compatibility alias
+    "QuantonAdapter",
     # DataFrame adapters
     "PolarsDataFrameAdapter",
     "PandasDataFrameAdapter",
@@ -387,23 +435,26 @@ def get_dataframe_adapter(platform_name: str, **config):
         ValueError: If platform is not a recognized DataFrame platform
         ImportError: If required dependencies are not installed
     """
-    dataframe_mapping = {
-        "polars-df": PolarsDataFrameAdapter,
-        "pandas-df": PandasDataFrameAdapter,
-        "modin-df": ModinDataFrameAdapter,
-        "cudf-df": CuDFDataFrameAdapter,
-        "dask-df": DaskDataFrameAdapter,
-        "datafusion-df": DataFusionDataFrameAdapter,
-        "pyspark-df": PySparkDataFrameAdapter,
+    # Mapping uses lazy-loaded adapter names (resolved via __getattr__)
+    dataframe_adapter_names = {
+        "polars-df": "PolarsDataFrameAdapter",
+        "pandas-df": "PandasDataFrameAdapter",
+        "modin-df": "ModinDataFrameAdapter",
+        "cudf-df": "CuDFDataFrameAdapter",
+        "dask-df": "DaskDataFrameAdapter",
+        "datafusion-df": "DataFusionDataFrameAdapter",
+        "pyspark-df": "PySparkDataFrameAdapter",
     }
 
     platform_lower = platform_name.lower()
 
-    if platform_lower not in dataframe_mapping:
-        available = ", ".join(sorted(dataframe_mapping.keys()))
+    if platform_lower not in dataframe_adapter_names:
+        available = ", ".join(sorted(dataframe_adapter_names.keys()))
         raise ValueError(f"Unknown DataFrame platform: {platform_name}. Available: {available}")
 
-    adapter_class = dataframe_mapping[platform_lower]
+    # Trigger lazy load via __getattr__
+    adapter_name = dataframe_adapter_names[platform_lower]
+    adapter_class = _load_lazy_adapter(adapter_name)
 
     if adapter_class is None:
         requirements = get_dataframe_requirements(platform_lower)
@@ -420,16 +471,18 @@ def list_available_dataframe_platforms() -> dict[str, bool]:
     Returns:
         Dictionary mapping platform name to availability boolean
     """
-    platforms = {
-        "polars-df": POLARS_AVAILABLE,
-        "pandas-df": PANDAS_AVAILABLE,
-        "modin-df": MODIN_AVAILABLE,
-        "cudf-df": CUDF_AVAILABLE,
-        "dask-df": DASK_AVAILABLE,
-        "datafusion-df": DATAFUSION_DF_AVAILABLE,
-        "pyspark-df": PYSPARK_AVAILABLE,
+    # Mapping uses lazy-loaded constant names (resolved via __getattr__)
+    availability_constants = {
+        "polars-df": "POLARS_AVAILABLE",
+        "pandas-df": "PANDAS_AVAILABLE",
+        "modin-df": "MODIN_AVAILABLE",
+        "cudf-df": "CUDF_AVAILABLE",
+        "dask-df": "DASK_AVAILABLE",
+        "datafusion-df": "DATAFUSION_DF_AVAILABLE",
+        "pyspark-df": "PYSPARK_AVAILABLE",
     }
-    return platforms
+    # Trigger lazy load via __getattr__ for each constant
+    return {platform: _load_lazy_constant(const_name) for platform, const_name in availability_constants.items()}
 
 
 def get_dataframe_requirements(platform_name: str) -> str:
@@ -442,13 +495,17 @@ def get_dataframe_requirements(platform_name: str) -> str:
         Installation command string
     """
     requirements = {
-        "polars-df": "uv add polars (core dependency - should be installed)",
-        "pandas-df": "uv add benchbox --extra dataframe-pandas",
-        "modin-df": "uv add modin[ray] (or modin[dask])",
+        "polars-df": "pip install polars (core dependency - should be installed)",
+        "pandas-df": (
+            "pip install pandas  # standalone\n  uv add benchbox --extra dataframe-pandas  # inside a project"
+        ),
+        "modin-df": "pip install modin[ray] (or modin[dask])",
         "cudf-df": "pip install cudf-cu12 (requires NVIDIA GPU with CUDA)",
-        "dask-df": "uv add dask[distributed]",
-        "datafusion-df": "uv add datafusion (or uv add benchbox --extra datafusion)",
-        "pyspark-df": "uv add benchbox --extra dataframe-pyspark",
+        "dask-df": "pip install dask[distributed]",
+        "datafusion-df": "pip install datafusion",
+        "pyspark-df": (
+            "pip install pyspark  # standalone\n  uv add benchbox --extra dataframe-pyspark  # inside a project"
+        ),
     }
 
     return requirements.get(platform_name.lower(), "Unknown DataFrame platform")
@@ -475,514 +532,575 @@ def is_dataframe_platform(platform_name: str) -> bool:
 
 
 # ============================================================================
-# Platform Hook Registration
+# Platform Hook Registration (Deferred)
 # ============================================================================
-# IMPORTANT: This registration block MUST be at the bottom of the module to
-# avoid circular import issues.
-#
-# The registration imports benchbox.cli.platform_hooks, which imports
-# benchbox.core.platform_registry, which can trigger re-entrant imports of
-# benchbox.platforms. By placing this registration at the very bottom, we
-# ensure that all platform imports (clickhouse, databricks, etc.) have
-# completed before we import PlatformHookRegistry.
+# Platform hooks are registered lazily to avoid triggering SDK imports during
+# module load. The option specs are registered unconditionally (they're just
+# metadata), but config builders are wrapped in lazy loaders that only import
+# the adapter module when the builder is actually called.
 #
-# Previous circular import chain that this placement prevents:
-#   1. from benchbox.platforms.databricks import DatabricksAdapter
-#   2. benchbox/platforms/__init__.py starts loading
-#   3. Line 14: imports platform_registry → triggers platforms.base import
-#   4. Lines 32-40: tries to import clickhouse module
-#   5. clickhouse/__init__.py:27 imports platform_hooks
-#   6. platform_hooks imports platform_registry
-#   7. platform_registry tries to re-import platforms
-#   8. ERROR: platforms is partially initialized (stuck at clickhouse import)
-#
-# With this placement at the bottom, all imports complete before registration.
+# This is critical for test performance - importing adapters like Databricks
+# or Snowflake triggers heavy SDK imports (300+ seconds). By deferring these
+# imports, pytest collection time is dramatically reduced.
 # ============================================================================
 
-# Register config builders for platforms that can't do it themselves due to circular imports
-# (specifically, package-structured platforms like databricks)
+
+def _make_lazy_config_builder(module_path: str, builder_name: str):
+    """Create a lazy config builder that defers module import until called.
+
+    Args:
+        module_path: Relative module path (e.g., '.databricks')
+        builder_name: Name of the config builder function in the module
+
+    Returns:
+        A wrapper function that lazily imports and calls the real builder
+    """
+    from typing import Any
+
+    def lazy_builder(
+        platform: str,
+        options: dict[str, Any],
+        overrides: dict[str, Any],
+        info: Any,
+    ):
+        module = importlib.import_module(module_path, __package__)
+        real_builder = getattr(module, builder_name)
+        return real_builder(platform, options, overrides, info)
+
+    return lazy_builder
+
+
 try:
     from benchbox.cli.platform_hooks import PlatformHookRegistry, PlatformOptionSpec, parse_bool
 
-    # Register Databricks config builder (can't register in databricks/__init__.py due to circular import)
-    if DatabricksAdapter is not None:
-        from benchbox.platforms.databricks import _build_databricks_config
-
-        PlatformHookRegistry.register_config_builder("databricks", _build_databricks_config)
-
-        # Register Databricks platform options
-        PlatformHookRegistry.register_option_specs(
-            "databricks",
-            PlatformOptionSpec(
-                name="uc_catalog",
-                help="Unity Catalog catalog name for staging data",
-            ),
-            PlatformOptionSpec(
-                name="uc_schema",
-                help="Unity Catalog schema name for staging data",
-            ),
-            PlatformOptionSpec(
-                name="uc_volume",
-                help="Unity Catalog volume name for staging data",
-            ),
-            PlatformOptionSpec(
-                name="staging_root",
-                help="Cloud storage path for staging data (e.g., dbfs:/Volumes/..., s3://..., abfss://...)",
-            ),
-        )
+    # ========================================================================
+    # Cloud Platform Hooks (Lazy Config Builders)
+    # ========================================================================
+    # These platforms use lazy config builders to avoid importing heavy SDKs
+    # at module load time. Option specs are registered unconditionally.
 
-    # Register BigQuery config builder and platform options
-    if BigQueryAdapter is not None:
-        from benchbox.platforms.bigquery import _build_bigquery_config
-
-        PlatformHookRegistry.register_config_builder("bigquery", _build_bigquery_config)
-
-        # Register BigQuery platform options
-        PlatformHookRegistry.register_option_specs(
-            "bigquery",
-            PlatformOptionSpec(
-                name="staging_root",
-                help="GCS path for staging data (e.g., gs://bucket/path)",
-            ),
-            PlatformOptionSpec(
-                name="storage_bucket",
-                help="GCS bucket name for data staging (alternative to staging_root)",
-            ),
-            PlatformOptionSpec(
-                name="storage_prefix",
-                help="GCS path prefix within bucket for data staging",
-            ),
-        )
+    # Databricks
+    PlatformHookRegistry.register_config_builder(
+        "databricks", _make_lazy_config_builder(".databricks", "_build_databricks_config")
+    )
+    PlatformHookRegistry.register_option_specs(
+        "databricks",
+        PlatformOptionSpec(
+            name="uc_catalog",
+            help="Unity Catalog catalog name for staging data",
+        ),
+        PlatformOptionSpec(
+            name="uc_schema",
+            help="Unity Catalog schema name for staging data",
+        ),
+        PlatformOptionSpec(
+            name="uc_volume",
+            help="Unity Catalog volume name for staging data",
+        ),
+        PlatformOptionSpec(
+            name="staging_root",
+            help="Cloud storage path for staging data (e.g., dbfs:/Volumes/..., s3://..., abfss://...)",
+        ),
+    )
 
-    # Register Trino config builder and platform options
-    if TrinoAdapter is not None:
-        from benchbox.platforms.trino import _build_trino_config
-
-        PlatformHookRegistry.register_config_builder("trino", _build_trino_config)
-
-        # Register Trino platform options
-        PlatformHookRegistry.register_option_specs(
-            "trino",
-            PlatformOptionSpec(
-                name="catalog",
-                help="Trino catalog to use (e.g., hive, iceberg, memory). Auto-discovered if not specified.",
-            ),
-            PlatformOptionSpec(
-                name="staging_root",
-                help="Cloud storage path for staging data (e.g., s3://..., gs://..., abfss://...)",
-            ),
-            PlatformOptionSpec(
-                name="table_format",
-                help="Table format for creating tables (memory, hive, iceberg, delta)",
-                default="memory",
-            ),
-            PlatformOptionSpec(
-                name="source_catalog",
-                help="Source catalog for external data loading (e.g., hive connector)",
-            ),
-        )
+    # BigQuery
+    PlatformHookRegistry.register_config_builder(
+        "bigquery", _make_lazy_config_builder(".bigquery", "_build_bigquery_config")
+    )
+    PlatformHookRegistry.register_option_specs(
+        "bigquery",
+        PlatformOptionSpec(
+            name="staging_root",
+            help="GCS path for staging data (e.g., gs://bucket/path)",
+        ),
+        PlatformOptionSpec(
+            name="storage_bucket",
+            help="GCS bucket name for data staging (alternative to staging_root)",
+        ),
+        PlatformOptionSpec(
+            name="storage_prefix",
+            help="GCS path prefix within bucket for data staging",
+        ),
+    )
 
-    # Register Firebolt config builder and platform options
-    if FireboltAdapter is not None:
-        from benchbox.platforms.firebolt import _build_firebolt_config
-
-        PlatformHookRegistry.register_config_builder("firebolt", _build_firebolt_config)
-
-        # Register Firebolt platform options
-        PlatformHookRegistry.register_option_specs(
-            "firebolt",
-            PlatformOptionSpec(
-                name="firebolt_mode",
-                help="Explicit Firebolt mode: 'core' for local Docker, 'cloud' for managed Firebolt",
-            ),
-            PlatformOptionSpec(
-                name="url",
-                help="Firebolt Core endpoint URL (default: http://localhost:3473)",
-                default="http://localhost:3473",
-            ),
-            PlatformOptionSpec(
-                name="client_id",
-                help="Firebolt Cloud OAuth client ID",
-            ),
-            PlatformOptionSpec(
-                name="client_secret",
-                help="Firebolt Cloud OAuth client secret",
-            ),
-            PlatformOptionSpec(
-                name="account_name",
-                help="Firebolt Cloud account name",
-            ),
-            PlatformOptionSpec(
-                name="engine_name",
-                help="Firebolt Cloud engine name",
-            ),
-            PlatformOptionSpec(
-                name="api_endpoint",
-                help="Firebolt Cloud API endpoint",
-                default="api.app.firebolt.io",
-            ),
-        )
+    # Trino
+    PlatformHookRegistry.register_config_builder("trino", _make_lazy_config_builder(".trino", "_build_trino_config"))
+    PlatformHookRegistry.register_option_specs(
+        "trino",
+        PlatformOptionSpec(
+            name="catalog",
+            help="Trino catalog to use (e.g., hive, iceberg, memory). Auto-discovered if not specified.",
+        ),
+        PlatformOptionSpec(
+            name="staging_root",
+            help="Cloud storage path for staging data (e.g., s3://..., gs://..., abfss://...)",
+        ),
+        PlatformOptionSpec(
+            name="table_format",
+            help="Table format for creating tables (memory, hive, iceberg, delta)",
+            default="memory",
+        ),
+        PlatformOptionSpec(
+            name="source_catalog",
+            help="Source catalog for external data loading (e.g., hive connector)",
+        ),
+    )
 
-    # Register Presto config builder and platform options
-    if PrestoAdapter is not None:
-        from benchbox.platforms.presto import _build_presto_config
-
-        PlatformHookRegistry.register_config_builder("presto", _build_presto_config)
-
-        # Register Presto platform options
-        PlatformHookRegistry.register_option_specs(
-            "presto",
-            PlatformOptionSpec(
-                name="catalog",
-                help="Presto catalog to use (e.g., hive, memory). Auto-discovered if not specified.",
-            ),
-            PlatformOptionSpec(
-                name="staging_root",
-                help="Cloud storage path for staging data (e.g., s3://..., gs://...)",
-            ),
-            PlatformOptionSpec(
-                name="table_format",
-                help="Table format for creating tables (memory, hive)",
-                default="memory",
-            ),
-            PlatformOptionSpec(
-                name="source_catalog",
-                help="Source catalog for external data loading (e.g., hive connector)",
-            ),
-        )
+    # Firebolt
+    PlatformHookRegistry.register_config_builder(
+        "firebolt", _make_lazy_config_builder(".firebolt", "_build_firebolt_config")
+    )
+    PlatformHookRegistry.register_option_specs(
+        "firebolt",
+        PlatformOptionSpec(
+            name="firebolt_mode",
+            help="Explicit Firebolt mode: 'core' for local Docker, 'cloud' for managed Firebolt",
+        ),
+        PlatformOptionSpec(
+            name="url",
+            help="Firebolt Core endpoint URL (default: http://localhost:3473)",
+            default="http://localhost:3473",
+        ),
+        PlatformOptionSpec(
+            name="client_id",
+            help="Firebolt Cloud OAuth client ID",
+        ),
+        PlatformOptionSpec(
+            name="client_secret",
+            help="Firebolt Cloud OAuth client secret",
+        ),
+        PlatformOptionSpec(
+            name="account_name",
+            help="Firebolt Cloud account name",
+        ),
+        PlatformOptionSpec(
+            name="engine_name",
+            help="Firebolt Cloud engine name",
+        ),
+        PlatformOptionSpec(
+            name="api_endpoint",
+            help="Firebolt Cloud API endpoint",
+            default="api.app.firebolt.io",
+        ),
+    )
+
+    # Presto
+    PlatformHookRegistry.register_config_builder("presto", _make_lazy_config_builder(".presto", "_build_presto_config"))
+    PlatformHookRegistry.register_option_specs(
+        "presto",
+        PlatformOptionSpec(
+            name="catalog",
+            help="Presto catalog to use (e.g., hive, memory). Auto-discovered if not specified.",
+        ),
+        PlatformOptionSpec(
+            name="staging_root",
+            help="Cloud storage path for staging data (e.g., s3://..., gs://...)",
+        ),
+        PlatformOptionSpec(
+            name="table_format",
+            help="Table format for creating tables (memory, hive)",
+            default="memory",
+        ),
+        PlatformOptionSpec(
+            name="source_catalog",
+            help="Source catalog for external data loading (e.g., hive connector)",
+        ),
+    )
 
-    # Register PostgreSQL config builder and platform options
+    # ========================================================================
+    # Eagerly-Loaded Platform Hooks (PostgreSQL, TimescaleDB)
+    # ========================================================================
+    # These platforms have lightweight dependencies that are already loaded
+    # eagerly, so we can use direct imports for their config builders.
+
+    # PostgreSQL (eagerly loaded - uses psycopg2 which is a core dependency)
     if PostgreSQLAdapter is not None:
         from benchbox.platforms.postgresql import _build_postgresql_config
 
         PlatformHookRegistry.register_config_builder("postgresql", _build_postgresql_config)
 
-        # Register PostgreSQL platform options
-        PlatformHookRegistry.register_option_specs(
-            "postgresql",
-            PlatformOptionSpec(
-                name="host",
-                help="PostgreSQL server hostname",
-                default="localhost",
-            ),
-            PlatformOptionSpec(
-                name="port",
-                help="PostgreSQL server port",
-                default="5432",
-            ),
-            PlatformOptionSpec(
-                name="database",
-                help="PostgreSQL database name (auto-generated if not specified)",
-            ),
-            PlatformOptionSpec(
-                name="username",
-                help="PostgreSQL username",
-                default="postgres",
-            ),
-            PlatformOptionSpec(
-                name="password",
-                help="PostgreSQL password",
-            ),
-            PlatformOptionSpec(
-                name="schema",
-                help="PostgreSQL schema name",
-                default="public",
-            ),
-            PlatformOptionSpec(
-                name="work_mem",
-                help="PostgreSQL work_mem setting for queries",
-                default="256MB",
-            ),
-            PlatformOptionSpec(
-                name="enable_timescale",
-                help="Enable TimescaleDB extensions if available",
-                default="false",
-            ),
-        )
+    PlatformHookRegistry.register_option_specs(
+        "postgresql",
+        PlatformOptionSpec(
+            name="host",
+            help="PostgreSQL server hostname",
+            default="localhost",
+        ),
+        PlatformOptionSpec(
+            name="port",
+            help="PostgreSQL server port",
+            default="5432",
+        ),
+        PlatformOptionSpec(
+            name="database",
+            help="PostgreSQL database name (auto-generated if not specified)",
+        ),
+        PlatformOptionSpec(
+            name="username",
+            help="PostgreSQL username",
+            default="postgres",
+        ),
+        PlatformOptionSpec(
+            name="password",
+            help="PostgreSQL password",
+        ),
+        PlatformOptionSpec(
+            name="schema",
+            help="PostgreSQL schema name",
+            default="public",
+        ),
+        PlatformOptionSpec(
+            name="work_mem",
+            help="PostgreSQL work_mem setting for queries",
+            default="256MB",
+        ),
+        PlatformOptionSpec(
+            name="enable_timescale",
+            help="Enable TimescaleDB extensions if available",
+            default="false",
+        ),
+    )
 
-    # Register TimescaleDB config builder and platform options
+    # TimescaleDB (eagerly loaded - shares psycopg2 with PostgreSQL)
     if TimescaleDBAdapter is not None:
         from benchbox.platforms.timescaledb import _build_timescaledb_config
 
         PlatformHookRegistry.register_config_builder("timescaledb", _build_timescaledb_config)
 
-        # Register TimescaleDB platform options
-        PlatformHookRegistry.register_option_specs(
-            "timescaledb",
-            PlatformOptionSpec(
-                name="host",
-                help="TimescaleDB server hostname",
-                default="localhost",
-            ),
-            PlatformOptionSpec(
-                name="port",
-                help="TimescaleDB server port",
-                default="5432",
-            ),
-            PlatformOptionSpec(
-                name="database",
-                help="TimescaleDB database name (auto-generated if not specified)",
-            ),
-            PlatformOptionSpec(
-                name="username",
-                help="TimescaleDB username",
-                default="postgres",
-            ),
-            PlatformOptionSpec(
-                name="password",
-                help="TimescaleDB password",
-            ),
-            PlatformOptionSpec(
-                name="schema",
-                help="TimescaleDB schema name",
-                default="public",
-            ),
-            PlatformOptionSpec(
-                name="chunk_interval",
-                help="Chunk time interval for hypertables (e.g., '1 day', '1 week')",
-                default="1 day",
-            ),
-            PlatformOptionSpec(
-                name="compression_enabled",
-                help="Enable compression on hypertables",
-                default="false",
-            ),
-            PlatformOptionSpec(
-                name="compression_after",
-                help="Compress chunks older than this interval (e.g., '7 days')",
-                default="7 days",
-            ),
-        )
+    PlatformHookRegistry.register_option_specs(
+        "timescaledb",
+        PlatformOptionSpec(
+            name="host",
+            help="TimescaleDB server hostname",
+            default="localhost",
+        ),
+        PlatformOptionSpec(
+            name="port",
+            help="TimescaleDB server port",
+            default="5432",
+        ),
+        PlatformOptionSpec(
+            name="database",
+            help="TimescaleDB database name (auto-generated if not specified)",
+        ),
+        PlatformOptionSpec(
+            name="username",
+            help="TimescaleDB username",
+            default="postgres",
+        ),
+        PlatformOptionSpec(
+            name="password",
+            help="TimescaleDB password",
+        ),
+        PlatformOptionSpec(
+            name="schema",
+            help="TimescaleDB schema name",
+            default="public",
+        ),
+        PlatformOptionSpec(
+            name="chunk_interval",
+            help="Chunk time interval for hypertables (e.g., '1 day', '1 week')",
+            default="1 day",
+        ),
+        PlatformOptionSpec(
+            name="compression_enabled",
+            help="Enable compression on hypertables",
+            default="false",
+        ),
+        PlatformOptionSpec(
+            name="compression_after",
+            help="Compress chunks older than this interval (e.g., '7 days')",
+            default="7 days",
+        ),
+    )
 
-    # Register Azure Synapse config builder and platform options
-    if AzureSynapseAdapter is not None:
-        from benchbox.platforms.azure_synapse import _build_synapse_config
-
-        PlatformHookRegistry.register_config_builder("synapse", _build_synapse_config)
-
-        # Register Azure Synapse platform options
-        PlatformHookRegistry.register_option_specs(
-            "synapse",
-            PlatformOptionSpec(
-                name="server",
-                help="Azure Synapse server endpoint (e.g., myworkspace.sql.azuresynapse.net)",
-            ),
-            PlatformOptionSpec(
-                name="database",
-                help="Azure Synapse database name (auto-generated if not specified)",
-            ),
-            PlatformOptionSpec(
-                name="username",
-                help="Azure Synapse username",
-            ),
-            PlatformOptionSpec(
-                name="password",
-                help="Azure Synapse password",
-            ),
-            PlatformOptionSpec(
-                name="auth_method",
-                help="Authentication method: sql, aad_password, or aad_msi",
-                default="sql",
-            ),
-            PlatformOptionSpec(
-                name="storage_account",
-                help="Azure storage account for data staging",
-            ),
-            PlatformOptionSpec(
-                name="container",
-                help="Azure blob container name",
-            ),
-            PlatformOptionSpec(
-                name="storage_sas_token",
-                help="SAS token for Azure storage access",
-            ),
-            PlatformOptionSpec(
-                name="resource_class",
-                help="Workload resource class (e.g., staticrc20, staticrc30)",
-                default="staticrc20",
-            ),
-        )
+    # ========================================================================
+    # Lazy Cloud Platform Hooks (Azure Synapse, Fabric)
+    # ========================================================================
 
-    # Register Microsoft Fabric Warehouse config builder and platform options
-    if FabricWarehouseAdapter is not None:
-        # Fabric uses from_config pattern, no separate config builder needed
-        # (the adapter's from_config method handles configuration)
-
-        # Register Fabric Warehouse platform options
-        PlatformHookRegistry.register_option_specs(
-            "fabric_dw",
-            PlatformOptionSpec(
-                name="server",
-                help="Fabric warehouse endpoint (e.g., workspace-guid.datawarehouse.fabric.microsoft.com)",
-            ),
-            PlatformOptionSpec(
-                name="workspace",
-                help="Fabric workspace name or GUID",
-            ),
-            PlatformOptionSpec(
-                name="warehouse",
-                help="Fabric warehouse name",
-            ),
-            PlatformOptionSpec(
-                name="database",
-                help="Database/warehouse name (alias for --warehouse)",
-            ),
-            PlatformOptionSpec(
-                name="auth_method",
-                help="Authentication method: service_principal, default_credential, or interactive",
-                default="default_credential",
-            ),
-            PlatformOptionSpec(
-                name="tenant_id",
-                help="Azure tenant ID for service principal auth",
-            ),
-            PlatformOptionSpec(
-                name="client_id",
-                help="Service principal client ID",
-            ),
-            PlatformOptionSpec(
-                name="client_secret",
-                help="Service principal client secret",
-            ),
-            PlatformOptionSpec(
-                name="staging_path",
-                help="OneLake staging path for data loading",
-                default="benchbox-staging",
-            ),
-        )
+    # Azure Synapse (lazy - uses pyodbc and azure-identity)
+    PlatformHookRegistry.register_config_builder(
+        "synapse", _make_lazy_config_builder(".azure_synapse", "_build_synapse_config")
+    )
+    PlatformHookRegistry.register_option_specs(
+        "synapse",
+        PlatformOptionSpec(
+            name="server",
+            help="Azure Synapse server endpoint (e.g., myworkspace.sql.azuresynapse.net)",
+        ),
+        PlatformOptionSpec(
+            name="database",
+            help="Azure Synapse database name (auto-generated if not specified)",
+        ),
+        PlatformOptionSpec(
+            name="username",
+            help="Azure Synapse username",
+        ),
+        PlatformOptionSpec(
+            name="password",
+            help="Azure Synapse password",
+        ),
+        PlatformOptionSpec(
+            name="auth_method",
+            help="Authentication method: sql, aad_password, or aad_msi",
+            default="sql",
+        ),
+        PlatformOptionSpec(
+            name="storage_account",
+            help="Azure storage account for data staging",
+        ),
+        PlatformOptionSpec(
+            name="container",
+            help="Azure blob container name",
+        ),
+        PlatformOptionSpec(
+            name="storage_sas_token",
+            help="SAS token for Azure storage access",
+        ),
+        PlatformOptionSpec(
+            name="resource_class",
+            help="Workload resource class (e.g., staticrc20, staticrc30)",
+            default="staticrc20",
+        ),
+    )
+
+    # Microsoft Fabric Warehouse (lazy - uses pyodbc and azure-identity)
+    # Fabric uses from_config pattern, no separate config builder needed
+    PlatformHookRegistry.register_option_specs(
+        "fabric_dw",
+        PlatformOptionSpec(
+            name="server",
+            help="Fabric warehouse endpoint (e.g., workspace-guid.datawarehouse.fabric.microsoft.com)",
+        ),
+        PlatformOptionSpec(
+            name="workspace",
+            help="Fabric workspace name or GUID",
+        ),
+        PlatformOptionSpec(
+            name="warehouse",
+            help="Fabric warehouse name",
+        ),
+        PlatformOptionSpec(
+            name="database",
+            help="Database/warehouse name (alias for --warehouse)",
+        ),
+        PlatformOptionSpec(
+            name="auth_method",
+            help="Authentication method: service_principal, default_credential, or interactive",
+            default="default_credential",
+        ),
+        PlatformOptionSpec(
+            name="tenant_id",
+            help="Azure tenant ID for service principal auth",
+        ),
+        PlatformOptionSpec(
+            name="client_id",
+            help="Service principal client ID",
+        ),
+        PlatformOptionSpec(
+            name="client_secret",
+            help="Service principal client secret",
+        ),
+        PlatformOptionSpec(
+            name="staging_path",
+            help="OneLake staging path for data loading",
+            default="benchbox-staging",
+        ),
+    )
+
+    # Onehouse Quanton (lazy - uses requests and boto3)
+    PlatformHookRegistry.register_config_builder(
+        "quanton", _make_lazy_config_builder(".onehouse", "_build_quanton_config")
+    )
+    PlatformHookRegistry.register_option_specs(
+        "quanton",
+        PlatformOptionSpec(
+            name="api_key",
+            help="Onehouse API key (or set ONEHOUSE_API_KEY env var)",
+        ),
+        PlatformOptionSpec(
+            name="s3_staging_dir",
+            help="S3 path for data staging (e.g., s3://bucket/path)",
+        ),
+        PlatformOptionSpec(
+            name="region",
+            help="AWS region for cluster deployment",
+            default="us-east-1",
+        ),
+        PlatformOptionSpec(
+            name="database",
+            help="Database name for benchmarks",
+            default="benchbox",
+        ),
+        PlatformOptionSpec(
+            name="table_format",
+            help="Table format: iceberg, hudi, or delta",
+            choices=("iceberg", "hudi", "delta"),
+            default="iceberg",
+        ),
+        PlatformOptionSpec(
+            name="cluster_size",
+            help="Cluster size: small, medium, large, xlarge",
+            choices=("small", "medium", "large", "xlarge"),
+            default="small",
+        ),
+    )
+
+    # ClickHouse Cloud (lazy - uses clickhouse-connect)
+    PlatformHookRegistry.register_config_builder(
+        "clickhouse-cloud", _make_lazy_config_builder(".clickhouse_cloud", "_build_clickhouse_cloud_config")
+    )
+    PlatformHookRegistry.register_option_specs(
+        "clickhouse-cloud",
+        PlatformOptionSpec(
+            name="host",
+            help="ClickHouse Cloud hostname (e.g., abc123.us-east-2.aws.clickhouse.cloud)",
+        ),
+        PlatformOptionSpec(
+            name="password",
+            help="ClickHouse Cloud password (or set CLICKHOUSE_CLOUD_PASSWORD env var)",
+        ),
+        PlatformOptionSpec(
+            name="username",
+            help="Username (default: 'default')",
+            default="default",
+        ),
+        PlatformOptionSpec(
+            name="database",
+            help="Database name",
+            default="default",
+        ),
+    )
 
     # ========================================================================
     # DataFrame Platform Hooks
     # ========================================================================
+    # DataFrame platform option specs are registered unconditionally since
+    # they're just metadata. The actual adapter availability is checked at
+    # runtime when the adapter is instantiated.
 
-    # Register Polars DataFrame platform options
-    if PolarsDataFrameAdapter is not None:
-        PlatformHookRegistry.register_option_specs(
-            "polars-df",
-            PlatformOptionSpec(
-                name="streaming",
-                help="Enable streaming mode for large datasets",
-                parser=parse_bool,
-                default="false",
-            ),
-            PlatformOptionSpec(
-                name="rechunk",
-                help="Rechunk data for better memory layout",
-                parser=parse_bool,
-                default="true",
-            ),
-            PlatformOptionSpec(
-                name="n_rows",
-                help="Limit number of rows to read (for testing)",
-                parser=int,
-            ),
-        )
+    # Polars DataFrame
+    PlatformHookRegistry.register_option_specs(
+        "polars-df",
+        PlatformOptionSpec(
+            name="streaming",
+            help="Enable streaming mode for large datasets",
+            parser=parse_bool,
+            default="false",
+        ),
+        PlatformOptionSpec(
+            name="rechunk",
+            help="Rechunk data for better memory layout",
+            parser=parse_bool,
+            default="true",
+        ),
+        PlatformOptionSpec(
+            name="n_rows",
+            help="Limit number of rows to read (for testing)",
+            parser=int,
+        ),
+    )
 
-    # Register Pandas DataFrame platform options
-    if PandasDataFrameAdapter is not None:
-        PlatformHookRegistry.register_option_specs(
-            "pandas-df",
-            PlatformOptionSpec(
-                name="dtype_backend",
-                help="Backend for nullable dtypes",
-                choices=("numpy", "numpy_nullable", "pyarrow"),
-                default="numpy_nullable",
-            ),
-        )
+    # Pandas DataFrame
+    PlatformHookRegistry.register_option_specs(
+        "pandas-df",
+        PlatformOptionSpec(
+            name="dtype_backend",
+            help="Backend for nullable dtypes",
+            choices=("numpy", "numpy_nullable", "pyarrow"),
+            default="numpy_nullable",
+        ),
+    )
 
-    # Register Modin DataFrame platform options
-    if ModinDataFrameAdapter is not None:
-        PlatformHookRegistry.register_option_specs(
-            "modin-df",
-            PlatformOptionSpec(
-                name="engine",
-                help="Modin execution engine",
-                choices=("ray", "dask"),
-                default="ray",
-            ),
-        )
+    # Modin DataFrame
+    PlatformHookRegistry.register_option_specs(
+        "modin-df",
+        PlatformOptionSpec(
+            name="engine",
+            help="Modin execution engine",
+            choices=("ray", "dask"),
+            default="ray",
+        ),
+    )
 
-    # Register cuDF DataFrame platform options
-    if CuDFDataFrameAdapter is not None:
-        PlatformHookRegistry.register_option_specs(
-            "cudf-df",
-            PlatformOptionSpec(
-                name="device_id",
-                help="CUDA device ID to use",
-                parser=int,
-                default="0",
-            ),
-            PlatformOptionSpec(
-                name="spill_to_host",
-                help="Enable GPU memory spilling to host RAM",
-                parser=parse_bool,
-                default="true",
-            ),
-        )
+    # cuDF DataFrame
+    PlatformHookRegistry.register_option_specs(
+        "cudf-df",
+        PlatformOptionSpec(
+            name="device_id",
+            help="CUDA device ID to use",
+            parser=int,
+            default="0",
+        ),
+        PlatformOptionSpec(
+            name="spill_to_host",
+            help="Enable GPU memory spilling to host RAM",
+            parser=parse_bool,
+            default="true",
+        ),
+    )
 
-    # Register Dask DataFrame platform options
-    if DaskDataFrameAdapter is not None:
-        PlatformHookRegistry.register_option_specs(
-            "dask-df",
-            PlatformOptionSpec(
-                name="n_workers",
-                help="Number of worker processes",
-                parser=int,
-            ),
-            PlatformOptionSpec(
-                name="threads_per_worker",
-                help="Threads per worker process",
-                parser=int,
-                default="1",
-            ),
-            PlatformOptionSpec(
-                name="use_distributed",
-                help="Use distributed scheduler (enables dashboard)",
-                parser=parse_bool,
-                default="false",
-            ),
-            PlatformOptionSpec(
-                name="scheduler_address",
-                help="Connect to existing scheduler (e.g., 'tcp://...')",
-            ),
-        )
+    # Dask DataFrame
+    PlatformHookRegistry.register_option_specs(
+        "dask-df",
+        PlatformOptionSpec(
+            name="n_workers",
+            help="Number of worker processes",
+            parser=int,
+        ),
+        PlatformOptionSpec(
+            name="threads_per_worker",
+            help="Threads per worker process",
+            parser=int,
+            default="1",
+        ),
+        PlatformOptionSpec(
+            name="use_distributed",
+            help="Use distributed scheduler (enables dashboard)",
+            parser=parse_bool,
+            default="false",
+        ),
+        PlatformOptionSpec(
+            name="scheduler_address",
+            help="Connect to existing scheduler (e.g., 'tcp://...')",
+        ),
+    )
 
-    # Register DataFusion DataFrame platform options
-    if DataFusionDataFrameAdapter is not None:
-        PlatformHookRegistry.register_option_specs(
-            "datafusion-df",
-            PlatformOptionSpec(
-                name="target_partitions",
-                help="Number of target partitions for parallelism (default: CPU count)",
-                parser=int,
-            ),
-            PlatformOptionSpec(
-                name="repartition_joins",
-                help="Enable automatic repartitioning for joins",
-                parser=parse_bool,
-                default="true",
-            ),
-            PlatformOptionSpec(
-                name="parquet_pushdown",
-                help="Enable predicate/projection pushdown for Parquet files",
-                parser=parse_bool,
-                default="true",
-            ),
-            PlatformOptionSpec(
-                name="batch_size",
-                help="Batch size for query execution",
-                parser=int,
-                default="8192",
-            ),
-            PlatformOptionSpec(
-                name="memory_limit",
-                help="Memory limit for fair spill pool (e.g., '8G', '16GB')",
-            ),
-            PlatformOptionSpec(
-                name="temp_dir",
-                help="Temporary directory for disk spilling (default: system temp)",
-            ),
-        )
+    # DataFusion DataFrame
+    PlatformHookRegistry.register_option_specs(
+        "datafusion-df",
+        PlatformOptionSpec(
+            name="target_partitions",
+            help="Number of target partitions for parallelism (default: CPU count)",
+            parser=int,
+        ),
+        PlatformOptionSpec(
+            name="repartition_joins",
+            help="Enable automatic repartitioning for joins",
+            parser=parse_bool,
+            default="true",
+        ),
+        PlatformOptionSpec(
+            name="parquet_pushdown",
+            help="Enable predicate/projection pushdown for Parquet files",
+            parser=parse_bool,
+            default="true",
+        ),
+        PlatformOptionSpec(
+            name="batch_size",
+            help="Batch size for query execution",
+            parser=int,
+            default="8192",
+        ),
+        PlatformOptionSpec(
+            name="memory_limit",
+            help="Memory limit for fair spill pool (e.g., '8G', '16GB')",
+        ),
+        PlatformOptionSpec(
+            name="temp_dir",
+            help="Temporary directory for disk spilling (default: system temp)",
+        ),
+    )
 except ImportError:
     # Platform hooks may not be available in all contexts
     pass