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

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 

parqv/views/components/error_display.py

@@ -0,0 +1,72 @@
+"""
+Error display component for parqv views.
+"""
+
+from typing import Optional
+
+from textual.containers import VerticalScroll
+from textual.widgets import Static, Label
+
+
+class ErrorDisplay(VerticalScroll):
+    """
+    A reusable component for displaying error messages in a consistent format.
+    """
+    
+    def __init__(self, 
+                 title: str = "Error", 
+                 message: str = "An error occurred",
+                 details: Optional[str] = None,
+                 **kwargs):
+        """
+        Initialize the error display.
+        
+        Args:
+            title: Error title/category
+            message: Main error message
+            details: Optional detailed error information
+            **kwargs: Additional arguments for VerticalScroll
+        """
+        super().__init__(**kwargs)
+        self.title = title
+        self.message = message
+        self.details = details
+    
+    def compose(self):
+        """Compose the error display layout."""
+        yield Label(self.title, classes="error-title")
+        yield Static(f"[red]{self.message}[/red]", classes="error-content")
+        
+        if self.details:
+            yield Static("Details:", classes="error-details-label")
+            yield Static(f"[dim]{self.details}[/dim]", classes="error-details")
+    
+    @classmethod
+    def file_not_found(cls, file_path: str, **kwargs) -> 'ErrorDisplay':
+        """Create an error display for file not found errors."""
+        return cls(
+            title="File Not Found",
+            message=f"Could not find file: {file_path}",
+            details="Please check that the file path is correct and the file exists.",
+            **kwargs
+        )
+    
+    @classmethod
+    def handler_not_available(cls, **kwargs) -> 'ErrorDisplay':
+        """Create an error display for missing data handler."""
+        return cls(
+            title="Data Handler Not Available",
+            message="No data handler is currently loaded",
+            details="This usually means the file could not be processed or loaded.",
+            **kwargs
+        )
+    
+    @classmethod
+    def data_loading_error(cls, error_msg: str, **kwargs) -> 'ErrorDisplay':
+        """Create an error display for data loading errors."""
+        return cls(
+            title="Data Loading Error",
+            message="Failed to load data from the file",
+            details=f"Technical details: {error_msg}",
+            **kwargs
+        ) 

parqv/views/components/loading_display.py

@@ -0,0 +1,44 @@
+"""
+Loading display component for parqv views.
+"""
+
+from textual.containers import Center, Middle
+from textual.widgets import LoadingIndicator, Label
+
+
+class LoadingDisplay(Center):
+    """
+    A reusable component for displaying loading states in a consistent format.
+    """
+    
+    def __init__(self, message: str = "Loading...", **kwargs):
+        """
+        Initialize the loading display.
+        
+        Args:
+            message: Loading message to display
+            **kwargs: Additional arguments for Center container
+        """
+        super().__init__(**kwargs)
+        self.message = message
+    
+    def compose(self):
+        """Compose the loading display layout."""
+        with Middle():
+            yield LoadingIndicator()
+            yield Label(self.message, classes="loading-message")
+    
+    @classmethod
+    def data_loading(cls, **kwargs) -> 'LoadingDisplay':
+        """Create a loading display for data loading operations."""
+        return cls(message="Loading data...", **kwargs)
+    
+    @classmethod
+    def metadata_loading(cls, **kwargs) -> 'LoadingDisplay':
+        """Create a loading display for metadata loading operations."""
+        return cls(message="Loading metadata...", **kwargs)
+    
+    @classmethod
+    def schema_loading(cls, **kwargs) -> 'LoadingDisplay':
+        """Create a loading display for schema loading operations."""
+        return cls(message="Loading schema...", **kwargs) 

parqv/views/data_view.py

@@ -1,68 +1,141 @@
-import logging
+"""
+Data view for displaying tabular data preview.
+"""
+
 from typing import Optional
 
 import pandas as pd
 from textual.app import ComposeResult
-from textual.containers import Container
-from textual.widgets import DataTable, Static
 
