iparq 0.1.7__py3-none-any.whl → 0.2.5__py3-none-any.whl

iparq/source.py

@@ -1,13 +1,27 @@
+import json
+from enum import Enum
+from typing import List, Optional
+
 import pyarrow.parquet as pq
 import typer
 from pydantic import BaseModel
 from rich import print
 from rich.console import Console
+from rich.table import Table
 
-app = typer.Typer()
+app = typer.Typer(
+    help="Inspect Parquet files for metadata, compression, and bloom filters"
+)
 console = Console()
 
 
+class OutputFormat(str, Enum):
+    """Enum for output format options."""
+
+    RICH = "rich"
+    JSON = "json"
+
+
 class ParquetMetaModel(BaseModel):
     """
     ParquetMetaModel is a data model representing metadata for a Parquet file.
@@ -29,6 +43,36 @@ class ParquetMetaModel(BaseModel):
     serialized_size: int
 
 
+class ColumnInfo(BaseModel):
+    """
+    ColumnInfo is a data model representing information about a column in a Parquet file.
+
+    Attributes:
+        row_group (int): The row group index.
+        column_name (str): The name of the column.
+        column_index (int): The index of the column.
+        compression_type (str): The compression type used for the column.
+        has_bloom_filter (bool): Whether the column has a bloom filter.
+    """
+
+    row_group: int
+    column_name: str
+    column_index: int
+    compression_type: str
+    has_bloom_filter: Optional[bool] = False
+
+
+class ParquetColumnInfo(BaseModel):
+    """
+    ParquetColumnInfo is a data model representing information about all columns in a Parquet file.
+
+    Attributes:
+        columns (List[ColumnInfo]): List of column information.
+    """
+
+    columns: List[ColumnInfo] = []
+
+
 def read_parquet_metadata(filename: str):
     """
     Reads the metadata of a Parquet file and extracts the compression codecs used.
@@ -94,88 +138,188 @@ def print_parquet_metadata(parquet_metadata):
         pass
 
 
-def print_compression_types(parquet_metadata) -> None:
+def print_compression_types(parquet_metadata, column_info: ParquetColumnInfo) -> None:
     """
-    Prints the compression type for each column in each row group of the Parquet file.
+    Collects compression type information for each column and adds it to the column_info model.
+
+    Args:
+        parquet_metadata: The Parquet file metadata.
+        column_info: The ParquetColumnInfo model to update.
     """
     try:
         num_row_groups = parquet_metadata.num_row_groups
         num_columns = parquet_metadata.num_columns
-        console.print("[bold underline]Column Compression Info:[/bold underline]")
+
         for i in range(num_row_groups):
-            console.print(f"[bold]Row Group {i}:[/bold]")
+            row_group = parquet_metadata.row_group(i)
             for j in range(num_columns):
-                column_chunk = parquet_metadata.row_group(i).column(j)
+                column_chunk = row_group.column(j)
                 compression = column_chunk.compression
