tab-cli 0.1.0__tar.gz

tab_cli-0.1.0/.gitignore

@@ -0,0 +1,62 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+
+# uv
+.uv/
+uv.lock
+
+# PyCharm
+.idea/
+*.iml
+*.ipr
+*.iws
+out/
+
+# Testing
+.tox/
+.nox/
+.coverage
+.coverage.*
+htmlcov/
+.pytest_cache/
+.hypothesis/
+
+# Mypy
+.mypy_cache/
+
+# Ruff
+.ruff_cache/
+
+# Distribution
+*.manifest
+*.spec
+
+# Misc
+*.log
+.DS_Store

tab_cli-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2026-- Tongfei Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

tab_cli-0.1.0/Makefile

@@ -0,0 +1,32 @@
+.PHONY: install dev clean lint format test build publish publish-test
+
+install:
+	uv tool install . --force
+
+dev:
+	uv sync --dev
+
+clean:
+	rm -rf dist/ build/ *.egg-info .pytest_cache .mypy_cache .ruff_cache
+	find . -type d -name __pycache__ -exec rm -rf {} +
+
+lint:
+	uv run ruff check tab_cli/
+
+format:
+	uv run ruff format tab_cli/
+
+typecheck:
+	uv run ty check tab_cli/
+
+test:
+	uv run pytest
+
+build: clean
+	uv build
+
+publish: build
+	uv publish
+
+publish-test: build
+	uv publish --publish-url https://test.pypi.org/legacy/

tab_cli-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: tab-cli
+Version: 0.1.0
+Summary: A CLI tool for tabular data
+Author-email: Tongfei Chen <tongfei@pm.me>
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: blobfile>=3.0
+Requires-Dist: fire>=0.5
+Requires-Dist: polars>=1.0
+Requires-Dist: pyarrow>=15.0
+Requires-Dist: rich>=13.0
+Description-Content-Type: text/markdown
+
+# tab
+
+A fast CLI tool for viewing, querying, and converting tabular data files.
+
+## Supported Formats
+ - Parquet
+ - CSV
+ - TSV
+ - Jsonl
+
+## Usage
+
+### View data
+
+Display rows from a tabular data file:
+
+```bash
+tab view data.parquet
+tab view data.csv --limit 20
+tab view data.tsv --skip 100 --limit 50
+```
+
+Output to different formats:
+
+```bash
+tab view data.parquet -o jsonl
+tab view data.parquet -o csv
+```
+
+### Schema
+
+Display the schema (column names and types):
+
+```bash
+tab schema data.parquet
+```
+
+### Summary
+
+Display summary information about a file:
+
+```bash
+tab summary data.parquet
+```
+
+### SQL queries
+
+Run SQL queries on your data. The table is referenced as `t`:
+
+```bash
+tab sql "SELECT * FROM t WHERE age > 30" data.parquet
+tab sql "SELECT name, COUNT(*) FROM t GROUP BY name" data.csv
+```
+
+### Convert
+
+Convert between formats:
+
+```bash
+tab convert data.csv data.parquet
+tab convert data.parquet data.jsonl -o jsonl
+```
+
+Write partitioned output:
+
+```bash
+tab convert data.csv output_dir/ -o parquet -n 4
+```
+
+## Options
+
+### Common options
+
+| Option    | Description                                                                   |
+|-----------|-------------------------------------------------------------------------------|
+| `-i`      | Input format (`parquet`, `csv`, `tsv`, `jsonl`). Auto-detected from extension. |
+| `-o`      | Output format (`parquet`, `csv`, `tsv`, `jsonl`).                             |
+| `--limit` | Maximum number of rows to display.                                            |
+| `--skip`  | Number of rows to skip from the beginning.                                    |
+
+### Convert options
+
+| Option | Description |
+|--------|-------------|
+| `-n`   | Number of output partitions. Creates a directory with part files. |
+

tab_cli-0.1.0/README.md

