dtypeflow 1.0.0__py3-none-any.whl

dtypeflow/tui/app.tcss

@@ -0,0 +1,220 @@
+Screen {
+    align: center top;
+}
+
+.hero {
+    align: center middle;
+    height: auto;
+    padding: 2 4;
+}
+
+.app-title {
+    text-style: bold;
+    color: $accent;
+    width: auto;
+    content-align: center middle;
+}
+
+.app-subtitle {
+    color: $text-muted;
+    width: auto;
+    content-align: center middle;
+    margin-bottom: 1;
+}
+
+.panel {
+    width: 100%;
+    max-width: 90;
+    height: auto;
+    border: round $panel-lighten-2;
+    padding: 1 2;
+    margin: 1 0;
+    background: $panel;
+}
+
+.field-row {
+    height: auto;
+    width: 100%;
+    align: center middle;
+}
+
+.field-row Input {
+    width: 1fr;
+    margin-right: 1;
+}
+
+.primary-action {
+    width: 100%;
+    margin-top: 1;
+}
+
+.status {
+    color: $warning;
+    height: auto;
+    margin-top: 1;
+}
+
+.status.-ok {
+    color: $success;
+}
+
+.status.-error {
+    color: $error;
+}
+
+#pick-file-screen {
+    align: center middle;
+}
+
+#configure-header {
+    width: 100%;
+    height: auto;
+    padding: 0 2;
+    margin-bottom: 1;
+    border-bottom: solid $panel-lighten-2;
+}
+
+#configure-columns {
+    width: 100%;
+    height: 1fr;
+    padding: 1 2;
+}
+
+ColumnPanel {
+    height: auto;
+    width: 100%;
+    padding: 0 1;
+}
+
+ColumnPanel .column-stats {
+    height: auto;
+    color: $text-muted;
+    margin-bottom: 1;
+}
+
+ColumnPanel .column-title {
+    color: $primary;
+    text-style: bold;
+    margin-bottom: 1;
+}
+
+ColumnPanel .column-recommended {
+    color: $text-muted;
+    text-style: bold;
+    margin-bottom: 1;
+}
+
+ColumnPanel #dtype-tabs {
+    margin-bottom: 1;
+}
+
+ColumnPanel .dtype-description {
+    color: $text-muted;
+    margin: 1 0;
+}
+
+ColumnPanel #dtype-options {
+    height: auto;
+    max-height: 16;
+    border: round $panel-lighten-2;
+}
+
+ColumnPanel RadioSet {
+    height: auto;
+    border: none;
+    background: transparent;
+    margin: 1 0;
+}
+
+ColumnPanel .boolean-caption {
+    margin-top: 1;
+    color: $text-muted;
+}
+
+.dictionary-box {
+    height: auto;
+    width: 100%;
+    margin-top: 1;
+    border: round $panel-lighten-2;
+    padding: 1;
+}
+
+CategoryOrderPicker {
+    height: auto;
+    width: 100%;
+}
+
+CategoryOrderPicker OptionList {
+    height: auto;
+    max-height: 12;
+    border: round $panel-lighten-2;
+}
+
+CategoryOrderPicker .reorder-buttons {
+    height: auto;
+    width: 100%;
+    align: center middle;
+    margin-top: 1;
+}
+
+CategoryOrderPicker .reorder-buttons Button {
+    margin: 0 1;
+}
+
+#configure-footer {
+    height: auto;
+    width: 100%;
+    padding: 1 2;
+    border-top: solid $panel-lighten-2;
+}
+
+#configure-footer-nav {
+    height: auto;
+    width: 100%;
+    align: left middle;
+}
+
+.footer-counter {
+    width: 1fr;
+    content-align: center middle;
+    color: $text-muted;
+}
+
+#configure-footer-nav Button {
+    width: auto;
+}
+
+#export-result {
+    height: 1fr;
+    margin-top: 1;
+}
+
+.browse-modal {
+    align: center middle;
+}
+
+.browse-dialog {
+    width: 80%;
+    height: 80%;
+    max-width: 100;
+    border: thick $primary;
+    background: $surface;
+    padding: 1 2;
+}
+
+.browse-dialog DirectoryTree {
+    height: 1fr;
+    border: round $panel-lighten-2;
+    margin: 1 0;
+}
+
+.browse-buttons {
+    height: auto;
+    width: 100%;
+    align: right middle;
+    margin-top: 1;
+}
+
+.browse-buttons Button {
+    margin-left: 1;
+}

