tab-cli 0.1.6__tar.gz → 0.1.8__tar.gz

{tab_cli-0.1.6 → tab_cli-0.1.8}/.gitignore

@@ -29,7 +29,6 @@ ENV/
 
 # uv
 .uv/
-uv.lock
 
 # PyCharm
 .idea/

{tab_cli-0.1.6 → tab_cli-0.1.8}/AGENTS.md

@@ -43,7 +43,7 @@ Use it as the default operating guide when changing code in this repo.
 - The CLI tests rely on `typer.testing.CliRunner`.
 - Test data is stored under `tests/assets`.
 - Existing tests emphasize user-visible CLI output, not internal implementation details.
-- When adding CLI behavior, extend `tests/test_cli.py` unless the change clearly deserves a new file.
+- The CLI tests are split across focused files under `tests/`; extend the nearest existing file unless a new one is clearly warranted.
 - Assert both `exit_code` and key output fragments.
 - For stdin support, pass `"-"` as the path and provide `input=` to `runner.invoke(...)`.
 
@@ -89,6 +89,9 @@ Use it as the default operating guide when changing code in this repo.
 
 ## Types
 
+- NEVER implicitly cast any variable to bool with `if var:` or `if not var:` unless the variable is already a bool. Do NOT rely on truthiness for control flow:
+  for example, testing if a list is empty with `if not my_list:` is not allowed. Instead, use explicit length checks like `if len(my_list) > 0:`.
+  always write `if x is not None:` or `if x is None:` when checking for `None` values.
 - Type hints are used widely and should be preserved.
 - Prefer modern built-in generics like `list[str]` and `dict[str, Any]`.
 - Use `X | None` instead of `Optional[X]` in new code unless matching nearby style requires otherwise.
@@ -118,6 +121,7 @@ Use it as the default operating guide when changing code in this repo.
 ## Logging And Output
 
 - The CLI configures Loguru with `RichHandler` in the Typer callback.
+- When writing Loguru messages, use f-strings instead of Loguru brace-style formatting.
 - User-facing table and summary output is rendered with Rich.
 - Streaming command output usually writes bytes to `sys.stdout.buffer`.
 - Keep stderr/stdout behavior consistent with the existing command design.
@@ -155,4 +159,4 @@ Use it as the default operating guide when changing code in this repo.
 - Run `uv run pytest` for broader validation before finalizing cross-cutting changes.
 - Mention pre-existing lint or type-check failures separately from regressions you introduce.
 - Update CHANGELOG.md when necessary.
-- 
+- 

tab_cli-0.1.8/CHANGELOG.md

@@ -0,0 +1,34 @@
+- 0.1.8:
+  - Improved `tab view` performance for partitioned directories by reading only as many early partitions as needed for an unfiltered preview.
+  - Added glob-pattern support for multi-file inputs such as `s3://.../date=*/*.parquet`.
+  - Speed up Parquet row counting in summaries by reading footer metadata instead of scanning file contents.
+  - Fixed S3 Polars `storage_options` to avoid nested `client_kwargs` values that could break native reads.
+  - Added `default_num_view_rows` config so the default `tab view` preview size can be customized.
+  - Added `log_level` config so the CLI log level can default from `~/.config/tab/config.json` when `--log-level` is omitted.
+  - Added `max_cell_length` config so `tab view` can default to truncating long cell values without passing `--max-cell-len` every time.
+  - Added `num_remote_workers` config to parallelize remote per-partition summary row counting.
+  - Validated config file value types instead of silently accepting invalid JSON types.
+  - Fixed the developer `Makefile` targets to point at `src/tab_cli`.
+  - Tightened multi-file summary validation to reject inconsistent schemas, not just mismatched column counts.
+  - `tab cat` now rejects mixed input formats with a clear error instead of reusing the first reader implicitly.
+  - Cleaned up package metadata and repository hygiene issues including version drift and `uv.lock` ignore rules.
+- 0.1.7:
+  - Optional dependency groups are now named `tab-cli[s3|gs|az]`, in accordance with the protocol name.
+- 0.1.6:
+  - Fixed bug in pyarrow loading of Parquet files.
+  - Added global config file support: settings can be persisted in `~/.config/tab/config.json`. Config file values serve as defaults that CLI flags override.
+- 0.1.5:
+  - Added stdin support: use `-` as the file path to read from stdin (e.g. `cat data.csv | tab view -i csv -`). Requires `-i`/`--input-format` since format cannot be inferred. Works with `view`, `schema`, `summary`, `convert`, and `cat`.
+  - Added row-wise JMESPath queries via `--jmespath` / `--jp` on `view`, `convert`, and `cat`. Object results become columns; non-object results go into a `value` column. `--sql` and `--jp` are mutually exclusive.
+  - Implemented `--jp` with `LazyFrame.map_batches(...)` so row reshaping stays batch-oriented instead of materializing the full transformed dataset up front.
+- 0.1.4:
+  - Removed `tab sql` subcommand; SQL is now a `--sql` option on `tab view`, `tab convert`, and `tab cat`.
+  - Automatic PyArrow fallback for Parquet files that fail to read with Polars' native reader.
+- 0.1.3:
+  - Separate `tab view` from `tab cat`: `tab view` does not convert formats, `tab cat` does.
+  - Added `--max-cell-len` option to `tab view` to truncate long cell contents.
+- 0.1.2:
+  - Bugfix on reading directories.
+- 0.1.1:
+  - Better credential handling for Azure Blob Storage and Google Cloud Storage.
+- 0.1.0: Initial release

