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

benchbox/platforms/dataframe/pandas_family.py

@@ -42,8 +42,10 @@ from benchbox.core.dataframe.profiling import (
 )
 from benchbox.core.dataframe.query import DataFrameQuery
 from benchbox.core.dataframe.tuning import DataFrameTuningConfiguration
+from benchbox.platforms.dataframe.benchmark_mixin import BenchmarkExecutionMixin
 from benchbox.platforms.dataframe.tuning_mixin import TuningConfigurableMixin
 from benchbox.platforms.dataframe.unified_pandas_frame import UnifiedPandasFrame
+from benchbox.utils.file_format import detect_data_format
 
 if TYPE_CHECKING:
     pass
@@ -359,6 +361,23 @@ class PandasFamilyContext(DataFrameContextImpl[DF], Generic[DF]):
         """
         return self._adapter.scalar(df, column)
 
+    def scalar_to_df(self, data: dict[str, Any]) -> Any:
+        """Create a single-row DataFrame from scalar values.
+
+        This creates a DataFrame with one row containing the provided values.
+        Provides a platform-agnostic way to return scalar aggregation results.
+
+        Args:
+            data: Dictionary mapping column names to scalar values
+
+        Returns:
+            UnifiedPandasFrame wrapping a single-row DataFrame
+        """
+        from benchbox.platforms.dataframe.unified_pandas_frame import UnifiedPandasFrame
+
+        native_df = self._adapter.scalar_to_df(data)
+        return UnifiedPandasFrame(native_df, self._adapter)
+
     def to_set(self, series_or_df: Any) -> set[Any]:
         """Convert a Series or single-column DataFrame to a set.
 
@@ -419,12 +438,15 @@ class PandasFamilyContext(DataFrameContextImpl[DF], Generic[DF]):
         return UnifiedPandasFrame(result, self._adapter)
 
 
-class PandasFamilyAdapter(TuningConfigurableMixin, ABC, Generic[DF]):
+class PandasFamilyAdapter(BenchmarkExecutionMixin, TuningConfigurableMixin, ABC, Generic[DF]):
     """Abstract base class for Pandas-like DataFrame platform adapters.
 
     This class provides the common interface and functionality for
     Pandas-family DataFrame libraries (Pandas, Modin, cuDF, Vaex, Dask).
 
+    Implements run_benchmark() for unified interface with SQL adapters,
+    enabling polymorphic adapter usage without caller branching.
+
     Subclasses must implement:
     - read_csv(): Read CSV file to DataFrame
     - read_parquet(): Read Parquet file to DataFrame
@@ -780,6 +802,39 @@ class PandasFamilyAdapter(TuningConfigurableMixin, ABC, Generic[DF]):
         # Return first column, first row value
         return df.iloc[0, 0]  # type: ignore[index]
 
+    def scalar_to_df(self, data: dict[str, Any]) -> DF:
+        """Create a single-row DataFrame from scalar values.
+
+        This is the base implementation for Pandas-family adapters. It uses
+        the native DataFrame creation mechanism for the platform.
+
+        Args:
+            data: Dictionary mapping column names to scalar values
+
+        Returns:
+            DataFrame with a single row containing the scalar values
+        """
+        return self._create_single_row_df(data)
+
+    def _create_single_row_df(self, data: dict[str, Any]) -> DF:
+        """Platform-specific single-row DataFrame creation.
+
+        Override in subclasses for platform-specific implementations.
+        Default uses Pandas-style dict-with-list construction.
+
+        Args:
+            data: Dictionary mapping column names to scalar values
+
+        Returns:
+            Single-row DataFrame
+        """
+        # Default implementation wraps each value in a list
+        # This works for Pandas, Modin, cuDF
+        # Subclasses may override for platform-specific optimizations
+        import pandas as pd
+
+        return pd.DataFrame({k: [v] for k, v in data.items()})  # type: ignore[return-value]
+
     def groupby_size(
         self,
         df: DF,
@@ -1162,19 +1217,15 @@ class PandasFamilyAdapter(TuningConfigurableMixin, ABC, Generic[DF]):
     def _detect_format(self, path: Path) -> str:
         """Detect file format from path.
 
+        Uses centralized utility that handles compression extensions.
+
         Args:
             path: Path to the file
 
         Returns:
             Format string: 'parquet', 'csv', or 'tbl'
         """
-        suffix = path.suffix.lower()
-        if suffix == ".parquet":
-            return "parquet"
-        elif suffix == ".tbl":
-            return "tbl"
-        else:
-            return "csv"
+        return detect_data_format(path)
 
     def _load_parquet_files(self, file_paths: list[Path]) -> DF:
         """Load Parquet files.

benchbox/platforms/dataframe/platform_checker.py

@@ -23,6 +23,8 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any
 
+from benchbox.utils.dependencies import get_extra_install_message
+
 logger = logging.getLogger(__name__)
 
 