-log = logging.getLogger(__name__)
+from .base import BaseView
+from .components import EnhancedDataTable
+from ..core import DEFAULT_PREVIEW_ROWS
+
 
+class DataView(BaseView):
+    """
+    View for displaying a preview of the data in tabular format.
+    
+    Shows the first N rows of data in an interactive table format
+    with proper error handling and loading states.
+    """
 
-class DataView(Container):
-    DEFAULT_ROWS = 50
+    def __init__(self, preview_rows: int = DEFAULT_PREVIEW_ROWS, **kwargs):
+        """
+        Initialize the data view.
+        
+        Args:
+            preview_rows: Number of rows to show in preview
+            **kwargs: Additional arguments for BaseView
+        """
+        super().__init__(**kwargs)
+        self.preview_rows = preview_rows
+        self._data_table: Optional[EnhancedDataTable] = None
 
     def compose(self) -> ComposeResult:
-        yield DataTable(id="data-table")
+        """Compose the data view layout."""
+        self._data_table = EnhancedDataTable(id="data-preview-table")
+        yield self._data_table
 
-    def on_mount(self) -> None:
-        self.load_data()
+    def load_content(self) -> None:
+        """Load and display data content."""
+        if not self.check_handler_available():
+            return
 
-    def load_data(self):
-        table: Optional[DataTable] = self.query_one("#data-table", DataTable)
+        if not self._data_table:
+            self.show_error("Data table component not initialized")
+            return
 
         try:
-            table.clear(columns=True)
-        except Exception as e:
-            log.error(f"Error clearing DataTable: {e}")
-            try:
-                table.remove()
-                table = DataTable(id="data-table")
-                self.mount(table)
-            except Exception as remount_e:
-                log.error(f"Failed to remount DataTable: {remount_e}")
-                self.mount(Static("[red]Error initializing data table.[/red]", classes="error-content"))
+            # Get data preview from handler
+            self.logger.info(f"Loading data preview ({self.preview_rows} rows)")
+            df = self.handler.get_data_preview(num_rows=self.preview_rows)
+
+            # Validate DataFrame
+            if df is None:
+                self.show_error("Could not load data preview - handler returned None")
                 return
 
-        try:
-            if not self.app.handler:
-                self.mount(Static("Parquet handler not available.", classes="error-content"))
+            # Handle error DataFrame (some handlers return error as DataFrame)
+            if self._is_error_dataframe(df):
+                error_msg = self._extract_error_from_dataframe(df)
+                self.show_error(error_msg)
                 return
 
-            df: Optional[pd.DataFrame] = self.app.handler.get_data_preview(num_rows=self.DEFAULT_ROWS)
+            # Load DataFrame into table
+            success = self._data_table.load_dataframe(df, max_rows=self.preview_rows)
 
-            if df is None:
-                self.mount(Static("Could not load data preview."))
-                return
+            if success:
+                self.logger.info(f"Data preview loaded successfully: {len(df)} rows")
+            else:
+                self.show_error("Failed to load data into table component")
 
-            if df.empty:
-                self.mount(Static("No data in the preview range or file is empty."))
-                return
+        except Exception as e:
+            self.show_error("Failed to load data preview", e)
+
+    def _is_error_dataframe(self, df: pd.DataFrame) -> bool:
+        """
+        Check if the DataFrame represents an error condition.
+        
+        Args:
+            df: DataFrame to check
+            
+        Returns:
+            True if the DataFrame contains error information
+        """
+        return (
+                not df.empty and
+                "error" in df.columns and
+                len(df.columns) == 1
+        )
+
+    def _extract_error_from_dataframe(self, df: pd.DataFrame) -> str:
+        """
+        Extract error message from an error DataFrame.
+        
+        Args:
+            df: Error DataFrame
+            
+        Returns:
+            Error message string
+        """
+        try:
+            if not df.empty and "error" in df.columns:
+                return str(df["error"].iloc[0])
+        except Exception:
+            pass
+        return "Unknown error in data loading"
+
+    def refresh_data(self) -> None:
+        """Refresh the data display."""
+        self.clear_content()
+        self.load_content()
 
