csvsmith 0.6.0__tar.gz → 0.7.0__tar.gz

{csvsmith-0.6.0/src/csvsmith.egg-info → csvsmith-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csvsmith
-Version: 0.6.0
+Version: 0.7.0
 Summary: Small CSV utilities: row deduplication, classification, row filtering, and CLI helpers.
 Author-email: Eiichi YAMAMOTO <info@yeiichi.com>
 License: MIT License
@@ -227,7 +227,7 @@ CSV File Classification (Python)
 
 .. code-block:: python
 
-   from csvsmith.classify import CSVClassifier
+   from csvsmith.tools.classify import CSVClassifier
 
    classifier = CSVClassifier(
        source_dir="./raw_data",

{csvsmith-0.6.0 → csvsmith-0.7.0}/README.rst

@@ -185,7 +185,7 @@ CSV File Classification (Python)
 
 .. code-block:: python
 
-   from csvsmith.classify import CSVClassifier
+   from csvsmith.tools.classify import CSVClassifier
 
    classifier = CSVClassifier(
        source_dir="./raw_data",

{csvsmith-0.6.0 → csvsmith-0.7.0}/pyproject.toml

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

{csvsmith-0.6.0 → csvsmith-0.7.0}/src/csvsmith/__init__.py

@@ -31,22 +31,24 @@ Submodules:
 - csvsmith.cli (CLI entrypoint)
 """
 
-__version__ = "0.6.0"
+__version__ = "0.7.0"
 
-from .clean_numeric import clean_numeric
-from .row_dedup import (
-    count_duplicates_sorted,
+from .tools.clean_numeric import clean_numeric
+from .tools.row_dedup import (
     add_row_digest,
     find_duplicate_rows,
     dedupe_with_report,
+)
+from .utils.io import (
+    count_duplicates_sorted,
     read_csv_rows,
     write_csv_rows,
 )
-from .classify import CSVClassifier
-from .filter_rows import DropRowsBySubstring, CSVCleaner
-from .excel2csv import excel_to_csv
-from .move_files import move_by_suffix
-from .string_distance import StringDistance, Relation, Result, analyze_pair
+from .tools.classify import CSVClassifier
+from .tools.filter_rows import DropRowsBySubstring, CSVCleaner
+from .tools.excel2csv import excel_to_csv
+from .tools.move_files import move_by_suffix
+from .utils.distance import StringDistance, Relation, Result, analyze_pair
 
 __all__ = [
     "count_duplicates_sorted",

{csvsmith-0.6.0 → csvsmith-0.7.0}/src/csvsmith/cli.py

@@ -7,33 +7,18 @@ from typing import Optional, Sequence
 
 
 from . import __version__
-from .classify import CSVClassifier
-from .excel2csv import excel_to_csv
-from .clean_numeric import clean_numeric
-from .filter_rows import DropRowsBySubstring
-from .move_files import move_by_suffix
-from .row_dedup import (
+from .tools.classify import CSVClassifier
+from .tools.excel2csv import excel_to_csv
+from .tools.clean_numeric import clean_numeric
+from .tools.filter_rows import DropRowsBySubstring
+from .tools.move_files import move_by_suffix, normalize_suffixes
+from .tools.row_dedup import (
     dedupe_with_report,
     find_duplicate_rows,
-    read_csv_rows,
-    write_csv_rows,
 )
-from .string_distance import analyze_pair
-
-
-def _parse_suffixes(value: str | None) -> set[str]:
-    if not value:
-        return {".csv", ".pdf"}
-
-    suffixes: set[str] = set()
-    for item in value.split(","):
-        suffix = item.strip().lower()
-        if not suffix:
-            continue
-        if not suffix.startswith("."):
-            suffix = f".{suffix}"
-        suffixes.add(suffix)
-    return suffixes
+from .tools.find_matches_in_csv import find_matches_in_csv
+from .utils.distance import analyze_pair
+from .utils.io import read_csv_rows, write_csv_rows
 
 
 def cmd_row_duplicates(args: argparse.Namespace) -> int:
@@ -89,7 +74,7 @@ def cmd_classify(args: argparse.Namespace) -> int:
 
 
 def cmd_move_files(args: argparse.Namespace) -> int:
-    suffixes = _parse_suffixes(args.suffixes)
+    suffixes = normalize_suffixes(args.suffixes.split(",") if args.suffixes else [])
     moved_count = move_by_suffix(args.source, args.dest, suffixes=suffixes)
     print(f"Moved {moved_count} file(s).")
     return 0
@@ -164,6 +149,32 @@ def cmd_clean_numeric(args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_find_matches(args: argparse.Namespace) -> int:
+    results = find_matches_in_csv(
+        args.input,
+        args.target,
+        ignore_case=args.ignore_case,
+        ignore_whitespace=args.ignore_whitespace,
+        nfkc=not args.no_nfkc,
+    )
+
+    if not results:
+        print("No matches found.")
+    else:
+        print(json.dumps(results, indent=2))
+    return 0
+
+
+def _add_find_matches_parser(subparsers) -> None:
+    parser = subparsers.add_parser("find-matches", help="Find matches in a CSV file.")
+    parser.add_argument("input", help="Input CSV file.")
+    parser.add_argument("target", help="Target string to find.")
+    parser.add_argument("--ignore-case", action="store_true", help="Ignore case.")
+    parser.add_argument("--ignore-whitespace", action="store_true", help="Ignore whitespace.")
+    parser.add_argument("--no-nfkc", action="store_true", help="Disable NFKC normalization.")
+    parser.set_defaults(func=cmd_find_matches)
+
+
 def _add_row_duplicates_parser(subparsers) -> None:
     parser = subparsers.add_parser("row-duplicates", help="Find duplicate rows in a CSV.")
     parser.add_argument("input", help="Input CSV file.")
@@ -274,6 +285,7 @@ def build_parser() -> argparse.ArgumentParser:
     subparsers = parser.add_subparsers(dest="command", required=True)
 
     _add_row_duplicates_parser(subparsers)
+    _add_find_matches_parser(subparsers)
     _add_dedupe_parser(subparsers)
     _add_classify_parser(subparsers)
     _add_move_files_parser(subparsers)
@@ -298,3 +310,4 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
 
 if __name__ == "__main__":
     sys.exit(main())
+

csvsmith-0.7.0/src/csvsmith/tools/excel2csv.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+from ..utils.io import _open_worksheet, write_worksheet_to_csv
+
+
+def _resolve_csv_path(excel_path: Path, csv_path: str | Path | None) -> Path:
+    """Return the output CSV path, defaulting to the Excel file's stem."""
+    return Path(csv_path) if csv_path else excel_path.with_suffix(".csv")
+
+
+def excel_to_csv(
+    excel_path: str | Path,
+    csv_path: str | Path | None = None,
+    *,
+    sheet_name: str | None = None,
+) -> Path:
+    """Convert one Excel worksheet into a CSV file."""
+    excel_path = Path(excel_path)
+    csv_path = _resolve_csv_path(excel_path, csv_path)
+
+    with _open_worksheet(excel_path, sheet_name=sheet_name) as worksheet:
+        write_worksheet_to_csv(worksheet, csv_path)
+
+    return csv_path

csvsmith-0.7.0/src/csvsmith/tools/find_matches_in_csv.py

@@ -0,0 +1,43 @@
+import csv
+
+from ..utils.normalize import normalize
+
+def find_matches_in_csv(file_path, target_key, stringency=1.0, **kwargs):
+    """
+    Scans a CSV for a key and returns coordinates and neighbor data.
+    """
+    # Merge defaults with user overrides
+    cfg = {
+        'ignore_case': kwargs.get('ignore_case', True),
+        'ignore_whitespace': kwargs.get('ignore_whitespace', True),
+        'nfkc': kwargs.get('nfkc', True)
+    }
+    
+    clean_target = normalize(target_key, **cfg)
+    results = []
+    
+    # encoding='utf-8-sig' + dialect='excel' is the 'Anti-BOOM' shield
+    with open(file_path, mode='r', encoding='utf-8-sig', newline='') as f:
+        reader = csv.reader(f, dialect='excel')
+
+        header = next(reader, None)
+        if header is None:
+            return results
+
+        for r_idx, row in enumerate(reader):
+            for c_idx, cell in enumerate(row):
+                if normalize(cell, **cfg) == clean_target:
+                    # Key found! Map all non-empty values in this row
+                    associated = {
+                        f"col_{i}": val.strip()
+                        for i, val in enumerate(row)
+                        if val.strip() and i != c_idx
+                    }
+
+                    results.append({
+                        "match": cell,
+                        "coords": (r_idx, c_idx),
+                        "data": associated
+                    })
+
+    return results

{csvsmith-0.6.0/src/csvsmith → csvsmith-0.7.0/src/csvsmith/tools}/row_dedup.py

@@ -6,50 +6,14 @@ from hashlib import sha256
 from pathlib import Path
 from typing import Hashable, Iterable, Mapping, Optional, Sequence
 
+from ..utils.io import Row, read_csv_rows, write_csv_rows
 
-ROW_SEP = "\x1f"
 KEEP_OPTIONS = {"first", "last"}
+ROW_SEP = "\x1f"
 
-Row = dict[str, str]
 RowLike = Mapping[str, object]
 
 
-def count_duplicates_sorted(
-    items: Iterable[Hashable],
-    threshold: int = 2,
-    reverse: bool = True,
-) -> list[tuple[Hashable, int]]:
-    """Count items and return those occurring at least `threshold` times."""
-    counter = Counter(items)
-    duplicates = [(key, count) for key, count in counter.items() if count >= threshold]
-    duplicates.sort(key=lambda x: x[1], reverse=reverse)
-    return duplicates
-
-
-def read_csv_rows(csv_path: Path | str, encoding: str = "utf-8") -> list[Row]:
-    """Read a CSV file into a list of row dictionaries."""
-    path = Path(csv_path)
-    with path.open("r", encoding=encoding, newline="") as fp:
-        reader = csv.DictReader(fp)
-        return list(reader)
-
-
-def write_csv_rows(
-    csv_path: Path | str,
-    rows: Sequence[Mapping[str, object]],
-    *,
-    fieldnames: Sequence[str],
-    encoding: str = "utf-8",
-) -> None:
-    """Write row dictionaries to a CSV file."""
-    path = Path(csv_path)
-    with path.open("w", encoding=encoding, newline="") as fp:
-        writer = csv.DictWriter(fp, fieldnames=fieldnames)
-        writer.writeheader()
-        for row in rows:
-            writer.writerow(row)
-
-
 def _normalize_cell(value: object) -> str:
     """Convert a cell value to a stable string for hashing."""
     if value is None:
@@ -176,7 +140,7 @@ def dedupe_csv_file(
     subset: Optional[Sequence[Hashable]] = None,
     exclude: Optional[Sequence[Hashable]] = None,
     keep: str = "first",
-    encoding: str = "utf-8",
+    encoding: str = "utf-8-sig",
 ) -> list[dict[str, object]]:
     """Deduplicate a CSV file, write the result, and return the report."""
     rows = read_csv_rows(src, encoding=encoding)

csvsmith-0.6.0/src/csvsmith/excel2csv.py → csvsmith-0.7.0/src/csvsmith/utils/io.py

@@ -3,12 +3,27 @@ from __future__ import annotations
 import csv
 from contextlib import contextmanager
 from pathlib import Path
-from typing import Iterable, Iterator
+from typing import Any, Hashable, Iterable, Iterator, Mapping, Sequence
 
 from openpyxl import load_workbook
 from openpyxl.workbook.workbook import Workbook
 from openpyxl.worksheet.worksheet import Worksheet
 
+Row = dict[str, Any]
+
+from collections import Counter
+
+def count_duplicates_sorted(
+    items: Iterable[Hashable],
+    threshold: int = 2,
+    reverse: bool = True,
+) -> list[tuple[Hashable, int]]:
+    """Count items and return those occurring at least `threshold` times."""
+    counter = Counter(items)
+    duplicates = [(key, count) for key, count in counter.items() if count >= threshold]
+    duplicates.sort(key=lambda x: x[1], reverse=reverse)
+    return duplicates
+
 
 @contextmanager
 def _open_worksheet(excel_path: str | Path, *, sheet_name: str | None = None) -> Iterator[Worksheet]:
@@ -37,22 +52,25 @@ def write_worksheet_to_csv(worksheet: Worksheet, csv_path: str | Path) -> None:
         writer.writerows(iter_worksheet_rows(worksheet))
 
 
-def _resolve_csv_path(excel_path: Path, csv_path: str | Path | None) -> Path:
-    """Return the output CSV path, defaulting to the Excel file's stem."""
-    return Path(csv_path) if csv_path else excel_path.with_suffix(".csv")
+def read_csv_rows(csv_path: Path | str, encoding: str = "utf-8-sig") -> list[Row]:
+    """Read a CSV file into a list of row dictionaries."""
+    path = Path(csv_path)
+    with path.open("r", encoding=encoding, newline="") as fp:
+        reader = csv.DictReader(fp)
+        return list(reader)
 
 
-def excel_to_csv(
-    excel_path: str | Path,
-    csv_path: str | Path | None = None,
+def write_csv_rows(
+    csv_path: Path | str,
+    rows: Sequence[Mapping[str, object]],
     *,
-    sheet_name: str | None = None,
-) -> Path:
-    """Convert one Excel worksheet into a CSV file."""
-    excel_path = Path(excel_path)
-    csv_path = _resolve_csv_path(excel_path, csv_path)
-
-    with _open_worksheet(excel_path, sheet_name=sheet_name) as worksheet:
-        write_worksheet_to_csv(worksheet, csv_path)
-
-    return csv_path
+    fieldnames: Sequence[str],
+    encoding: str = "utf-8-sig",
+) -> None:
+    """Write row dictionaries to a CSV file."""
+    path = Path(csv_path)
+    with path.open("w", encoding=encoding, newline="") as fp:
+        writer = csv.DictWriter(fp, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in rows:
+            writer.writerow(row)

csvsmith-0.7.0/src/csvsmith/utils/normalize.py

@@ -0,0 +1,28 @@
+import unicodedata
+
+
+def normalize(text, ignore_case=True, ignore_whitespace=True, nfkc=True):
+    """
+    Standardizes strings to bypass Excel formatting artifacts.
+    """
+    if text is None:
+        return ""
+
+    # Cast to string to handle numeric cells safely
+    text = str(text)
+
+    # 1. Unicode Compatibility (Handles full-width/ligatures)
+    if nfkc:
+        text = unicodedata.normalize('NFKC', text)
+
+    # 2. Case Folding
+    if ignore_case:
+        text = text.lower()
+
+    # 3. Whitespace handling
+    # Always trim outer whitespace, and optionally remove all internal whitespace.
+    text = text.strip()
+    if ignore_whitespace:
+        text = "".join(text.split())
+
+    return text

{csvsmith-0.6.0 → csvsmith-0.7.0/src/csvsmith.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: csvsmith
-Version: 0.6.0
+Version: 0.7.0
 Summary: Small CSV utilities: row deduplication, classification, row filtering, and CLI helpers.
 Author-email: Eiichi YAMAMOTO <info@yeiichi.com>
 License: MIT License
@@ -227,7 +227,7 @@ CSV File Classification (Python)
 
 .. code-block:: python
 
-   from csvsmith.classify import CSVClassifier
+   from csvsmith.tools.classify import CSVClassifier
 
    classifier = CSVClassifier(
        source_dir="./raw_data",

csvsmith-0.7.0/src/csvsmith.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+LICENSE
+README.rst
+pyproject.toml
+src/csvsmith/__init__.py
+src/csvsmith/cli.py
+src/csvsmith.egg-info/PKG-INFO
+src/csvsmith.egg-info/SOURCES.txt
+src/csvsmith.egg-info/dependency_links.txt
+src/csvsmith.egg-info/entry_points.txt
+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/clean_numeric.py
+src/csvsmith/tools/excel2csv.py
+src/csvsmith/tools/filter_rows.py
+src/csvsmith/tools/find_matches_in_csv.py
+src/csvsmith/tools/move_files.py
+src/csvsmith/tools/row_dedup.py
+src/csvsmith/utils/__init__.py
+src/csvsmith/utils/distance.py
+src/csvsmith/utils/io.py
+src/csvsmith/utils/normalize.py
+tests/test_classify.py
+tests/test_clean_numeric.py
+tests/test_cli.py
+tests/test_excel2csv.py
+tests/test_filter_rows.py
+tests/test_find_matches_in_csv.py
+tests/test_move_files.py
+tests/test_normalize.py
+tests/test_row_dedup.py
+tests/test_string_distance.py

{csvsmith-0.6.0 → csvsmith-0.7.0}/tests/test_classify.py

@@ -1,5 +1,5 @@
 import pytest
-from csvsmith.classify import CSVClassifier
+from csvsmith.tools.classify import CSVClassifier
 
 
 @pytest.fixture

{csvsmith-0.6.0 → csvsmith-0.7.0}/tests/test_clean_numeric.py

@@ -1,5 +1,5 @@
 import pytest
-from src.csvsmith.clean_numeric import clean_numeric
+from csvsmith.tools.clean_numeric import clean_numeric
 
 
 def test_clean_numeric_with_valid_integer_string() -> None:

{csvsmith-0.6.0 → csvsmith-0.7.0}/tests/test_cli.py

@@ -157,3 +157,24 @@ def test_cli_parses_string_distance_command():
     assert args.string_a == "a"
     assert args.string_b == "b"
     assert args.ignore_case is True
+
+
+def test_cli_parses_find_matches_command():
+    parser = build_parser()
+    args = parser.parse_args(
+        [
+            "find-matches",
+            "input.csv",
+            "target",
+            "--ignore-case",
+            "--ignore-whitespace",
+            "--no-nfkc",
+        ]
+    )
+
+    assert args.command == "find-matches"
+    assert args.input == "input.csv"
+    assert args.target == "target"
+    assert args.ignore_case is True
+    assert args.ignore_whitespace is True
+    assert args.no_nfkc is True

{csvsmith-0.6.0 → csvsmith-0.7.0}/tests/test_excel2csv.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 from openpyxl import Workbook
 
-from csvsmith.excel2csv import excel_to_csv
+from csvsmith.tools.excel2csv import excel_to_csv
 
 
 def _create_workbook(path: Path) -> None:

{csvsmith-0.6.0 → csvsmith-0.7.0}/tests/test_filter_rows.py

@@ -2,7 +2,7 @@ from pathlib import Path
 
 import pytest
 
-from csvsmith.filter_rows import DropRowsBySubstring
+from csvsmith.tools.filter_rows import DropRowsBySubstring
 
 
 def test_write_filtered_rows_keeps_header_and_filters_matching_rows(tmp_path: Path):

csvsmith-0.7.0/tests/test_find_matches_in_csv.py

@@ -0,0 +1,57 @@
+import pytest
+from csvsmith.tools.find_matches_in_csv import find_matches_in_csv
+
+
+@pytest.fixture
+def sample_csv_file(tmp_path):
+    file_content = """name,age,city
+John,30,New York
+Alice,25,Los Angeles
+Bob,35,New York"""
+    file_path = tmp_path / "sample.csv"
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(file_content)
+    return file_path
+
+
+def test_find_matches_in_csv_key_matches_in_file(sample_csv_file):
+    result = find_matches_in_csv(sample_csv_file, "New York")
+    assert len(result) == 2
+    assert result[0]["match"] == "New York"
+    assert result[0]["coords"] == (0, 2)
+    assert result[1]["match"] == "New York"
+    assert result[1]["coords"] == (2, 2)
+
+
+def test_find_matches_in_csv_key_not_found(sample_csv_file):
+    result = find_matches_in_csv(sample_csv_file, "Chicago")
+    assert len(result) == 0
+
+
+def test_find_matches_in_csv_with_ignore_case(sample_csv_file):
+    result = find_matches_in_csv(sample_csv_file, "new york", ignore_case=True)
+    assert len(result) == 2
+    assert result[0]["match"] == "New York"
+    assert result[1]["match"] == "New York"
+
+
+def test_find_matches_in_csv_ignore_whitespace(tmp_path):
+    file_content = """name,age,city
+John,30,  New York
+Alice,25,  Los Angeles
+Bob,35,New  York"""
+    file_path = tmp_path / "sample_with_whitespace.csv"
+    with open(file_path, "w", encoding="utf-8") as f:
+        f.write(file_content)
+
+    result = find_matches_in_csv(file_path, "New York", ignore_whitespace=True)
+    assert len(result) == 2
+    assert result[0]["coords"] == (0, 2)
+    assert result[1]["coords"] == (2, 2)
+
+
+def test_find_matches_in_csv_correct_neighbor_data(sample_csv_file):
+    result = find_matches_in_csv(sample_csv_file, "Alice")
+    assert len(result) == 1
+    assert result[0]["coords"] == (1, 0)
+    assert result[0]["data"] == {"col_1": "25", "col_2": "Los Angeles"}

{csvsmith-0.6.0 → csvsmith-0.7.0}/tests/test_move_files.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from csvsmith.move_files import move_by_suffix, normalize_suffixes
+from csvsmith.tools.move_files import move_by_suffix, normalize_suffixes
 
 
 def test_normalize_suffixes_adds_leading_dot_and_lowercases() -> None:

csvsmith-0.7.0/tests/test_normalize.py

@@ -0,0 +1,53 @@
+# File: tests/test_normalize.py
+
+from src.csvsmith.utils.normalize import normalize
+
+
+def test_normalize_with_spaces():
+    result = normalize("  hello  world   ")
+    assert result == "helloworld"
+
+
+def test_normalize_with_case_insensitivity():
+    result = normalize("HeLLo WoRLD")
+    assert result == "helloworld"
+
+
+def test_normalize_with_nfkc():
+    result = normalize("ｈｅｌｌｏ　ｗｏｒｌｄ", nfkc=True)
+    assert result == "helloworld"
+
+
+def test_normalize_without_nfkc():
+    result = normalize("ｈｅｌｌｏ　ｗｏｒｌｄ", nfkc=False)
+    assert result == "ｈｅｌｌｏｗｏｒｌｄ"  # Full-width characters remain unchanged
+
+
+def test_normalize_empty_string():
+    result = normalize("")
+    assert result == ""
+
+
+def test_normalize_none():
+    result = normalize(None)
+    assert result == ""
+
+
+def test_normalize_spaces_only():
+    result = normalize("     ")
+    assert result == ""
+
+
+def test_normalize_numbers():
+    result = normalize(12345)
+    assert result == "12345"
+
+
+def test_normalize_ignore_whitespace_false():
+    result = normalize("   hello   world   ", ignore_whitespace=False)
+    assert result == "hello   world"
+
+
+def test_normalize_ignore_case_false():
+    result = normalize("HeLLo WoRLD", ignore_case=False)
+    assert result == "HeLLoWoRLD"

{csvsmith-0.6.0 → csvsmith-0.7.0}/tests/test_row_dedup.py

@@ -1,9 +1,13 @@
-from csvsmith.row_dedup import (
-    count_duplicates_sorted,
+from csvsmith.tools.row_dedup import (
     add_row_digest,
     find_duplicate_rows,
     dedupe_with_report,
 )
+from csvsmith.utils.io import (
+    count_duplicates_sorted,
+    read_csv_rows,
+    write_csv_rows,
+)
 
 
 # -------------------------------------------------------------------

{csvsmith-0.6.0 → csvsmith-0.7.0}/tests/test_string_distance.py

@@ -1,4 +1,4 @@
-from csvsmith.string_distance import StringDistance, Relation
+from csvsmith.utils.distance import StringDistance, Relation
 
 def test_exact_match():
     res = StringDistance.analyze("hello", "hello")

csvsmith-0.6.0/src/csvsmith.egg-info/SOURCES.txt

@@ -1,26 +0,0 @@
-LICENSE
-README.rst
-pyproject.toml
-src/csvsmith/__init__.py
-src/csvsmith/classify.py
-src/csvsmith/clean_numeric.py
-src/csvsmith/cli.py
-src/csvsmith/excel2csv.py
-src/csvsmith/filter_rows.py
-src/csvsmith/move_files.py
-src/csvsmith/row_dedup.py
-src/csvsmith/string_distance.py
-src/csvsmith.egg-info/PKG-INFO
-src/csvsmith.egg-info/SOURCES.txt
-src/csvsmith.egg-info/dependency_links.txt
-src/csvsmith.egg-info/entry_points.txt
-src/csvsmith.egg-info/requires.txt
-src/csvsmith.egg-info/top_level.txt
-tests/test_classify.py
-tests/test_clean_numeric.py
-tests/test_cli.py
-tests/test_excel2csv.py
-tests/test_filter_rows.py
-tests/test_move_files.py
-tests/test_row_dedup.py
-tests/test_string_distance.py