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

parqv/views/schema_view.py

@@ -1,17 +1,21 @@
-import logging
-from typing import Dict, Any, Optional, List, Union
+"""
+Schema view for displaying column schema and statistics.
+"""
+
+from typing import Dict, Any, Optional, List
 
 from rich.text import Text
 from textual.app import ComposeResult
-from textual.containers import VerticalScroll, Container
+from textual.containers import VerticalScroll, Container, Horizontal
 from textual.reactive import var
 from textual.widgets import Static, ListView, ListItem, Label, LoadingIndicator
 
-log = logging.getLogger(__name__)
+from .base import BaseView
+from .utils import format_stats_for_display
 
 
 class ColumnListItem(ListItem):
-    """A ListItem that stores the column name."""
+    """A ListItem that stores the column name for schema display."""
 
     def __init__(self, column_name: str) -> None:
         # Ensure IDs are CSS-safe (replace spaces, etc.)
@@ -20,227 +24,213 @@ class ColumnListItem(ListItem):
         self.column_name = column_name
 
 
-def format_stats_for_display(stats_data: Dict[str, Any]) -> List[Union[str, Text]]:
-    """Formats the statistics dictionary for display as lines of text."""
-    if not stats_data:
-        return [Text.from_markup("[red]No statistics data available.[/red]")]
-
-    lines: List[Union[str, Text]] = []
-    col_name = stats_data.get("column", "N/A")
-    col_type = stats_data.get("type", "Unknown")
-    nullable_val = stats_data.get("nullable")
-
-    if nullable_val is True:
-        nullable_str = "Nullable"
-    elif nullable_val is False:
-        nullable_str = "Required"
-    else:
-        nullable_str = "Unknown Nullability"
-    lines.append(Text.assemble(("Column: ", "bold"), f"`{col_name}`"))
-    lines.append(Text.assemble(("Type:   ", "bold"), f"{col_type} ({nullable_str})"))
-    lines.append("─" * (len(col_name) + len(col_type) + 20))
-
-    calc_error = stats_data.get("error")
-    if calc_error:
-        lines.append(Text("Calculation Error:", style="bold red"))
-        lines.append(f"```\n{calc_error}\n```")
-        lines.append("")
-
-    message = stats_data.get("message")
-    if message:
-        lines.append(Text(f"Info: {message}", style="italic cyan"))
-        lines.append("")
-
-    calculated = stats_data.get("calculated")
-    if calculated:
-        lines.append(Text("Calculated Statistics:", style="bold"))
-        keys_to_display = [
-            "Total Count", "Valid Count", "Null Count", "Null Percentage",
-            "Min", "Max", "Mean", "StdDev", "Variance",
-            "Distinct Count", "Min Length", "Max Length", "Avg Length",
-            "Value Counts"
-        ]
-        found_stats = False
-        for key in keys_to_display:
-            if key in calculated:
-                found_stats = True
-                value = calculated[key]
-                if key == "Value Counts" and isinstance(value, dict):
-                    lines.append(f"  - {key}:")
-                    for sub_key, sub_val in value.items():
-                        sub_val_str = f"{sub_val:,}" if isinstance(sub_val, (int, float)) else str(sub_val)
-                        lines.append(f"    - {sub_key}: {sub_val_str}")
-                elif isinstance(value, (int, float)):
-                    lines.append(f"  - {key}: {value:,}")
-                else:
-                    lines.append(f"  - {key}: {value}")
-        if not found_stats and not calc_error:
-            lines.append(Text("  (No specific stats calculated for this type)", style="dim"))
-    return lines
+class SchemaView(BaseView):
+    """
+    View for displaying schema information and column statistics.
+    
+    Shows a list of columns on the left and detailed statistics
+    for the selected column on the right.
+    """
 
+    DEFAULT_STATS_MESSAGE = "Select a column from the list to view its statistics."
 
-class SchemaView(VerticalScroll):
-    """Displays a list of columns and the statistics for the selected column."""
-    DEFAULT_STATS_MESSAGE = "Select a column from the list above to view its statistics."
+    # Reactive variable for loading state
     loading = var(False)
 
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._columns_data: Optional[List[Dict[str, Any]]] = None
+        self._current_column: Optional[str] = None
+
     def compose(self) -> ComposeResult:
