parqv 0.1.0__py3-none-any.whl

parqv/app.py

@@ -0,0 +1,131 @@
+import sys
+from pathlib import Path
+import logging
+from logging.handlers import RotatingFileHandler
+from typing import Optional
+
+from textual.app import App, ComposeResult, Binding
+from textual.containers import Container
+from textual.widgets import Header, Footer, Static, Label, TabbedContent, TabPane
+
+from .parquet_handler import ParquetHandler, ParquetHandlerError
+from .views.metadata_view import MetadataView
+from .views.schema_view import SchemaView
+from .views.data_view import DataView
+from .views.row_group_view import RowGroupView
+
+LOG_FILENAME = "parqv.log"
+file_handler = RotatingFileHandler(
+    LOG_FILENAME, maxBytes=1024 * 1024 * 5, backupCount=3, encoding="utf-8"
+)
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s [%(levelname)-5.5s] %(name)s (%(filename)s:%(lineno)d) - %(message)s",
+    handlers=[file_handler], # Log to file
+)
+
+log = logging.getLogger(__name__)
+
+
+class ParqV(App[None]):
+    """A Textual app to visualize Parquet files."""
+
+    CSS_PATH = "parqv.css"
+    BINDINGS = [
+        Binding("q", "quit", "Quit", priority=True),
+    ]
+
+    # App State
+    file_path: Optional[Path] = None
+    handler: Optional[ParquetHandler] = None
+    error_message: Optional[str] = None
+
+    def __init__(self, file_path_str: Optional[str] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        log.info("Initializing ParqVApp...")
+        if file_path_str:
+            self.file_path = Path(file_path_str)
+            log.info(f"Attempting to load file: {self.file_path}")
+            try:
+                # Initialize the Parquet handler on app start
+                self.handler = ParquetHandler(self.file_path)
+                log.info("Parquet handler initialized successfully.")
+            except ParquetHandlerError as e:
+                self.error_message = str(e)
+                log.error(f"Failed to initialize handler: {e}", exc_info=True)
+            except Exception as e:
+                self.error_message = (
+                    f"An unexpected error occurred during initialization: {e}"
+                )
+                log.exception("Unexpected error during app initialization:")
+
+    def compose(self) -> ComposeResult:
+        yield Header()
+
+        if self.error_message:
+            log.error(f"Displaying error message: {self.error_message}")
+            yield Container(
+                Label("Error Loading File:", classes="error-title"),
+                Static(self.error_message, classes="error-content"),
+            )
+        elif self.handler:
+            log.debug("Composing main layout with TabbedContent.")
+            with TabbedContent(id="main-tabs"):
+                with TabPane("Metadata", id="tab-metadata"):
+                    yield MetadataView(id="metadata-view")
+                with TabPane("Schema", id="tab-schema"):
+                    yield SchemaView(id="schema-view")
+                with TabPane("Data Preview", id="tab-data"):
+                    yield DataView(id="data-view")
+                with TabPane("Row Groups", id="tab-rowgroups"):
+                    yield RowGroupView(id="rowgroup-view")
+        else:
+            log.warning("No handler available, showing 'no file' message.")
+            yield Container(Label("No file loaded or handler initialization failed."))
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        log.debug("App mounted.")
+        try:
+            header = self.query_one(Header)
+            if self.handler and self.file_path:
+                header.title = f"parqv - {self.file_path.name}"
+            elif self.error_message:
+                header.title = "parqv - Error"
+            else:
+                header.title = "parqv"
+        except Exception as e:
+            log.error(f"Failed to set header title: {e}")
+
+
+    def action_quit(self) -> None:
+        log.info("Quit action triggered.")
+        self.exit()
+
+
+# CLI Entry Point
+def run_app():
+    log.info("--- parqv started ---")
+    if len(sys.argv) < 2:
+        print("Usage: parqv <path_to_parquet_file>")
+        log.error("No file path provided.")
+        sys.exit(1)
+
+    file_path_str = sys.argv[1]
+    file_path = Path(file_path_str)
+    log.debug(f"File path from argument: {file_path}")
+
+    # Basic file validation
+    if not file_path.is_file():
+        print(f"Error: Path is not a file or does not exist: {file_path}")
+        log.error(f"Invalid file path provided: {file_path}")
+        sys.exit(1)
+
+    app = ParqV(file_path_str=file_path_str)
+    app.run()
+    log.info("--- parqv finished ---")
+
+
+if __name__ == "__main__":
+    run_app()

parqv/parquet_handler.py

@@ -0,0 +1,389 @@
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Tuple, Optional, Union
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+
+log = logging.getLogger(__name__)
+
+
+class ParquetHandlerError(Exception):
+    pass
+
+
+class ParquetHandler:
+
+    def __init__(self, file_path: Path):
+        self.file_path = file_path
+        self.pq_file: Optional[pq.ParquetFile] = None
+        self.schema: Optional[pa.Schema] = None
+        self.metadata: Optional[pq.FileMetaData] = None
+        try:
+            self.pq_file = pq.ParquetFile(file_path)
+            self.schema = self.pq_file.schema_arrow
+            self.metadata = self.pq_file.metadata
+        except Exception as e:
+            log.exception("Error initializing ParquetHandler")
+            raise ParquetHandlerError(f"Failed to open or read Parquet file: {e}") from e
+
+    def get_metadata_summary(self) -> Dict[str, Any]:
+        if not self.metadata or not self.schema:
+            return {"error": "Metadata or schema not available"}
+
+        created_by = self._decode_metadata_bytes(self.metadata.created_by) or "N/A"
+        summary = {
+            "File Path": str(self.file_path.resolve()),
+            "Size": f"{self.file_path.stat().st_size:,} bytes",
+            "Total Rows": f"{self.metadata.num_rows:,}",
+            "Row Groups": self.metadata.num_row_groups,
+            "Columns": self.metadata.num_columns,
+            "Format Version": self.metadata.format_version,
+            "Creator": created_by,
+            "Schema Fields": len(self.schema.names),
+        }
+        kv_meta = self._decode_key_value_metadata(self.metadata.metadata)
+        if kv_meta:
+            summary["Key Value Metadata"] = kv_meta
+        return summary
+
+    def get_schema_tree_data(self) -> Optional[Dict[str, Any]]:
+        if not self.schema or not self.schema.names:
+            log.warning("Schema is not available or has no fields.")
+            return None
+
+        root_data: Dict[str, Any] = {}
+        for field in self.schema:
+            try:
+                label, children = self._build_schema_tree_nodes(field)
+                root_data[label] = children
+            except Exception as field_e:
+                log.error(f"Error processing schema field '{field.name}': {field_e}", exc_info=True)
+                root_data[f"[red]Error processing: {field.name}[/red]"] = None
+
+        if not root_data:
+            log.warning("Processed schema data resulted in an empty dictionary.")
+            return None
+
+        return root_data
+
+    def get_data_preview(self, num_rows: int = 50) -> Optional[pd.DataFrame]:
+        if not self.pq_file:
+            log.warning("ParquetFile handler not available for data preview.")
+            return None
+
+        tables_to_concat = []
+        rows_accumulated = 0
+        for i in range(self.pq_file.num_row_groups):
+            rg_meta = self.pq_file.metadata.row_group(i)
+            rows_to_read_from_group = min(rg_meta.num_rows, num_rows - rows_accumulated)
+
+            if rows_to_read_from_group <= 0:
+                log.debug(f"Limit {num_rows} reached after {i} groups.")
+                break
+
+            rg_table = self.pq_file.read_row_group(i)
+            tables_to_concat.append(rg_table)
+            rows_accumulated += rg_meta.num_rows
+
+        if not tables_to_concat:
+            log.warning("No row groups read or file is empty.")
+            return pd.DataFrame()
+
+        combined_table = pa.concat_tables(tables_to_concat)
+        preview_table = combined_table.slice(0, num_rows)
+
+        df = preview_table.to_pandas(
+            split_blocks=True, self_destruct=True, date_as_object=False, types_mapper=pd.ArrowDtype
+        )
+        return df
+
+    def get_column_stats(self, column_name: str) -> Dict[str, Any]:
+        if not self.pq_file or not self.schema or not column_name:
+            log.warning("Prerequisites not met for get_column_stats.")
+            return {"error": "File, schema, or column name not available"}
+
+        error_msg: Optional[str] = None
+        field: Optional[pa.Field] = None
+        calculated_stats: Dict[str, Any] = {}
+
+        field = self.schema.field(column_name)
+        col_type = field.type
+
+        table = self.pq_file.read(columns=[column_name])
+        if table.num_rows == 0:
+            log.warning(f"Column '{column_name}' is empty.")
+            return self._create_stats_result(column_name, field, msg="Column is empty (0 rows).")
+
+        column_data = table.column(column_name)
+        # Basic counts
+        total_count = len(column_data)
+        null_count = column_data.null_count
+        valid_count = total_count - null_count
+        calculated_stats["Total Count"] = f"{total_count:,}"
+        calculated_stats["Valid Count"] = f"{valid_count:,}"
+        calculated_stats["Null Count"] = f"{null_count:,}"
+        calculated_stats[
+            "Null Percentage"] = f"{(null_count / total_count * 100):.2f}%" if total_count > 0 else "N/A"
+
+        # Type-specific calculations
+        if valid_count > 0:
+            valid_data = column_data.drop_null()
+            if pa.types.is_integer(col_type) or pa.types.is_floating(col_type):
+                calculated_stats.update(self._calculate_numeric_stats(valid_data))
+            elif pa.types.is_temporal(col_type):
+                calculated_stats.update(self._calculate_temporal_stats(valid_data))
+            elif pa.types.is_string(col_type) or pa.types.is_large_string(col_type):
+                calculated_stats.update(self._calculate_string_stats(valid_data))
+            elif pa.types.is_boolean(col_type):
+                calculated_stats.update(self._calculate_boolean_stats(valid_data))
+        else:
+            log.debug("No valid data points for calculation.")
+
+        metadata_stats, metadata_stats_error = self._get_stats_from_metadata(column_name)
+        return self._create_stats_result(
+            column_name, field, calculated_stats, metadata_stats, metadata_stats_error, error_msg
+        )
+
+    def get_row_group_info(self) -> List[Dict[str, Any]]:
+        if not self.metadata:
+            log.warning("Metadata not available for row group info.")
+            return []
+        groups = []
+        num_groups = self.metadata.num_row_groups
+
+        for i in range(num_groups):
+            try:
+                rg_meta = self.metadata.row_group(i)
+                num_rows = getattr(rg_meta, 'num_rows', 'N/A')
+                size = getattr(rg_meta, 'total_byte_size', 'N/A')
+                comp_size_val = getattr(rg_meta, 'total_compressed_size', -1)
+                comp_size = f"{comp_size_val:,}" if isinstance(comp_size_val, int) and comp_size_val > 0 else "N/A"
+
+                groups.append({
+                    "Group": i,
+                    "Rows": f"{num_rows:,}" if isinstance(num_rows, int) else num_rows,
+                    "Size (bytes)": f"{size:,}" if isinstance(size, int) else size,
+                    "Size (comp.)": comp_size,
+                })
+            except Exception as e:
+                log.error(f"Error reading metadata for row group {i}", exc_info=True)
+                groups.append({"Group": i, "Rows": "Error", "Size (bytes)": "Error", "Size (comp.)": "Error"})
+        return groups
+
+    def _decode_metadata_bytes(self, value: Optional[bytes]) -> Optional[str]:
+        if isinstance(value, bytes):
+            try:
+                return value.decode('utf-8', errors='replace')
+            except Exception as e:
+                log.warning(f"Could not decode metadata bytes: {e}")
+                return repr(value)
+        return value
+
+    def _decode_key_value_metadata(self, kv_meta: Optional[Dict[bytes, bytes]]) -> Optional[Dict[str, str]]:
+        if not kv_meta:
+            return None
+        decoded_kv = {}
+        try:
+            for k, v in kv_meta.items():
+                key_str = self._decode_metadata_bytes(k) or repr(k)
+                val_str = self._decode_metadata_bytes(v) or repr(v)
+                decoded_kv[key_str] = val_str
+            return decoded_kv
+        except Exception as e:
+            log.warning(f"Could not decode key-value metadata: {e}")
+            return {"error": f"Error decoding: {e}"}
+
+    def _format_pyarrow_type(self, field_type: pa.DataType) -> str:
+        if pa.types.is_timestamp(field_type):
+            return f"TIMESTAMP(unit={field_type.unit}, tz={field_type.tz})"
+
+        if pa.types.is_decimal128(field_type) or pa.types.is_decimal256(field_type):
+            return f"DECIMAL({field_type.precision}, {field_type.scale})"
+
+        if pa.types.is_list(field_type) or pa.types.is_large_list(field_type):
+            return f"LIST<{self._format_pyarrow_type(field_type.value_type)}>"
+
+        if pa.types.is_struct(field_type):
+            return f"STRUCT<{field_type.num_fields} fields>"
+
+        if pa.types.is_map(field_type):
+            return f"MAP<{self._format_pyarrow_type(field_type.key_type)}, {self._format_pyarrow_type(field_type.item_type)}>"
+
+        return str(field_type).upper()
+
+    def _build_schema_tree_nodes(self, field: pa.Field) -> Tuple[str, Optional[Dict]]:
+        node_label = f"[bold]{field.name}[/] ({self._format_pyarrow_type(field.type)})"
+        if not field.nullable:
+            node_label += " [red]REQUIRED[/]"
+
+        children_data: Dict[str, Any] = {}
+        field_type = field.type
+
+        if pa.types.is_struct(field_type):
+            for i in range(field_type.num_fields):
+                child_label, grandchild_data = self._build_schema_tree_nodes(field_type.field(i))
+                children_data[child_label] = grandchild_data
+
+        elif pa.types.is_list(field_type) or pa.types.is_large_list(field_type):
+            element_field = pa.field("item", field_type.value_type, nullable=True)
+            child_label, grandchild_data = self._build_schema_tree_nodes(element_field)
+            children_data[child_label] = grandchild_data
+
+        elif pa.types.is_map(field_type):
+            key_field = pa.field("key", field_type.key_type, nullable=False)
+            value_field = pa.field("value", field_type.item_type, nullable=True)
+            key_label, _ = self._build_schema_tree_nodes(key_field)
+            value_label, value_grandchild = self._build_schema_tree_nodes(value_field)
+            children_data[key_label] = None
+            children_data[value_label] = value_grandchild
+
+        return node_label, children_data if children_data else None
+
+    def _calculate_numeric_stats(self, valid_data: pa.ChunkedArray) -> Dict[str, Any]:
+        stats: Dict[str, Any] = {}
+        try:
+            stats["Min"] = pc.min(valid_data).as_py()
+        except Exception as e:
+            log.warning(f"Min calc error: {e}");
+            stats["Min"] = "Error"
+        try:
+            stats["Max"] = pc.max(valid_data).as_py()
+        except Exception as e:
+            log.warning(f"Max calc error: {e}");
+            stats["Max"] = "Error"
+        try:
+            stats["Mean"] = f"{pc.mean(valid_data).as_py():.4f}"
+        except Exception as e:
+            log.warning(f"Mean calc error: {e}");
+            stats["Mean"] = "Error"
+        try:
+            stats["StdDev"] = f"{pc.stddev(valid_data, ddof=1).as_py():.4f}"
+        except Exception as e:
+            log.warning(f"StdDev calc error: {e}");
+            stats["StdDev"] = "Error"
+        return stats
+
+    def _calculate_temporal_stats(self, valid_data: pa.ChunkedArray) -> Dict[str, Any]:
+        stats: Dict[str, Any] = {}
+        try:
+            stats["Min"] = pc.min(valid_data).as_py()
+        except Exception as e:
+            log.warning(f"Min calc error (temporal): {e}");
+            stats["Min"] = "Error"
+        try:
+            stats["Max"] = pc.max(valid_data).as_py()
+        except Exception as e:
+            log.warning(f"Max calc error (temporal): {e}");
+            stats["Max"] = "Error"
+        return stats
+
+    def _calculate_string_stats(self, valid_data: pa.ChunkedArray) -> Dict[str, Any]:
+        stats: Dict[str, Any] = {}
+        try:
+            stats["Distinct Count"] = f"{pc.count_distinct(valid_data).as_py():,}"
+        except Exception as e:
+            log.warning(f"Distinct count error: {e}");
+            stats["Distinct Count"] = "Error"
+        # TopN removed as requested
+        return stats
+
+    def _calculate_boolean_stats(self, valid_data: pa.ChunkedArray) -> Dict[str, Any]:
+        stats: Dict[str, Any] = {}
+        try:
+            value_counts_table = valid_data.value_counts()
+            if isinstance(value_counts_table, pa.Table):
+                counts_df = value_counts_table.to_pandas()
+            elif isinstance(value_counts_table, pa.StructArray):
+                try:
+                    counts_df = value_counts_table.flatten().to_pandas()
+                except NotImplementedError:
+                    counts_df = pd.DataFrame(value_counts_table.to_pylist())  # Fallback
+
+            else:
+                counts_df = pd.DataFrame(value_counts_table.to_pylist())
+
+            if 'values' in counts_df.columns and 'counts' in counts_df.columns:
+                stats["Value Counts"] = counts_df.set_index('values')['counts'].to_dict()
+            elif len(counts_df.columns) == 2:  # Assume first is value, second is count
+                stats["Value Counts"] = counts_df.set_index(counts_df.columns[0])[counts_df.columns[1]].to_dict()
+            else:
+                log.warning("Could not parse boolean value counts structure.")
+                stats["Value Counts"] = "Could not parse structure"
+
+        except Exception as vc_e:
+            log.warning(f"Boolean value count error: {vc_e}");
+            stats["Value Counts"] = "Error calculating"
+        return stats
+
+    def _extract_stats_for_single_group(
+            self, rg_meta: pq.RowGroupMetaData, col_index: int
+    ) -> Union[str, Dict[str, Any]]:
+
+        if col_index >= rg_meta.num_columns:
+            log.warning(
+                f"Column index {col_index} out of bounds for row group "
+                f"with {rg_meta.num_columns} columns."
+            )
+            return "Index Error"
+
+        col_chunk_meta = rg_meta.column(col_index)
+        stats = col_chunk_meta.statistics
+
+        if not stats:
+            return "No stats"
+
+        has_min_max = getattr(stats, 'has_min_max', False)
+        has_distinct = getattr(stats, 'has_distinct_count', False)
+
+        return {
+            "min": getattr(stats, 'min', 'N/A') if has_min_max else "N/A",
+            "max": getattr(stats, 'max', 'N/A') if has_min_max else "N/A",
+            "nulls": getattr(stats, 'null_count', 'N/A'),
+            "distinct": getattr(stats, 'distinct_count', 'N/A') if has_distinct else "N/A",
+        }
+
+    def _get_stats_from_metadata(self, column_name: str) -> Tuple[Dict[str, Any], Optional[str]]:
+        metadata_stats: Dict[str, Any] = {}
+        if not self.metadata or not self.schema:
+            log.warning("Metadata or Schema not available for _get_stats_from_metadata.")
+            return {}, "Metadata or Schema not available"
+        col_index = self.schema.get_field_index(column_name)
+
+        for i in range(self.metadata.num_row_groups):
+            group_key = f"RG {i}"
+            try:
+                rg_meta = self.metadata.row_group(i)
+                metadata_stats[group_key] = self._extract_stats_for_single_group(
+                    rg_meta, col_index
+                )
+            except Exception as e:
+                log.warning(
+                    f"Error processing metadata for row group {i}, column '{column_name}': {e}"
+                )
+                metadata_stats[group_key] = f"Read Error: {e}"
+
+        return metadata_stats, None
+
+    def _create_stats_result(
+            self,
+            column_name: str,
+            field: Optional[pa.Field],
+            calculated_stats: Optional[Dict] = None,
+            metadata_stats: Optional[Dict] = None,
+            metadata_stats_error: Optional[str] = None,
+            calculation_error: Optional[str] = None,
+            message: Optional[str] = None
+    ) -> Dict[str, Any]:
+        return {
+            "column": column_name,
+            "type": self._format_pyarrow_type(field.type) if field else "Unknown",
+            "nullable": field.nullable if field else "Unknown",
+            "calculated": calculated_stats if calculated_stats else None,
+            "basic_metadata_stats": metadata_stats if metadata_stats else None,
+            "metadata_stats_error": metadata_stats_error,
+            "error": calculation_error,
+            "message": message
+        }

parqv/parqv.css

@@ -0,0 +1,150 @@
+/* --- Base Screen Styles --- */
+Screen {
+    background: $surface;
+    color: $text;
+}
+
+/* --- Header & Footer Styles --- */
+Header {
+    background: $primary;
+}
+Footer {
+    background: $primary-darken-1;
+}
+Footer > .footer--key {
+    color: $text-muted;
+}
+Footer > .footer--highlight-key {
+    background: $accent-darken-1;
+    color: $text;
+    text-style: bold;
+}
+
+/* --- Tabbed Interface Styles --- */
+TabbedContent {
+    height: 100%;
+}
+TabbedContent > Tabs {
+    background: $primary-darken-1;
+    color: $text-muted;
+}
+TabbedContent > Tabs > Tab {
+    padding: 1 2;
+}
+TabbedContent > Tabs > Tab:hover {
+    background: $primary;
+}
+TabbedContent > Tabs > .--current {
+     background: $accent;
+     color: $text;
+     text-style: bold;
+}
+TabbedContent > Content {
+    padding: 1 2;
+    height: 1fr;
+    width: 100%;
+    overflow: hidden;
+}
+TabbedContent > Content > * {
+     height: 100%;
+     width: 100%;
+}
+
+/* --- Schema Tab (#schema-view - VerticalScroll) --- */
+#schema-view {
+    padding: 0;
+}
+#schema-view > ListView#column-list-view {
+    border: round $accent-lighten-2;
+    margin-bottom: 1;
+    background: $primary-background;
+    overflow: auto;
+}
+#schema-view > ListView#column-list-view > ListItem {
+    padding: 0 1;
+    height: auto;
+}
+#schema-view > ListView#column-list-view > ListItem.--highlight {
+    background: $accent;
+    color: $text;
+}
+#schema-view > ListView#column-list-view > ListItem.--highlight Label {
+    color: $text;
+}
+#schema-view > LoadingIndicator#schema-loading-indicator {
+    margin: 1 0;
+    width: 100%;
+    text-align: center;
+}
+#schema-view > Container#schema-stats-content {
+    padding: 1;
+    overflow: auto;
+}
+#schema-view .stats-line {
+    margin-bottom: 0;
+    height: auto;
+    width: 100%;
+}
+#schema-view .stats-code {
+    background: $panel-darken-1;
+    border: solid $accent-lighten-1;
+    padding: 0 1;
+    margin: 1 0;
+    width: 100%;
+    height: auto;
+    overflow: auto;
+}
+#schema-view .stats-error {
+    color: $error;
+}
+
+/* --- Metadata Tab (#metadata-view - VerticalScroll) --- */
+#metadata-view {
+    overflow-y: auto;
+}
+#metadata-view > Pretty {
+    width: 100%;
+}
+
+/* --- Data Preview Tab (#data-view - Container) --- */
+#data-view {
+}
+#data-view > DataTable {
+    height: 100%;
+    width: 100%;
+}
+
+/* --- Row Groups Tab (#rowgroup-view - VerticalScroll) --- */
+#rowgroup-view {
+    overflow-y: auto;
+}
+#rowgroup-view > DataTable {
+    width: 100%;
+}
+
+/* --- General Widget Styles --- */
+DataTable {
+    margin-top: 1;
+}
+DataTable > Header {
+    background: $secondary;
+    color: $text;
+    text-style: bold;
+}
+DataTable > Body > Row.--cursor {
+     background: $accent;
+     color: $text;
+}
+DataTable > Body > Row:hover {
+     background: $secondary-darken-2;
+}
+
+/* --- Error Message Styles (Used in App Level Error) --- */
+.error-title {
+    color: $error;
+    text-style: bold;
+    margin-bottom: 1;
+}
+.error-content {
+    color: $error;
+}