dtypeflow/tui/compatibility.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Final
+
+from dtypeflow.core.candidate import Compatibility
+
+GROUP_SAFE: Final[str] = "Safe"
+GROUP_TOO_SMALL: Final[str] = "Too small"
+GROUP_DISCOURAGED: Final[str] = "Discouraged"
+GROUP_INCOMPATIBLE: Final[str] = "Incompatible"
+GROUP_ORDER: Final[tuple[str, ...]] = (
+    GROUP_SAFE,
+    GROUP_TOO_SMALL,
+    GROUP_DISCOURAGED,
+    GROUP_INCOMPATIBLE,
+)
+_GROUP_BY_COMPATIBILITY: Final[dict[Compatibility, str]] = {
+    Compatibility.FULL_RANGE_FIT: GROUP_SAFE,
+    Compatibility.VALUES_PRESERVED: GROUP_SAFE,
+    Compatibility.OBSERVED_ONLY_FIT: GROUP_SAFE,
+    Compatibility.BOOLEAN_MAPPING: GROUP_SAFE,
+    Compatibility.DICTIONARY_ENCODING: GROUP_SAFE,
+    Compatibility.RANGE_NO_FIT: GROUP_TOO_SMALL,
+    Compatibility.UNEVALUATED_NO_FIT: GROUP_TOO_SMALL,
+    Compatibility.PRECISION_REDUCTION: GROUP_DISCOURAGED,
+    Compatibility.DECIMAL_TRUNCATION: GROUP_DISCOURAGED,
+    Compatibility.DICTIONARY_INEFFICIENT: GROUP_DISCOURAGED,
+    Compatibility.VALUES_NO_FIT: GROUP_INCOMPATIBLE,
+    Compatibility.NOT_NUMERIC: GROUP_INCOMPATIBLE,
+}
+
+
+def group_of(compatibility: Compatibility, /) -> str:
+    return _GROUP_BY_COMPATIBILITY[compatibility]
+
+
+def is_selectable(compatibility: Compatibility, /) -> bool:
+    return group_of(compatibility) != GROUP_INCOMPATIBLE

dtypeflow/tui/dto.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class DtypeOption:
+    name: str
+    label: str
+    description: str
+    group: str
+
+
+@dataclass(frozen=True)
+class ColumnReport:
+    name: str
+    inferred_dtype: str
+    description: str
+    num_unique: int
+    total: int
+    samples: tuple[str, ...]
+    stats: tuple[tuple[str, str], ...]
+    options: tuple[DtypeOption, ...]
+
+
+@dataclass(frozen=True)
+class DatasetReport:
+    source: str
+    columns: tuple[ColumnReport, ...]
+
+
+@dataclass(frozen=True)
+class ColumnSelection:
+    dtype_name: str
+    true_value: str | None = None
+    false_value: str | None = None
+    ordered: bool = False
+    categories: tuple[str, ...] | None = None
+
+
+@dataclass
+class LoadedDataset:
+    report: DatasetReport
+    dataset_ref: object = field(repr=False)