-        """Create child widgets for the SchemaView."""
-        yield ListView(id="column-list-view")
-        yield LoadingIndicator(id="schema-loading-indicator")
-        yield VerticalScroll(Container(id="schema-stats-content"), id="schema-stats-scroll")
-
-    def on_mount(self) -> None:
-        """Called when the widget is mounted."""
-        self.query_one("#schema-loading-indicator", LoadingIndicator).display = False
-        self.query_one("#schema-stats-content", Container).display = False
-        self.call_later(self.load_column_list)
-        self.call_later(self._display_default_message)
-
-    def _display_default_message(self):
-        """Helper to display the initial message in the stats area."""
+        """Compose the schema view layout."""
+        with Horizontal():
+            # Left side: Column list
+            with Container(id="column-list-container", classes="column-list"):
+                yield Static("Columns", classes="section-title")
+                yield ListView(id="column-list-view")
+
+            # Right side: Column statistics
+            with Container(id="stats-container", classes="column-stats"):
+                yield Static("Column Statistics", classes="section-title")
+                with VerticalScroll(id="schema-stats-scroll"):
+                    yield Container(id="schema-stats-content")
+                yield LoadingIndicator(id="schema-loading-indicator")
+
+    def load_content(self) -> None:
+        """Load schema content."""
+        if not self.check_handler_available():
+            return
+
+        try:
+            # Load column list
+            self._load_column_list()
+
+            # Display default message in stats area
+            self._display_default_message()
+
+            self.logger.info("Schema loaded successfully")
+
+        except Exception as e:
+            self.show_error("Failed to load schema", e)
+
+    def _load_column_list(self) -> None:
+        """Load the list of columns from the data handler."""
+        try:
+            list_view = self.query_one("#column-list-view", ListView)
+            list_view.clear()
+
+            # Get schema data from handler
+            self._columns_data = self.handler.get_schema_data()
+            self.logger.debug(f"Received schema data: {self._columns_data}")
+
+            if self._columns_data is None:
+                self._show_list_error("Could not load schema data")
+                return
+
+            if not self._columns_data:
+                self._show_list_warning("Schema has no columns")
+                return
+
+            # Populate column list
+            column_count = 0
+            for col_info in self._columns_data:
+                column_name = col_info.get("name")
+                if column_name:
+                    list_view.append(ColumnListItem(column_name))
+                    column_count += 1
+                else:
+                    self.logger.warning("Found column info without a 'name' key")
+
+            self.logger.info(f"Populated column list with {column_count} columns")
+
+        except Exception as e:
+            self.logger.exception("Error loading column list")
+            self._show_list_error(f"Error loading schema: {e}")
+
+    def _show_list_error(self, message: str) -> None:
+        """Show error message in the column list."""
+        try:
+            list_view = self.query_one("#column-list-view", ListView)
+            list_view.clear()
+            list_view.append(ListItem(Label(f"[red]{message}[/red]")))
+        except Exception as e:
+            self.logger.error(f"Failed to show list error: {e}")
+
+    def _show_list_warning(self, message: str) -> None:
+        """Show warning message in the column list."""
+        try:
+            list_view = self.query_one("#column-list-view", ListView)
+            list_view.clear()
+            list_view.append(ListItem(Label(f"[yellow]{message}[/yellow]")))
+        except Exception as e:
+            self.logger.error(f"Failed to show list warning: {e}")
+
+    def _display_default_message(self) -> None:
+        """Display the initial message in the stats area."""
         try:
             stats_container = self.query_one("#schema-stats-content", Container)
             stats_container.query("*").remove()
             stats_container.mount(Static(self.DEFAULT_STATS_MESSAGE, classes="stats-line"))
-            stats_container.display = True
         except Exception as e:
-            log.error(f"Failed to display default stats message: {e}")
+            self.logger.error(f"Failed to display default stats message: {e}")
+
+    def on_list_view_selected(self, event: ListView.Selected) -> None:
+        """Handle column selection from the list."""
+        if hasattr(event.item, 'column_name'):
+            column_name = event.item.column_name
+            self._current_column = column_name
+            self._load_column_stats(column_name)
+        else:
+            self.logger.warning("Selected item does not have column_name attribute")
+
+    def _load_column_stats(self, column_name: str) -> None:
+        """
+        Load and display statistics for the selected column.
+        
+        Args:
+            column_name: Name of the column to analyze
+        """
+        if not self.handler:
+            self._show_stats_error("Data handler not available")
+            return
+
+        try:
+            # Set loading state
+            self.loading = True
 