{tab_cli-0.1.6 → tab_cli-0.1.8}/Makefile

@@ -13,13 +13,13 @@ clean:
 	find . -type d -name __pycache__ -exec rm -rf {} +
 
 lint:
-	uv run ruff check tab_cli/
+	uv run ruff check src/tab_cli tests
 
 format:
-	uv run ruff format tab_cli/
+	uv run ruff format src/tab_cli tests
 
 typecheck:
-	uv run ty check tab_cli/
+	uv run ty check src/tab_cli
 
 test:
 	uv run pytest

tab_cli-0.1.8/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: tab-cli
+Version: 0.1.8
+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: fsspec>=2025.1.0
+Requires-Dist: jmespath>=1.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: polars-fastavro>=0.5.1
+Requires-Dist: polars>=1.0
+Requires-Dist: pyarrow>=15.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.21.1
+Provides-Extra: az
+Requires-Dist: adlfs>=2025.1.0; extra == 'az'
+Requires-Dist: azure-identity>=1.10.0; extra == 'az'
+Provides-Extra: gs
+Requires-Dist: gcsfs>=2025.1.0; extra == 'gs'
+Requires-Dist: google-auth>=2.27.0; extra == 'gs'
+Provides-Extra: s3
+Requires-Dist: boto3>=1.28.0; extra == 's3'
+Requires-Dist: s3fs>=2025.1.0; extra == 's3'
+Description-Content-Type: text/markdown
+
+# tab
+
+[![pypi](https://img.shields.io/pypi/v/tab-cli)](https://pypi.org/project/tab-cli/)
+
+A CLI tool for viewing, querying, and converting tabular data files.
+Reads CSV, TSV, JSON Lines, Parquet, and Avro -- locally or from S3, GCS, and Azure Blob Storage.
+
+```sh
+pip install tab-cli
+```
+
+**Documentation**: [tongfei.me/tab](https://tongfei.me/tab)
+
+---
+
+## Quick look
+
+### View any tabular file
+
+```bash
+tab view data.csv
+```
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/ctongfei/tab/refs/heads/gh-pages/assets/test.svg" alt="tab view" width="680">
+</p>
+
+### Query with SQL
+
+The table is always available as `t`:
+
+```bash
+tab view --sql 'SELECT * FROM t WHERE Metric_A_Value > 80' data.csv
+```
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/ctongfei/tab/refs/heads/gh-pages/assets/test-where.svg" alt="tab view --sql" width="680">
+</p>
+
+### Reshape rows with JMESPath
+
+```bash
+tab view --jp '{id: participant.id, city: profile.address.city}' data.parquet 
+```
+
+### Convert between formats
+
+```bash
+tab convert data.csv data.parquet
+tab convert data.parquet data.jsonl -o jsonl
+tab convert data.csv output_dir/ -o parquet -n 4   # partitioned
+```
+
+### Concatenate files
+
+```bash
+tab cat part1.csv part2.csv part3.csv -o jsonl > combined.jsonl
+```
+
+### Inspect schema and summary
+
+```bash
+tab schema data.parquet
+tab summary data.parquet
+```
+
+### Read from stdin
+
+```bash
+curl -s https://example.com/data.csv | tab view -i csv -
+```
+
+### Read from cloud storage
+
+```bash
+tab view s3://bucket/path/data.parquet
+tab view gs://bucket/path/data.csv
+tab view az://container/path/data.jsonl
+```
+
+Install cloud extras as needed:
+
+```sh
+pip install 'tab-cli[s3]'    # AWS S3
+pip install 'tab-cli[gs]'    # Google Cloud Storage
+pip install 'tab-cli[az]'    # Azure Blob Storage
+```
+
+## Supported formats
+ - csv
+ - tsv
+ - jsonl
+ - parquet
+ - avro

tab_cli-0.1.8/README.md

@@ -0,0 +1,94 @@
+# tab
+
+[![pypi](https://img.shields.io/pypi/v/tab-cli)](https://pypi.org/project/tab-cli/)
+
+A CLI tool for viewing, querying, and converting tabular data files.
+Reads CSV, TSV, JSON Lines, Parquet, and Avro -- locally or from S3, GCS, and Azure Blob Storage.
+
+```sh
+pip install tab-cli
+```
+
+**Documentation**: [tongfei.me/tab](https://tongfei.me/tab)
+
+---
+
+## Quick look
+
+### View any tabular file
+
+```bash
+tab view data.csv
+```
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/ctongfei/tab/refs/heads/gh-pages/assets/test.svg" alt="tab view" width="680">
+</p>
+
+### Query with SQL
+
+The table is always available as `t`:
+
+```bash
+tab view --sql 'SELECT * FROM t WHERE Metric_A_Value > 80' data.csv
+```
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/ctongfei/tab/refs/heads/gh-pages/assets/test-where.svg" alt="tab view --sql" width="680">
+</p>
+
+### Reshape rows with JMESPath
+
+```bash
+tab view --jp '{id: participant.id, city: profile.address.city}' data.parquet 
+```
+
+### Convert between formats
+
+```bash
+tab convert data.csv data.parquet
+tab convert data.parquet data.jsonl -o jsonl
+tab convert data.csv output_dir/ -o parquet -n 4   # partitioned
+```
+
+### Concatenate files
+
+```bash
+tab cat part1.csv part2.csv part3.csv -o jsonl > combined.jsonl
+```
+
+### Inspect schema and summary
+
+```bash
+tab schema data.parquet
+tab summary data.parquet
+```
+
+### Read from stdin
+
+```bash
+curl -s https://example.com/data.csv | tab view -i csv -
+```
+
+### Read from cloud storage
+
+```bash
+tab view s3://bucket/path/data.parquet
+tab view gs://bucket/path/data.csv
+tab view az://container/path/data.jsonl
+```
+
+Install cloud extras as needed:
+
+```sh
+pip install 'tab-cli[s3]'    # AWS S3
+pip install 'tab-cli[gs]'    # Google Cloud Storage
+pip install 'tab-cli[az]'    # Azure Blob Storage
+```
+
+## Supported formats
+ - csv
+ - tsv
+ - jsonl
+ - parquet
+ - avro

{tab_cli-0.1.6 → tab_cli-0.1.8}/docs/cli-ref.md

@@ -17,7 +17,7 @@ Options:
 | `--jmespath` / `--jp`   | JMESPath expression to apply to each row as JSON. Object outputs become columns; non-object outputs go to a `value` column. The result shape must stay consistent across rows. |
 | `--limit`               | Maximum number of rows to display.                                                                        |
 | `--skip`                | Number of rows to skip from the beginning.                                                                |
-| `--max-cell-len`        | Truncate cell contents longer than this.                                                                 |
+| `--max-cell-len`        | Truncate cell contents longer than this. If omitted, `max_cell_length` from config is used when set.    |
 
 ## `tab schema`
 
@@ -91,4 +91,4 @@ Options:
 | Option                  | Description                                                                                                                  |
 |-------------------------|------------------------------------------------------------------------------------------------------------------------------|
 | `--az-url-authority-is-account` | Interpret az:// URL authority as storage account name instead of container name. See [azure.md](Azure) for more information. |
-| `--log-level`               | Log level from `{DEBUG, INFO, WARNING, ERROR, CRITICAL}`.                                                                     |
+| `--log-level`               | Log level from `{DEBUG, INFO, WARNING, ERROR, CRITICAL}`. If omitted, uses `log_level` from config.                         |

{tab_cli-0.1.6 → tab_cli-0.1.8}/docs/configuration.md

@@ -11,6 +11,10 @@ mkdir -p ~/.config/tab
 cat > ~/.config/tab/config.json << 'EOF'
 {
   "az_url_authority_is_account": false,
+  "default_num_view_rows": 20,
+  "log_level": "INFO",
+  "max_cell_length": null,
+  "num_remote_workers": 8,
   "sampling_size_for_schema_inference": 32
 }
 EOF
@@ -21,6 +25,10 @@ EOF
 | Key | Type | Default | Description |
 |-----|------|---------|-------------|
 | `az_url_authority_is_account` | `bool` | `false` | Interpret `az://` URL authority as storage account name instead of container name. |
+| `default_num_view_rows` | `int` | `20` | Default number of rows shown by `tab view` when `--limit` is omitted. |
+| `log_level` | `str` | `"INFO"` | Default CLI log level when `--log-level` is omitted. |
+| `max_cell_length` | `int \| null` | `null` | Default maximum cell length for `tab view`. The CLI `--max-cell-len` flag overrides it. |
+| `num_remote_workers` | `int` | `8` | Maximum worker threads for remote per-partition summary work such as Parquet row counts. |
 | `sampling_size_for_schema_inference` | `int` | `32` | Number of rows sampled for schema inference (e.g. when using `--jp`). |
 
 ## Precedence

{tab_cli-0.1.6 → tab_cli-0.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tab-cli"
-version = "0.1.6"
+version = "0.1.8"
 description = "A CLI tool for tabular data"
 authors = [{name = "Tongfei Chen", email = "tongfei@pm.me"}]
 readme = "README.md"
@@ -20,8 +20,8 @@ dependencies = [
 
 [project.optional-dependencies]
 s3 = ["s3fs>=2025.1.0", "boto3>=1.28.0"]
-gcs = ["gcsfs>=2025.1.0", "google-auth>=2.27.0"]
-azure = ["adlfs>=2025.1.0", "azure-identity>=1.10.0"]
+gs = ["gcsfs>=2025.1.0", "google-auth>=2.27.0"]
+az = ["adlfs>=2025.1.0", "azure-identity>=1.10.0"]
 
 [dependency-groups]
 dev = [

{tab_cli-0.1.6 → tab_cli-0.1.8}/src/tab_cli/__init__.py

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

{tab_cli-0.1.6 → tab_cli-0.1.8}/src/tab_cli/cli.py

@@ -79,6 +79,8 @@ app = typer.Typer(
     no_args_is_help=True,
 )
 
+DEFAULT_VIEW_TRUNCATION_PROBE_ROWS = 1
+
 
 @app.callback()
 def main_callback(
@@ -90,13 +92,18 @@ def main_callback(
         ),
     ] = False,
     log_level: Annotated[
-        str,
+        str | None,
         typer.Option(
-            "--log-level", help="Log level from {DEBUG, INFO, WARNING, ERROR, CRITICAL}"
+            "--log-level",
+            help="Log level from {DEBUG, INFO, WARNING, ERROR, CRITICAL}; defaults to config when omitted",
         ),
-    ] = "INFO",
+    ] = None,
 ) -> None:
     """Global options for tab_cli CLI."""
+    load_config_file()
+    effective_log_level = (
+        log_level.upper() if log_level is not None else config.config.log_level.upper()
+    )
     logger.remove()
     logger.add(
         RichHandler(
@@ -105,9 +112,8 @@ def main_callback(
             markup=True,
         ),
         format="{message}",
-        level=log_level.upper(),
+        level=effective_log_level,
     )
-    load_config_file()
     # CLI flags override config file values
     if az_url_authority_is_account:
         config.config.az_url_authority_is_account = az_url_authority_is_account
@@ -176,12 +182,20 @@ def _apply_jmespath(lf: pl.LazyFrame, expression: str) -> pl.LazyFrame:
 
     compiled = jmespath.compile(expression)
     sample_df = lf.slice(0, Config.sampling_size_for_schema_inference).collect()
+    logger.debug(
+        "Inferring JMESPath output schema from "
+        f"{Config.sampling_size_for_schema_inference} sampled row(s)"
+    )
     if sample_df.is_empty():
+        logger.debug("JMESPath schema inference sample was empty; returning empty LazyFrame")
         return pl.DataFrame().lazy()
 
     transformed_sample, result_mode = _transform_jmespath_batch(sample_df, compiled)
     output_schema = transformed_sample.schema
     expected_columns = tuple(transformed_sample.columns)
+    logger.debug(
+        f"Inferred JMESPath result mode '{result_mode}' with columns {expected_columns}"
+    )
 
     return lf.map_batches(
         lambda batch: _transform_jmespath_batch(
@@ -223,16 +237,119 @@ def _apply_limit(
     and returns whether the data was truncated.
     """
     if limit is None and default_limit is not None:
+        logger.debug(
+            f"Applying inferred default row limit {default_limit} with skip {skip}"
+        )
         lf = lf.slice(skip, length=default_limit + 1)
         df = lf.collect()
         truncated = len(df) > default_limit
         if truncated:
             df = df.head(default_limit)
+            logger.debug("Detected truncated preview after applying inferred default row limit")
         return df.lazy(), truncated
-    else:
-        if skip > 0 or limit is not None:
-            lf = lf.slice(skip, length=limit)
-        return lf, False
+    if skip > 0 or limit is not None:
+        lf = lf.slice(skip, length=limit)
+    return lf, False
+
+
+def _read_source(path: str, input_format: str | None) -> tuple[pl.LazyFrame, str | None]:
+    """Read a source path and return its LazyFrame and inferred format."""
+    if is_stdin(path):
+        logger.debug(
+            "Using stdin source with explicit format "
+            f"'{input_format.lower() if input_format is not None else None}'"
+        )
+        return (
+            read_stdin(format=input_format),
+            input_format.lower() if input_format is not None else None,
+        )
+
+    reader = infer_reader(path, format=input_format)
+    logger.debug(
+        f"Read source '{path}' using inferred format '{reader.format.extension()}'"
+    )
+    return reader.read(path), reader.format.extension()
+
+
+def _prepare_view_frame(
+    path: str,
+    input_format: str | None,
+    sql: str | None,
+    jmespath_expr: str | None,
+    limit: int | None,
+    skip: int,
+) -> tuple[pl.LazyFrame, bool]:
+    """Prepare the LazyFrame used by `tab view` and report truncation."""
+    default_view_rows = config.config.default_num_view_rows
+
+    if is_stdin(path):
+        logger.debug("Preparing view for stdin input")
+        lf = read_stdin(format=input_format)
+        lf = _apply_query(lf, sql=sql, jmespath_expr=jmespath_expr)
+        return _apply_limit(
+            lf,
+            limit=limit,
+            skip=skip,
+            default_limit=default_view_rows if limit is None else None,
+        )
+
+    reader = infer_reader(path, format=input_format)
+    if sql is None and jmespath_expr is None:
+        preview_limit = (
+            limit
+            if limit is not None
+            else default_view_rows + DEFAULT_VIEW_TRUNCATION_PROBE_ROWS
+        )
+        logger.debug(
+            f"Using preview read for '{path}' with inferred preview limit "
+            f"{preview_limit} and skip {skip}"
+        )
+        lf = reader.read_preview(path, limit=preview_limit, offset=skip)
+        if limit is not None:
+            return lf, False
+
+        df = lf.collect()
+        truncated = len(df) > default_view_rows
+        if truncated:
+            df = df.head(default_view_rows)
+        return df.lazy(), truncated
+
+    logger.debug(f"Using full read for '{path}' because a query transform was provided")
+    lf = reader.read(path)
+    lf = _apply_query(lf, sql=sql, jmespath_expr=jmespath_expr)
+    return _apply_limit(
+        lf,
+        limit=limit,
+        skip=skip,
+        default_limit=default_view_rows if limit is None else None,
+    )
+
+
+def _resolve_cat_output_format(
+    paths: list[str],
+    input_format: str | None,
+) -> tuple[list[pl.LazyFrame], str | None]:
+    """Read all inputs for `tab cat` and validate format consistency."""
+    files: list[pl.LazyFrame] = []
+    resolved_format = input_format.lower() if input_format is not None else None
+    if resolved_format is not None:
+        logger.debug(f"Using explicit shared input format '{resolved_format}' for `tab cat`")
+
+    for path in paths:
+        lf, current_format = _read_source(path, input_format)
+        if current_format is not None:
+            if resolved_format is None:
+                resolved_format = current_format
+                logger.debug(
+                    f"Inferred shared `tab cat` format '{resolved_format}' from '{path}'"
+                )
+            elif current_format != resolved_format:
+                raise ValueError(
+                    "All inputs to `tab cat` must use the same format unless -i/--input-format is provided"
+                )
+        files.append(lf)
+
+    return files, resolved_format
 
 
 @app.command()
@@ -247,19 +364,25 @@ def view(
     table_svg: TableSvgOpt = False,
 ) -> None:
     """View tabular data as a formatted table."""
-    if is_stdin(path):
-        lf = read_stdin(format=input)
-    else:
-        reader = infer_reader(path, format=input)
-        lf = reader.read(path)
-    lf = _apply_query(lf, sql=sql, jmespath_expr=jmespath_expr)
-    lf, truncated = _apply_limit(
-        lf, limit=limit, skip=skip, default_limit=20 if limit is None else None
+    effective_max_cell_len = (
+        max_cell_len if max_cell_len is not None else config.config.max_cell_length
+    )
+    if max_cell_len is None and effective_max_cell_len is not None:
+        logger.debug(
+            f"Inferred max_cell_len={effective_max_cell_len} for `tab view` from config"
+        )
+    lf, truncated = _prepare_view_frame(
+        path,
+        input_format=input,
+        sql=sql,
+        jmespath_expr=jmespath_expr,
+        limit=limit,
+        skip=skip,
     )
     writer = infer_writer(
         "table-svg" if table_svg else None,
         truncated=truncated,
-        max_cell_len=max_cell_len,
+        max_cell_len=effective_max_cell_len,
     )
     for chunk in writer.write(lf):
         sys.stdout.buffer.write(chunk)
@@ -278,7 +401,7 @@ def schema(
     else:
         reader = infer_reader(path, format=input)
         table_schema = reader.schema(path)
-    console = Console(force_terminal=True)
+    console = Console()
     console.print(table_schema)
 
 
@@ -299,7 +422,7 @@ def summary(
     else:
         handler = infer_reader(path, format=input)
         table_summary = handler.summary(path)
-    console = Console(force_terminal=True)
+    console = Console()
     console.print(table_summary)
 
 
@@ -320,6 +443,9 @@ def convert(
         if output is not None:
             writer = infer_writer(format=output)
         elif input is not None:
+            logger.debug(
+                f"Inferred convert output format '{input.lower()}' from stdin input format"
+            )
             writer = infer_writer(format=input)
         else:
             raise ValueError(
@@ -333,9 +459,15 @@ def convert(
         if output is not None:
             writer = infer_writer(format=output)
         elif input is not None:
+            logger.debug(
+                f"Inferred convert output format '{input.lower()}' from explicit input format override"
+            )
             writer = infer_writer(format=input)
         else:
             writer = reader
+            logger.debug(
+                f"Inferred convert output format '{reader.format.extension()}' from source '{src}'"
+            )
             assert isinstance(writer, TableWriter)
         lf = reader.read(src)
         lf = _apply_query(lf, sql=sql, jmespath_expr=jmespath_expr)
@@ -351,24 +483,14 @@ def cat(
     jmespath_expr: JmespathOpt = None,
 ) -> None:
     """Concatenate tabular data from multiple files, or just print a single file."""
-    files: list[pl.LazyFrame] = []
-    reader = None
-    for path in paths:
-        if is_stdin(path):
-            files.append(read_stdin(format=input))
-        else:
-            if reader is None:
-                reader = infer_reader(path, format=input)
-            files.append(reader.read(path))
+    files, resolved_format = _resolve_cat_output_format(paths, input)
     lf = pl.concat(files, how="vertical")
     lf = _apply_query(lf, sql=sql, jmespath_expr=jmespath_expr)
     if output is not None:
         writer = infer_writer(format=output)
-    elif reader is not None:
-        writer = infer_writer(format=reader.format.extension())
-        assert isinstance(writer, TableWriter)
-    elif input is not None:
-        writer = infer_writer(format=input)
+    elif resolved_format is not None:
+        logger.debug(f"Inferred `tab cat` output format '{resolved_format}' from input sources")
+        writer = infer_writer(format=resolved_format)
         assert isinstance(writer, TableWriter)
     else:
         raise ValueError(