parqv/views/data_view.py

@@ -0,0 +1,68 @@
+import logging
+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__)
+
+
+class DataView(Container):
+    DEFAULT_ROWS = 50
+
+    def compose(self) -> ComposeResult:
+        yield DataTable(id="data-table")
+
+    def on_mount(self) -> None:
+        self.load_data()
+
+    def load_data(self):
+        table: Optional[DataTable] = self.query_one("#data-table", DataTable)
+
+        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"))
+                return
+
+        try:
+            if not self.app.handler:
+                self.mount(Static("Parquet handler not available.", classes="error-content"))
+                return
+
+            df: Optional[pd.DataFrame] = self.app.handler.get_data_preview(num_rows=self.DEFAULT_ROWS)
+
+            if df is None:
+                self.mount(Static("Could not load data preview."))
+                return
+
+            if df.empty:
+                self.mount(Static("No data in the preview range or file is empty."))
+                return
+
+            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.")
+
+        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}")

parqv/views/metadata_view.py

@@ -0,0 +1,19 @@
+from textual.containers import VerticalScroll
+from textual.widgets import Static, Pretty
+
+
+class MetadataView(VerticalScroll):
+
+    def on_mount(self) -> None:
+        self.load_metadata()
+
+    def load_metadata(self):
+        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"))
+        except Exception as e:
+            self.mount(Static(f"Error loading metadata: {e}", classes="error-content"))

