csvsmith 0.10.0__tar.gz → 0.11.1__tar.gz

{csvsmith-0.10.0/src/csvsmith.egg-info → csvsmith-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csvsmith
-Version: 0.10.0
+Version: 0.11.1
 Summary: Small CSV utilities: row deduplication, classification, row filtering, and CLI helpers.
 Author-email: Eiichi YAMAMOTO <info@yeiichi.com>
 License: MIT License
@@ -69,6 +69,7 @@ Small, focused CSV utilities for common data wrangling tasks.
 files, including cleaning numeric values, filtering rows, deduplicating
 records, classifying files, converting Excel spreadsheets to CSV, moving
 files by suffix, and finding matches inside CSV content.
+It also includes a lightweight CSV viewer for quick terminal inspection.
 
 Documentation
 -------------
@@ -86,6 +87,7 @@ Features
 - Classify CSV files into folders based on headers/signatures
 - Convert Excel workbooks to CSV
 - Generate sample CSV files for testing and examples
+- View selected CSV rows and columns as a text table
 - Mark rows selected by a knapsack-style capacity fit
 - Move files by suffix
 - Find matching values inside CSV files
@@ -180,6 +182,12 @@ Generate a sample CSV:
 
    csvsmith sample-csv -o sample.csv --rows 16 --seed 42
 
+View a CSV file:
+
+.. code-block:: console
+
+   csvsmith view sample.csv --columns date,value --filter value ">" 700 --head 5
+
 Mark rows whose values best fit a capacity:
 
 .. code-block:: console

{csvsmith-0.10.0 → csvsmith-0.11.1}/README.rst

@@ -23,6 +23,7 @@ Small, focused CSV utilities for common data wrangling tasks.
 files, including cleaning numeric values, filtering rows, deduplicating
 records, classifying files, converting Excel spreadsheets to CSV, moving
 files by suffix, and finding matches inside CSV content.
+It also includes a lightweight CSV viewer for quick terminal inspection.
 
 Documentation
 -------------
@@ -40,6 +41,7 @@ Features
 - Classify CSV files into folders based on headers/signatures
 - Convert Excel workbooks to CSV
 - Generate sample CSV files for testing and examples
+- View selected CSV rows and columns as a text table
 - Mark rows selected by a knapsack-style capacity fit
 - Move files by suffix
 - Find matching values inside CSV files
@@ -134,6 +136,12 @@ Generate a sample CSV:
 
    csvsmith sample-csv -o sample.csv --rows 16 --seed 42
 
+View a CSV file:
+
+.. code-block:: console
+
+   csvsmith view sample.csv --columns date,value --filter value ">" 700 --head 5
+
 Mark rows whose values best fit a capacity:
 
 .. code-block:: console

{csvsmith-0.10.0 → csvsmith-0.11.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "csvsmith"
-version = "0.10.0"
+version = "0.11.1"
 description = "Small CSV utilities: row deduplication, classification, row filtering, and CLI helpers."
 readme = "README.rst"
 requires-python = ">=3.10"

{csvsmith-0.10.0 → csvsmith-0.11.1}/src/csvsmith/__init__.py

@@ -21,6 +21,9 @@ Public API:
 - concentrate_csv
 - rehydrate_csv
 - create_sample_csv
+- DataFrame
+- build_filter
+- infer_type
 - find_knapsack_indices
 - mark_knapsack_csv
 
@@ -42,6 +45,7 @@ Submodules:
 __version__ = "0.8.0"
 
 from .tools.classify import CSVClassifier
+from .tools.csv_viewer import DataFrame, build_filter, infer_type
 from .tools.dense_csv import (
     ConcentrateResult,
     RehydrateResult,
@@ -97,6 +101,9 @@ __all__ = [
     "rehydrate_csv",
     "SampleCSVResult",
     "create_sample_csv",
+    "DataFrame",
+    "build_filter",
+    "infer_type",
     "KnapsackCSVResult",
     "find_knapsack_indices",
     "mark_knapsack_csv",

{csvsmith-0.10.0 → csvsmith-0.11.1}/src/csvsmith/cli.py

@@ -8,6 +8,7 @@ from typing import Optional, Sequence
 
 from . import __version__
 from .tools.classify import CSVClassifier
+from .tools.csv_viewer import DataFrame, build_filter
 from .tools.dense_csv import concentrate_csv, rehydrate_csv
 from .tools.excel2csv import excel_to_csv
 from .utils.clean_numeric import clean_currency_numeric, clean_numeric
@@ -30,6 +31,20 @@ from .utils.distance import analyze_pair
 from .utils.io import read_csv_rows, write_csv_rows
 
 
+def _non_negative_int(value: str) -> int:
+    number = int(value)
+    if number < 0:
+        raise argparse.ArgumentTypeError("must be 0 or greater")
+    return number
+
+
+def _positive_int(value: str) -> int:
+    number = int(value)
+    if number < 1:
+        raise argparse.ArgumentTypeError("must be 1 or greater")
+    return number
+
+
 def cmd_row_duplicates(args: argparse.Namespace) -> int:
     rows = read_csv_rows(args.input)
     subset = args.subset.split(",") if args.subset else None
@@ -287,6 +302,61 @@ def cmd_sample_csv(args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_view(args: argparse.Namespace) -> int:
+    try:
+        df = DataFrame.from_csv(
+            args.input,
+            convert_types=not args.no_convert_types,
+        )
+
+        if args.filter:
+            column, op, value = args.filter
+            df = df.filter(build_filter(column, op, value))
+
+        if args.columns:
+            columns = [column.strip() for column in args.columns.split(",") if column.strip()]
+            df = df.select(columns)
+
+        if args.head is not None:
+            output = df.head(args.head)
+            if output:
+                print(output)
+        elif sys.stdin.isatty() and sys.stdout.isatty():
+            _paginate_dataframe(df, args.page_size)
+        else:
+            output = df.render()
+            if output:
+                print(output)
+    except (OSError, csv.Error) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except KeyError as e:
+        print(f"Error: unknown column: {e.args[0]}", file=sys.stderr)
+        return 1
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+def _paginate_dataframe(df: DataFrame, page_size: int) -> None:
+    for start in range(0, len(df), page_size):
+        end = min(start + page_size, len(df))
+        output = df.render(start=start, end=end)
+        if output:
+            print(output)
+
+        if end >= len(df):
+            break
+
+        print(f"\nRows {start + 1}-{end} of {len(df)}")
+        response = input("Press Enter for next page, or q to quit: ").strip().lower()
+        if response == "q":
+            break
+        print()
+
+
 def cmd_knapsack(args: argparse.Namespace) -> int:
     try:
         result = mark_knapsack_csv(
@@ -403,6 +473,45 @@ def _add_sample_csv_parser(subparsers) -> None:
     parser.set_defaults(func=cmd_sample_csv)
 
 
+def _add_view_parser(subparsers) -> None:
+    parser = subparsers.add_parser(
+        "view",
+        help="View and lightly query CSV files as a text table.",
+    )
+    parser.add_argument("input", help="Input CSV file.")
+    parser.add_argument(
+        "-n",
+        "--head",
+        type=_non_negative_int,
+        help="Print only the first N rows.",
+    )
+    parser.add_argument(
+        "-p",
+        "--page-size",
+        type=_positive_int,
+        default=20,
+        help="Number of rows per interactive page (default: 20).",
+    )
+    parser.add_argument(
+        "-c",
+        "--columns",
+        help="Comma-separated columns to display, such as date,amount.",
+    )
+    parser.add_argument(
+        "-f",
+        "--filter",
+        nargs=3,
+        metavar=("COLUMN", "OP", "VALUE"),
+        help="Filter rows with a simple expression, such as: value '>' 700.",
+    )
+    parser.add_argument(
+        "--no-convert-types",
+        action="store_true",
+        help="Keep all CSV values as strings instead of inferring numbers.",
+    )
+    parser.set_defaults(func=cmd_view)
+
+
 def _add_knapsack_parser(subparsers) -> None:
     parser = subparsers.add_parser(
         "knapsack",
@@ -559,6 +668,7 @@ def build_parser() -> argparse.ArgumentParser:
     _add_concentrate_parser(subparsers)
     _add_rehydrate_parser(subparsers)
     _add_sample_csv_parser(subparsers)
+    _add_view_parser(subparsers)
     _add_knapsack_parser(subparsers)
     _add_dedupe_parser(subparsers)
     _add_classify_parser(subparsers)

csvsmith-0.11.1/src/csvsmith/tools/csv_viewer.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import csv
+import operator
+from pathlib import Path
+from typing import Any, Callable, TextIO
+
+
+OPERATORS: dict[str, Callable[[Any, Any], bool]] = {
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">": operator.gt,
+    ">=": operator.ge,
+    "<": operator.lt,
+    "<=": operator.le,
+}
+
+
+class DataFrame:
+    """A lightweight in-memory CSV table for inspection and simple filtering."""
+
+    def __init__(self, data: dict[str, list[Any]]) -> None:
+        self._data = data
+        self.columns = list(data)
+
+    @classmethod
+    def from_csv(
+        cls,
+        filepath: str | Path,
+        *,
+        convert_types: bool = True,
+    ) -> DataFrame:
+        """Read a CSV file into a column-oriented ``DataFrame``."""
+        with Path(filepath).open("r", newline="", encoding="utf-8-sig") as file:
+            reader = csv.DictReader(file)
+            fieldnames = reader.fieldnames or []
+            data: dict[str, list[Any]] = {column: [] for column in fieldnames}
+
+            for row in reader:
+                for column in fieldnames:
+                    value = row.get(column)
+                    if convert_types:
+                        value = infer_type(value)
+                    data[column].append(value)
+
+        return cls(data)
+
+    def render(self, *, start: int = 0, end: int | None = None) -> str:
+        """Return rows from ``start`` up to ``end`` formatted as a text table."""
+        start = max(start, 0)
+        end = len(self) if end is None else min(end, len(self))
+        if start >= end or not self.columns:
+            return ""
+
+        row_indexes = range(start, end)
+        widths = {column: len(column) for column in self.columns}
+        for column in self.columns:
+            for index in row_indexes:
+                widths[column] = max(widths[column], len(str(self._data[column][index])))
+
+        lines = [
+            " | ".join(f"{column:<{widths[column]}}" for column in self.columns),
+            "-+-".join("-" * widths[column] for column in self.columns),
+        ]
+        for index in row_indexes:
+            lines.append(
+                " | ".join(
+                    f"{str(self._data[column][index]):<{widths[column]}}"
+                    for column in self.columns
+                )
+            )
+
+        return "\n".join(lines)
+
+    def show(
+        self,
+        *,
+        start: int = 0,
+        end: int | None = None,
+        file: TextIO | None = None,
+    ) -> None:
+        """Print rows from ``start`` up to ``end`` as a text table."""
+        rendered = self.render(start=start, end=end)
+        if rendered:
+            print(rendered, file=file)
+
+    def head(self, n: int = 5) -> str:
+        """Return the first ``n`` rows formatted as a text table."""
+        return self.render(end=n)
+
+    def select(self, columns: list[str]) -> DataFrame:
+        """Return a new ``DataFrame`` with the selected columns."""
+        missing = [column for column in columns if column not in self._data]
+        if missing:
+            raise KeyError(", ".join(missing))
+        return DataFrame({column: self._data[column] for column in columns})
+
+    def filter(self, condition_func: Callable[[dict[str, Any]], bool]) -> DataFrame:
+        """Return rows for which ``condition_func`` evaluates to true."""
+        filtered_data: dict[str, list[Any]] = {column: [] for column in self.columns}
+
+        for index in range(len(self)):
+            row = {column: self._data[column][index] for column in self.columns}
+            if condition_func(row):
+                for column in self.columns:
+                    filtered_data[column].append(self._data[column][index])
+
+        return DataFrame(filtered_data)
+
+    def __getitem__(self, column_name: str) -> list[Any]:
+        return self._data[column_name]
+
+    def __setitem__(self, column_name: str, values: list[Any]) -> None:
+        if len(values) != len(self):
+            raise ValueError(
+                f"Length of values ({len(values)}) does not match "
+                f"DataFrame length ({len(self)})"
+            )
+        self._data[column_name] = list(values)
+        if column_name not in self.columns:
+            self.columns.append(column_name)
+
+    def __len__(self) -> int:
+        if not self.columns:
+            return 0
+        return len(self._data[self.columns[0]])
+
+    def __repr__(self) -> str:
+        return f"<DataFrame with {len(self)} rows and {len(self.columns)} columns>"
+
+
+def infer_type(value: str | None) -> int | float | str | None:
+    """Convert strings to ``int`` or ``float`` when possible."""
+    if value is None:
+        return None
+
+    stripped = value.strip()
+    try:
+        return int(stripped)
+    except ValueError:
+        pass
+
+    try:
+        return float(stripped)
+    except ValueError:
+        return stripped
+
+
+def build_filter(column: str, op: str, raw_value: str) -> Callable[[dict[str, Any]], bool]:
+    """Build a row predicate from a column, operator, and comparison value."""
+    if op not in OPERATORS:
+        allowed = ", ".join(OPERATORS)
+        raise ValueError(f"Unsupported operator {op!r}. Use one of: {allowed}.")
+
+    expected = infer_type(raw_value)
+    compare = OPERATORS[op]
+
+    def row_matches(row: dict[str, Any]) -> bool:
+        if column not in row:
+            raise KeyError(column)
+
+        actual = row[column]
+        try:
+            return compare(actual, expected)
+        except TypeError:
+            return compare(str(actual), str(expected))
+
+    return row_matches

{csvsmith-0.10.0 → csvsmith-0.11.1/src/csvsmith.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csvsmith
-Version: 0.10.0
+Version: 0.11.1
 Summary: Small CSV utilities: row deduplication, classification, row filtering, and CLI helpers.
 Author-email: Eiichi YAMAMOTO <info@yeiichi.com>
 License: MIT License
@@ -69,6 +69,7 @@ Small, focused CSV utilities for common data wrangling tasks.
 files, including cleaning numeric values, filtering rows, deduplicating
 records, classifying files, converting Excel spreadsheets to CSV, moving
 files by suffix, and finding matches inside CSV content.
+It also includes a lightweight CSV viewer for quick terminal inspection.
 
 Documentation
 -------------
@@ -86,6 +87,7 @@ Features
 - Classify CSV files into folders based on headers/signatures
 - Convert Excel workbooks to CSV
 - Generate sample CSV files for testing and examples
+- View selected CSV rows and columns as a text table
 - Mark rows selected by a knapsack-style capacity fit
 - Move files by suffix
 - Find matching values inside CSV files
@@ -180,6 +182,12 @@ Generate a sample CSV:
 
    csvsmith sample-csv -o sample.csv --rows 16 --seed 42
 
+View a CSV file:
+
+.. code-block:: console
+
+   csvsmith view sample.csv --columns date,value --filter value ">" 700 --head 5
+
 Mark rows whose values best fit a capacity:
 
 .. code-block:: console

{csvsmith-0.10.0 → csvsmith-0.11.1}/src/csvsmith.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/csvsmith.egg-info/requires.txt
 src/csvsmith.egg-info/top_level.txt
 src/csvsmith/tools/__init__.py
 src/csvsmith/tools/classify.py
+src/csvsmith/tools/csv_viewer.py
 src/csvsmith/tools/dense_csv.py
 src/csvsmith/tools/excel2csv.py
 src/csvsmith/tools/filter_rows.py
@@ -28,6 +29,7 @@ src/csvsmith/utils/normalize.py
 tests/test_classify.py
 tests/test_clean_numeric.py
 tests/test_cli.py
+tests/test_csv_viewer.py
 tests/test_dense_csv.py
 tests/test_excel2csv.py
 tests/test_filter_rows.py

{csvsmith-0.10.0 → csvsmith-0.11.1}/tests/test_cli.py

@@ -279,6 +279,35 @@ def test_cli_parses_sample_csv_command():
     assert args.seed == 42
 
 
+def test_cli_parses_view_command():
+    parser = build_parser()
+    args = parser.parse_args(
+        [
+            "view",
+            "sample.csv",
+            "--head",
+            "3",
+            "--page-size",
+            "10",
+            "--columns",
+            "date,value",
+            "--filter",
+            "value",
+            ">",
+            "700",
+            "--no-convert-types",
+        ]
+    )
+
+    assert args.command == "view"
+    assert args.input == "sample.csv"
+    assert args.head == 3
+    assert args.page_size == 10
+    assert args.columns == "date,value"
+    assert args.filter == ["value", ">", "700"]
+    assert args.no_convert_types is True
+
+
 def test_cli_parses_knapsack_command():
     parser = build_parser()
     args = parser.parse_args(

csvsmith-0.11.1/tests/test_csv_viewer.py

@@ -0,0 +1,124 @@
+import csv
+from pathlib import Path
+
+import pytest
+
+from csvsmith.cli import main
+from csvsmith.tools.csv_viewer import DataFrame, build_filter, infer_type
+
+
+def write_csv(path: Path, rows: list[list[str]]) -> None:
+    with path.open("w", encoding="utf-8", newline="") as outfile:
+        csv.writer(outfile).writerows(rows)
+
+
+def test_dataframe_reads_csv_and_infers_numeric_types(tmp_path):
+    source = tmp_path / "sample.csv"
+    write_csv(source, [["name", "value"], ["Alice", "12"], ["Bob", "13.5"]])
+
+    df = DataFrame.from_csv(source)
+
+    assert df.columns == ["name", "value"]
+    assert df["name"] == ["Alice", "Bob"]
+    assert df["value"] == [12, 13.5]
+    assert repr(df) == "<DataFrame with 2 rows and 2 columns>"
+
+
+def test_dataframe_reads_utf8_bom_csv_headers(tmp_path):
+    source = tmp_path / "sample.csv"
+    with source.open("w", encoding="utf-8-sig", newline="") as outfile:
+        csv.writer(outfile).writerows([["name", "value"], ["Alice", "12"]])
+
+    df = DataFrame.from_csv(source)
+
+    assert df.columns == ["name", "value"]
+    assert df["name"] == ["Alice"]
+
+
+def test_dataframe_can_keep_values_as_strings(tmp_path):
+    source = tmp_path / "sample.csv"
+    write_csv(source, [["id"], ["001"]])
+
+    df = DataFrame.from_csv(source, convert_types=False)
+
+    assert df["id"] == ["001"]
+
+
+def test_dataframe_render_select_and_head(tmp_path):
+    source = tmp_path / "sample.csv"
+    write_csv(
+        source,
+        [
+            ["name", "score", "city"],
+            ["Alice", "10", "Tokyo"],
+            ["Bob", "8", "Osaka"],
+        ],
+    )
+
+    df = DataFrame.from_csv(source).select(["name", "score"])
+
+    assert df.head(1) == "name  | score\n------+------\nAlice | 10   "
+    assert df.render(start=1) == "name | score\n-----+------\nBob  | 8    "
+
+
+def test_dataframe_filter_supports_numeric_comparisons(tmp_path):
+    source = tmp_path / "sample.csv"
+    write_csv(source, [["name", "score"], ["Alice", "10"], ["Bob", "8"]])
+
+    df = DataFrame.from_csv(source).filter(build_filter("score", ">", "8"))
+
+    assert df["name"] == ["Alice"]
+
+
+def test_view_command_filters_and_selects_columns(tmp_path, capsys):
+    source = tmp_path / "sample.csv"
+    write_csv(
+        source,
+        [
+            ["name", "score", "city"],
+            ["Alice", "10", "Tokyo"],
+            ["Bob", "8", "Osaka"],
+        ],
+    )
+
+    exit_code = main(
+        [
+            "view",
+            str(source),
+            "--columns",
+            "name,score",
+            "--filter",
+            "score",
+            ">",
+            "8",
+        ]
+    )
+
+    assert exit_code == 0
+    assert capsys.readouterr().out == "name  | score\n------+------\nAlice | 10   \n"
+
+
+def test_dataframe_select_rejects_missing_columns(tmp_path):
+    source = tmp_path / "sample.csv"
+    write_csv(source, [["name"], ["Alice"]])
+
+    with pytest.raises(KeyError, match="score"):
+        DataFrame.from_csv(source).select(["score"])
+
+
+def test_build_filter_rejects_unknown_operator():
+    with pytest.raises(ValueError, match="Unsupported operator"):
+        build_filter("score", "~", "10")
+
+
+@pytest.mark.parametrize(
+    ("raw_value", "expected"),
+    [
+        (" 12 ", 12),
+        ("12.5", 12.5),
+        ("Alice", "Alice"),
+        (None, None),
+    ],
+)
+def test_infer_type(raw_value, expected):
+    assert infer_type(raw_value) == expected