-                column_name = parquet_metadata.schema.column(j).name
-                console.print(
-                    f"  Column '{column_name}' (Index {j}): [italic]{compression}[/italic]"
+                column_name = parquet_metadata.schema.names[j]
+
+                # Create or update column info
+                column_info.columns.append(
+                    ColumnInfo(
+                        row_group=i,
+                        column_name=column_name,
+                        column_index=j,
+                        compression_type=compression,
+                    )
                 )
     except Exception as e:
         console.print(
-            f"Error while printing compression types: {e}",
+            f"Error while collecting compression types: {e}",
             style="blink bold red underline on white",
         )
-    finally:
-        pass
 
 
-def print_bloom_filter_info(parquet_metadata) -> None:
+def print_bloom_filter_info(parquet_metadata, column_info: ParquetColumnInfo) -> None:
     """
-    Prints information about bloom filters for each column in each row group of the Parquet file.
+    Updates the column_info model with bloom filter information.
+
+    Args:
+        parquet_metadata: The Parquet file metadata.
+        column_info: The ParquetColumnInfo model to update.
     """
     try:
         num_row_groups = parquet_metadata.num_row_groups
         num_columns = parquet_metadata.num_columns
-        has_bloom_filters = False
-
-        console.print("[bold underline]Bloom Filter Info:[/bold underline]")
 
         for i in range(num_row_groups):
             row_group = parquet_metadata.row_group(i)
-            bloom_filters_in_group = False
 
             for j in range(num_columns):
                 column_chunk = row_group.column(j)
-                column_name = parquet_metadata.schema.column(j).name
-
-                # Check if this column has bloom filters using is_stats_set
-                if hasattr(column_chunk, "is_stats_set") and column_chunk.is_stats_set:
-                    if not bloom_filters_in_group:
-                        console.print(f"[bold]Row Group {i}:[/bold]")
-                        bloom_filters_in_group = True
-                    has_bloom_filters = True
-                    console.print(
-                        f"  Column '{column_name}' (Index {j}): [green]Has bloom filter[/green]"
-                    )
-
-        if not has_bloom_filters:
-            console.print("  [italic]No bloom filters found in any column[/italic]")
 
+                # Find the corresponding column in our model
+                for col in column_info.columns:
+                    if col.row_group == i and col.column_index == j:
+                        # Check if this column has bloom filters
+                        has_bloom_filter = (
+                            hasattr(column_chunk, "is_stats_set")
+                            and column_chunk.is_stats_set
+                        )
+                        col.has_bloom_filter = has_bloom_filter
+                        break
     except Exception as e:
         console.print(
-            f"Error while printing bloom filter information: {e}",
+            f"Error while collecting bloom filter information: {e}",
             style="blink bold red underline on white",
         )
 
 
-@app.command()
-def main(filename: str):
+def print_column_info_table(column_info: ParquetColumnInfo) -> None:
     """
-    Main function to read and print Parquet file metadata.
+    Prints the column information using a Rich table.
 
     Args:
-        filename (str): The path to the Parquet file.
+        column_info: The ParquetColumnInfo model to display.
+    """
+    table = Table(title="Parquet Column Information")
+
+    # Add table columns
+    table.add_column("Row Group", justify="center", style="cyan")
+    table.add_column("Column Name", style="green")
+    table.add_column("Index", justify="center")
+    table.add_column("Compression", style="magenta")
+    table.add_column("Bloom Filter", justify="center")
+
+    # Add rows to the table
+    for col in column_info.columns:
+        table.add_row(
+            str(col.row_group),
+            col.column_name,
+            str(col.column_index),
+            col.compression_type,
+            "✅" if col.has_bloom_filter else "❌",
+        )
 
-    Returns:
-        Metadata of the Parquet file and the compression codecs used.
+    # Print the table
+    console.print(table)
+
+
+def output_json(
+    meta_model: ParquetMetaModel,
+    column_info: ParquetColumnInfo,
+    compression_codecs: set,
+) -> None:
+    """
+    Outputs the parquet information in JSON format.
+
+    Args:
+        meta_model: The Parquet metadata model
+        column_info: The column information model
+        compression_codecs: Set of compression codecs used
+    """
+    result = {
+        "metadata": meta_model.model_dump(),
+        "columns": [column.model_dump() for column in column_info.columns],
+        "compression_codecs": list(compression_codecs),
+    }
+
+    print(json.dumps(result, indent=2))
+
+
+@app.command(name="")
+@app.command(name="inspect")
+def inspect(
+    filename: str = typer.Argument(..., help="Path to the Parquet file to inspect"),
+    format: OutputFormat = typer.Option(
+        OutputFormat.RICH, "--format", "-f", help="Output format (rich or json)"
+    ),
+    metadata_only: bool = typer.Option(
+        False,
+        "--metadata-only",
+        "-m",
+        help="Show only file metadata without column details",
+    ),
+    column_filter: Optional[str] = typer.Option(
+        None, "--column", "-c", help="Filter results to show only specific column"
+    ),
+):
+    """
+    Inspect a Parquet file and display its metadata, compression settings, and bloom filter information.
     """
     (parquet_metadata, compression) = read_parquet_metadata(filename)
 
-    print_parquet_metadata(parquet_metadata)
-    print_compression_types(parquet_metadata)
-    print_bloom_filter_info(parquet_metadata)
-    print(f"Compression codecs: {compression}")
+    # Create metadata model
+    meta_model = ParquetMetaModel(
+        created_by=parquet_metadata.created_by,
+        num_columns=parquet_metadata.num_columns,
+        num_rows=parquet_metadata.num_rows,
+        num_row_groups=parquet_metadata.num_row_groups,
+        format_version=str(parquet_metadata.format_version),
+        serialized_size=parquet_metadata.serialized_size,
+    )
+
+    # Create a model to store column information
+    column_info = ParquetColumnInfo()
+
+    # Collect information
+    print_compression_types(parquet_metadata, column_info)
+    print_bloom_filter_info(parquet_metadata, column_info)
+
+    # Filter columns if requested
+    if column_filter:
+        column_info.columns = [
+            col for col in column_info.columns if col.column_name == column_filter
+        ]
+        if not column_info.columns:
+            console.print(
+                f"No columns match the filter: {column_filter}", style="yellow"
+            )
+
+    # Output based on format selection
+    if format == OutputFormat.JSON:
+        output_json(meta_model, column_info, compression)
+    else:  # Rich format
+        # Print the metadata
+        console.print(meta_model)
+
+        # Print column details if not metadata only
+        if not metadata_only:
+            print_column_info_table(column_info)
+            console.print(f"Compression codecs: {compression}")
 
 
 if __name__ == "__main__":

iparq-0.2.5.dist-info/METADATA

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: iparq
+Version: 0.2.5
+Summary: Display version compression and bloom filter information about a parquet file
+Author-email: MiguelElGallo <miguel.zurcher@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: pyarrow
+Requires-Dist: pydantic
+Requires-Dist: rich
+Requires-Dist: typer[all]
+Provides-Extra: checks
+Requires-Dist: mypy>=1.14.1; extra == 'checks'
+Requires-Dist: ruff>=0.9.3; extra == 'checks'
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# iparq
+
+[![Python package](https://github.com/MiguelElGallo/iparq/actions/workflows/python-package.yml/badge.svg)](https://github.com/MiguelElGallo/iparq/actions/workflows/python-package.yml)
+
+[![Dependabot Updates](https://github.com/MiguelElGallo/iparq/actions/workflows/dependabot/dependabot-updates/badge.svg)](https://github.com/MiguelElGallo/iparq/actions/workflows/dependabot/dependabot-updates)
+
+[![Upload Python Package](https://github.com/MiguelElGallo/iparq/actions/workflows/python-publish.yml/badge.svg)](https://github.com/MiguelElGallo/iparq/actions/workflows/python-publish.yml)
+
+![alt text](media/iparq.png)
+After reading [this blog](https://duckdb.org/2025/01/22/parquet-encodings.html), I began to wonder which Parquet version and compression methods the everyday tools we rely on actually use, only to find that there's no straightforward way to determine this. That curiosity and the difficulty of quickly discovering such details motivated me to create iparq (Information Parquet). My goal with iparq is to help users easily identify the specifics of the Parquet files generated by different engines, making it clear which features—like newer encodings or certain compression algorithms—the creator of the parquet is using.
+
+***New*** Bloom filters information: Displays if there are bloom filters.
+Read more about bloom filters in this [great article](https://duckdb.org/2025/03/07/parquet-bloom-filters-in-duckdb.html).
+
+## Installation
+
+### Zero installation - Recommended
+
+1) Make sure to have Astral's UV installed by following the steps here:  
+
+    <https://docs.astral.sh/uv/getting-started/installation/>
+
+2) Execute the following command:
+
+    ```sh
+    uvx --refresh iparq inspect yourparquet.parquet
+    ```
+
+### Using pip
+
+1) Install the package using pip:
+
+    ```sh
+    pip install iparq
+    ```
+
+2) Verify the installation by running:
+
+    ```sh
+    iparq --help
+    ```
+
+### Using uv
+
+1) Make sure to have Astral's UV installed by following the steps here:  
+
+    <https://docs.astral.sh/uv/getting-started/installation/>
+
+2) Execute the following command:
+
+    ```sh
+    uv pip install iparq
+    ```
+
+3) Verify the installation by running:
+
+    ```sh
+    iparq --help
+    ```
+
+### Using Homebrew in a MAC
+
+1) Run the following:
+
+    ```sh
+    brew tap MiguelElGallo/tap https://github.com/MiguelElGallo//homebrew-iparq.git
+    brew install MiguelElGallo/tap/iparq
+    iparq --help
+    ```
+
+## Usage
+
+iparq now supports additional options:
+
+```sh
+iparq inspect <filename> [OPTIONS]
+```
+
+Options include:
+
+- `--format`, `-f`: Output format, either `rich` (default) or `json`
+- `--metadata-only`, `-m`: Show only file metadata without column details
+- `--column`, `-c`: Filter results to show only a specific column
+
+Examples:
+
+```sh
+# Output in JSON format
+iparq inspect yourfile.parquet --format json
+
+# Show only metadata
+iparq inspect yourfile.parquet --metadata-only
+
+# Filter to show only a specific column
+iparq inspect yourfile.parquet --column column_name
+```
+
+Replace `<filename>` with the path to your .parquet file. The utility will read the metadata of the file and print the compression codecs used in the parquet file.
+
+## Example ouput - Bloom Filters
+
+```log
+ParquetMetaModel(
+    created_by='DuckDB version v1.2.1 (build 8e52ec4395)',
+    num_columns=1,
+    num_rows=100000000,
+    num_row_groups=10,
+    format_version='1.0',
+    serialized_size=1196
+)
+                   Parquet Column Information                   
+┏━━━━━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
+┃ Row Group ┃ Column Name ┃ Index ┃ Compression ┃ Bloom Filter ┃
+┡━━━━━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
+│     0     │ r           │   0   │ SNAPPY      │      ✅      │
+│     1     │ r           │   0   │ SNAPPY      │      ✅      │
+│     2     │ r           │   0   │ SNAPPY      │      ✅      │
+│     3     │ r           │   0   │ SNAPPY      │      ✅      │
+│     4     │ r           │   0   │ SNAPPY      │      ✅      │
+│     5     │ r           │   0   │ SNAPPY      │      ✅      │
+│     6     │ r           │   0   │ SNAPPY      │      ✅      │
+│     7     │ r           │   0   │ SNAPPY      │      ✅      │
+│     8     │ r           │   0   │ SNAPPY      │      ✅      │
+│     9     │ r           │   0   │ SNAPPY      │      ✅      │
+└───────────┴─────────────┴───────┴─────────────┴──────────────┘
+Compression codecs: {'SNAPPY'}
+```

iparq-0.2.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+iparq/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
+iparq/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iparq/source.py,sha256=huC6I0hqwyv4BZ5xjI6FMZs9KH60xVHEKbmX6X8hhiA,10721
+iparq-0.2.5.dist-info/METADATA,sha256=QpkD25vwzqlQo9e2JQKFx9VHdyV0So9u20TtZHkf4LY,5501
+iparq-0.2.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+iparq-0.2.5.dist-info/entry_points.txt,sha256=vrE2lwvuheySWTOJdr_gh9AT47ck02WCHo0muRq5HS8,43
+iparq-0.2.5.dist-info/licenses/LICENSE,sha256=apqXCIYD_rrtbJVE-Ex1-1X7N0cBwZTOm4KL3TEFmYA,1067
+iparq-0.2.5.dist-info/RECORD,,

iparq-0.1.7.dist-info/METADATA

@@ -1,216 +0,0 @@
-Metadata-Version: 2.4
-Name: iparq
-Version: 0.1.7
-Summary: Display version and compression information about a parquet file
-Author-email: MiguelElGallo <miguel.zurcher@gmail.com>
-License-File: LICENSE
-Requires-Python: >=3.9
-Requires-Dist: pyarrow>=19.0.0
-Requires-Dist: pydantic>=2.10.6
-Requires-Dist: typer>=0.15.1
-Provides-Extra: checks
-Requires-Dist: mypy>=1.14.1; extra == 'checks'
-Requires-Dist: ruff>=0.9.3; extra == 'checks'
-Provides-Extra: test
-Requires-Dist: pytest>=7.0; extra == 'test'
-Description-Content-Type: text/markdown
-
-# iparq
-
-[![Python package](https://github.com/MiguelElGallo/iparq/actions/workflows/python-package.yml/badge.svg)](https://github.com/MiguelElGallo/iparq/actions/workflows/python-package.yml)
-
-[![Dependabot Updates](https://github.com/MiguelElGallo/iparq/actions/workflows/dependabot/dependabot-updates/badge.svg)](https://github.com/MiguelElGallo/iparq/actions/workflows/dependabot/dependabot-updates)
-
-[![Upload Python Package](https://github.com/MiguelElGallo/iparq/actions/workflows/python-publish.yml/badge.svg)](https://github.com/MiguelElGallo/iparq/actions/workflows/python-publish.yml)
-
-![alt text](media/iparq.png)
-After reading [this blog](https://duckdb.org/2025/01/22/parquet-encodings.html), I began to wonder which Parquet version and compression methods the everyday tools we rely on actually use, only to find that there’s no straightforward way to determine this. That curiosity and the difficulty of quickly discovering such details motivated me to create iparq (Information Parquet). My goal with iparq is to help users easily identify the specifics of the Parquet files generated by different engines, making it clear which features—like newer encodings or certain compression algorithms—the creator of the parquet is using.
-
-***New*** Bloom filters information: Displays if there are bloom filters.
-Read more about bloom filters in this [great article](https://duckdb.org/2025/03/07/parquet-bloom-filters-in-duckdb.html).
-
-
-## Installation
-
-### Using pip
-
-1) Install the package using pip:
-
-    ```sh
-    pip install iparq
-    ```
-
-2) Verify the installation by running:
-
-    ```sh
-    iparq --help
-    ```
-
-### Using uv
-
-1) Make sure to have Astral’s UV installed by following the steps here:  
-
-    <https://docs.astral.sh/uv/getting-started/installation/>
-
-2) Execute the following command:
-
-    ```sh
-    uv pip install iparq
-    ```
-
-3) Verify the installation by running:
-
-    ```sh
-    iparq --help
-    ```
-
-### Using Homebrew in a MAC
-
-1) Run the following:
-
-    ```sh
-    brew tap MiguelElGallo/tap https://github.com/MiguelElGallo//homebrew-iparq.git
-    brew install MiguelElGallo/tap/iparq
-    iparq —help
-    ```
-
-## Usage
-
-Run
-
-```sh
-iparq <filename>
-```
-
-Replace `<filename>` with the path to your .parquet file. The utility will read the metadata of the file and print the compression codecs used in the parquet file.
-
-## Example ouput - Bloom Filters
-
-```log
-ParquetMetaModel(
-    created_by='DuckDB version v1.2.1 (build 8e52ec4395)',
-    num_columns=1,
-    num_rows=100000000,
-    num_row_groups=10,
-    format_version='1.0',
-    serialized_size=1196
-)
-Column Compression Info:
-Row Group 0:
-  Column 'r' (Index 0): SNAPPY
-Row Group 1:
-  Column 'r' (Index 0): SNAPPY
-Row Group 2:
-  Column 'r' (Index 0): SNAPPY
-Row Group 3:
-  Column 'r' (Index 0): SNAPPY
-Row Group 4:
-  Column 'r' (Index 0): SNAPPY
-Row Group 5:
-  Column 'r' (Index 0): SNAPPY
-Row Group 6:
-  Column 'r' (Index 0): SNAPPY
-Row Group 7:
-  Column 'r' (Index 0): SNAPPY
-Row Group 8:
-  Column 'r' (Index 0): SNAPPY
-Row Group 9:
-  Column 'r' (Index 0): SNAPPY
-Bloom Filter Info:
-Row Group 0:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 1:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 2:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 3:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 4:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 5:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 6:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 7:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 8:
-  Column 'r' (Index 0): Has bloom filter
-Row Group 9:
-  Column 'r' (Index 0): Has bloom filter
-Compression codecs: {'SNAPPY'}
-```
-
-## Example output 
-
-```log
-ParquetMetaModel(
-    created_by='parquet-cpp-arrow version 14.0.2',
-    num_columns=19,
-    num_rows=2964624,
-    num_row_groups=3,
-    format_version='2.6',
-    serialized_size=6357
-)
-Column Compression Info:
-Row Group 0:
-  Column 'VendorID' (Index 0): ZSTD
-  Column 'tpep_pickup_datetime' (Index 1): ZSTD
-  Column 'tpep_dropoff_datetime' (Index 2): ZSTD
-  Column 'passenger_count' (Index 3): ZSTD
-  Column 'trip_distance' (Index 4): ZSTD
-  Column 'RatecodeID' (Index 5): ZSTD
-  Column 'store_and_fwd_flag' (Index 6): ZSTD
-  Column 'PULocationID' (Index 7): ZSTD
-  Column 'DOLocationID' (Index 8): ZSTD
-  Column 'payment_type' (Index 9): ZSTD
-  Column 'fare_amount' (Index 10): ZSTD
-  Column 'extra' (Index 11): ZSTD
-  Column 'mta_tax' (Index 12): ZSTD
-  Column 'tip_amount' (Index 13): ZSTD
-  Column 'tolls_amount' (Index 14): ZSTD
-  Column 'improvement_surcharge' (Index 15): ZSTD
-  Column 'total_amount' (Index 16): ZSTD
-  Column 'congestion_surcharge' (Index 17): ZSTD
-  Column 'Airport_fee' (Index 18): ZSTD
-Row Group 1:
-  Column 'VendorID' (Index 0): ZSTD
-  Column 'tpep_pickup_datetime' (Index 1): ZSTD
-  Column 'tpep_dropoff_datetime' (Index 2): ZSTD
-  Column 'passenger_count' (Index 3): ZSTD
-  Column 'trip_distance' (Index 4): ZSTD
-  Column 'RatecodeID' (Index 5): ZSTD
-  Column 'store_and_fwd_flag' (Index 6): ZSTD
-  Column 'PULocationID' (Index 7): ZSTD
-  Column 'DOLocationID' (Index 8): ZSTD
-  Column 'payment_type' (Index 9): ZSTD
-  Column 'fare_amount' (Index 10): ZSTD
-  Column 'extra' (Index 11): ZSTD
-  Column 'mta_tax' (Index 12): ZSTD
-  Column 'tip_amount' (Index 13): ZSTD
-  Column 'tolls_amount' (Index 14): ZSTD
-  Column 'improvement_surcharge' (Index 15): ZSTD
-  Column 'total_amount' (Index 16): ZSTD
-  Column 'congestion_surcharge' (Index 17): ZSTD
-  Column 'Airport_fee' (Index 18): ZSTD
-Row Group 2:
-  Column 'VendorID' (Index 0): ZSTD
-  Column 'tpep_pickup_datetime' (Index 1): ZSTD
-  Column 'tpep_dropoff_datetime' (Index 2): ZSTD
-  Column 'passenger_count' (Index 3): ZSTD
-  Column 'trip_distance' (Index 4): ZSTD
-  Column 'RatecodeID' (Index 5): ZSTD
-  Column 'store_and_fwd_flag' (Index 6): ZSTD
-  Column 'PULocationID' (Index 7): ZSTD
-  Column 'DOLocationID' (Index 8): ZSTD
-  Column 'payment_type' (Index 9): ZSTD
-  Column 'fare_amount' (Index 10): ZSTD
-  Column 'extra' (Index 11): ZSTD
-  Column 'mta_tax' (Index 12): ZSTD
-  Column 'tip_amount' (Index 13): ZSTD
-  Column 'tolls_amount' (Index 14): ZSTD
-  Column 'improvement_surcharge' (Index 15): ZSTD
-  Column 'total_amount' (Index 16): ZSTD
-  Column 'congestion_surcharge' (Index 17): ZSTD
-  Column 'Airport_fee' (Index 18): ZSTD
-Compression codecs: {'ZSTD'}
-```

iparq-0.1.7.dist-info/RECORD

@@ -1,7 +0,0 @@
-iparq/__init__.py,sha256=sXLh7g3KC4QCFxcZGBTpG2scR7hmmBsMjq6LqRptkRg,22
-iparq/source.py,sha256=crKRTuZY6W2zEhFfAzb4XWopaVy9qnEkFqz4jbyGmeM,6439
-iparq-0.1.7.dist-info/METADATA,sha256=ku4ZsLQ1Iq2ovPzKqv8aGqBGBkn3nTviW6hFzFsP6bw,6884
-iparq-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-iparq-0.1.7.dist-info/entry_points.txt,sha256=vrE2lwvuheySWTOJdr_gh9AT47ck02WCHo0muRq5HS8,43
-iparq-0.1.7.dist-info/licenses/LICENSE,sha256=apqXCIYD_rrtbJVE-Ex1-1X7N0cBwZTOm4KL3TEFmYA,1067
-iparq-0.1.7.dist-info/RECORD,,