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

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

@@ -143,6 +143,7 @@ Use it as the default operating guide when changing code in this repo.
 ## Documentation
 
 - Update `docs/` and CLI help text when changing user-facing behavior.
+- Update `CHANGELOG.md` with a clear description of user-facing changes and bug fixes.
 - Keep examples aligned with the actual command names and flags.
 - If you change build, test, or auth flows, reflect that in this file too.
 

{tab_cli-0.1.5 → tab_cli-0.1.6}/CHANGELOG.md

@@ -1,3 +1,6 @@
+  - 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.

{tab_cli-0.1.5 → tab_cli-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tab-cli
-Version: 0.1.5
+Version: 0.1.6
 Summary: A CLI tool for tabular data
 Author-email: Tongfei Chen <tongfei@pm.me>
 License-File: LICENSE

tab_cli-0.1.6/docs/configuration.md

@@ -0,0 +1,34 @@
+# Configuration
+
+`tab` supports a global configuration file at `~/.config/tab/config.json`. Settings in this file serve as defaults and are overridden by CLI flags.
+
+## Setup
+
+Create the config file:
+
+```bash
+mkdir -p ~/.config/tab
+cat > ~/.config/tab/config.json << 'EOF'
+{
+  "az_url_authority_is_account": false,
+  "sampling_size_for_schema_inference": 32
+}
+EOF
+```
+
+## Available settings
+
+| Key | Type | Default | Description |
+|-----|------|---------|-------------|
+| `az_url_authority_is_account` | `bool` | `false` | Interpret `az://` URL authority as storage account name instead of container name. |
+| `sampling_size_for_schema_inference` | `int` | `32` | Number of rows sampled for schema inference (e.g. when using `--jp`). |
+
+## Precedence
+
+Settings are applied in this order (last wins):
+
+1. Built-in defaults
+2. Config file (`~/.config/tab/config.json`)
+3. CLI flags (e.g. `--az-url-authority-is-account`)
+
+If the config file does not exist, built-in defaults are used. Unknown keys in the file are ignored with a warning.

{tab_cli-0.1.5 → tab_cli-0.1.6}/mkdocs.yml

@@ -31,6 +31,7 @@ repo_url: 'https://github.com/ctongfei/tab'
 
 nav:
   - 'Introduction': 'index.md'
+  - 'Configuration': 'configuration.md'
   - 'Cloud support': 'cloud.md'
   - 'CLI reference': 'cli-ref.md'
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "tab-cli"
-version = "0.1.5"
+version = "0.1.6"
 description = "A CLI tool for tabular data"
 authors = [{name = "Tongfei Chen", email = "tongfei@pm.me"}]
 readme = "README.md"

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

@@ -12,27 +12,67 @@ from rich.console import Console
 from rich.logging import RichHandler
 
 from tab_cli import config
-from tab_cli.config import Config
-from tab_cli.handlers import TableWriter, infer_reader, infer_writer, is_stdin, read_stdin
+from tab_cli.config import Config, load_config_file
+from tab_cli.handlers import (
+    TableWriter,
+    infer_reader,
+    infer_writer,
+    is_stdin,
+    read_stdin,
+)
 from tab_cli.handlers.base import TableSchema, TableSummary
 
 # Reusable type aliases for common CLI options
-PathArg: TypeAlias = Annotated[str, typer.Argument(help="Path to the data file or directory")]
-PathsArg: TypeAlias = Annotated[list[str], typer.Argument(help="Paths to the data files or directories")]
-SrcArg: TypeAlias = Annotated[str, typer.Argument(help="Path to the source file or directory")]
-DstArg: TypeAlias = Annotated[str, typer.Argument(help="Path to the destination file or directory")]
-InputOpt: TypeAlias = Annotated[Optional[str], typer.Option("-i", "--input-format", help="Input format, auto-detected from extension if omitted")]
-OutputOpt: TypeAlias = Annotated[Optional[str], typer.Option("-o", "--output-format", help="Output format")]
-SqlOpt: TypeAlias = Annotated[Optional[str], typer.Option("--sql", help="SQL query to apply (table is available as 't')")]
+PathArg: TypeAlias = Annotated[
+    str, typer.Argument(help="Path to the data file or directory")
+]
+PathsArg: TypeAlias = Annotated[
+    list[str], typer.Argument(help="Paths to the data files or directories")
+]
+SrcArg: TypeAlias = Annotated[
+    str, typer.Argument(help="Path to the source file or directory")
+]
+DstArg: TypeAlias = Annotated[
+    str, typer.Argument(help="Path to the destination file or directory")
+]
+InputOpt: TypeAlias = Annotated[
+    Optional[str],
+    typer.Option(
+        "-i",
+        "--input-format",
+        help="Input format, auto-detected from extension if omitted",
+    ),
+]
+OutputOpt: TypeAlias = Annotated[
+    Optional[str], typer.Option("-o", "--output-format", help="Output format")
+]
+SqlOpt: TypeAlias = Annotated[
+    Optional[str],
+    typer.Option("--sql", help="SQL query to apply (table is available as 't')"),
+]
 JmespathOpt: TypeAlias = Annotated[
     Optional[str],
-    typer.Option("--jmespath", "--jp", help="JMESPath expression to apply to each row as JSON"),
+    typer.Option(
+        "--jmespath", "--jp", help="JMESPath expression to apply to each row as JSON"
+    ),
+]
+LimitOpt: TypeAlias = Annotated[
+    Optional[int], typer.Option("--limit", help="Maximum number of rows to display")
+]
+SkipOpt: TypeAlias = Annotated[
+    int, typer.Option("--skip", help="Number of rows to skip")
+]
+MaxCellLenOpt: TypeAlias = Annotated[
+    Optional[int],
+    typer.Option("--max-cell-len", help="Truncate cell contents longer than this"),
+]
+TableSvgOpt: TypeAlias = Annotated[
+    bool, typer.Option("--table-svg", help="Output table as SVG")
+]
+NumPartitionsOpt: TypeAlias = Annotated[
+    Optional[int],
+    typer.Option("-n", "--num-partitions", help="Number of output partitions"),
 ]
-LimitOpt: TypeAlias = Annotated[Optional[int], typer.Option("--limit", help="Maximum number of rows to display")]
-SkipOpt: TypeAlias = Annotated[int, typer.Option("--skip", help="Number of rows to skip")]
-MaxCellLenOpt: TypeAlias = Annotated[Optional[int], typer.Option("--max-cell-len", help="Truncate cell contents longer than this")]
-TableSvgOpt: TypeAlias = Annotated[bool, typer.Option("--table-svg", help="Output table as SVG")]
-NumPartitionsOpt: TypeAlias = Annotated[Optional[int], typer.Option("-n", "--num-partitions", help="Number of output partitions")]
 
 app = typer.Typer(
     help="A CLI tool for viewing and manipulating tabular data.",
@@ -51,11 +91,12 @@ def main_callback(
     ] = False,
     log_level: Annotated[
         str,
-        typer.Option("--log-level", help="Log level from {DEBUG, INFO, WARNING, ERROR, CRITICAL}"),
+        typer.Option(
+            "--log-level", help="Log level from {DEBUG, INFO, WARNING, ERROR, CRITICAL}"
+        ),
     ] = "INFO",
 ) -> None:
     """Global options for tab_cli CLI."""
-    config.config.az_url_authority_is_account = az_url_authority_is_account
     logger.remove()
     logger.add(
         RichHandler(
@@ -66,6 +107,10 @@ def main_callback(
         format="{message}",
         level=log_level.upper(),
     )
+    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
 
 
 def _apply_sql(lf: pl.LazyFrame, sql: str | None) -> pl.LazyFrame:
@@ -94,21 +139,29 @@ def _transform_jmespath_batch(
             if mode is None:
                 mode = "object"
             elif mode != "object":
-                raise ValueError("JMESPath query must return a consistent shape across rows")
+                raise ValueError(
+                    "JMESPath query must return a consistent shape across rows"
+                )
 
             if expected_columns is not None:
                 extra_columns = set(result) - set(expected_columns)
                 if extra_columns:
                     extras = ", ".join(sorted(extra_columns))
-                    raise ValueError(f"JMESPath query produced unexpected columns: {extras}")
-                normalized_row = {column: result.get(column) for column in expected_columns}
+                    raise ValueError(
+                        f"JMESPath query produced unexpected columns: {extras}"
+                    )
+                normalized_row = {
+                    column: result.get(column) for column in expected_columns
+                }
             else:
                 normalized_row = result
         else:
             if mode is None:
                 mode = "value"
             elif mode != "value":
-                raise ValueError("JMESPath query must return a consistent shape across rows")
+                raise ValueError(
+                    "JMESPath query must return a consistent shape across rows"
+                )
             normalized_row = {"value": result}
 
         rows.append(normalized_row)
@@ -143,10 +196,14 @@ def _apply_jmespath(lf: pl.LazyFrame, expression: str) -> pl.LazyFrame:
     )
 
 
-def _apply_query(lf: pl.LazyFrame, sql: str | None, jmespath_expr: str | None) -> pl.LazyFrame:
+def _apply_query(
+    lf: pl.LazyFrame, sql: str | None, jmespath_expr: str | None
+) -> pl.LazyFrame:
     """Apply exactly zero or one supported query transform to a LazyFrame."""
     if sql is not None and jmespath_expr is not None:
-        raise ValueError("At most one query may be provided: use either --sql or --jmespath/--jp")
+        raise ValueError(
+            "At most one query may be provided: use either --sql or --jmespath/--jp"
+        )
     if sql is not None:
         return _apply_sql(lf, sql)
     if jmespath_expr is not None:
@@ -196,11 +253,18 @@ def view(
         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)
-    writer = infer_writer("table-svg" if table_svg else None, truncated=truncated, max_cell_len=max_cell_len)
+    lf, truncated = _apply_limit(
+        lf, limit=limit, skip=skip, default_limit=20 if limit is None else None
+    )
+    writer = infer_writer(
+        "table-svg" if table_svg else None,
+        truncated=truncated,
+        max_cell_len=max_cell_len,
+    )
     for chunk in writer.write(lf):
         sys.stdout.buffer.write(chunk)
 
+
 @app.command()
 def schema(
     path: PathArg,
@@ -258,7 +322,9 @@ def convert(
         elif input is not None:
             writer = infer_writer(format=input)
         else:
-            raise ValueError("Output format (-o/--output-format) is required when reading from stdin (-)")
+            raise ValueError(
+                "Output format (-o/--output-format) is required when reading from stdin (-)"
+            )
         assert isinstance(writer, TableWriter)
         writer.write_to_path(lf, dst, partitions=num_partitions)
     else:
@@ -305,7 +371,9 @@ def cat(
         writer = infer_writer(format=input)
         assert isinstance(writer, TableWriter)
     else:
-        raise ValueError("Output format (-o/--output-format) or input format (-i/--input-format) is required when reading from stdin (-)")
+        raise ValueError(
+            "Output format (-o/--output-format) or input format (-i/--input-format) is required when reading from stdin (-)"
+        )
     for chunk in writer.write(lf):
         sys.stdout.buffer.write(chunk)
 

tab_cli-0.1.6/src/tab_cli/config.py

@@ -0,0 +1,47 @@
+"""Global configuration for tab_cli-cli."""
+
+import json
+from dataclasses import dataclass, fields
+from pathlib import Path
+
+from loguru import logger
+
+CONFIG_DIR = Path.home() / ".config" / "tab"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+@dataclass
+class Config:
+    """Global configuration settings."""
+
+    az_url_authority_is_account: bool = False
+    sampling_size_for_schema_inference: int = 32
+
+
+# Global config instance
+config: Config = Config()
+
+
+def load_config_file(path: Path = CONFIG_FILE) -> None:
+    """Load settings from a JSON config file into the global config.
+
+    Unknown keys are logged and ignored. Type mismatches raise ValueError.
+    If the file does not exist, this is a no-op.
+    """
+    if not path.is_file():
+        return
+
+    text = path.read_text(encoding="utf-8")
+    data = json.loads(text)
+    if not isinstance(data, dict):
+        raise ValueError(
+            f"Config file must contain a JSON object, got {type(data).__name__}"
+        )
+
+    known = {f.name: f.type for f in fields(Config)}
+    for key, value in data.items():
+        if key not in known:
+            logger.warning("Unknown config key '{}' in {}", key, path)
+            continue
+        setattr(config, key, value)
+    logger.debug("Loaded config from {}", path)

{tab_cli-0.1.5 → tab_cli-0.1.6}/src/tab_cli/formats/parquet.py

@@ -30,7 +30,7 @@ def _scan_parquet_with_pyarrow_fallback(
             "Polars native Parquet reader failed ({}), retrying with PyArrow backend",
             e,
         )
-        return pl.scan_parquet(url, storage_options=storage_options, use_pyarrow=True)
+        return pl.read_parquet(url, storage_options=storage_options, use_pyarrow=True).lazy()
 
 
 class ParquetFormat(FormatHandler):

{tab_cli-0.1.5 → tab_cli-0.1.6}/tests/test_cli.py

@@ -2,10 +2,13 @@
 
 import json
 import os
+from unittest.mock import patch
 
 from typer.testing import CliRunner
 
+from tab_cli import config as config_module
 from tab_cli.cli import app
+from tab_cli.config import Config, load_config_file
 
 runner = CliRunner()
 TEST_CSV = os.path.join(os.path.dirname(__file__), "assets", "test.csv")
@@ -57,7 +60,11 @@ class TestView:
         result = runner.invoke(app, ["view", TEST_CSV])
         assert result.exit_code == 0
         # 8 rows < 20 default limit, so no truncation
-        lines_with_ellipsis = [line for line in result.output.splitlines() if line.strip() == "...   ...   ...   ...   ...   ..."]
+        lines_with_ellipsis = [
+            line
+            for line in result.output.splitlines()
+            if line.strip() == "...   ...   ...   ...   ...   ..."
+        ]
         assert len(lines_with_ellipsis) == 0
 
 
@@ -66,7 +73,11 @@ class TestCat:
         result = runner.invoke(app, ["cat", TEST_CSV])
         assert result.exit_code == 0
         # Should output in CSV format (the input format), not a Rich table
-        assert "Participant_ID," in result.output or "Participant_ID\t" in result.output or "P001" in result.output
+        assert (
+            "Participant_ID," in result.output
+            or "Participant_ID\t" in result.output
+            or "P001" in result.output
+        )
 
     def test_output_format_csv(self):
         result = runner.invoke(app, ["cat", TEST_CSV, "-o", "csv"])
@@ -93,21 +104,36 @@ class TestCat:
 
 class TestSqlOption:
     def test_view_with_sql(self):
-        result = runner.invoke(app, ["view", TEST_CSV, "--sql", "SELECT * FROM t WHERE Status = 'Baseline'"])
+        result = runner.invoke(
+            app,
+            ["view", TEST_CSV, "--sql", "SELECT * FROM t WHERE Status = 'Baseline'"],
+        )
         assert result.exit_code == 0
         assert "Baseline" in result.output
         # Should show as a table by default
         assert "Active" not in result.output
 
     def test_view_with_sql_and_limit(self):
-        result = runner.invoke(app, ["view", TEST_CSV, "--sql", "SELECT * FROM t", "--limit", "2"])
+        result = runner.invoke(
+            app, ["view", TEST_CSV, "--sql", "SELECT * FROM t", "--limit", "2"]
+        )
         assert result.exit_code == 0
         # Should have limited rows
         count = sum(1 for line in result.output.splitlines() if "P00" in line)
         assert count <= 2
 
     def test_cat_with_sql_and_output_format(self):
-        result = runner.invoke(app, ["cat", TEST_CSV, "--sql", "SELECT Participant_ID, Status FROM t", "-o", "csv"])
+        result = runner.invoke(
+            app,
+            [
+                "cat",
+                TEST_CSV,
+                "--sql",
+                "SELECT Participant_ID, Status FROM t",
+                "-o",
+                "csv",
+            ],
+        )
         assert result.exit_code == 0
         lines = result.output.strip().splitlines()
         assert "Participant_ID" in lines[0]
@@ -116,38 +142,68 @@ class TestSqlOption:
 
 class TestJmespathOption:
     def test_view_with_jmespath_object(self):
-        result = runner.invoke(app, ["view", TEST_CSV, "--jp", "{id: Participant_ID, status: Status}"])
+        result = runner.invoke(
+            app, ["view", TEST_CSV, "--jp", "{id: Participant_ID, status: Status}"]
+        )
         assert result.exit_code == 0
         assert "id" in result.output
         assert "status" in result.output
         assert "Baseline" in result.output
 
     def test_cat_with_jmespath_object_output(self):
-        result = runner.invoke(app, ["cat", TEST_CSV, "--jp", "{id: Participant_ID, status: Status}", "-o", "jsonl"])
+        result = runner.invoke(
+            app,
+            [
+                "cat",
+                TEST_CSV,
+                "--jp",
+                "{id: Participant_ID, status: Status}",
+                "-o",
+                "jsonl",
+            ],
+        )
         assert result.exit_code == 0
         first_row = json.loads(result.output.strip().splitlines()[0])
         assert first_row == {"id": "P001", "status": "Baseline"}
 
     def test_cat_with_jmespath_scalar_output(self):
-        result = runner.invoke(app, ["cat", TEST_CSV, "--jp", "Participant_ID", "-o", "jsonl"])
+        result = runner.invoke(
+            app, ["cat", TEST_CSV, "--jp", "Participant_ID", "-o", "jsonl"]
+        )
         assert result.exit_code == 0
         first_row = json.loads(result.output.strip().splitlines()[0])
         assert first_row == {"value": "P001"}
 
     def test_cat_with_jmespath_list_output(self):
-        result = runner.invoke(app, ["cat", TEST_CSV, "--jp", "[Participant_ID, Status]", "-o", "jsonl"])
+        result = runner.invoke(
+            app, ["cat", TEST_CSV, "--jp", "[Participant_ID, Status]", "-o", "jsonl"]
+        )
         assert result.exit_code == 0
         first_row = json.loads(result.output.strip().splitlines()[0])
         assert first_row == {"value": ["P001", "Baseline"]}
 
     def test_cat_with_jmespath_null_output(self):
-        result = runner.invoke(app, ["cat", TEST_CSV, "--jp", "MissingField", "-o", "jsonl"])
+        result = runner.invoke(
+            app, ["cat", TEST_CSV, "--jp", "MissingField", "-o", "jsonl"]
+        )
         assert result.exit_code == 0
         first_row = json.loads(result.output.strip().splitlines()[0])
         assert first_row == {"value": None}
 
     def test_sql_and_jmespath_are_mutually_exclusive(self):
-        result = runner.invoke(app, ["cat", TEST_CSV, "--sql", "SELECT * FROM t", "--jp", "Participant_ID", "-o", "jsonl"])
+        result = runner.invoke(
+            app,
+            [
+                "cat",
+                TEST_CSV,
+                "--sql",
+                "SELECT * FROM t",
+                "--jp",
+                "Participant_ID",
+                "-o",
+                "jsonl",
+            ],
+        )
         assert result.exit_code != 0
         assert result.exception is not None
         assert "At most one query may be provided" in str(result.exception)
@@ -174,7 +230,9 @@ class TestStdin:
         assert len(lines) == 9  # header + 8 data rows
 
     def test_cat_stdin_with_output_format(self):
-        result = runner.invoke(app, ["cat", "-i", "csv", "-o", "tsv", "-"], input=TEST_CSV_TEXT)
+        result = runner.invoke(
+            app, ["cat", "-i", "csv", "-o", "tsv", "-"], input=TEST_CSV_TEXT
+        )
         assert result.exit_code == 0
         lines = result.output.strip().splitlines()
         assert "\t" in lines[0]
@@ -193,7 +251,14 @@ class TestStdin:
     def test_view_stdin_with_sql(self):
         result = runner.invoke(
             app,
-            ["view", "-i", "csv", "--sql", "SELECT * FROM t WHERE Status = 'Baseline'", "-"],
+            [
+                "view",
+                "-i",
+                "csv",
+                "--sql",
+                "SELECT * FROM t WHERE Status = 'Baseline'",
+                "-",
+            ],
             input=TEST_CSV_TEXT,
         )
         assert result.exit_code == 0
@@ -201,7 +266,92 @@ class TestStdin:
         assert "Active" not in result.output
 
     def test_view_stdin_with_limit(self):
-        result = runner.invoke(app, ["view", "-i", "csv", "--limit", "2", "-"], input=TEST_CSV_TEXT)
+        result = runner.invoke(
+            app, ["view", "-i", "csv", "--limit", "2", "-"], input=TEST_CSV_TEXT
+        )
         assert result.exit_code == 0
         assert "P001" in result.output
         assert "P003" not in result.output
+
+
+class TestConfigFile:
+    """Tests for loading config from ~/.config/tab/config.json."""
+
+    def setup_method(self):
+        """Reset global config before each test."""
+        config_module.config = Config()
+
+    def test_load_missing_file(self, tmp_path):
+        """No-op when the config file does not exist."""
+        load_config_file(tmp_path / "nonexistent.json")
+        assert config_module.config.az_url_authority_is_account is False
+        assert config_module.config.sampling_size_for_schema_inference == 32
+
+    def test_load_valid_config(self, tmp_path):
+        """Known keys are applied to the global config."""
+        cfg = tmp_path / "config.json"
+        cfg.write_text(
+            json.dumps(
+                {
+                    "az_url_authority_is_account": True,
+                    "sampling_size_for_schema_inference": 64,
+                }
+            )
+        )
+        load_config_file(cfg)
+        assert config_module.config.az_url_authority_is_account is True
+        assert config_module.config.sampling_size_for_schema_inference == 64
+
+    def test_load_partial_config(self, tmp_path):
+        """Only specified keys are changed; others keep defaults."""
+        cfg = tmp_path / "config.json"
+        cfg.write_text(json.dumps({"sampling_size_for_schema_inference": 128}))
+        load_config_file(cfg)
+        assert config_module.config.az_url_authority_is_account is False
+        assert config_module.config.sampling_size_for_schema_inference == 128
+
+    def test_unknown_keys_ignored(self, tmp_path):
+        """Unknown keys are silently ignored (with a warning log)."""
+        cfg = tmp_path / "config.json"
+        cfg.write_text(
+            json.dumps(
+                {"unknown_key": "value", "sampling_size_for_schema_inference": 16}
+            )
+        )
+        load_config_file(cfg)
+        assert config_module.config.sampling_size_for_schema_inference == 16
+        assert not hasattr(config_module.config, "unknown_key")
+
+    def test_invalid_json_raises(self, tmp_path):
+        """Non-object JSON raises ValueError."""
+        cfg = tmp_path / "config.json"
+        cfg.write_text('"just a string"')
+        try:
+            load_config_file(cfg)
+            assert False, "Expected ValueError"
+        except ValueError as e:
+            assert "JSON object" in str(e)
+
+    def test_cli_flag_overrides_config_file(self, tmp_path):
+        """CLI --az-url-authority-is-account overrides the config file value."""
+        cfg = tmp_path / "config.json"
+        cfg.write_text(json.dumps({"az_url_authority_is_account": False}))
+        with patch(
+            "tab_cli.cli.load_config_file", side_effect=lambda: load_config_file(cfg)
+        ):
+            result = runner.invoke(
+                app, ["--az-url-authority-is-account", "view", TEST_CSV]
+            )
+            assert result.exit_code == 0
+            assert config_module.config.az_url_authority_is_account is True
+
+    def test_config_file_sets_default(self, tmp_path):
+        """Config file value is used when CLI flag is not passed."""
+        cfg = tmp_path / "config.json"
+        cfg.write_text(json.dumps({"az_url_authority_is_account": True}))
+        with patch(
+            "tab_cli.cli.load_config_file", side_effect=lambda: load_config_file(cfg)
+        ):
+            result = runner.invoke(app, ["view", TEST_CSV])
+            assert result.exit_code == 0
+            assert config_module.config.az_url_authority_is_account is True

tab_cli-0.1.5/src/tab_cli/config.py

@@ -1,15 +0,0 @@
-"""Global configuration for tab_cli-cli."""
-
-from dataclasses import dataclass
-
-
-@dataclass
-class Config:
-    """Global configuration settings."""
-
-    az_url_authority_is_account: bool = False
-    sampling_size_for_schema_inference: int = 32
-
-
-# Global config instance
-config: Config = Config()