dtypeflow/tui/service.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+from decimal import Decimal
+from pathlib import Path
+from typing import TYPE_CHECKING, Final, cast
+
+import pyarrow.parquet as pq
+
+from dtypeflow import profile as profile_dataset
+from dtypeflow.core.dtype import (
+    ALL_TYPES,
+    BooleanDtype,
+    DictionaryDtype,
+    Dtype,
+    Float16Dtype,
+    Float32Dtype,
+    Float64Dtype,
+    FloatDtype,
+    Int8Dtype,
+    Int16Dtype,
+    Int32Dtype,
+    Int64Dtype,
+    IntegerDtype,
+    StringDtype,
+    UInt8Dtype,
+    UInt16Dtype,
+    UInt32Dtype,
+    UInt64Dtype,
+)
+from dtypeflow.core.override import (
+    BooleanOverride,
+    DictionaryOverride,
+    Float16Override,
+    Float32Override,
+    Float64Override,
+    Int8Override,
+    Int16Override,
+    Int32Override,
+    Int64Override,
+    Override,
+    StringOverride,
+    UInt8Override,
+    UInt16Override,
+    UInt32Override,
+    UInt64Override,
+)
+from dtypeflow.core.schema import Schema
+
+from .compatibility import GROUP_SAFE, group_of, is_selectable
+from .dto import (
+    ColumnReport,
+    ColumnSelection,
+    DatasetReport,
+    DtypeOption,
+    LoadedDataset,
+)
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+    from dtypeflow.core.dataset import Dataset
+    from dtypeflow.core.profile import Profile
+_DTYPE_BY_NAME: Final[dict[str, type[Dtype]]] = {
+    dtype.__name__: dtype for dtype in ALL_TYPES
+}
+_OVERRIDE_BY_DTYPE: Final[dict[type[Dtype], type[Override]]] = {
+    BooleanDtype: BooleanOverride,
+    UInt8Dtype: UInt8Override,
+    UInt16Dtype: UInt16Override,
+    UInt32Dtype: UInt32Override,
+    UInt64Dtype: UInt64Override,
+    Int8Dtype: Int8Override,
+    Int16Dtype: Int16Override,
+    Int32Dtype: Int32Override,
+    Int64Dtype: Int64Override,
+    Float16Dtype: Float16Override,
+    Float32Dtype: Float32Override,
+    Float64Dtype: Float64Override,
+    StringDtype: StringOverride,
+    DictionaryDtype: DictionaryOverride,
+}
+DESCRIPTIONS: Final[dict[type[Dtype], str]] = {
+    BooleanDtype: f"{BooleanDtype.TRUE} or {BooleanDtype.FALSE}",
+    UInt8Dtype: f"Whole non-negative number, {UInt8Dtype.LOWER_BOUND:,} to {UInt8Dtype.HIGHER_BOUND:,}",
+    UInt16Dtype: f"Whole non-negative number, {UInt16Dtype.LOWER_BOUND:,} to {UInt16Dtype.HIGHER_BOUND:,}",
+    UInt32Dtype: f"Whole non-negative number, {UInt32Dtype.LOWER_BOUND:,} to {float(UInt32Dtype.HIGHER_BOUND):.1E}",
+    UInt64Dtype: f"Whole non-negative number, {UInt64Dtype.LOWER_BOUND:,} to {float(UInt64Dtype.HIGHER_BOUND):.1E}",
+    Int8Dtype: f"Whole number, {Int8Dtype.LOWER_BOUND:,} to {Int8Dtype.HIGHER_BOUND:,}",
+    Int16Dtype: f"Whole number, {Int16Dtype.LOWER_BOUND:,} to {Int16Dtype.HIGHER_BOUND:,}",
+    Int32Dtype: f"Whole number, {float(Int32Dtype.LOWER_BOUND):.1E} to {float(Int32Dtype.HIGHER_BOUND):.1E}",
+    Int64Dtype: f"Whole number, {float(Int64Dtype.LOWER_BOUND):.1E} to {float(Int64Dtype.HIGHER_BOUND):.1E}",
+    Float16Dtype: f"Decimal number, about {Float16Dtype.MAX_SIGNIFICANT_DIGITS} digits of precision, up to {Float16Dtype.MAX_ABSOLUTE_VALUE:.1E}",
+    Float32Dtype: f"Decimal number, about {Float32Dtype.MAX_SIGNIFICANT_DIGITS} digits of precision, up to {Float32Dtype.MAX_ABSOLUTE_VALUE:.1E}",
+    Float64Dtype: f"Decimal number, about {Float64Dtype.MAX_SIGNIFICANT_DIGITS} digits of precision, up to {Float64Dtype.MAX_ABSOLUTE_VALUE:.1E}",
+    StringDtype: "Text",
+    DictionaryDtype: "Category, a fixed set of repeating values",
+}
+
+
+def _label(dtype: type[Dtype], /) -> str:
+    return dtype.__name__.removesuffix("Dtype")
+
+
+def _dtype_option(dtype: type[Dtype], group: str, /) -> DtypeOption:
+    return DtypeOption(
+        name=dtype.__name__,
+        label=_label(dtype),
+        description=DESCRIPTIONS[dtype],
+        group=group,
+    )
+
+
+def _format_sample(dtype: type[Dtype], value: str, /) -> str:
+    if issubclass(dtype, IntegerDtype):
+        return f"{int(value):,}"
+    if issubclass(dtype, FloatDtype):
+        return f"{Decimal(value):,}"
+    return value
+
+
+def _stats(dtype: type[Dtype], profile: Profile, /) -> tuple[tuple[str, str], ...]:
+    samples = ", ".join(
+        _format_sample(dtype, value) for value in profile.uniques(n=5)
+    )
+    stats: list[tuple[str, str]] = [
+        ("Unique values", f"{profile.num_unique:,}"),
+        ("Samples", samples),
+    ]
+    if issubclass(dtype, (FloatDtype, IntegerDtype)):
+        stats.append(("Range", f"{profile.min:,} – {profile.max:,}"))
+        if issubclass(dtype, FloatDtype):
+            stats.append(("Precision", str(profile.precision)))
+            stats.append(("Scale", str(profile.scale)))
+    elif issubclass(dtype, StringDtype):
+        stats.append(
+            ("Length range", f"{profile.min_length:,} – {profile.max_length:,}"),
+        )
+    return tuple(stats)
+
+
+def _column_report(column: str, profile: Profile, /) -> ColumnReport:
+    dtype: type[Dtype] = type(profile).DTYPE
+    options: list[DtypeOption] = [_dtype_option(dtype, GROUP_SAFE)]
+    options.extend(
+
+            _dtype_option(candidate.DTYPE, group_of(candidate.compatibility))
+            for candidate in profile.candidates
+            if is_selectable(candidate.compatibility)
+
+    )
+    return ColumnReport(
+        name=column,
+        inferred_dtype=dtype.__name__,
+        description=DESCRIPTIONS[dtype],
+        num_unique=profile.num_unique,
+        total=profile.total,
+        samples=profile.uniques(n=5),
+        stats=_stats(dtype, profile),
+        options=tuple(options),
+    )
+
+
+def _build_override(column: str, selection: ColumnSelection, /) -> Override:
+    dtype: type[Dtype] = _DTYPE_BY_NAME[selection.dtype_name]
+    override_cls: type[Override] = _OVERRIDE_BY_DTYPE[dtype]
+    if dtype is BooleanDtype:
+        if selection.true_value is None or selection.false_value is None:
+            msg = f"Column {column!r} needs both a true and a false value to become Boolean."
+            raise ValueError(msg)
+        return BooleanOverride(
+            column, true_value=selection.true_value, false_value=selection.false_value,
+        )
+    if dtype is DictionaryDtype:
+        if selection.categories is None:
+            msg = f"Column {column!r} needs a category list to become Dictionary."
+            raise ValueError(msg)
+        return DictionaryOverride(
+            column, *selection.categories, ordered=selection.ordered,
+        )
+    return override_cls(column)
+
+
+class DtypeflowService:
+    def load_dataset(self, path: str | Path, /) -> LoadedDataset:
+        dataset: Dataset = profile_dataset(path)
+        columns = tuple(
+            _column_report(column, dataset[column]) for column in dataset.columns
+        )
+        report = DatasetReport(source=str(dataset.source), columns=columns)
+        return LoadedDataset(report=report, dataset_ref=dataset)
+
+    def unique_values(self, loaded: LoadedDataset, column: str, /) -> tuple[str, ...]:
+        dataset = cast("Dataset", loaded.dataset_ref)
+        return dataset[column].uniques()
+
+    def export(
+        self,
+        loaded: LoadedDataset,
+        destination: str | Path,
+        selections: Mapping[str, ColumnSelection],
+        /,
+    ) -> tuple[tuple[str, str], ...]:
+        dataset = cast("Dataset", loaded.dataset_ref)
+        overrides = tuple(
+
+                _build_override(column, selection)
+                for (column, selection) in selections.items()
+
+        )
+        destination = Path(destination)
+        Schema(*overrides).apply(dataset, destination=destination)
+        written = pq.read_table(destination).schema
+        return tuple((field.name, str(field.type)) for field in written)