parqv/views/row_group_view.py

@@ -0,0 +1,33 @@
+from textual.containers import VerticalScroll
+from textual.widgets import DataTable, Static
+
+
+class RowGroupView(VerticalScroll):
+
+    def on_mount(self) -> None:
+        self.load_row_groups()
+
+    def load_row_groups(self):
+        try:
+            if self.app.handler:
+                rg_info_list = self.app.handler.get_row_group_info()
+
+                if rg_info_list:
+                    table = DataTable(id="rowgroup-table")
+                    table.cursor_type = "row"
+
+                    columns = list(rg_info_list[0].keys())
+                    table.add_columns(*columns)
+
+                    rows_data = [
+                        tuple(str(rg.get(col, '')) for col in columns)
+                        for rg in rg_info_list
+                    ]
+                    table.add_rows(rows_data)
+                    self.mount(table)
+                else:
+                    self.mount(Static("No row group information available or file has no row groups."))
+            else:
+                self.mount(Static("Parquet handler not available.", classes="error-content"))
+        except Exception as e:
+            self.mount(Static(f"Error loading row group info: {e}", classes="error-content"))

parqv/views/schema_view.py

@@ -0,0 +1,187 @@
+import json
+import logging
+from typing import Dict, Any, Optional, List, Union
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import VerticalScroll, Container
+from textual.reactive import var
+from textual.widgets import Static, ListView, ListItem, Label, LoadingIndicator
+
+log = logging.getLogger(__name__)
+
+
+class ColumnListItem(ListItem):
+    def __init__(self, column_name: str) -> None:
+        super().__init__(Label(column_name), name=column_name, id=f"col-item-{column_name.replace(' ', '_')}")
+        self.column_name = column_name
+
+
+def format_stats_for_display(stats_data: Dict[str, Any]) -> List[Union[str, 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 = stats_data.get("nullable", "Unknown")
+
+    lines.append(Text.assemble(("Column: ", "bold"), f"`{col_name}`"))
+    lines.append(Text.assemble(("Type:   ", "bold"), f"{col_type} ({'Nullable' if nullable else 'Required'})"))
+    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"```{calc_error}```")
+
+    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", "Distinct Count", "Value Counts"
+        ]
+        for key in keys_to_display:
+            if key in calculated:
+                value = calculated[key]
+                if isinstance(value, dict):
+                    lines.append(f"  - {key}:")
+                    for sub_key, sub_val in value.items():
+                        lines.append(f"    - {sub_key}: {sub_val:,}")
+                else:
+                    lines.append(f"  - {key}: {value}")
+        lines.append("")
+
+    meta_stats = stats_data.get("basic_metadata_stats")
+    if meta_stats:
+        lines.append(Text("Stats from File Metadata (Per Row Group):", style="bold"))
+        try:
+            json_str = json.dumps(meta_stats, indent=2, default=str)
+            lines.append(f"```json\n{json_str}\n```")
+        except Exception as e:
+            lines.append(f"  (Error formatting metadata: {e})")
+        lines.append("")
+
+    meta_stats_error = stats_data.get("metadata_stats_error")
+    if meta_stats_error:
+        lines.append(Text(f"Metadata Stats Warning: {meta_stats_error}", style="yellow"))
+
+    message = stats_data.get("message")
+    if message and not calculated:
+        lines.append(Text(message, style="italic"))
+
+    return lines
+
+
+class SchemaView(VerticalScroll):
+    DEFAULT_STATS_MESSAGE = "Select a column above to view statistics."
+    loading = var(False)
+
+    def compose(self) -> ComposeResult:
+        yield ListView(id="column-list-view")
+        yield LoadingIndicator(id="schema-loading-indicator")
+        yield Container(id="schema-stats-content")
+
+    def on_mount(self) -> None:
+        self.query_one("#schema-loading-indicator", LoadingIndicator).styles.display = "none"
+        self.call_later(self.load_column_list)
+        self.call_later(self._update_stats_display, [])
+
+    def load_column_list(self):
+        list_view: Optional[ListView] = None
+        try:
+            list_views = self.query("#column-list-view")
+            if not list_views:
+                log.error("ListView widget (#column-list-view) not found!")
+                return
+            list_view = list_views.first()
+            log.debug("ListView widget found.")
+
+            list_view.clear()
+
+            if self.app.handler and self.app.handler.schema:
+                column_names: List[str] = self.app.handler.schema.names
+                if column_names:
+                    for name in column_names:
+                        list_view.append(ColumnListItem(name))
+                else:
+                    log.warning("Schema has no columns.")
+                    list_view.append(ListItem(Label("[yellow]Schema has no columns.[/yellow]")))
+            elif not self.app.handler:
+                log.error("Parquet handler not available.")
+                list_view.append(ListItem(Label("[red]Parquet handler not available.[/red]")))
+            else:
+                log.error("Parquet schema not available.")
+                list_view.append(ListItem(Label("[red]Parquet schema not available.[/red]")))
+
+        except Exception as e:
+            log.exception("Error loading column list in SchemaView:")
+            if list_view:
+                list_view.clear()
+                list_view.append(ListItem(Label(f"[red]Error loading schema view: {e}[/red]")))
+
+    def watch_loading(self, loading: bool) -> None:
+        loading_indicator = self.query_one("#schema-loading-indicator", LoadingIndicator)
+        stats_content = self.query_one("#schema-stats-content", Container)
+        loading_indicator.styles.display = "block" if loading else "none"
+        stats_content.styles.display = "none" if loading else "block"
+
+    async def _update_stats_display(self, lines: List[Union[str, Text]]) -> None:
+        try:
+            content_area = self.query_one("#schema-stats-content", Container)
+            await content_area.query("*").remove()
+
+            if not lines:
+                await content_area.mount(Static(self.DEFAULT_STATS_MESSAGE, classes="stats-line"))
+                return
+
+            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("` \n")
+                    css_class = "stats-code"
+                elif isinstance(line, Text) and ("red" in str(line.style) or "yellow" in str(line.style)):
+                    css_class = "stats-error stats-line"
+
+                new_widgets.append(Static(content, classes=css_class))
+
+            if new_widgets:
+                await content_area.mount_all(new_widgets)
+        except Exception as e:
+            log.error(f"Error updating stats display: {e}", exc_info=True)
+            try:
+                await content_area.query("*").remove()
+                await content_area.mount(Static(f"[red]Internal error displaying stats: {e}[/red]"))
+            except Exception:
+                pass
+
+    async def on_list_view_selected(self, event: ListView.Selected) -> None:
+        event.stop()
+        selected_item = event.item
+
+        if isinstance(selected_item, ColumnListItem):
+            column_name = selected_item.column_name
+            log.info(f"Column selected: {column_name}")
+            self.loading = True
+
+            stats_data: Dict[str, Any] = {}
+            error_str: Optional[str] = None
+            try:
+                if self.app.handler:
+                    stats_data = self.app.handler.get_column_stats(column_name)
+                else:
+                    error_str = "[red]Error: Parquet handler not available.[/]"
+                    log.error("Parquet handler not found on app.")
+            except Exception as e:
+                log.exception(f"ERROR calculating stats for {column_name}")
+                error_str = f"[red]Error loading stats for {column_name}:\n{type(e).__name__}: {e}[/]"
+
+            lines_to_render = format_stats_for_display(stats_data) if not error_str else [Text.from_markup(error_str)]
+            await self._update_stats_display(lines_to_render)
+            self.loading = False
+        else:
+            await self._update_stats_display([])
+            self.loading = False

