parqv 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

parqv/{handlers → data_sources/formats}/parquet.py

@@ -1,4 +1,3 @@
-import logging
 from pathlib import Path
 from typing import Any, Dict, List, Tuple, Optional, Union
 
@@ -7,9 +6,7 @@ import pyarrow as pa
 import pyarrow.compute as pc
 import pyarrow.parquet as pq
 
-from .base_handler import DataHandler, DataHandlerError
-
-log = logging.getLogger(__name__)
+from ..base import DataHandler, DataHandlerError
 
 
 class ParquetHandlerError(DataHandlerError):
@@ -49,17 +46,17 @@ class ParquetHandler(DataHandler):
             self.pq_file = pq.ParquetFile(self.file_path)
             self.schema = self.pq_file.schema_arrow
             self.metadata = self.pq_file.metadata
-            log.info(f"Successfully initialized ParquetHandler for: {self.file_path.name}")
+            self.logger.info(f"Successfully initialized ParquetHandler for: {self.file_path.name}")
 
         except FileNotFoundError as fnf_e:
-            log.error(f"File not found during ParquetHandler initialization: {fnf_e}")
+            self.logger.error(f"File not found during ParquetHandler initialization: {fnf_e}")
             raise ParquetHandlerError(str(fnf_e)) from fnf_e
         except pa.lib.ArrowIOError as arrow_io_e:
-            log.error(f"Arrow IO Error initializing ParquetHandler for {self.file_path.name}: {arrow_io_e}")
+            self.logger.error(f"Arrow IO Error initializing ParquetHandler for {self.file_path.name}: {arrow_io_e}")
             raise ParquetHandlerError(
                 f"Failed to open Parquet file '{self.file_path.name}': {arrow_io_e}") from arrow_io_e
         except Exception as e:
-            log.exception(f"Unexpected error initializing ParquetHandler for {self.file_path.name}")
+            self.logger.exception(f"Unexpected error initializing ParquetHandler for {self.file_path.name}")
             self.close()
             raise ParquetHandlerError(f"Failed to initialize Parquet handler '{self.file_path.name}': {e}") from e
 
@@ -71,10 +68,10 @@ class ParquetHandler(DataHandler):
                 # ParquetFile might not have a close method depending on source, check first
                 if hasattr(self.pq_file, 'close'):
                     self.pq_file.close()
-                log.info(f"Closed Parquet file: {self.file_path.name}")
+                self.logger.info(f"Closed Parquet file: {self.file_path.name}")
             except Exception as e:
                 # Log error during close but don't raise, as we're cleaning up
-                log.warning(f"Exception while closing Parquet file {self.file_path.name}: {e}")
+                self.logger.warning(f"Exception while closing Parquet file {self.file_path.name}: {e}")
             finally:
                 self.pq_file = None
                 self.schema = None
@@ -102,7 +99,7 @@ class ParquetHandler(DataHandler):
             A dictionary containing key metadata attributes, or an error dictionary.
         """
         if not self.metadata or not self.schema:
-            log.warning(f"Metadata or schema not available for summary: {self.file_path.name}")
+            self.logger.warning(f"Metadata or schema not available for summary: {self.file_path.name}")
             return {"error": "Metadata or schema not available"}
 
         try:
@@ -126,7 +123,7 @@ class ParquetHandler(DataHandler):
 
             return summary
         except Exception as e:
-            log.exception(f"Error generating metadata summary for {self.file_path.name}")
+            self.logger.exception(f"Error generating metadata summary for {self.file_path.name}")
             return {"error": f"Error getting metadata summary: {e}"}
 
     def get_schema_data(self) -> Optional[List[Dict[str, Any]]]:
@@ -138,7 +135,7 @@ class ParquetHandler(DataHandler):
             or None if the schema is unavailable.
         """
         if not self.schema:
-            log.warning(f"Schema is not available for get_schema_data: {self.file_path.name}")
+            self.logger.warning(f"Schema is not available for get_schema_data: {self.file_path.name}")
             return None
 
         schema_list = []
@@ -151,7 +148,7 @@ class ParquetHandler(DataHandler):
                     "nullable": field.nullable
                 })
             except Exception as e:
-                log.error(f"Error processing field '{field.name}' for schema data: {e}", exc_info=True)
+                self.logger.error(f"Error processing field '{field.name}' for schema data: {e}", exc_info=True)
                 schema_list.append({
                     "name": field.name,
                     "type": f"[Error: {e}]",
@@ -172,11 +169,11 @@ class ParquetHandler(DataHandler):
             Returns a DataFrame with an 'error' column on failure.
         """
         if not self.pq_file:
-            log.warning(f"ParquetFile handler not available for data preview: {self.file_path.name}")
+            self.logger.warning(f"ParquetFile handler not available for data preview: {self.file_path.name}")
             return pd.DataFrame({"error": ["Parquet handler not initialized or closed."]})
 
         if self.metadata and self.metadata.num_rows == 0:
-            log.info(f"Parquet file is empty based on metadata: {self.file_path.name}")
+            self.logger.info(f"Parquet file is empty based on metadata: {self.file_path.name}")
             if self.schema:
                 return pd.DataFrame(columns=self.schema.names)
             else:
@@ -206,10 +203,10 @@ class ParquetHandler(DataHandler):
             if not batches:
                 # Check if file might have rows but reading yielded nothing
                 if self.metadata and self.metadata.num_rows > 0:
-                    log.warning(
+                    self.logger.warning(
                         f"No batches read for preview, though metadata indicates {self.metadata.num_rows} rows: {self.file_path.name}")
                 else:
-                    log.info(f"No data read for preview (file likely empty): {self.file_path.name}")
+                    self.logger.info(f"No data read for preview (file likely empty): {self.file_path.name}")
                 # Return empty DF with columns if schema available
                 if self.schema:
                     return pd.DataFrame(columns=self.schema.names)
@@ -223,11 +220,11 @@ class ParquetHandler(DataHandler):
                 self_destruct=True,
                 types_mapper=pd.ArrowDtype
             )
-            log.info(f"Generated preview of {len(df)} rows for {self.file_path.name}")
+            self.logger.info(f"Generated preview of {len(df)} rows for {self.file_path.name}")
             return df
 
         except Exception as e:
-            log.exception(f"Error generating data preview from Parquet file: {self.file_path.name}")
+            self.logger.exception(f"Error generating data preview from Parquet file: {self.file_path.name}")
             return pd.DataFrame({"error": [f"Failed to fetch preview: {e}"]})
 
     def get_column_stats(self, column_name: str) -> Dict[str, Any]:
@@ -242,13 +239,13 @@ class ParquetHandler(DataHandler):
             and potential error or message keys.
         """
         if not self.pq_file or not self.schema:
-            log.warning(f"Parquet file/schema unavailable for column stats: {self.file_path.name}")
+            self.logger.warning(f"Parquet file/schema unavailable for column stats: {self.file_path.name}")
             return self._create_stats_result(column_name, None, error="File or schema not available")
 
         try:
             field = self.schema.field(column_name)
         except KeyError:
-            log.warning(f"Column '{column_name}' not found in schema: {self.file_path.name}")
+            self.logger.warning(f"Column '{column_name}' not found in schema: {self.file_path.name}")
             return self._create_stats_result(column_name, None, error=f"Column '{column_name}' not found in schema")
 
         calculated_stats: Dict[str, Any] = {}
@@ -261,7 +258,7 @@ class ParquetHandler(DataHandler):
             # Data Reading
             table = self.pq_file.read(columns=[column_name])
             column_data = table.column(0)
-            log.debug(
+            self.logger.debug(
                 f"Finished reading column '{column_name}'. Rows: {len(column_data)}, Nulls: {column_data.null_count}")
 
             # Basic Counts
@@ -274,14 +271,14 @@ class ParquetHandler(DataHandler):
                 calculated_stats["Null Count"] = f"{null_count:,}"
                 calculated_stats["Null Percentage"] = f"{(null_count / total_count * 100):.2f}%"
             else:
-                log.info(f"Column '{column_name}' read resulted in 0 rows.")
+                self.logger.info(f"Column '{column_name}' read resulted in 0 rows.")
                 message = "Column is empty (0 rows)."
                 valid_count = 0  # Ensure valid_count is 0 for later checks
 
             # Type-Specific Calculations
             if valid_count > 0:
                 col_type = field.type
-                log.debug(f"Calculating stats for type: {self._format_pyarrow_type(col_type)}")
+                self.logger.debug(f"Calculating stats for type: {self._format_pyarrow_type(col_type)}")
                 try:
                     if pa.types.is_floating(col_type) or pa.types.is_integer(col_type):
                         calculated_stats.update(self._calculate_numeric_stats(column_data))
@@ -300,11 +297,11 @@ class ParquetHandler(DataHandler):
                         calculated_stats.update(self._calculate_complex_type_stats(column_data, col_type))
                         message = f"Basic aggregate stats (min/max/mean) not applicable for complex type '{self._format_pyarrow_type(col_type)}'."
                     else:
-                        log.warning(f"Statistics calculation not fully implemented for type: {col_type}")
+                        self.logger.warning(f"Statistics calculation not fully implemented for type: {col_type}")
                         message = f"Statistics calculation not implemented for type '{self._format_pyarrow_type(col_type)}'."
 
                 except Exception as calc_err:
-                    log.exception(f"Error during type-specific calculation for column '{column_name}': {calc_err}")
+                    self.logger.exception(f"Error during type-specific calculation for column '{column_name}': {calc_err}")
                     error_msg = f"Calculation error for type {field.type}: {calc_err}"
                     calculated_stats["Calculation Error"] = str(calc_err)  # Add specific error key
 
@@ -315,10 +312,10 @@ class ParquetHandler(DataHandler):
             metadata_stats, metadata_stats_error = self._get_stats_from_metadata(column_name)
 
         except pa.lib.ArrowException as arrow_e:
-            log.exception(f"Arrow error during stats processing for column '{column_name}': {arrow_e}")
+            self.logger.exception(f"Arrow error during stats processing for column '{column_name}': {arrow_e}")
             error_msg = f"Arrow processing error: {arrow_e}"
         except Exception as e:
-            log.exception(f"Unexpected error during stats calculation for column '{column_name}'")
+            self.logger.exception(f"Unexpected error during stats calculation for column '{column_name}'")
             error_msg = f"Calculation failed unexpectedly: {e}"
 
         return self._create_stats_result(
@@ -331,7 +328,7 @@ class ParquetHandler(DataHandler):
             try:
                 return value.decode('utf-8', errors='replace')
             except Exception as e:
-                log.warning(f"Could not decode metadata bytes: {e}. Value: {value!r}")
+                self.logger.warning(f"Could not decode metadata bytes: {e}. Value: {value!r}")
                 return f"[Decode Error: {value!r}]"
         return str(value) if value is not None else None
 
@@ -348,7 +345,7 @@ class ParquetHandler(DataHandler):
                 decoded_kv[key_str] = val_str
             return decoded_kv
         except Exception as e:
-            log.warning(f"Could not decode key-value metadata: {e}")
+            self.logger.warning(f"Could not decode key-value metadata: {e}")
             return {"error": f"Error decoding key-value metadata: {e}"}
 
     def _format_pyarrow_type(self, field_type: pa.DataType) -> str:
@@ -438,23 +435,10 @@ class ParquetHandler(DataHandler):
         return stats
 
     def _calculate_string_binary_stats(self, column_data: pa.ChunkedArray) -> Dict[str, Any]:
-        """Calculates distinct count and optionally length stats for string/binary."""
+        """Calculates distinct count for string/binary columns."""
         stats: Dict[str, Any] = {}
         distinct_val, err = self._safe_compute(pc.count_distinct, column_data)
         stats["Distinct Count"] = f"{distinct_val:,}" if distinct_val is not None and err is None else (err or "N/A")
-
-        if pa.types.is_string(column_data.type) or pa.types.is_large_string(column_data.type):
-            lengths, err_len = self._safe_compute(pc.binary_length, column_data)
-            if err_len is None and lengths is not None:
-                min_len, err_min = self._safe_compute(pc.min, lengths)
-                stats["Min Length"] = min_len if err_min is None else err_min
-                max_len, err_max = self._safe_compute(pc.max, lengths)
-                stats["Max Length"] = max_len if err_max is None else err_max
-                avg_len, err_avg = self._safe_compute(pc.mean, lengths)
-                stats["Avg Length"] = f"{avg_len:.2f}" if avg_len is not None and err_avg is None else (
-                        err_avg or "N/A")
-            else:
-                stats.update({"Min Length": "Error", "Max Length": "Error", "Avg Length": "Error"})
         return stats
 
     def _calculate_boolean_stats(self, column_data: pa.ChunkedArray) -> Dict[str, Any]:
@@ -480,7 +464,7 @@ class ParquetHandler(DataHandler):
             if 'False' not in stats["Value Counts"]: stats["Value Counts"]['False'] = "0"
 
         except Exception as vc_e:
-            log.warning(f"Boolean value count calculation error: {vc_e}", exc_info=True)
+            self.logger.warning(f"Boolean value count calculation error: {vc_e}", exc_info=True)
             stats["Value Counts"] = "Error calculating"
         return stats
 
@@ -490,7 +474,7 @@ class ParquetHandler(DataHandler):
         try:
             unwrapped_data = column_data.dictionary_decode()
             value_type = col_type.value_type
-            log.debug(f"Calculating dictionary stats based on value type: {value_type}")
+            self.logger.debug(f"Calculating dictionary stats based on value type: {value_type}")
 
             # Delegate calculation based on the *value* type
             if pa.types.is_floating(value_type) or pa.types.is_integer(value_type):
@@ -511,10 +495,10 @@ class ParquetHandler(DataHandler):
                         err or "N/A")
 
         except pa.lib.ArrowException as arrow_decode_err:
-            log.warning(f"Arrow error decoding dictionary type for stats: {arrow_decode_err}")
+            self.logger.warning(f"Arrow error decoding dictionary type for stats: {arrow_decode_err}")
             stats["Dictionary Error"] = f"Decode Error: {arrow_decode_err}"
         except Exception as dict_e:
-            log.warning(f"Could not process dictionary type for stats: {dict_e}")
+            self.logger.warning(f"Could not process dictionary type for stats: {dict_e}")
             stats["Dictionary Error"] = f"Processing Error: {dict_e}"
         return stats
 
@@ -545,17 +529,17 @@ class ParquetHandler(DataHandler):
                     rg_meta = self.metadata.row_group(i)
                     metadata_stats[group_key] = self._extract_stats_for_single_group(rg_meta, col_index)
                 except IndexError:
-                    log.warning(f"Column index {col_index} out of bounds for row group {i}.")
+                    self.logger.warning(f"Column index {col_index} out of bounds for row group {i}.")
                     metadata_stats[group_key] = "Index Error"
                 except Exception as e:
-                    log.warning(f"Error processing metadata stats for RG {i}, column '{column_name}': {e}")
+                    self.logger.warning(f"Error processing metadata stats for RG {i}, column '{column_name}': {e}")
                     metadata_stats[group_key] = f"Read Error: {e}"
 
         except KeyError:
-            log.warning(f"Column '{column_name}' not found in schema for metadata stats.")
+            self.logger.warning(f"Column '{column_name}' not found in schema for metadata stats.")
             error_str = f"Column '{column_name}' not found in schema"
         except Exception as e:
-            log.exception(f"Failed to get metadata statistics structure for column '{column_name}'.")
+            self.logger.exception(f"Failed to get metadata statistics structure for column '{column_name}'.")
             error_str = f"Error accessing metadata structure: {e}"
 
         return metadata_stats, error_str
@@ -587,10 +571,10 @@ class ParquetHandler(DataHandler):
                                             col_chunk_meta.total_uncompressed_size is not None),
             }
         except IndexError:
-            log.warning(f"Column index {col_index} out of bounds for row group {rg_meta.num_columns} columns.")
+            self.logger.warning(f"Column index {col_index} out of bounds for row group {rg_meta.num_columns} columns.")
             return "Index Error"
         except Exception as e:
-            log.error(f"Error reading column chunk metadata stats for index {col_index}: {e}", exc_info=True)
+            self.logger.error(f"Error reading column chunk metadata stats for index {col_index}: {e}", exc_info=True)
             return f"Metadata Read Error: {e}"
 
     def _create_stats_result(
@@ -613,7 +597,7 @@ class ParquetHandler(DataHandler):
                 col_type_str = self._format_pyarrow_type(field.type)
                 col_nullable = field.nullable
             except Exception as e:
-                log.error(f"Error formatting type for column {column_name}: {e}")
+                self.logger.error(f"Error formatting type for column {column_name}: {e}")
                 col_type_str = f"[Error formatting: {field.type}]"
                 col_nullable = None
 

parqv/views/__init__.py

@@ -0,0 +1,38 @@
+"""
+Views package for parqv application.
+
+This package contains all UI views and their supporting components and utilities.
+"""
+
+# Main views
+from .metadata_view import MetadataView
+from .data_view import DataView
+from .schema_view import SchemaView
+
+# Base classes
+from .base import BaseView
+
+# Components (optional, for advanced usage)
+from .components import ErrorDisplay, LoadingDisplay, EnhancedDataTable
+
+# Utilities (optional, for advanced usage)
+from .utils import format_metadata_for_display, format_stats_for_display
+
+__all__ = [
+    # Main views - these are the primary exports
+    "MetadataView",
+    "DataView", 
+    "SchemaView",
+    
+    # Base class - for extending functionality
+    "BaseView",
+    
+    # Components - for custom view development
+    "ErrorDisplay",
+    "LoadingDisplay",
+    "EnhancedDataTable",
+    
+    # Utilities - for data formatting
+    "format_metadata_for_display",
+    "format_stats_for_display",
+]

parqv/views/base.py

@@ -0,0 +1,98 @@
+"""
+Base classes for parqv views.
+"""
+
+from typing import Optional
+
+from textual.containers import Container
+from textual.widgets import Static
+
+from ..core import get_logger
+from ..data_sources import DataHandler
+
+
+class BaseView(Container):
+    """
+    Base class for all parqv views.
+    
+    Provides common functionality for data loading, error handling,
+    and handler access.
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._is_mounted = False
+
+    @property
+    def logger(self):
+        """Get a logger for this view."""
+        return get_logger(f"{self.__class__.__module__}.{self.__class__.__name__}")
+
+    @property
+    def handler(self) -> Optional[DataHandler]:
+        """Get the data handler from the app."""
+        if hasattr(self.app, 'handler'):
+            return self.app.handler
+        return None
+
+    def on_mount(self) -> None:
+        """Called when the view is mounted."""
+        self._is_mounted = True
+        self.load_content()
+
+    def load_content(self) -> None:
+        """
+        Load the main content for this view. Must be implemented by subclasses.
+        
+        Raises:
+            NotImplementedError: If not implemented by subclass
+        """
+        raise NotImplementedError("Subclasses must implement load_content()")
+
+    def clear_content(self) -> None:
+        """Clear all content from the view."""
+        try:
+            self.query("*").remove()
+        except Exception as e:
+            self.logger.error(f"Error clearing content: {e}")
+
+    def show_error(self, message: str, exception: Optional[Exception] = None) -> None:
+        """
+        Display an error message in the view.
+        
+        Args:
+            message: Error message to display
+            exception: Optional exception that caused the error
+        """
+        if exception:
+            self.logger.exception(f"Error in {self.__class__.__name__}: {message}")
+        else:
+            self.logger.error(f"Error in {self.__class__.__name__}: {message}")
+
+        self.clear_content()
+        error_widget = Static(f"[red]Error: {message}[/red]", classes="error-content")
+        self.mount(error_widget)
+
+    def show_info(self, message: str) -> None:
+        """
+        Display an informational message in the view.
+        
+        Args:
+            message: Info message to display
+        """
+        self.logger.info(f"Info in {self.__class__.__name__}: {message}")
+        self.clear_content()
+        info_widget = Static(f"[blue]Info: {message}[/blue]", classes="info-content")
+        self.mount(info_widget)
+
+    def check_handler_available(self) -> bool:
+        """
+        Check if handler is available and show error if not.
+        
+        Returns:
+            True if handler is available, False otherwise
+        """
+        if not self.handler:
+            self.show_error("Data handler not available")
+            return False
+        return True

parqv/views/components/__init__.py

@@ -0,0 +1,13 @@
+"""
+Reusable UI components for parqv views.
+"""
+
+from .error_display import ErrorDisplay
+from .loading_display import LoadingDisplay
+from .enhanced_data_table import EnhancedDataTable
+
+__all__ = [
+    "ErrorDisplay",
+    "LoadingDisplay", 
+    "EnhancedDataTable",
+] 

parqv/views/components/enhanced_data_table.py

@@ -0,0 +1,152 @@
+"""
+Enhanced data table component for parqv views.
+"""
+
+from typing import Optional, List, Tuple, Any
+
+import pandas as pd
+from textual.containers import Container
+from textual.widgets import DataTable, Static
+
+from ...core import get_logger
+
+log = get_logger(__name__)
+
+
+class EnhancedDataTable(Container):
+    """
+    An enhanced data table component that handles DataFrame display with better error handling.
+    """
+    
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._table: Optional[DataTable] = None
+    
+    def compose(self):
+        """Compose the data table layout."""
+        self._table = DataTable(id="enhanced-data-table")
+        self._table.cursor_type = "row"
+        yield self._table
+    
+    def clear_table(self) -> bool:
+        """
+        Clear the table contents safely.
+        
+        Returns:
+            True if cleared successfully, False if recreation was needed
+        """
+        if not self._table:
+            return False
+            
+        try:
+            self._table.clear(columns=True)
+            return True
+        except Exception as e:
+            log.warning(f"Failed to clear table, recreating: {e}")
+            return self._recreate_table()
+    
+    def _recreate_table(self) -> bool:
+        """
+        Recreate the table if clearing failed.
+        
+        Returns:
+            True if recreation was successful, False otherwise
+        """
+        try:
+            if self._table:
+                self._table.remove()
+            
+            self._table = DataTable(id="enhanced-data-table")
+            self._table.cursor_type = "row"
+            self.mount(self._table)
+            return True
+        except Exception as e:
+            log.error(f"Failed to recreate table: {e}")
+            return False
+    
+    def load_dataframe(self, df: pd.DataFrame, max_rows: Optional[int] = None) -> bool:
+        """
+        Load a pandas DataFrame into the table.
+        
+        Args:
+            df: The DataFrame to load
+            max_rows: Optional maximum number of rows to display
+            
+        Returns:
+            True if loaded successfully, False otherwise
+        """
+        if not self._table:
+            log.error("Table not initialized")
+            return False
+        
+        try:
+            # Clear existing content
+            if not self.clear_table():
+                return False
+            
+            # Handle empty DataFrame
+            if df.empty:
+                self._show_empty_message()
+                return True
+            
+            # Limit rows if specified
+            display_df = df.head(max_rows) if max_rows else df
+            
+            # Add columns
+            columns = [str(col) for col in display_df.columns]
+            self._table.add_columns(*columns)
+            
+            # Add rows
+            rows_data = self._prepare_rows_data(display_df)
+            self._table.add_rows(rows_data)
+            
+            log.info(f"Loaded {len(display_df)} rows and {len(columns)} columns into table")
+            return True
+            
+        except Exception as e:
+            log.exception(f"Error loading DataFrame into table: {e}")
+            self._show_error_message(f"Failed to load data: {e}")
+            return False
+    
+    def _prepare_rows_data(self, df: pd.DataFrame) -> List[Tuple[str, ...]]:
+        """
+        Prepare DataFrame rows for the DataTable.
+        
+        Args:
+            df: The DataFrame to process
+            
+        Returns:
+            List of tuples representing table rows
+        """
+        rows_data = []
+        for row in df.itertuples(index=False, name=None):
+            # Convert each item to string, handling NaN values
+            row_strings = tuple(
+                str(item) if pd.notna(item) else "" 
+                for item in row
+            )
+            rows_data.append(row_strings)
+        return rows_data
+    
+    def _show_empty_message(self) -> None:
+        """Show a message when the DataFrame is empty."""
+        try:
+            self.query("Static").remove()  # Remove any existing messages
+            empty_msg = Static("No data available in the selected range or file is empty.", 
+                             classes="info-content")
+            self.mount(empty_msg)
+        except Exception as e:
+            log.error(f"Failed to show empty message: {e}")
+    
+    def _show_error_message(self, message: str) -> None:
+        """Show an error message in the table area."""
+        try:
+            self.query("DataTable, Static").remove()  # Remove table and any messages
+            error_msg = Static(f"[red]{message}[/red]", classes="error-content")
+            self.mount(error_msg)
+        except Exception as e:
+            log.error(f"Failed to show error message: {e}")
+    
+    def get_table(self) -> Optional[DataTable]:
+        """Get the underlying DataTable widget."""
+        return self._table