dtypeflow/utils.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from csv import DictReader
+from pathlib import Path
+
+from dtypeflow.core.table import Table
+
+
+def read_csv(path: str | Path, /, *, delimiter: str = ",", newline: str = "") -> Table:
+    if isinstance(path, str):
+        if not path:
+            msg = "The path to the CSV file cannot be empty."
+            raise ValueError(msg)
+        path: Path = Path(path)
+    if not path.exists():
+        msg = f"The CSV file at path '{path}' does not exist."
+        raise FileNotFoundError(msg)
+    if not path.is_file():
+        msg = f"The path '{path}' is not a valid file."
+        raise ValueError(msg)
+    if path.suffix.lower() != ".csv":
+        msg = f"The file '{path}' is not a CSV file."
+        raise ValueError(msg)
+    with path.open(newline=newline) as file:
+        reader: DictReader[str] = DictReader(file, delimiter=delimiter)
+        rows: list[dict[str, str]] = list(reader)
+        return Table(
+            **{
+                name: tuple(row[name] for row in rows)
+                for name in reader.fieldnames or ()
+            },
+        )

dtypeflow-1.0.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: dtypeflow
+Version: 1.0.0
+Summary: Terminal UI to infer CSV column dtypes and convert CSV to Parquet, locally.
+Keywords: csv,parquet,dtype,tui,textual,arrow
+Author: Pedro José Mora Gallegos
+Author-email: Pedro José Mora Gallegos <developmentbypedrojose@outlook.de>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Utilities
+Classifier: Topic :: Scientific/Engineering
+Requires-Dist: pyarrow>=17.0.0
+Requires-Dist: textual>=0.89.0
+Requires-Python: >=3.11
+Project-URL: Homepage, https://github.com/pedrojosemoragallegos/dtypeflow
+Project-URL: Repository, https://github.com/pedrojosemoragallegos/dtypeflow
+Project-URL: Issues, https://github.com/pedrojosemoragallegos/dtypeflow/issues
+Description-Content-Type: text/markdown
+
+# dtypeflow
+
+`dtypeflow` is a terminal UI to convert a CSV file to Parquet.
+
+Point it at a CSV file, and for each column it infers the tightest-fitting
+dtype (`Boolean`, unsigned/signed integers `UInt8`…`UInt64`/`Int8`…`Int64`,
+floats `Float16`/`Float32`/`Float64`, `String`, or `Dictionary`), shows the
+observed statistics, and lets you review or override the choice before
+writing the result to Parquet — all locally, no data leaves your machine.
+
+## Installation
+
+```bash
+uv tool install dtypeflow
+```
+
+Or with `pipx`:
+
+```bash
+pipx install dtypeflow
+```
+
+Or with `pip`:
+
+```bash
+pip install dtypeflow
+```
+
+## Usage
+
+Launch the picker and choose a CSV file interactively:
+
+```bash
+dtypeflow
+```
+
+Or pass a path directly to skip straight to configuring column types:
+
+```bash
+dtypeflow path/to/data.csv
+```
+
+The workflow has three steps:
+
+1. **Pick a file** — enter or browse for a CSV path.
+2. **Configure types** — for each column, review the recommended dtype, its
+   stats (unique values, samples, range/precision/scale), and pick from
+   compatible alternatives grouped by safety (Safe / Too small / Discouraged).
+3. **Export** — write the configured dataset to a Parquet file.
+
+## Development
+
+This project uses [uv](https://docs.astral.sh/uv/) for dependency management.
+
+```bash
+uv sync
+uv run dtypeflow
+```
+
+Lint:
+
+```bash
+uv run --with ruff ruff check src/
+```
+
+## License
+
+[MIT](LICENSE)

dtypeflow-1.0.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+dtypeflow/__init__.py,sha256=42mpdAvj8VsnaMJYL6O8zTWiwokd80lEQ7LWJENCHaw,114
+dtypeflow/core/__init__.py,sha256=U4S_2y3zgLZVfMenHRaJFBW8yqh2mUBuI291LGQVOJ8,35
+dtypeflow/core/candidate/__init__.py,sha256=g7tif4In9KVcvMgeVX_lsoGD3xgM8wtR899gnIu0s2k,996
+dtypeflow/core/candidate/base.py,sha256=jOUkmGwtUPLo_gi-z_lIX_MHvpNqq__YVcV64-TjZnY,972
+dtypeflow/core/candidate/factory.py,sha256=zatB4ve4fVT_o7SW3FmqoMMg4Q08FYD4TrswAzXFl6k,7672
+dtypeflow/core/candidate/primitive.py,sha256=MbPVpyt32OL8DxNVnkLkipW97nHgAwBEhiD7G39u9HI,1377
+dtypeflow/core/dataset.py,sha256=X1PQWRXsyvYuaaVN0iLAb2ffhWSs_a2_WTIOBPfRAmI,1356
+dtypeflow/core/dtype/__init__.py,sha256=NKrfx0kFygJnewD9eMcOdtevKpjD98oEdkmUEa73yRw,1642
+dtypeflow/core/dtype/base.py,sha256=EYcwO5oE2w6E-UCReHczgGmpbCUqYSsRgggdzmXXSJA,255
+dtypeflow/core/dtype/hierachy.md,sha256=Nqpky_L6GdWRNW4fO_pfKaAPfW03eFNtStRK-YwJcD8,2040
+dtypeflow/core/dtype/nested/__init__.py,sha256=hLj8pD6YuGT29_Q1CeFLcTa4SqQKOqI8OG0cRg7axG0,132
+dtypeflow/core/dtype/nested/dictionary.py,sha256=njg9lRN4Pw2Br2yOY04Qas0YJqLe35zk1j7dpdFDn9Y,271
+dtypeflow/core/dtype/primitive/__init__.py,sha256=AvFuCtdt5slYOugbSiucL3aCXrRkSZ_ZhjP_Y4U2qFU,740
+dtypeflow/core/dtype/primitive/base.py,sha256=GqhcoqMKnD9KAW9NrmfjeUdPJD62N2X09HerdXXzw0Y,110
+dtypeflow/core/dtype/primitive/boolean.py,sha256=8RiEDwSyZ42IIHzf5wpaYKxImCkVMgi2JhcMNd_HOtw,432
+dtypeflow/core/dtype/primitive/float.py,sha256=f7f5_VLLSA2fcLD7pfeFa_W-8TngFnGYJuPoMbgbseU,991
+dtypeflow/core/dtype/primitive/integer/__init__.py,sha256=54bdf3_PpdLz9gpm6abmxbXNK2N_DGlWlu1UtUK5-tI,622
+dtypeflow/core/dtype/primitive/integer/base.py,sha256=pGCngH5O4CdBqTFLZYRxKi2fsMVgl0ZvUJnLsFutufc,445
+dtypeflow/core/dtype/primitive/integer/signed.py,sha256=pnNMITMMw-YsORGqSEMGBA3kLTLyPVLOpY9kzIOn76k,768
+dtypeflow/core/dtype/primitive/integer/unsigned.py,sha256=ks0o2Prmq2M3dzWB5Sell_oVTqou8R-lG7Z2ZH7zICw,746
+dtypeflow/core/dtype/primitive/string.py,sha256=tqz8np4VfjKZJqJAHdKYzAZke-3h4YpYONi-Z9ul9AM,255
+dtypeflow/core/override/__init__.py,sha256=TFfzxo_ZNBVFUgiWVe5xRFia7YMLYGQ6dOCqSCYl-p0,970
+dtypeflow/core/override/base.py,sha256=ALzi2yTvqlFQ56-hikd1bD289qn7XN5EFiu1uvHkIIs,507
+dtypeflow/core/override/primitive.py,sha256=9bCP7fXKkmZBY3dDCxrWy1ny-LMMCSuXSXRurl33C2c,5712
+dtypeflow/core/profile/__init__.py,sha256=JqyT6sqFWLnh3fBWfcm1tQjhHT8fQQnlhuTbHkHU3-8,874
+dtypeflow/core/profile/base.py,sha256=qtRfKMqm65JoQR9qufekxesc2Sw_7T8ptfcj-B-_M2U,1489
+dtypeflow/core/profile/primitive.py,sha256=YWap_IB5w2AOQrZ3NvXiSr75JwSB2UdSaj2i-RTAsTc,4130
+dtypeflow/core/profiler.py,sha256=EI3qrR3I5UV-jLJT_Xv8fEFh5G_FPdzpvdhXMYs62vc,5123
+dtypeflow/core/schema.py,sha256=CMfyZbaaLsSITYRRdmYuefaFk_Xj-VxB6oXZ-xQWeC4,1173
+dtypeflow/core/table.py,sha256=07cJKLYz2USEgHqo1o4LN6QwL0MsWtHGnkBbYHhjnLE,833
+dtypeflow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dtypeflow/tui/__init__.py,sha256=fVjm0bBy49pMsLreE2h9NUIPA3l5gr3Nw4S3JdfTLX4,469
+dtypeflow/tui/app.py,sha256=8Lic3uG69phm1tjJugjTCTOpCKQwbmhCAYw1ZMIVKXs,26952
+dtypeflow/tui/app.tcss,sha256=zGCT_-OyzEpAcLwS50gTpc5FGVqeKvvEyr6VPH7xNN4,3216
+dtypeflow/tui/compatibility.py,sha256=t2x3h1uISJq35HfoBZZJnzpME5du9tA-7glap22EvrU,1321
+dtypeflow/tui/dto.py,sha256=eU9pgRkDIC9va6h0q3iSDy3YpwF3sSCv3K5oj_bsMxE,847
+dtypeflow/tui/service.py,sha256=4hlAWNiIMkwkuQ2x-85n6HMUC_GbfwIFL3HVpC7KOwU,7536
+dtypeflow/utils.py,sha256=rBHJy1hMEKGDr08vsQo91PIW8xNf4LAU0LtxHtLcUL4,1095
+dtypeflow-1.0.0.dist-info/licenses/LICENSE,sha256=tr5T8mamK1bEK0fgZrIlLs2qbJDJmL-_zTZ7HpiPvVA,1082
+dtypeflow-1.0.0.dist-info/WHEEL,sha256=mru_b36sH6joUMnwf7IlFCun3RoDjrNg9RcfBmEcqsE,81
+dtypeflow-1.0.0.dist-info/entry_points.txt,sha256=HoEXQsH0UUf7ReHGhDcWliO1uX7VzblTGQoIlk5cOCg,49
+dtypeflow-1.0.0.dist-info/METADATA,sha256=cSNYfEZHgEnuDeFAZjfY8-YgXpkwNj35yO9FztcZVAM,2453
+dtypeflow-1.0.0.dist-info/RECORD,,

dtypeflow-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.11
+Root-Is-Purelib: true
+Tag: py3-none-any

dtypeflow-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+dtypeflow = dtypeflow.tui:run
+