@@ -0,0 +1,86 @@
+# tab
+
+A fast CLI tool for viewing, querying, and converting tabular data files.
+
+## Supported Formats
+ - Parquet
+ - CSV
+ - TSV
+ - Jsonl
+
+## Usage
+
+### View data
+
+Display rows from a tabular data file:
+
+```bash
+tab view data.parquet
+tab view data.csv --limit 20
+tab view data.tsv --skip 100 --limit 50
+```
+
+Output to different formats:
+
+```bash
+tab view data.parquet -o jsonl
+tab view data.parquet -o csv
+```
+
+### Schema
+
+Display the schema (column names and types):
+
+```bash
+tab schema data.parquet
+```
+
+### Summary
+
+Display summary information about a file:
+
+```bash
+tab summary data.parquet
+```
+
+### SQL queries
+
+Run SQL queries on your data. The table is referenced as `t`:
+
+```bash
+tab sql "SELECT * FROM t WHERE age > 30" data.parquet
+tab sql "SELECT name, COUNT(*) FROM t GROUP BY name" data.csv
+```
+
+### Convert
+
+Convert between formats:
+
+```bash
+tab convert data.csv data.parquet
+tab convert data.parquet data.jsonl -o jsonl
+```
+
+Write partitioned output:
+
+```bash
+tab convert data.csv output_dir/ -o parquet -n 4
+```
+
+## Options
+
+### Common options
+
+| Option    | Description                                                                   |
+|-----------|-------------------------------------------------------------------------------|
+| `-i`      | Input format (`parquet`, `csv`, `tsv`, `jsonl`). Auto-detected from extension. |
+| `-o`      | Output format (`parquet`, `csv`, `tsv`, `jsonl`).                             |
+| `--limit` | Maximum number of rows to display.                                            |
+| `--skip`  | Number of rows to skip from the beginning.                                    |
+
+### Convert options
+
+| Option | Description |
+|--------|-------------|
+| `-n`   | Number of output partitions. Creates a directory with part files. |
+

tab_cli-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "tab-cli"
+version = "0.1.0"
+description = "A CLI tool for tabular data"
+authors = [{name = "Tongfei Chen", email = "tongfei@pm.me"}]
+readme = "README.md"
+repository = "https://github.com/tongfei/tab"
+requires-python = ">=3.10"
+dependencies = [
+    "fire>=0.5",
+    "rich>=13.0",
+    "polars>=1.0",
+    "pyarrow>=15.0",
+    "blobfile>=3.0",
+]
+
+[project.scripts]
+tab = "tab_cli.cli:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.14.14",
+    "ty>=0.0.14",
+]