@@ -288,27 +290,15 @@ def get_installation_suggestion(platform: str) -> str:
         # Core dependency (polars)
         return f"{info.name} is a core dependency and should already be installed."
 
-    lines = [
-        f"Platform '{info.name}' is not available.",
-        "",
-        "To install:",
-        f"  uv add benchbox --extra {info.extra_name}",
-        "",
-        "Alternative (pip-compatible):",
-        f'  uv pip install "benchbox[{info.extra_name}]"',
-        f'  python -m pip install "benchbox[{info.extra_name}]"',
-    ]
+    message = f"Platform '{info.name}' is not available.\n\n{get_extra_install_message(info.extra_name)}"
 
     if info.min_version:
-        lines.extend(
-            [
-                "",
-                f"Or install directly (minimum version {info.min_version}):",
-                f'  uv pip install "{info.import_name}>={info.min_version}"',
-            ]
+        message += (
+            f"\n\nOr install directly (minimum version {info.min_version}):\n"
+            f'  pip install "{info.import_name}>={info.min_version}"'
         )
 
-    return "\n".join(lines)
+    return message
 
 
 def get_platform_error_message(platform: str, error: Exception | None = None) -> str:
@@ -342,51 +332,28 @@ def get_platform_error_message(platform: str, error: Exception | None = None) ->
     ]
 
     if info.extra_name:
-        lines.extend(
-            [
-                "",
-                "Installation:",
-                f"  uv add benchbox --extra {info.extra_name}",
-                "",
-                "Alternative:",
-                f'  pip install "benchbox[{info.extra_name}]"',
-            ]
-        )
+        lines.append("")
+        lines.append(get_extra_install_message(info.extra_name))
     else:
         lines.extend(
             [
                 "",
                 f"{info.name} is a core dependency and should be installed automatically.",
                 "Try reinstalling benchbox:",
-                "  uv sync",
+                "  uv sync  # inside a project\n  uv tool install benchbox --force  # standalone tool",
             ]
         )
 
     # Add family group suggestions
     if info.family == DataFrameFamily.PANDAS:
-        lines.extend(
-            [
-                "",
-                "For all Pandas-family platforms:",
-                "  uv add benchbox --extra dataframe-pandas-family",
-            ]
-        )
+        lines.append("")
+        lines.append(get_extra_install_message("dataframe-pandas-family", "For all Pandas-family platforms:"))
     else:
-        lines.extend(
-            [
-                "",
-                "For all expression-family platforms:",
-                "  uv add benchbox --extra dataframe-expression-family",
-            ]
-        )
+        lines.append("")
+        lines.append(get_extra_install_message("dataframe-expression-family", "For all expression-family platforms:"))
 
-    lines.extend(
-        [
-            "",
-            "For all DataFrame platforms:",
-            "  uv add benchbox --extra dataframe-all",
-        ]
-    )
+    lines.append("")
+    lines.append(get_extra_install_message("dataframe-all", "For all DataFrame platforms:"))
 
     return "\n".join(lines)
 

benchbox/platforms/dataframe/polars_df.py

@@ -269,6 +269,8 @@ class PolarsDataFrameAdapter(ExpressionFamilyAdapter[PolarsDF, PolarsLazyDF, Pol
             "has_header": has_header,
             "rechunk": self.rechunk,
             "ignore_errors": True,
+            # Handle files with or without trailing delimiters
+            "truncate_ragged_lines": True,
         }
 
         # Add row limit if specified
@@ -277,22 +279,11 @@ class PolarsDataFrameAdapter(ExpressionFamilyAdapter[PolarsDF, PolarsLazyDF, Pol
 
         # Handle column names
         if column_names:
-            # For TBL files with trailing delimiter, add dummy column
-            path_str = str(path)
-            if path_str.endswith(".tbl"):
-                # TPC files have trailing delimiter
-                extended_names = column_names + ["_trailing_"]
-                scan_kwargs["new_columns"] = extended_names
-            else:
-                scan_kwargs["new_columns"] = column_names
+            scan_kwargs["new_columns"] = column_names
 
         # Scan the file(s)
         lf = pl.scan_csv(path, **scan_kwargs)
 
-        # Drop trailing column if present
-        if column_names and str(path).endswith(".tbl"):
-            lf = lf.drop("_trailing_")
-
         return lf
 
     def read_parquet(self, path: Path) -> PolarsLazyDF:
@@ -375,6 +366,17 @@ class PolarsDataFrameAdapter(ExpressionFamilyAdapter[PolarsDF, PolarsLazyDF, Pol
         # For multi-column DataFrames, select first column
         return df.select(df.columns[0]).item()
 
+    def scalar_to_df(self, data: dict[str, Any]) -> PolarsDF:
+        """Create a single-row Polars DataFrame from scalar values.
+
+        Args:
+            data: Dictionary mapping column names to scalar values
+
+        Returns:
+            Polars DataFrame with a single row
+        """
+        return pl.DataFrame({k: [v] for k, v in data.items()})
+
     # =========================================================================
     # Override Methods
     # =========================================================================