-    def load_column_list(self):
-        """Loads the list of columns from the data handler."""
-        list_view: Optional[ListView] = self.query_one("#column-list-view", ListView)
-        list_view.clear()
+            # Get column statistics
+            self.logger.debug(f"Loading stats for column: {column_name}")
+            raw_stats = self.handler.get_column_stats(column_name)
+
+            # Format stats for display
+            formatted_lines = format_stats_for_display(raw_stats)
+
+            # Display the formatted stats
+            self._display_column_stats(formatted_lines)
+
+        except Exception as e:
+            self.logger.exception(f"Error loading stats for column {column_name}")
+            self._show_stats_error(f"Failed to load statistics: {e}")
+        finally:
+            self.loading = False
 
+    def _display_column_stats(self, formatted_lines: List) -> None:
+        """
+        Display formatted column statistics.
+        
+        Args:
+            formatted_lines: List of formatted text lines to display
+        """
         try:
-            if not self.app.handler:
-                log.error("SchemaView: Data handler not available.")
-                list_view.append(ListItem(Label("[red]Data handler not available.[/red]")))
-                return
+            stats_container = self.query_one("#schema-stats-content", Container)
+            stats_container.query("*").remove()
 
-            schema_data: Optional[List[Dict[str, str]]] = self.app.handler.get_schema_data()
-            log.debug(f"SchemaView: Received schema data for list: {schema_data}")
+            for line in formatted_lines:
+                if isinstance(line, Text):
+                    stats_container.mount(Static(line, classes="stats-line"))
+                else:
+                    stats_container.mount(Static(str(line), classes="stats-line"))
 
-            if schema_data is None:
-                log.error("SchemaView: Failed to retrieve schema data (handler returned None).")
-                list_view.append(ListItem(Label("[red]Could not load schema.[/red]")))
-            elif not schema_data:
-                log.warning("SchemaView: Schema has no columns.")
-                list_view.append(ListItem(Label("[yellow]Schema has no columns.[/yellow]")))
-            else:
-                column_count = 0
-                for col_info in schema_data:
-                    column_name = col_info.get("name")
-                    if column_name:
-                        list_view.append(ColumnListItem(column_name))
-                        column_count += 1
-                    else:
-                        log.warning("SchemaView: Found column info without a 'name' key.")
-                log.info(f"SchemaView: Populated column list with {column_count} columns.")
+        except Exception as e:
+            self.logger.error(f"Failed to display column stats: {e}")
+            self._show_stats_error("Failed to display statistics")
 
+    def _show_stats_error(self, message: str) -> None:
+        """Show error message in the stats area."""
+        try:
+            stats_container = self.query_one("#schema-stats-content", Container)
+            stats_container.query("*").remove()
+            stats_container.mount(Static(f"[red]Error: {message}[/red]", classes="error-content"))
         except Exception as e:
-            log.exception("Error loading column list in SchemaView:")
-            list_view.clear()
-            list_view.append(ListItem(Label(f"[red]Error loading schema: {e}[/red]")))
+            self.logger.error(f"Failed to show stats error: {e}")
 
     def watch_loading(self, loading: bool) -> None:
         """React to changes in the loading state."""
         try:
             loading_indicator = self.query_one("#schema-loading-indicator", LoadingIndicator)
             stats_scroll = self.query_one("#schema-stats-scroll", VerticalScroll)
-            loading_indicator.display = loading
-            stats_scroll.display = not loading
-            if loading:
-                stats_content = self.query_one("#schema-stats-content", Container)
-                stats_content.display = False
-        except Exception as e:
-            log.error(f"Error updating loading display: {e}")
-
-    async def _update_stats_display(self, lines: List[Union[str, Text]]) -> None:
-        """Updates the statistics display area with formatted lines."""
-        try:
-            stats_content_container = self.query_one("#schema-stats-content", Container)
-            stats_scroll_container = self.query_one("#schema-stats-scroll", VerticalScroll)
-            await stats_content_container.query("*").remove()
 
-            if not lines:
-                await stats_content_container.mount(Static(self.DEFAULT_STATS_MESSAGE, classes="stats-line"))
+            if loading:
+                loading_indicator.display = True
+                stats_scroll.display = False
             else:
-                new_widgets: List[Static] = []
-                for line in lines:
-                    content: Union[str, Text] = line
-                    css_class = "stats-line"
-                    if isinstance(line, str) and line.startswith("```"):
-                        content = line.strip()
-                        if content.startswith("```json"):
-                            content = content[7:]
-                        elif content.startswith("```"):
-                            content = content[3:]
-                        if content.endswith("```"):
-                            content = content[:-3]
-                        content = content.strip()
-                        css_class = "stats-code"
-                    elif isinstance(line, Text):
-                        style_str = str(line.style).lower()
-                        if "red" in style_str:
-                            css_class = "stats-error stats-line"
-                        elif "yellow" in style_str:
-                            css_class = "stats-warning stats-line"
-                        elif "italic" in style_str:
-                            css_class = "stats-info stats-line"
-                        elif "bold" in style_str:
-                            css_class = "stats-header stats-line"
-                    new_widgets.append(Static(content, classes=css_class))
-                if new_widgets:
-                    await stats_content_container.mount_all(new_widgets)
-
-            stats_content_container.display = True
-            stats_scroll_container.display = True
-            stats_scroll_container.scroll_home(animate=False)
+                loading_indicator.display = False
+                stats_scroll.display = True
+
         except Exception as e:
-            log.error(f"Error updating stats display: {e}", exc_info=True)
-            try:
-                await stats_content_container.query("*").remove()
-                await stats_content_container.mount(Static(f"[red]Internal error displaying stats: {e}[/red]"))
-                stats_content_container.display = True
-                stats_scroll_container.display = True
-            except Exception:
-                pass
-
-    async def on_list_view_selected(self, event: ListView.Selected) -> None:
-        """Handle column selection in the ListView."""
-        event.stop()
-        selected_item = event.item
-
-        if isinstance(selected_item, ColumnListItem):
-            column_name = selected_item.column_name
-            self.loading = True
+            self.logger.error(f"Error updating loading state: {e}")
 
-            stats_data: Dict[str, Any] = {}
-            error_markup: Optional[str] = None
+    def refresh_schema(self) -> None:
+        """Refresh the schema display."""
+        self._current_column = None
+        self.clear_content()
+        self.load_content()
 
-            try:
-                if self.app.handler:
-                    stats_data = self.app.handler.get_column_stats(column_name)
-                    if stats_data.get("error"):
-                        log.warning(f"Handler returned error for column '{column_name}': {stats_data['error']}")
-                        error_markup = f"[red]Error getting stats: {stats_data['error']}[/]"
-                        stats_data = {}
-                else:
-                    error_markup = "[red]Error: Data handler not available.[/]"
-                    log.error("SchemaView: Data handler not found on app.")
-            except Exception as e:
-                log.exception(f"Exception calculating stats for {column_name}")
-                error_markup = f"[red]Error loading stats for '{column_name}':\n{type(e).__name__}: {e}[/]"
-
-            if error_markup:
-                lines_to_render = [Text.from_markup(error_markup)]
-            else:
-                lines_to_render = format_stats_for_display(stats_data)
+    def get_current_column(self) -> Optional[str]:
+        """Get the currently selected column name."""
+        return self._current_column
 
-            await self._update_stats_display(lines_to_render)
-            self.loading = False
-        else:
-            log.debug("Non-column item selected in ListView.")
-            await self._update_stats_display([])
-            self.loading = False
+    def get_columns_data(self) -> Optional[List[Dict[str, Any]]]:
+        """Get the current columns data."""
+        return self._columns_data

parqv/views/utils/__init__.py

@@ -0,0 +1,19 @@
+"""
+Utility functions for parqv views.
+"""
+
+from .data_formatters import format_metadata_for_display, format_value_for_display
+from .stats_formatters import format_stats_for_display, format_column_info
+from .visualization import create_text_histogram, should_show_histogram
+
+__all__ = [
+    # Data formatting
+    "format_metadata_for_display",
+    "format_value_for_display",
+    "format_stats_for_display",
+    "format_column_info",
+
+    # Visualization
+    "create_text_histogram",
+    "should_show_histogram",
+]

parqv/views/utils/data_formatters.py