-            table.cursor_type = "row"
-            columns = [str(col) for col in df.columns]
-            table.add_columns(*columns)
-            rows_data = [
-                tuple(str(item) if pd.notna(item) else "" for item in row)
-                for row in df.itertuples(index=False, name=None)
-            ]
-            table.add_rows(rows_data)
-            log.info("DataTable populated successfully.")
+    def set_preview_rows(self, new_rows: int) -> None:
+        """
+        Update the number of preview rows and refresh display.
+        
+        Args:
+            new_rows: New number of rows to preview
+        """
+        if new_rows > 0:
+            self.preview_rows = new_rows
+            self.refresh_data()
+        else:
+            self.logger.warning(f"Invalid preview_rows value: {new_rows}")
 
+    def get_current_data(self) -> Optional[pd.DataFrame]:
+        """
+        Get the currently displayed data if available.
+        
+        Returns:
+            Currently loaded DataFrame or None
+        """
+        if not self.handler:
+            return None
+
+        try:
+            return self.handler.get_data_preview(num_rows=self.preview_rows)
         except Exception as e:
-            log.exception("Error loading data preview in DataView:")
-            try:
-                self.query("DataTable, Static").remove()
-                self.mount(Static(f"Error loading data preview: {e}", classes="error-content"))
-            except Exception as display_e:
-                log.error(f"Error displaying error message: {display_e}")
+            self.logger.error(f"Failed to get current data: {e}")
+            return None

parqv/views/metadata_view.py

@@ -1,19 +1,63 @@
-from textual.containers import VerticalScroll
-from textual.widgets import Static, Pretty
+"""
+Metadata view for displaying file metadata information.
+"""
 
+from textual.containers import VerticalScroll
+from textual.widgets import Pretty
 
-class MetadataView(VerticalScroll):
+from .base import BaseView
+from .components import ErrorDisplay
+from .utils import format_metadata_for_display
 
-    def on_mount(self) -> None:
-        self.load_metadata()
 
-    def load_metadata(self):
+class MetadataView(BaseView):
+    """
+    View for displaying metadata information about the loaded file.
+    
+    Shows file statistics, format information, and other metadata
+    in a formatted display.
+    """
+    
+    def load_content(self) -> None:
+        """Load and display metadata content."""
+        if not self.check_handler_available():
+            return
+        
+        try:
+            # Get raw metadata from handler
+            raw_metadata = self.handler.get_metadata_summary()
+            
+            # Format metadata for display
+            formatted_metadata = format_metadata_for_display(raw_metadata)
+            
+            # Check if there's an error in the formatted data
+            if "Error" in formatted_metadata and len(formatted_metadata) == 1:
+                self.show_error(formatted_metadata["Error"])
+                return
+            
+            # Display the formatted metadata
+            self._display_metadata(formatted_metadata)
+            
+            self.logger.info("Metadata loaded successfully")
+            
+        except Exception as e:
+            self.show_error("Failed to load metadata", e)
+    
+    def _display_metadata(self, metadata: dict) -> None:
+        """
+        Display the formatted metadata using Pretty widget.
+        
+        Args:
+            metadata: Formatted metadata dictionary
+        """
         try:
-            if self.app.handler:
-                meta_data = self.app.handler.get_metadata_summary()
-                pretty_widget = Pretty(meta_data)
-                self.mount(pretty_widget)
-            else:
-                self.mount(Static("Parquet handler not available.", classes="error-content"))
+            pretty_widget = Pretty(metadata, id="metadata-pretty")
+            self.mount(pretty_widget)
         except Exception as e:
-            self.mount(Static(f"Error loading metadata: {e}", classes="error-content"))
+            self.logger.error(f"Failed to create Pretty widget: {e}")
+            self.show_error("Failed to display metadata")
+    
+    def refresh_metadata(self) -> None:
+        """Refresh the metadata display."""
+        self.clear_content()
+        self.load_content()