tab_cli-0.1.0/tab_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Tab CLI - A CLI tool for tabular data."""
+
+__version__ = "0.1.0"

tab_cli-0.1.0/tab_cli/cli.py

@@ -0,0 +1,147 @@
+"""Main CLI entry point using Fire."""
+
+import sys
+
+import fire
+import polars as pl
+from rich.console import Console
+
+from tab_cli.handlers import infer_reader, infer_writer, TableWriter
+
+
+class Tab:
+
+    def _output(
+        self,
+        lf: pl.LazyFrame,
+        limit: int | None,
+        skip: int,
+        output: str | None,
+    ) -> None:
+        show_truncation = limit is None and output is None
+        actual_limit = 20 if show_truncation else limit
+
+        if show_truncation:
+            assert actual_limit is not None
+            lf = lf.slice(skip, length=actual_limit + 1)
+            df = lf.collect()
+            truncated = len(df) > actual_limit
+            if truncated:
+                df = df.head(actual_limit)
+            lf = df.lazy()
+        else:
+            if skip > 0 or actual_limit is not None:
+                lf = lf.slice(skip, length=actual_limit)
+            truncated = False
+
+        writer = infer_writer(output, truncated=show_truncation and truncated)
+
+        for chunk in writer.write(lf):
+            sys.stdout.buffer.write(chunk)
+
+    def view(
+        self,
+        path: str,
+        limit: int | None = None,
+        skip: int = 0,
+        output: str | None = None,
+        input: str | None = None,
+    ) -> None:
+        """View tabular data from a file.
+
+        Args:
+            path: Path to the data file.
+            limit: Maximum number of rows to display (default: 10).
+            skip: Number of rows to skip from the beginning (default: 0).
+            output: Output format ('jsonl', 'csv', 'tsv', 'parquet'). Default is a rich table.
+            input: Input format ('parquet', 'csv', 'tsv'). Default is inferred from extension.
+        """
+        reader = infer_reader(path, format=input)
+        lf = reader.read(path)
+        self._output(lf, limit=limit, skip=skip, output=output)
+
+    def schema(self, path: str, input: str | None = None) -> None:
+        """Display the schema of a tabular data file.
+
+        Args:
+            path: Path to the data file.
+            input: Input format ('parquet', 'csv', 'tsv'). Default is inferred from extension.
+        """
+        reader = infer_reader(path, format=input)
+        table_schema = reader.schema(path)
+        console = Console(force_terminal=True)
+        console.print(table_schema)
+
+    def sql(
+        self,
+        query: str,
+        path: str,
+        limit: int | None = None,
+        skip: int = 0,
+        output: str | None = None,
+        input: str | None = None,
+    ) -> None:
+        """Run a SQL query on tabular data. The table is available as `t`.
+
+        Args:
+            query: SQL query to execute. Reference the data as table `t`.
+            path: Path to the data file.
+            limit: Maximum number of rows to display (default: 10).
+            skip: Number of rows to skip from the beginning (default: 0).
+            output: Output format ('jsonl', 'csv', 'tsv', 'parquet'). Default is a rich table.
+            input: Input format ('parquet', 'csv', 'tsv'). Default is inferred from extension.
+        """
+        reader = infer_reader(path, format=input)
+        lf = reader.read(path)
+        ctx = pl.SQLContext(t=lf, eager=False)
+        result_lf = ctx.execute(query)
+        self._output(result_lf, limit=limit, skip=skip, output=output)
+
+    def summary(self, path: str, input: str | None = None) -> None:
+        """Display summary information about a tabular data file.
+
+        Args:
+            path: Path to the data file.
+            input: Input format ('parquet', 'csv', 'tsv'). Default is inferred from extension.
+        """
+        handler = infer_reader(path, format=input)
+        table_summary = handler.summary(path)
+        console = Console(force_terminal=True)
+        console.print(table_summary)
+
+    def convert(
+        self,
+        src: str,
+        dst: str,
+        input: str | None = None,
+        output: str | None = None,
+        num_partitions: int | None = None,
+    ) -> None:
+        """Convert tabular data from one format to another.
+
+        Args:
+            src: Path to the source data file.
+            dst: Path to the destination file or directory.
+            input: Input format ('parquet', 'csv', 'tsv'). Default is inferred from src extension.
+            output: Output format ('parquet', 'csv', 'tsv'). Default is same as input format.
+            num_partitions: Number of output partitions. If not specified, writes to a single file.
+        """
+        reader = infer_reader(src, format=input)
+        # Determine output format: use -o if specified, else inherit from input
+        if output is not None:
+            writer = infer_writer(format=output)
+        elif input is not None:
+            writer = infer_writer(format=input)
+        else:
+            writer = reader
+            assert isinstance(writer, TableWriter)
+        lf = reader.read(src)
+        writer.write_to_path(lf, dst, partitions=num_partitions)
+
+
+def main():
+    fire.Fire(Tab)
+
+
+if __name__ == "__main__":
+    main()

tab_cli-0.1.0/tab_cli/handlers/__init__.py

@@ -0,0 +1,55 @@
+import os
+
+from tab_cli.handlers.base import TableReader, TableWriter
+from tab_cli.handlers.cli_table import CliTableFormatter
+from tab_cli.handlers.csv import CsvHandler
+from tab_cli.handlers.directory import DirectoryReader
+from tab_cli.handlers.jsonl import JsonlHandler
+from tab_cli.handlers.parquet import ParquetHandler
+
+_READER_MAP = {
+    "csv": CsvHandler(","),
+    "tsv": CsvHandler("\t"),
+    "parquet": ParquetHandler(),
+    "jsonl": JsonlHandler(),
+}
+
+_WRITER_MAP = {
+    "csv": CsvHandler(","),
+    "tsv": CsvHandler("\t"),
+    "parquet": ParquetHandler(),
+    "jsonl": JsonlHandler(),
+}
+
+def infer_reader(path: str, format: str | None = None) -> TableReader:
+    """Infer the handler for a file. If format is given, use that instead of extension."""
+    if format is not None:
+        handler = _READER_MAP.get(format.lower())
+        if handler is None:
+            raise ValueError(f"Unknown format: {format}. Supported: {', '.join(_READER_MAP)}")
+        return handler
+
+    if os.path.isdir(path):
+        extension = os.path.splitext(os.listdir(path)[0])[1][1:].lower()
+        return DirectoryReader(extension, infer_reader_from_extension(extension))
+
+    extension = os.path.splitext(path)[1][1:].lower()
+    return infer_reader_from_extension(extension)
+
+
+def infer_reader_from_extension(extension: str) -> TableReader:
+    """Infer the handler for a file based on its extension."""
+    handler = _READER_MAP.get(extension)
+    if handler is None:
+        raise ValueError(f"Unknown extension: {extension}. Supported: {', '.join(_READER_MAP)}")
+    return handler
+
+
+def infer_writer(format: str | None = None, truncated: bool = False) -> TableWriter:
+    """Infer the writer for a format."""
+    if format is None:
+        return CliTableFormatter(truncated=truncated)
+    handler = _WRITER_MAP.get(format.lower())
+    if handler is None:
+        raise ValueError(f"Unknown format: {format}. Supported: {', '.join(_WRITER_MAP)}")
+    return handler

tab_cli-0.1.0/tab_cli/handlers/base.py

@@ -0,0 +1,126 @@
+"""Base reader interface for tabular data."""
+
+import os
+from abc import ABC, abstractmethod
+from collections.abc import Iterable
+from dataclasses import dataclass
+from rich.table import Table
+from rich.progress import Progress
+from rich import box
+
+import polars as pl
+
+from tab_cli.style import _KEY_STYLE, _VAL_STYLE, _ALT_ROW_STYLE
+
+
+@dataclass
+class TableSchema:
+    """Schema information for a table."""
+
+    columns: list[tuple[str, pl.DataType]]
+
+    def __rich__(self) -> Table:
+        """Rich-formatted output for the schema."""
+
+        table = Table(
+            show_header=False,
+            box=box.SIMPLE_HEAD,
+            row_styles=["", _ALT_ROW_STYLE],
+        )
+        table.add_column(style=_KEY_STYLE)
+        table.add_column(style=_VAL_STYLE)
+        for name, dtype in self.columns:
+            table.add_row(name, str(dtype))
+        return table
+
+
+@dataclass
+class TableSummary:
+    """Summary information for a table."""
+
+    file_size: int
+    num_rows: int
+    num_columns: int
+    extra: dict[str, str | int | float] | None = None
+
+    def __rich__(self) -> Table:
+        """Rich-formatted output for the summary."""
+
+        def format_size(size: int) -> str:
+            s: float = size
+            for unit in ["B", "KiB", "MiB", "GiB", "TiB"]:
+                if s < 1024:
+                    return f"{s:.1f} {unit}" if unit != "B" else f"{int(s)} {unit}"
+                s /= 1024
+            return f"{s:.1f} PiB"
+
+        table = Table(
+            show_header=False,
+            box=box.SIMPLE_HEAD,
+            row_styles=["", _ALT_ROW_STYLE],
+        )
+        table.add_column(style=_KEY_STYLE)
+        table.add_column(style=_VAL_STYLE)
+
+        table.add_row("File size", format_size(self.file_size))
+        table.add_row("Rows", f"{self.num_rows:,}")
+        table.add_row("Columns", str(self.num_columns))
+
+        if self.extra:
+            for key, value in self.extra.items():
+                table.add_row(key, str(value))
+
+        return table
+
+
+class TableReader(ABC):
+
+    @abstractmethod
+    def read(self, path: str, limit: int | None = None, offset: int = 0) -> pl.LazyFrame:
+        pass
+
+    @abstractmethod
+    def schema(self, path: str) -> TableSchema:
+        pass
+
+    @abstractmethod
+    def summary(self, path: str) -> TableSummary:
+        pass
+
+
+class TableWriter(ABC):
+
+    @abstractmethod
+    def extension(self) -> str:
+        """Return the file extension for this format (e.g., '.parquet', '.csv')."""
+        pass
+
+    @abstractmethod
+    def write(self, lf: pl.LazyFrame) -> Iterable[bytes]:
+        pass
+
+    @abstractmethod
+    def write_single(self, lf: pl.LazyFrame, path: str) -> None:
+        """Write a LazyFrame to a single file."""
+        pass
+
+    def write_to_path(self, lf: pl.LazyFrame, path: str, partitions: int | None = None) -> None:
+        """Write a LazyFrame to a file or partitioned directory."""
+        if partitions is None:
+            with Progress() as progress:
+                task = progress.add_task("Writing...", total=1)
+                self.write_single(lf, path)
+                progress.update(task, completed=1)
+        else:
+            os.makedirs(path, exist_ok=True)
+            row_count = lf.select(pl.len()).collect().item()
+            rows_per_part = (row_count + partitions - 1) // partitions
+            with Progress() as progress:
+                task = progress.add_task("Writing partitions...", total=partitions)
+                for i in range(partitions):
+                    offset = i * rows_per_part
+                    if offset < row_count:
+                        part_lf = lf.slice(offset, rows_per_part)
+                        part_path = os.path.join(path, f"part-{i:05d}{self.extension()}")
+                        self.write_single(part_lf, part_path)
+                    progress.update(task, advance=1)

tab_cli-0.1.0/tab_cli/handlers/cli_table.py

@@ -0,0 +1,48 @@
+from collections.abc import Iterable
+
+from rich.table import Table
+from rich import box
+from rich.console import Console
+import polars as pl
+
+from tab_cli.handlers.base import TableWriter
+from tab_cli.style import _ALT_ROW_STYLE, _KEY_STYLE
+
+
+class CliTableFormatter(TableWriter):
+    def __init__(self, truncated: bool = False):
+        self.truncated = truncated
+
+    def extension(self) -> str:
+        return ".txt"
+
+    def write(self, lf: pl.LazyFrame) -> Iterable[bytes]:
+
+        table = Table(
+            show_header=True,
+            header_style=_KEY_STYLE,
+            box=box.SIMPLE_HEAD,
+            row_styles=["default", _ALT_ROW_STYLE],
+        )
+
+        for col in lf.collect_schema().names():
+            table.add_column(col)
+
+        for batch in lf.collect_batches():
+            for row in batch.iter_rows():
+                table.add_row(*[str(v) if v is not None else "" for v in row])
+
+        if self.truncated:
+            table.add_row(*["..." for _ in lf.collect_schema().names()])
+
+        console = Console(force_terminal=True)
+        with console.capture() as capture:
+            console.print(table)
+
+        yield capture.get().encode("utf-8")
+
+    def write_single(self, lf: pl.LazyFrame, path: str) -> None:
+        """Write a LazyFrame to a single text file."""
+        with open(path, "wb") as f:
+            for chunk in self.write(lf):
+                f.write(chunk)

tab_cli-0.1.0/tab_cli/handlers/csv.py

@@ -0,0 +1,56 @@
+"""CSV file handler using Polars."""
+
+import os
+from collections.abc import Iterable
+from io import BytesIO
+
+import polars as pl
+
+from tab_cli.handlers.base import TableReader, TableWriter, TableSchema, TableSummary
+
+
+class CsvHandler(TableReader, TableWriter):
+    """Handler for CSV/TSV files."""
+
+    def __init__(self, separator: str = ","):
+        self.separator = separator
+
+    def extension(self) -> str:
+        return ".csv" if self.separator == "," else ".tsv"
+
+    def read(self, path: str, limit: int | None = None, offset: int = 0) -> pl.LazyFrame:
+        lf = pl.scan_csv(path, separator=self.separator)
+        if offset > 0:
+            lf = lf.slice(offset, length=limit)
+        elif limit is not None:
+            lf = lf.head(limit)
+        return lf
+
+    def schema(self, path: str) -> TableSchema:
+        lf = pl.scan_csv(path, separator=self.separator)
+        columns = list(lf.collect_schema().items())
+        return TableSchema(columns=columns)
+
+    def summary(self, path: str) -> TableSummary:
+        file_size = os.path.getsize(path)
+        lf = pl.scan_csv(path, separator=self.separator)
+        schema = lf.collect_schema()
+        num_columns = len(schema)
+        num_rows = lf.select(pl.len()).collect().item()
+        return TableSummary(
+            file_size=file_size,
+            num_rows=num_rows,
+            num_columns=num_columns,
+        )
+
+    def write(self, lf: pl.LazyFrame) -> Iterable[bytes]:
+        first = True
+        for batch in lf.collect_batches():
+            output = BytesIO()
+            batch.write_csv(output, separator=self.separator, include_header=first)
+            first = False
+            yield output.getvalue()
+
+    def write_single(self, lf: pl.LazyFrame, path: str) -> None:
+        """Write a LazyFrame to a single CSV/TSV file."""
+        lf.sink_csv(path, separator=self.separator)

tab_cli-0.1.0/tab_cli/handlers/directory.py

@@ -0,0 +1,96 @@
+"""Directory handler for partitioned datasets."""
+
+import os
+from collections.abc import Iterable
+from glob import glob
+
+import polars as pl
+
+from tab_cli.handlers.base import TableReader, TableSchema, TableSummary
+
+
+class DirectoryReader(TableReader):
+    """Handler wrapper for partitioned datasets (directories of files)."""
+
+    def __init__(self, extension: str, file_handler: TableReader) -> None:
+        self.extension = extension
+        self.file_handler = file_handler
+
+    def _get_files(self, path: str) -> list[str]:
+        """Get all files with matching extension in the directory."""
+        pattern = os.path.join(path, "**", f"*{self.extension}")
+        return sorted(glob(pattern, recursive=True))
+
+    def read(self, path: str, limit: int | None = None, offset: int = 0) -> pl.LazyFrame:
+        """Read data from a partitioned dataset."""
+        files = self._get_files(path)
+        if not files:
+            raise ValueError(f"No {self.extension} files found in {path}")
+
+        frames = [self.file_handler.read(file) for file in files]
+        lf = pl.concat(frames, how="vertical")
+
+        if offset > 0:
+            lf = lf.slice(offset, length=limit)
+        elif limit is not None:
+            lf = lf.head(limit)
+
+        return lf
+
+    def schema(self, path: str) -> TableSchema:
+        """Get the schema from the partitioned dataset."""
+        files = self._get_files(path)
+        if not files:
+            raise ValueError(f"No {self.extension} files found in {path}")
+        return self.file_handler.schema(files[0])
+
+    def summary(self, path: str) -> TableSummary:
+        """Get aggregated summary from all partition files."""
+        files = self._get_files(path)
+        if not files:
+            raise ValueError(f"No {self.extension} files found in {path}")
+
+        file_size = 0
+        num_rows = 0
+        num_columns: int | None = None
+
+        extra_numeric: dict[str, float] = {}
+        extra_strings: dict[str, set[str]] = {}
+
+        for file in files:
+            file_summary = self.file_handler.summary(file)
+            file_size += file_summary.file_size
+            num_rows += file_summary.num_rows
+
+            if num_columns is None:
+                num_columns = file_summary.num_columns
+            elif file_summary.num_columns != num_columns:
+                raise ValueError(f"Inconsistent column counts in {path}")
+
+            if file_summary.extra:
+                for key, value in file_summary.extra.items():
+                    if isinstance(value, (int, float)):
+                        extra_numeric[key] = extra_numeric.get(key, 0) + value
+                    else:
+                        extra_strings.setdefault(key, set()).add(str(value))
+
+        extra: dict[str, str | int | float] = {"Partitions": len(files)}
+        for key, value in extra_numeric.items():
+            if float(value).is_integer():
+                extra[key] = int(value)
+            else:
+                extra[key] = value
+
+        for key, values in extra_strings.items():
+            if len(values) == 1:
+                extra[key] = next(iter(values))
+            else:
+                extra[key] = ", ".join(sorted(values))
+
+        return TableSummary(
+            file_size=file_size,
+            num_rows=num_rows,
+            num_columns=num_columns or 0,
+            extra=extra,
+        )
+

tab_cli-0.1.0/tab_cli/handlers/jsonl.py

@@ -0,0 +1,47 @@
+import os
+from collections.abc import Iterable
+import json
+import polars as pl
+from tab_cli.handlers.base import TableReader, TableWriter, TableSchema, TableSummary
+
+
+class JsonlHandler(TableReader, TableWriter):
+
+    def read(self, path: str, limit: int | None = None, offset: int = 0) -> pl.LazyFrame:
+        lf = pl.scan_ndjson(path)
+        if offset > 0:
+            lf = lf.slice(offset, length=limit)
+        elif limit is not None:
+            lf = lf.head(limit)
+        return lf
+
+    def schema(self, path: str) -> TableSchema:
+        lf = pl.scan_ndjson(path)
+        columns = list(lf.collect_schema().items())
+        return TableSchema(columns=columns)
+
+    def summary(self, path: str) -> TableSummary:
+        file_size = os.path.getsize(path)
+        lf = pl.scan_ndjson(path)
+        schema = lf.collect_schema()
+        num_columns = len(schema)
+        num_rows = lf.select(pl.len()).collect().item()
+        return TableSummary(
+            file_size=file_size,
+            num_rows=num_rows,
+            num_columns=num_columns,
+        )
+
+    def extension(self) -> str:
+        return ".jsonl"
+
+    def write(self, lf: pl.LazyFrame) -> Iterable[bytes]:
+        for batch in lf.collect_batches():
+            for row in batch.iter_rows(named=True):
+                yield (json.dumps(row, default=str, ensure_ascii=False) + "\n").encode("utf-8")
+
+    def write_single(self, lf: pl.LazyFrame, path: str) -> None:
+        """Write a LazyFrame to a single JSONL file."""
+        with open(path, "wb") as f:
+            for chunk in self.write(lf):
+                f.write(chunk)

tab_cli-0.1.0/tab_cli/handlers/parquet.py

@@ -0,0 +1,75 @@
+"""Parquet file handler using Polars."""
+
+import os
+from collections.abc import Iterable
+from io import BytesIO
+
+import polars as pl
+
+from tab_cli.handlers.base import TableReader, TableWriter, TableSchema, TableSummary
+
+
+class ParquetHandler(TableReader, TableWriter):
+    """Handler for Parquet files."""
+
+    def extension(self) -> str:
+        return ".parquet"
+
+    def read(self, path: str, limit: int | None = None, offset: int = 0) -> pl.LazyFrame:
+        """Read data from a Parquet file."""
+        df = pl.scan_parquet(path)
+        if offset > 0:
+            df = df.slice(offset, length=limit)
+        elif limit is not None:
+            df = df.head(limit)
+        return df
+
+    def schema(self, path: str) -> TableSchema:
+        """Get the schema of the Parquet file."""
+        lf = pl.scan_parquet(path)
+        columns = list(lf.collect_schema().items())
+        return TableSchema(columns=columns)
+
+    def summary(self, path: str) -> TableSummary:
+        """Get summary information about the Parquet file."""
+        import pyarrow.parquet as pq
+
+        file_size = os.path.getsize(path)
+        lf = pl.scan_parquet(path)
+        schema = lf.collect_schema()
+        num_columns = len(schema)
+        num_rows = lf.select(pl.len()).collect().item()
+
+        # Get parquet metadata using pyarrow
+        pf = pq.ParquetFile(path)
+        metadata = pf.metadata
+
+        extra: dict[str, str | int | float] = {}
+
+        # Collect compression codecs from all column chunks
+        codecs: set[str] = set()
+        for rg_idx in range(metadata.num_row_groups):
+            rg = metadata.row_group(rg_idx)
+            for col_idx in range(rg.num_columns):
+                col = rg.column(col_idx)
+                codecs.add(col.compression)
+        extra["Row groups"] = metadata.num_row_groups
+        if codecs:
+            extra["Compression"] = ", ".join(sorted(codecs))
+
+        return TableSummary(
+            file_size=file_size,
+            num_rows=num_rows,
+            num_columns=num_columns,
+            extra=extra,
+        )
+
+    def write(self, lf: pl.LazyFrame) -> Iterable[bytes]:
+        """Write a LazyFrame to Parquet bytes."""
+        output = BytesIO()
+        lf.sink_parquet(output)
+        yield output.getvalue()
+
+    def write_single(self, lf: pl.LazyFrame, path: str) -> None:
+        """Write a LazyFrame to a single Parquet file."""
+        lf.sink_parquet(path)

tab_cli-0.1.0/tab_cli/style.py

@@ -0,0 +1,3 @@
+_KEY_STYLE = "sea_green3"
+_VAL_STYLE = "bold sky_blue3"
+_ALT_ROW_STYLE = "on #282828"