parqv-0.1.0.dist-info/METADATA

@@ -0,0 +1,91 @@
+Metadata-Version: 2.4
+Name: parqv
+Version: 0.1.0
+Summary: An interactive Python TUI for visualizing, exploring, and analyzing Parquet files directly in your terminal.
+Author-email: Sangmin Yoon <sanspareilsmyn@gmail.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: textual>=1.0.0
+Requires-Dist: pyarrow>=16.0.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.20.0
+Dynamic: license-file
+
+# parqv
+
+[![Python Version](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](LICENSE)
+[![PyPI version](https://badge.fury.io/py/parqv.svg)](https://badge.fury.io/py/parqv) <!-- Link after PyPI release -->
+[![Built with Textual](https://img.shields.io/badge/Built%20with-Textual-blueviolet.svg)](https://textual.textualize.io/)
+<!-- Optional: Add BuyMeACoffee or other badges later if desired -->
+
+**`parqv` is a Python-based interactive TUI (Text User Interface) tool designed to explore, analyze, and understand Parquet files directly within your terminal.** Forget juggling multiple commands; `parqv` provides a unified, visual experience.
+
+## 💻 Demo (Placeholder)
+
+![parqv.gif](assets/parqv.gif)
+
+## 🤔 Why `parqv`?
+1.  **Unified Interface:** Launch `parqv <file.parquet>` to access **metadata, schema, data preview, column statistics, and row group details** all within a single, navigable terminal window. No more memorizing different commands.
+2.  **Interactive Exploration:**
+    *   **🖱️ Keyboard & Mouse Driven:** Navigate using familiar keys (arrows, `hjkl`, Tab) or even your mouse (thanks to `Textual`).
+    *   **📜 Scrollable Views:** Easily scroll through large schemas, data tables, or row group lists.
+    *   **🌲 Expandable Schema:** Visualize and navigate complex nested structures (Structs, Lists) effortlessly.
+    *   **📊 Dynamic Stats:** Select a column and instantly see its detailed statistics and distribution.
+3.  **Enhanced Analysis & Visualization:**
+    *   **🎨 Rich Display:** Leverages `rich` and `Textual` for colorful, readable tables and syntax-highlighted schema.
+    *   **📈 Quick Stats:** Go beyond min/max/nulls. See means, medians, quantiles, distinct counts, frequency distributions, and even text-based histograms.
+    *   **🔬 Row Group Deep Dive:** Inspect individual row groups to understand compression, encoding, and potential data skew.
+
+## ✨ Features (TUI Mode)
+*   **Interactive TUI:** Run `parqv <file.parquet>` to launch the main interface.
+*   **Metadata Panel:** Displays key file information (path, creator, total rows, row groups, compression, etc.).
+*   **Schema Explorer:**
+    *   Interactive, collapsible tree view for schemas.
+    *   Clearly shows column names, data types (including nested types), and nullability.
+    *   Syntax highlighting for better readability.
+*   **Data Table Viewer:**
+    *   Scrollable table preview of the file's data.
+    *   Handles large files by loading data pages on demand.
+    *   (Planned) Column selection/reordering.
+*   **Row Group Inspector:**
+    *   List all row groups with key stats (row count, compressed/uncompressed size).
+    *   Select a row group to view per-column details (encoding, size, stats within the group).
+
+## 🚀 Getting Started
+
+**1. Prerequisites:**
+*   **Python:** Version 3.10 or higher.
+*   **pip:** The Python package installer.
+
+**2. Install `parqv`:**
+*   Open your terminal and run:
+    ```bash
+    pip install parqv
+    ```
+*   **Updating `parqv`:**
+    ```bash
+    pip install --upgrade parqv
+    ```
+
+**3. Run `parqv`:**
+*   Point `parqv` to your Parquet file:
+    ```bash
+    parqv /path/to/your/data.parquet
+    ```
+*   The interactive TUI will launch. Use your keyboard (and mouse, if supported by your terminal) to navigate:
+    *   **Arrow Keys / `h`,`j`,`k`,`l`:** Move focus within lists, tables, trees.
+    *   **`Tab` / `Shift+Tab`:** Cycle focus between different panes/widgets.
+    *   **`Enter`:** Select items, expand/collapse tree nodes.
+    *   **View Switching Keys (Examples - check help):** `m` (Metadata), `s` (Schema), `d` (Data), `t` (Stats), `g` (Row Groups).
+    *   **`PageUp` / `PageDown` / `Home` / `End`:** Scroll long lists or tables.
+    *   **`?`:** Show help screen with keybindings.
+    *   **`q` / `Ctrl+C`:** Quit `parqv`.
+
+---
+
+## 📄 License
+
+Licensed under the Apache License, Version 2.0. See [LICENSE](LICENSE) for the full license text.

parqv-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+parqv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+parqv/app.py,sha256=akN-tLb0QpYrG9A_1-Sa2zg--MOZpSGMbVYEZDFpyY0,4587
+parqv/parquet_handler.py,sha256=Jh210_neAhVZU4vcz8N4gVbV0NqilkYZ0IlQTMcrrkc,16589
+parqv/parqv.css,sha256=C42ZXUwMX1ZXfGo0AmixbHxz0CWKzWBHZ_hkhq5aehg,2920
+parqv/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+parqv/views/data_view.py,sha256=T_LPbXdxm_KOmwtTQWAxlUeNTlSGfIgQIg853WDMAME,2355
+parqv/views/metadata_view.py,sha256=KgLOjefGyY50zTs-H99PwvJ9IDPE1jfq6--qmD5zp48,656
+parqv/views/row_group_view.py,sha256=4BkaUM2Q2HQ-bvdRYpiYIl5T4oGJGReoaJOcttUd-8s,1210
+parqv/views/schema_view.py,sha256=IYsxkIV9kvOKGfylOQhqeUyakvymlGlgwXWMibhslmI,7880
+parqv-0.1.0.dist-info/licenses/LICENSE,sha256=Ewl2wCa8r6ncxHlpf-ZZXb77c82zdfxHuEeKzBbm6nM,11324
+parqv-0.1.0.dist-info/METADATA,sha256=TxX4NHmXdfu4O5bK6-UiMqlncusxfxj1KvZQaGVLPR0,4525
+parqv-0.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+parqv-0.1.0.dist-info/entry_points.txt,sha256=8Tm8rTiIB-tbVItoOA4M7seEmFnrtK25BMH9UKzqfXg,44
+parqv-0.1.0.dist-info/top_level.txt,sha256=_t3_49ZluJbvl0QU_P3GNVuXxCffqiTp37dzZIa2GEw,6
+parqv-0.1.0.dist-info/RECORD,,

parqv-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

parqv-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+parqv = parqv.app:run_app

parqv-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+ Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

parqv-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+parqv