@@ -0,0 +1,184 @@
+"""
+Data formatting utilities for parqv views.
+"""
+
+from typing import Any, Dict, Union
+from rich.text import Text
+
+
+def format_metadata_for_display(metadata: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Format metadata dictionary for consistent display.
+    
+    Args:
+        metadata: Raw metadata dictionary from handler
+        
+    Returns:
+        Formatted metadata dictionary ready for display
+    """
+    if not metadata:
+        return {"Error": "No metadata available"}
+    
+    # Check for error in metadata
+    if "error" in metadata:
+        return {"Error": metadata["error"]}
+    
+    formatted = {}
+    
+    # Format specific known fields with better presentation
+    field_formatters = {
+        "File Path": lambda x: str(x),
+        "Path": lambda x: str(x),
+        "Format": lambda x: str(x).upper(),
+        "Total Rows": lambda x: _format_number(x),
+        "Total Columns": lambda x: _format_number(x),
+        "Columns": lambda x: _format_number(x),
+        "Size": lambda x: _format_size_if_bytes(x),
+        "Memory Usage": lambda x: _format_size_if_bytes(x),
+        "DuckDB View": lambda x: f"`{x}`" if x else "N/A",
+    }
+    
+    for key, value in metadata.items():
+        if isinstance(value, dict):
+            # Handle nested dictionaries (like grouped metadata)
+            formatted[key] = _format_nested_metadata(value, field_formatters)
+        elif key in field_formatters:
+            formatted[key] = field_formatters[key](value)
+        else:
+            formatted[key] = format_value_for_display(value)
+    
+    return formatted
+
+
+def _format_nested_metadata(nested_dict: Dict[str, Any], field_formatters: Dict) -> Dict[str, Any]:
+    """Format nested metadata dictionaries."""
+    formatted_nested = {}
+    
+    for key, value in nested_dict.items():
+        if isinstance(value, dict):
+            # Handle further nesting if needed
+            formatted_nested[key] = _format_nested_metadata(value, field_formatters)
+        elif key in field_formatters:
+            formatted_nested[key] = field_formatters[key](value)
+        else:
+            formatted_nested[key] = format_value_for_display(value)
+    
+    return formatted_nested
+
+
+def format_value_for_display(value: Any) -> str:
+    """
+    Format a single value for display in the UI.
+    
+    Args:
+        value: The value to format
+        
+    Returns:
+        String representation suitable for display
+    """
+    if value is None:
+        return "N/A"
+    
+    if isinstance(value, (int, float)):
+        return _format_number(value)
+    
+    if isinstance(value, bool):
+        return "Yes" if value else "No"
+    
+    if isinstance(value, str):
+        # Handle empty strings
+        if not value.strip():
+            return "N/A"
+        return value
+    
+    # For other types, convert to string
+    return str(value)
+
+
+def _format_number(value: Union[str, int, float]) -> str:
+    """
+    Format numbers with thousand separators.
+    
+    Args:
+        value: Numeric value or string representation
+        
+    Returns:
+        Formatted number string
+    """
+    if isinstance(value, str):
+        # Try to extract number from string like "1,234" or "1234"
+        try:
+            # Remove existing commas and convert
+            clean_str = value.replace(",", "").strip()
+            if clean_str.isdigit():
+                return f"{int(clean_str):,}"
+            elif "." in clean_str:
+                return f"{float(clean_str):,.2f}"
+            else:
+                return value  # Return as-is if not numeric
+        except (ValueError, AttributeError):
+            return value
+    
+    if isinstance(value, int):
+        return f"{value:,}"
+    
+    if isinstance(value, float):
+        return f"{value:,.2f}"
+    
+    return str(value)
+
+
+def _format_size_if_bytes(value: Union[str, int]) -> str:
+    """
+    Format size values, detecting if they represent bytes.
+    
+    Args:
+        value: Size value that might be in bytes
+        
+    Returns:
+        Formatted size string
+    """
+    if isinstance(value, str):
+        # If it already contains size units, return as-is
+        if any(unit in value.lower() for unit in ["kb", "mb", "gb", "tb", "bytes"]):
+            return value
+        
+        # Try to parse as number and format as bytes
+        try:
+            clean_str = value.replace(",", "").strip()
+            if "bytes" in value.lower():
+                num_bytes = int(clean_str.split()[0])
+                return _format_bytes(num_bytes)
+            else:
+                return value
+        except (ValueError, IndexError):
+            return value
+    
+    if isinstance(value, int):
+        # Assume it's bytes if it's a large integer
+        if value > 1024:
+            return _format_bytes(value)
+        else:
+            return f"{value:,}"
+    
+    return str(value)
+
+
+def _format_bytes(num_bytes: int) -> str:
+    """
+    Format bytes into human-readable format.
+    
+    Args:
+        num_bytes: Number of bytes
+        
+    Returns:
+        Human-readable size string
+    """
+    if num_bytes < 1024:
+        return f"{num_bytes:,} bytes"
+    elif num_bytes < 1024 ** 2:
+        return f"{num_bytes / 1024:.1f} KB"
+    elif num_bytes < 1024 ** 3:
+        return f"{num_bytes / 1024 ** 2:.1f} MB"
+    else:
+        return f"{num_bytes / 1024 ** 3:.1f} GB"