blink-data-lint 0.1.0__py3-none-any.whl

blink_data_lint/__init__.py

@@ -0,0 +1 @@
+"""blink: diagnóstico de datos tabulares desde la terminal."""

blink_data_lint/cli.py

@@ -0,0 +1,105 @@
+"""Entrada de terminal y coordinación; sin reglas de análisis."""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from polars.exceptions import PolarsError
+from rich.console import Console
+from rich.text import Text
+
+from blink_data_lint.core.analyzer import analyze
+from blink_data_lint.core.comparison import compare
+from blink_data_lint.core.summary import summarize
+from blink_data_lint.io.loader import LoadError, load_dataset
+from blink_data_lint.io.serializer import serialize_error, serialize_report
+from blink_data_lint.ui.reporter import show_comparison, show_report
+
+app = typer.Typer(
+    help="blink: diagnóstico rápido de calidad de datos CSV y Parquet, de solo lectura.",
+    add_completion=False,
+    no_args_is_help=True,
+    pretty_exceptions_enable=False,
+)
+
+
+@app.command()
+def main(
+    file: Annotated[
+        Path,
+        typer.Argument(
+            metavar="FILE",
+            help="Ruta de un archivo CSV o Parquet local.",
+        ),
+    ],
+    ml: Annotated[bool, typer.Option("--ml", help="Ejecutar IsolationForest con muestra acotada y semilla fija.")] = False,
+    baseline: Annotated[
+        Path | None,
+        typer.Option(
+            "--baseline",
+            metavar="FILE", help="Comparar columnas, tipos y distribuciones con un CSV o Parquet anterior.",
+        ),
+    ] = None,
+    json_output: Annotated[bool, typer.Option("--json", help="Emitir JSON para programas, sin tablas ni color.")] = False,
+    exit_code: Annotated[bool, typer.Option("--exit-code", help="Devolver código 1 si hay avisos; útil en CI.")] = False,
+) -> None:
+    """Inspecciona salud, outliers IQR y posibles tipos rotos; --ml habilita IsolationForest."""
+    sources = {
+        "current": {"path": str(file), "format": None, "policy": None},
+        "baseline": {"path": str(baseline), "format": None, "policy": None} if baseline is not None else None,
+    }
+    stage = "current"
+    try:
+        dataset = load_dataset(file)
+        sources["current"].update(format=dataset.format, policy=dataset.policy)
+        stage = "baseline"
+        previous = load_dataset(baseline) if baseline is not None else None
+        if previous is not None:
+            sources["baseline"].update(format=previous.format, policy=previous.policy)
+        stage = "analysis"
+        report = analyze(dataset.frame, ml=ml)
+        comparison = compare(dataset.frame, previous.frame) if previous is not None else None
+    except LoadError as exc:
+        reading = "baseline" if stage == "baseline" else "archivo actual"
+        message = f"Error al leer el {reading}: {exc}"
+        _show_error(message, sources=sources, code="read_error", stage=stage, json_output=json_output)
+        raise typer.Exit(2) from exc
+    except PolarsError as exc:
+        message = (
+            f"Error: no se pudo analizar este esquema ({type(exc).__name__}). "
+            "Puede contener tipos anidados no soportados."
+        )
+        _show_error(message, sources=sources, code="analysis_error", stage=stage, json_output=json_output)
+        raise typer.Exit(2) from exc
+    except (ValueError, OverflowError) as exc:
+        message = f"Error: no se pudo completar el análisis numérico ({type(exc).__name__})."
+        _show_error(message, sources=sources, code="analysis_error", stage=stage, json_output=json_output)
+        raise typer.Exit(2) from exc
+    summary = summarize(report, comparison)
+    result_code = 1 if exit_code and summary.warnings else 0
+    if json_output:
+        try:
+            document = serialize_report(report, comparison, summary, sources=sources, exit_code=result_code)
+        except ValueError as exc:
+            _show_error("Error: el informe contiene métricas no representables en JSON.", sources=sources,
+                        code="serialization_error", stage="serialization", json_output=True)
+            raise typer.Exit(2) from exc
+        typer.echo(document)
+    else:
+        show_report(report, file, format=dataset.format, policy=dataset.policy)
+        if comparison is not None and baseline is not None:
+            show_comparison(comparison, baseline)
+    if result_code:
+        raise typer.Exit(result_code)
+
+
+def _show_error(message: str, *, sources: dict, code: str, stage: str, json_output: bool) -> None:
+    if json_output:
+        typer.echo(serialize_error(sources=sources, code=code, stage=stage, message=message))
+        typer.echo(message, err=True)
+    else:
+        Console(stderr=True).print(Text(message, style="red"))
+
+
+if __name__ == "__main__":
+    app()

blink_data_lint/core/__init__.py

@@ -0,0 +1 @@
+"""Lógica de inspección, independiente de la CLI y la presentación."""

blink_data_lint/core/analyzer.py

@@ -0,0 +1,98 @@
+"""Métricas exactas de salud y composición de detectores; sin I/O ni UI."""
+
+import polars as pl
+
+from blink_data_lint.core.models import AnalysisReport, ColumnMetrics, Finding
+from blink_data_lint.core.detectors import detect
+from blink_data_lint.core.duplicates import excess_duplicates
+from blink_data_lint.core.roles import code_like
+
+ID_MIN_VALUES = 10
+ID_UNIQUE_RATIO = 0.95
+
+
+def _percent(count: int, total: int) -> float | None:
+    return count * 100 / total if total else None
+
+
+def analyze(frame: pl.DataFrame, *, ml: bool = False) -> AnalysisReport:
+    rows, width = frame.shape
+    findings: list[Finding] = []
+    columns: list[ColumnMetrics] = []
+    if not rows or not width:
+        findings.append(Finding("empty_dataset", "warning", "Dataset sin datos para evaluar."))
+
+    # Una sola agregación columnar; no materializa filas en Python.
+    expressions = []
+    for index, (name, dtype) in enumerate(frame.schema.items()):
+        column = pl.col(name)
+        observed = column.drop_nulls()
+        nan = column.is_nan().sum() if dtype.is_float() else pl.lit(0)
+        if dtype.is_float():
+            observed = observed.filter(~observed.is_nan())
+        expressions.extend([
+            column.null_count().alias(f"null_{index}"),
+            nan.alias(f"nan_{index}"),
+            observed.n_unique().alias(f"unique_{index}"),
+        ])
+        if dtype == pl.String:
+            text = observed.filter(observed != "")
+            expressions.extend([
+                text.len().alias(f"text_{index}"),
+                text.n_unique().alias(f"text_unique_{index}"),
+            ])
+    stats = frame.select(expressions).row(0, named=True) if width else {}
+
+    for index, (name, dtype) in enumerate(frame.schema.items()):
+        nulls = stats[f"null_{index}"]
+        nans = stats[f"nan_{index}"]
+        distinct = stats[f"unique_{index}"]
+        all_null = rows > 0 and nulls == rows
+        constant = distinct == 1
+        text_count = stats.get(f"text_{index}", 0)
+        text_unique = stats.get(f"text_unique_{index}", 0)
+        possible_id = (
+            text_count >= ID_MIN_VALUES and text_unique / text_count >= ID_UNIQUE_RATIO
+        )
+        columns.append(ColumnMetrics(
+            name, str(dtype), nulls, _percent(nulls, rows), nans,
+            distinct, constant, all_null, possible_id,
+        ))
+        if nulls:
+            findings.append(Finding(
+                "all_null" if all_null else "nulls", "warning",
+                f"{nulls:,} nulos ({nulls / rows:.1%}).", name,
+            ))
+        if nans:
+            findings.append(Finding("nan", "warning", f"{nans:,} valores NaN (no son null).", name))
+        if constant:
+            findings.append(Finding(
+                "constant", "warning", "Un único valor observado; columna constante.", name,
+            ))
+        if possible_id:
+            findings.append(Finding(
+                "possible_id", "info",
+                f"Posible ID: {text_unique:,}/{text_count:,} textos no vacíos únicos "
+                f"({text_unique / text_count:.1%}).", name,
+            ))
+        elif code_like(name):
+            findings.append(Finding(
+                "possible_code", "info",
+                "Posible código/identificador por nombre; no se trata como medida numérica.", name,
+            ))
+
+    duplicates = excess_duplicates(frame)
+    if duplicates:
+        findings.append(Finding(
+            "duplicates", "warning",
+            f"{duplicates:,} filas duplicadas excedentes ({duplicates / rows:.1%}).",
+        ))
+    null_count = sum(column.null_count for column in columns)
+    detectors, detected_findings = detect(frame, ml=ml)
+    findings.extend(detected_findings)
+    return AnalysisReport(
+        rows, tuple(columns), null_count, _percent(null_count, rows * width),
+        sum(column.nan_count for column in columns), duplicates,
+        _percent(duplicates, rows), tuple(findings),
+        detectors=detectors,
+    )

blink_data_lint/core/comparison.py

@@ -0,0 +1,25 @@
+"""Comparación de esquemas y agregados; sin lectura ni presentación."""
+
+import polars as pl
+
+from blink_data_lint.core.models import ComparisonReport, SchemaChange
+from blink_data_lint.core.drift import detect_drift
+
+
+def compare(current: pl.DataFrame, baseline: pl.DataFrame) -> ComparisonReport:
+    changes = []
+    previous_schema = baseline.schema
+    current_schema = current.schema
+    # Conservar el orden de las columnas, sin convertir tipos ni adivinar renombres.
+    for name, dtype in current_schema.items():
+        if name not in previous_schema:
+            changes.append(SchemaChange(name, "added", None, str(dtype)))
+        elif dtype != previous_schema[name]:
+            changes.append(SchemaChange(name, "type_changed", str(previous_schema[name]), str(dtype)))
+    for name, dtype in previous_schema.items():
+        if name not in current_schema:
+            changes.append(SchemaChange(name, "removed", str(dtype), None))
+    return ComparisonReport(
+        baseline.height, current.height, baseline.width, current.width, tuple(changes),
+        detect_drift(current, baseline),
+    )

blink_data_lint/core/detectors.py

@@ -0,0 +1,143 @@
+"""Detectores de solo lectura; cobertura y omisiones explícitas."""
+
+import math
+
+import polars as pl
+
+from blink_data_lint.core.models import DetectorResult, Finding
+from blink_data_lint.core.roles import code_like
+
+MIN_VALUES = 10
+TYPE_RATIO = 0.9
+ML_ROWS = 10_000
+ML_COLUMNS = 32
+SEED = 42
+
+
+def numeric_outliers(series: pl.Series) -> DetectorResult:
+    values = series.drop_nulls()
+    values = values.filter(values.is_finite())
+    base = dict(method="IQR", columns=(series.name,), total_rows=len(series),
+                eligible_rows=len(values), evaluated_rows=0, count=None)
+    if len(values) < MIN_VALUES:
+        return DetectorResult(**base, reason="Menos de 10 valores finitos.")
+    if code_like(series.name):
+        return DetectorResult(**base, reason="Posible ID/código por nombre; no se aplica IQR a etiquetas.")
+    # Escalado evita overflow al restar extremos finitos; las comparaciones
+    # conservan el criterio IQR. Las cotas publicadas usan la escala original.
+    scale = max(abs(values.min()), abs(values.max())) or 1
+    normalized = values.cast(pl.Float64) / scale
+    q1 = normalized.quantile(0.25, interpolation="linear")
+    q3 = normalized.quantile(0.75, interpolation="linear")
+    spread = q3 - q1
+    if spread == 0:
+        return DetectorResult(**base, reason="IQR cero; no se divide ni se infieren outliers.")
+    low, high = q1 - 1.5 * spread, q3 + 1.5 * spread
+    lower, upper = low * scale, high * scale
+    if not math.isfinite(lower) or not math.isfinite(upper):
+        return DetectorResult(**base, reason="Cotas IQR fuera del rango float64.")
+    count = ((normalized < low) | (normalized > high)).sum()
+    base.update(evaluated_rows=len(values), count=count)
+    return DetectorResult(**base, parameters=(
+        ("factor", "1.5"), ("cuantiles", "lineales"),
+        ("inferior", f"{lower:.12g}"), ("superior", f"{upper:.12g}"),
+    ))
+
+
+def broken_type(series: pl.Series) -> DetectorResult:
+    values = series.drop_nulls().str.strip_chars()
+    values = values.filter(values != "")
+    base = dict(method="tipo textual", columns=(series.name,), total_rows=len(series),
+                eligible_rows=len(values), evaluated_rows=0, count=None)
+    if len(values) < MIN_VALUES:
+        return DetectorResult(**base, reason="Menos de 10 textos no vacíos.")
+    if code_like(series.name):
+        return DetectorResult(**base, reason="Posible ID/código por nombre; no se infiere un tipo roto.")
+    # No convertir la columna original: los valores incompatibles se conservan.
+    numeric = values.cast(pl.Float64, strict=False)
+    numeric_count = numeric.is_finite().fill_null(False).sum()
+    leading_zero = values.str.contains(r"^[+-]?0\d+$").any()
+    dates = values.str.contains(r"^\d{4}-\d{2}-\d{2}$") & (
+        values.str.to_date(format="%Y-%m-%d", strict=False).is_not_null()
+    )
+    date_count = dates.sum()
+    if numeric_count / len(values) >= TYPE_RATIO and not leading_zero:
+        target, compatible = "numérico finito", numeric_count
+    elif date_count / len(values) >= TYPE_RATIO:
+        target, compatible = "fecha ISO YYYY-MM-DD", date_count
+    else:
+        reason = ("Posible código con ceros iniciales; conversión numérica omitida."
+                  if leading_zero and numeric_count / len(values) >= TYPE_RATIO
+                  else "Sin mayoría ≥90% numérica o de fechas ISO; no se adivina intención.")
+        return DetectorResult(**base, reason=reason)
+    base.update(evaluated_rows=len(values), count=len(values) - compatible)
+    return DetectorResult(**base, parameters=(
+        ("tipo candidato", target), ("proporción mínima", "0.9"),
+        ("compatibles", str(compatible)),
+    ))
+
+
+def isolation_forest(frame: pl.DataFrame, *, enabled: bool) -> DetectorResult:
+    base = dict(method="IsolationForest", columns=(), total_rows=frame.height,
+                eligible_rows=0, evaluated_rows=0, count=None)
+    if not enabled:
+        return DetectorResult(**base, reason="Desactivado; usar --ml para ejecutar.")
+    columns = []
+    for name, dtype in frame.schema.items():
+        if not (dtype.is_integer() or dtype.is_float()):
+            continue
+        finite = frame[name].drop_nulls()
+        finite = finite.filter(finite.is_finite())
+        if len(finite) >= MIN_VALUES and finite.n_unique() > 1 and not code_like(name):
+            columns.append(name)
+    if len(columns) > ML_COLUMNS:
+        return DetectorResult(**base, reason="Más de 32 columnas elegibles; trabajo ML acotado.")
+    base.update(columns=tuple(columns))
+    if not columns:
+        return DetectorResult(**base, reason="Sin columnas numéricas variables elegibles.")
+    eligible = frame.select(columns).filter(pl.all_horizontal(
+        pl.col(name).is_finite().fill_null(False) for name in columns
+    ))
+    base.update(eligible_rows=eligible.height)
+    if eligible.height < 32:
+        return DetectorResult(**base, reason="Menos de 32 filas completas y finitas.")
+    sample = eligible.sample(n=ML_ROWS, seed=SEED, shuffle=True) if eligible.height > ML_ROWS else eligible
+    # Solo la muestra acotada cruza a NumPy. sklearn no se importa al arrancar.
+    import numpy as np
+    from sklearn.ensemble import IsolationForest
+
+    matrix = sample.to_numpy().astype(np.float64)
+    # sklearn convierte internamente a float32; escalar evita overflow.
+    matrix /= np.maximum(np.abs(matrix).max(axis=0), 1)
+    if not np.any(np.ptp(matrix.astype(np.float32), axis=0) > 0):
+        return DetectorResult(**base, reason="Sin variación representable en la muestra float32.")
+    model = IsolationForest(n_estimators=64, max_samples=min(256, sample.height), contamination="auto",
+                            random_state=SEED, n_jobs=1)
+    count = int((model.fit_predict(matrix) == -1).sum())
+    base.update(evaluated_rows=sample.height, count=count)
+    return DetectorResult(**base, parameters=(
+        ("seed", str(SEED)), ("árboles", "64"), ("max_samples", str(min(256, sample.height))),
+        ("límite de filas", str(ML_ROWS)), ("límite de columnas", str(ML_COLUMNS)),
+        ("contamination", "auto"), ("umbral decision_function", "<0"), ("n_jobs", "1"),
+    ))
+
+
+def detect(frame: pl.DataFrame, *, ml: bool = False) -> tuple[tuple[DetectorResult, ...], tuple[Finding, ...]]:
+    results = []
+    findings = []
+    for name, dtype in frame.schema.items():
+        if dtype.is_integer() or dtype.is_float():
+            results.append(numeric_outliers(frame[name]))
+        elif dtype == pl.String:
+            results.append(broken_type(frame[name]))
+    results.append(isolation_forest(frame, enabled=ml))
+    for result in results:
+        if result.count:
+            code = {"IQR": "numeric_outliers", "tipo textual": "broken_type",
+                    "IsolationForest": "isolation_outliers"}[result.method]
+            findings.append(Finding(
+                code, "warning", f"{result.count:,} indicios por {result.method} "
+                f"sobre {result.evaluated_rows:,} filas evaluadas; revisar contexto.",
+                result.columns[0] if len(result.columns) == 1 else None,
+            ))
+    return tuple(results), tuple(findings)

blink_data_lint/core/drift.py

@@ -0,0 +1,147 @@
+"""Comparación exacta de agregados; umbrales de revisión, no tests de hipótesis."""
+
+import math
+
+import polars as pl
+
+from blink_data_lint.core.models import DriftMetric
+from blink_data_lint.core.roles import code_like
+
+MIN_ROWS = 100
+MEAN_THRESHOLD = 0.5
+DISTRIBUTION_THRESHOLD = 0.2
+MISSING_THRESHOLD = 0.1
+MAX_CATEGORIES = 50
+CDF_CHUNK_ROWS = 65_536
+
+
+def _metric(
+    previous: pl.Series, current: pl.Series, method: str,
+    previous_count: int, current_count: int, *, score: float | None = None,
+    threshold: float | None = None, reason: str | None = None,
+    previous_value: float | None = None, current_value: float | None = None,
+) -> DriftMetric:
+    return DriftMetric(current.name, method, len(previous), len(current),
+                       previous_count, current_count, score, threshold, reason,
+                       previous_value, current_value)
+
+
+def _missing(previous: pl.Series, current: pl.Series) -> DriftMetric:
+    if min(len(previous), len(current)) < MIN_ROWS:
+        return _metric(previous, current, "missing_rate", len(previous), len(current),
+                       threshold=MISSING_THRESHOLD, reason="Menos de 100 filas en alguno de los archivos.")
+
+    def rate(series: pl.Series) -> float:
+        missing = series.null_count()
+        if series.dtype.is_float():
+            missing += series.is_nan().sum()
+        return missing / len(series)
+
+    before, after = rate(previous), rate(current)
+    return _metric(previous, current, "missing_rate", len(previous), len(current),
+                   score=abs(after - before), threshold=MISSING_THRESHOLD,
+                   previous_value=before, current_value=after)
+
+
+def _numeric(previous: pl.Series, current: pl.Series) -> tuple[DriftMetric, ...]:
+    before = previous.drop_nulls()
+    before = before.filter(before.is_finite())
+    after = current.drop_nulls()
+    after = after.filter(after.is_finite())
+
+    def result(method: str, threshold: float, **kwargs) -> DriftMetric:
+        return _metric(previous, current, method, len(before), len(after), threshold=threshold, **kwargs)
+
+    def skipped(reason: str) -> tuple[DriftMetric, ...]:
+        return (result("mean_shift", MEAN_THRESHOLD, reason=reason),
+                result("ks", DISTRIBUTION_THRESHOLD, reason=reason))
+
+    if min(len(before), len(after)) < MIN_ROWS:
+        return skipped("Menos de 100 valores finitos en alguno de los archivos.")
+    if current.dtype.is_integer():
+        if any(max(abs(values.min()), abs(values.max())) > 2**53 for values in (before, after)):
+            return skipped("Enteros fuera de ±2^53; float64 perdería precisión.")
+
+    # NumPy solo materializa dos columnas finitas cuando se usa --baseline.
+    import numpy as np
+
+    old = before.cast(pl.Float64).to_numpy()
+    new = after.cast(pl.Float64).to_numpy()
+    scale = max(float(np.abs(old).max()), float(np.abs(new).max())) or 1.0
+    old_scaled, new_scaled = old / scale, new / scale
+    lost_precision = (np.unique(old_scaled).size != before.n_unique()
+                      or np.unique(new_scaled).size != after.n_unique())
+    old_mean, new_mean = float(old_scaled.mean()), float(new_scaled.mean())
+    std = float(old_scaled.std(ddof=0))
+    if lost_precision:
+        mean = result("mean_shift", MEAN_THRESHOLD, reason="El escalado pierde valores distintos en float64.")
+    elif std == 0:
+        mean = result("mean_shift", MEAN_THRESHOLD, reason="Desviación del baseline cero o no representable.")
+    else:
+        score = abs(new_mean - old_mean) / std
+        if not math.isfinite(score):
+            mean = result("mean_shift", MEAN_THRESHOLD, reason="Desplazamiento de media no representable.")
+        else:
+            mean = result("mean_shift", MEAN_THRESHOLD, score=score,
+                          previous_value=old_mean * scale, current_value=new_mean * scale)
+
+    # Distancia empírica exacta: evaluar ambas CDF a la derecha de cada valor
+    # observado contempla empates y tamaños distintos, sin p-valores ni muestreo.
+    old_sorted, new_sorted = np.sort(old), np.sort(new)
+    distance = 0.0
+    # Recorrer todo el soporte en bloques, sin construir la unión ni dos CDF
+    # completas. Es el mismo máximo exacto, no una muestra de observaciones.
+    for values in (old_sorted, new_sorted):
+        for offset in range(0, len(values), CDF_CHUNK_ROWS):
+            support = np.unique(values[offset:offset + CDF_CHUNK_ROWS])
+            delta = np.searchsorted(new_sorted, support, side="right") / len(new_sorted)
+            delta -= np.searchsorted(old_sorted, support, side="right") / len(old_sorted)
+            distance = max(distance, float(np.max(np.abs(delta))))
+    return mean, result("ks", DISTRIBUTION_THRESHOLD, score=distance)
+
+
+def _categorical(previous: pl.Series, current: pl.Series) -> DriftMetric:
+    before, after = previous.drop_nulls(), current.drop_nulls()
+
+    def result(**kwargs) -> DriftMetric:
+        return _metric(previous, current, "total_variation", len(before), len(after),
+                       threshold=DISTRIBUTION_THRESHOLD, **kwargs)
+
+    if min(len(before), len(after)) < MIN_ROWS:
+        return result(reason="Menos de 100 valores no nulos en alguno de los archivos.")
+    if pl.concat([before, after]).n_unique() > MAX_CATEGORIES:
+        return result(reason="Más de 50 categorías; posible ID o texto libre.")
+    # Solo se materializan los conteos de hasta 50 categorías en Python.
+    def counts(values: pl.Series) -> dict:
+        table = values.rename("value").value_counts(name="frequency")
+        return dict(zip(table["value"].to_list(), table["frequency"].to_list()))
+
+    old_counts, new_counts = counts(before), counts(after)
+    categories = old_counts.keys() | new_counts.keys()
+    distance = math.fsum(abs(new_counts.get(key, 0) / len(after) - old_counts.get(key, 0) / len(before))
+                         for key in categories) / 2
+    return result(score=distance)
+
+
+def detect_drift(current: pl.DataFrame, baseline: pl.DataFrame) -> tuple[DriftMetric, ...]:
+    results = []
+    previous_schema = baseline.schema
+    for name, dtype in current.schema.items():
+        if name not in previous_schema:
+            continue
+        previous, column = baseline[name], current[name]
+        if dtype != previous_schema[name]:
+            results.append(_metric(previous, column, "distribution", 0, 0,
+                                   reason="Tipos diferentes; no se convierten valores para comparar."))
+            continue
+        results.append(_missing(previous, column))
+        if (dtype.is_integer() or dtype.is_float()) and code_like(name):
+            results.append(_categorical(previous, column))
+        elif dtype.is_integer() or dtype.is_float():
+            results.extend(_numeric(previous, column))
+        elif dtype in (pl.String, pl.Boolean):
+            results.append(_categorical(previous, column))
+        else:
+            results.append(_metric(previous, column, "distribution", 0, 0,
+                                   reason="Tipo sin comparación de distribución implementada."))
+    return tuple(results)

blink_data_lint/core/duplicates.py

@@ -0,0 +1,17 @@
+"""Conteo exacto con prefiltrado de candidatos; los hashes no deciden igualdad."""
+
+import polars as pl
+
+
+def excess_duplicates(frame: pl.DataFrame) -> int:
+    if not frame.height or not frame.width:
+        return 0
+    # Filas iguales tienen el mismo hash. Una colisión solo agrega candidatos;
+    # la comparación final se hace sobre sus valores completos con Polars.
+    candidates = frame.hash_rows(seed=0).is_duplicated()
+    count = candidates.sum()
+    if not count:
+        return 0
+    if count == frame.height:
+        return frame.height - frame.n_unique()
+    return count - frame.filter(candidates).n_unique()

blink_data_lint/core/models.py

@@ -0,0 +1,98 @@
+"""Resultados de inspección independientes de la terminal y del almacenamiento."""
+
+from dataclasses import dataclass
+import math
+from typing import Literal
+
+
+@dataclass(frozen=True)
+class Finding:
+    code: str
+    severity: Literal["info", "warning"]
+    message: str
+    column: str | None = None
+
+
+@dataclass(frozen=True)
+class ColumnMetrics:
+    name: str
+    dtype: str
+    null_count: int
+    null_percent: float | None
+    nan_count: int
+    distinct_count: int  # Valores observados; excluye null y NaN.
+    constant: bool
+    all_null: bool
+    possible_id: bool
+
+
+@dataclass(frozen=True)
+class DetectorResult:
+    method: str
+    columns: tuple[str, ...]
+    total_rows: int
+    eligible_rows: int
+    evaluated_rows: int
+    count: int | None
+    parameters: tuple[tuple[str, str], ...] = ()
+    reason: str | None = None
+
+
+@dataclass(frozen=True)
+class AnalysisReport:
+    rows: int
+    columns: tuple[ColumnMetrics, ...]
+    null_count: int
+    null_percent: float | None
+    nan_count: int
+    duplicate_count: int
+    duplicate_percent: float | None
+    findings: tuple[Finding, ...]
+    coverage: str = "exacta · todas las filas"
+    detectors: tuple[DetectorResult, ...] = ()
+
+
+@dataclass(frozen=True)
+class SchemaChange:
+    column: str
+    kind: Literal["added", "removed", "type_changed"]
+    previous_type: str | None
+    current_type: str | None
+
+
+@dataclass(frozen=True)
+class DriftMetric:
+    column: str
+    method: str
+    baseline_rows: int
+    current_rows: int
+    baseline_eligible: int
+    current_eligible: int
+    score: float | None
+    threshold: float | None
+    reason: str | None = None
+    baseline_value: float | None = None
+    current_value: float | None = None
+
+    @property
+    def flagged(self) -> bool:
+        return (self.score is not None and self.threshold is not None
+                and (self.score >= self.threshold
+                     or math.isclose(self.score, self.threshold, rel_tol=0, abs_tol=1e-12)))
+
+
+@dataclass(frozen=True)
+class ComparisonReport:
+    baseline_rows: int
+    current_rows: int
+    baseline_columns: int
+    current_columns: int
+    changes: tuple[SchemaChange, ...]
+    drift: tuple[DriftMetric, ...] = ()
+
+
+@dataclass(frozen=True)
+class ReportSummary:
+    warnings: int
+    information: int
+    skipped_analyses: int

blink_data_lint/core/roles.py

@@ -0,0 +1,10 @@
+"""Indicios conservadores por nombre; nunca afirman semántica de negocio."""
+
+import re
+
+CODE_TOKENS = {"id", "code", "codigo", "código", "type", "tipo", "status", "estado"}
+
+
+def code_like(name: str) -> bool:
+    separated = re.sub(r"(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])", "_", name)
+    return bool(CODE_TOKENS.intersection(re.split(r"[\W_]+", separated.casefold())))

blink_data_lint/core/summary.py

@@ -0,0 +1,12 @@
+"""Resumen compartido por la CLI y sus formatos; sin I/O ni códigos de proceso."""
+
+from blink_data_lint.core.models import AnalysisReport, ComparisonReport, ReportSummary
+
+
+def summarize(report: AnalysisReport, comparison: ComparisonReport | None = None) -> ReportSummary:
+    warnings = sum(item.severity == "warning" for item in report.findings)
+    skipped = sum(item.reason is not None for item in report.detectors)
+    if comparison is not None:
+        warnings += len(comparison.changes) + sum(item.flagged for item in comparison.drift)
+        skipped += sum(item.reason is not None for item in comparison.drift)
+    return ReportSummary(warnings, sum(item.severity == "info" for item in report.findings), skipped)

blink_data_lint/io/__init__.py

@@ -0,0 +1 @@
+"""Lectura de archivos tabulares locales."""

blink_data_lint/io/loader.py

@@ -0,0 +1,49 @@
+"""Lectura local y estricta; no corrige ni escribe los datos de entrada."""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import polars as pl
+
+
+class LoadError(Exception):
+    """La entrada no puede inspeccionarse como dataset soportado."""
+
+
+@dataclass(frozen=True)
+class LoadedDataset:
+    frame: pl.DataFrame
+    format: str
+    policy: str
+
+
+def load_dataset(path: Path) -> LoadedDataset:
+    suffix = path.suffix.lower()
+    try:
+        if not path.is_file():
+            raise LoadError("La entrada debe ser un archivo local regular existente.")
+        # Un handle evita interpretar caracteres como '[' o '*' como un glob.
+        with path.open("rb") as source:
+            if suffix == ".csv":
+                frame = pl.read_csv(
+                    source,
+                    infer_schema_length=None,
+                    try_parse_dates=False,
+                    ignore_errors=False,
+                    encoding="utf8",
+                    raise_if_empty=True,
+                )
+                return LoadedDataset(
+                    frame,
+                    "CSV",
+                    "UTF-8 · coma · cabecera · inferencia completa · fechas como texto",
+                )
+            if suffix == ".parquet":
+                return LoadedDataset(pl.read_parquet(source), "Parquet", "Esquema del archivo")
+            raise LoadError("Formato no soportado. Usá un archivo .csv o .parquet.")
+    except (OSError, pl.exceptions.PolarsError, UnicodeError) as exc:
+        # No mostrar valores de celdas que algunos errores de Polars incluyen.
+        raise LoadError(
+            f"No se pudo leer el archivo {suffix or 'sin extensión'} "
+            f"({type(exc).__name__}). Revisá permisos, codificación y estructura."
+        ) from exc

blink_data_lint/io/serializer.py

@@ -0,0 +1,44 @@
+"""Contrato JSON versionado; sin Rich, lectura de archivos ni cálculos estadísticos."""
+
+from dataclasses import asdict
+import json
+
+from blink_data_lint.core.models import AnalysisReport, ComparisonReport, ReportSummary
+
+SCHEMA_VERSION = "1.0"
+
+
+def serialize_report(
+    report: AnalysisReport, comparison: ComparisonReport | None, summary: ReportSummary,
+    *, sources: dict, exit_code: int,
+) -> str:
+    analysis = asdict(report)
+    analysis["detectors"] = [
+        dict(asdict(item), parameters=dict(item.parameters),
+             status="skipped" if item.reason is not None else "completed")
+        for item in report.detectors
+    ]
+    compared = asdict(comparison) if comparison is not None else None
+    if compared is not None:
+        compared["drift"] = [
+            dict(asdict(item), flagged=item.flagged,
+                 status="skipped" if item.reason is not None else "completed")
+            for item in comparison.drift
+        ]
+    return _encode(dict(
+        schema_version=SCHEMA_VERSION, status="completed", sources=sources,
+        analysis=analysis, comparison=compared, summary=asdict(summary),
+        error=None, exit_code=exit_code,
+    ))
+
+
+def serialize_error(*, sources: dict, code: str, stage: str, message: str) -> str:
+    return _encode(dict(
+        schema_version=SCHEMA_VERSION, status="error", sources=sources,
+        analysis=None, comparison=None, summary=None,
+        error=dict(code=code, stage=stage, message=message), exit_code=2,
+    ))
+
+
+def _encode(document: dict) -> str:
+    return json.dumps(document, ensure_ascii=True, allow_nan=False, indent=2)

blink_data_lint/ui/__init__.py

@@ -0,0 +1 @@
+"""Presentación de resultados en terminal."""

blink_data_lint/ui/reporter.py

@@ -0,0 +1,134 @@
+"""Presentación Rich a partir de resultados; sin cálculos de calidad."""
+
+from pathlib import Path
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from blink_data_lint.core.models import AnalysisReport, ComparisonReport
+
+
+def _percent(value: float | None) -> str:
+    return f"{value:.1f}%" if value is not None else "n/d"
+
+
+def show_report(
+    report: AnalysisReport, path: Path, *, format: str, policy: str,
+    console: Console | None = None,
+) -> None:
+    output = console if console is not None else Console()
+    warnings = sum(item.severity == "warning" for item in report.findings)
+    status = "REVISAR" if warnings else "CON INDICIOS" if report.findings else "SIN ALERTAS BÁSICAS"
+    summary = Text(str(path), style="bold")
+    summary.append(f"\n{format} · {report.rows:,} filas · {len(report.columns):,} columnas")
+    summary.append(f"\nNulos: {report.null_count:,} ({_percent(report.null_percent)})")
+    summary.append(f" · NaN: {report.nan_count:,}")
+    summary.append(f"\nDuplicados excedentes: {report.duplicate_count:,} ({_percent(report.duplicate_percent)})")
+    summary.append(f"\nCobertura: {report.coverage}\n{policy}", style="dim")
+    output.print(Panel(summary, title=f"blink · {status}", border_style="yellow" if warnings else "cyan"))
+
+    if report.columns:
+        if output.width >= 72:
+            table = Table(title="Salud por columna", expand=True, show_lines=False)
+            for label in ("Columna", "Tipo", "Nulos", "NaN", "Únicos¹", "Estado"):
+                table.add_column(label, overflow="fold")
+            for column in report.columns:
+                flags = []
+                if column.all_null:
+                    flags.append("SOLO NULOS")
+                if column.constant:
+                    flags.append("CONSTANTE")
+                if column.possible_id:
+                    flags.append("POSIBLE ID")
+                if column.null_count or column.nan_count:
+                    flags.append("FALTANTES")
+                table.add_row(
+                    Text(column.name), Text(column.dtype),
+                    f"{column.null_count:,} ({_percent(column.null_percent)})",
+                    f"{column.nan_count:,}", f"{column.distinct_count:,}",
+                    " · ".join(flags) or "Sin alertas",
+                )
+            output.print(table)
+        else:
+            for column in report.columns:
+                detail = Text(column.name, style="bold")
+                detail.append(f"\n{column.dtype} · únicos¹: {column.distinct_count:,}")
+                detail.append(f"\nNulos: {column.null_count:,} ({_percent(column.null_percent)}) · NaN: {column.nan_count:,}")
+                output.print(Panel(detail))
+        output.print(Text("¹ Únicos observados: excluyen null y NaN.", style="dim"))
+
+    if report.findings:
+        output.print(Text(f"\nHallazgos: {len(report.findings)}", style="bold"))
+        for item in report.findings:
+            line = Text("AVISO" if item.severity == "warning" else "INFO", style="yellow" if item.severity == "warning" else "cyan")
+            if item.column is not None:
+                line.append(f" · {item.column}", style="bold")
+            line.append(f": {item.message}")
+            output.print(line)
+    else:
+        output.print("Sin hallazgos en las reglas ejecutadas. Revisá la cobertura y las omisiones.")
+
+    if report.detectors:
+        output.print(Text("\nDetectores · cobertura independiente de la salud básica", style="bold"))
+        for result in report.detectors:
+            line = Text(f"{result.method} · ", style="bold")
+            line.append(", ".join(result.columns) or "dataset")
+            if result.reason:
+                line.append(f"\nOMITIDO: {result.reason}")
+                line.append(f"\n0 evaluadas / {result.eligible_rows:,} elegibles / {result.total_rows:,} totales")
+            else:
+                scope = "muestra" if result.evaluated_rows < result.eligible_rows else "todas las elegibles"
+                line.append(f"\n{result.count:,} indicios · {result.evaluated_rows:,} evaluadas "
+                            f"/ {result.eligible_rows:,} elegibles / {result.total_rows:,} totales · {scope}")
+            if result.parameters:
+                line.append("\n" + " · ".join(f"{key}={value}" for key, value in result.parameters))
+            output.print(line)
+
+
+def show_comparison(
+    report: ComparisonReport, baseline: Path, *, console: Console | None = None,
+) -> None:
+    output = console if console is not None else Console()
+    summary = Text("Archivo anterior: ", style="bold")
+    summary.append(str(baseline))
+    summary.append(f"\nFilas: {report.baseline_rows:,} → {report.current_rows:,}")
+    summary.append(f" · Columnas: {report.baseline_columns:,} → {report.current_columns:,}")
+    summary.append("\nCompara esquema y valores agregados, sin emparejar filas.")
+    warnings = bool(report.changes) or any(metric.flagged for metric in report.drift)
+    status = "REVISAR" if warnings else "SIN CAMBIOS DE ESQUEMA"
+    output.print(Panel(summary, title=f"Comparación · {status}",
+                       border_style="yellow" if warnings else "cyan"))
+    labels = {"added": "AGREGADA", "removed": "ELIMINADA", "type_changed": "CAMBIO DE TIPO"}
+    for change in report.changes:
+        line = Text(f"AVISO · {labels[change.kind]} · ", style="yellow")
+        line.append(change.column, style="bold")
+        line.append(f": {change.previous_type or 'ausente'} → {change.current_type or 'ausente'}")
+        output.print(line)
+    if not report.changes:
+        output.print("Sin cambios de nombres o tipos de columnas.")
+    if not report.drift:
+        output.print("Distribuciones: sin columnas comunes para comparar.")
+        return
+    output.print(Text("\nCambios de valores · exactos sobre observaciones elegibles", style="bold"))
+    methods = {"mean_shift": "CAMBIO DE MEDIA (σ anterior)", "ks": "DISTRIBUCIÓN KS",
+               "total_variation": "DISTRIBUCIÓN DE CATEGORÍAS", "missing_rate": "FALTANTES",
+               "distribution": "DISTRIBUCIÓN"}
+    for metric in report.drift:
+        status = "OMITIDO" if metric.reason else "AVISO" if metric.flagged else "INFO"
+        line = Text(f"{status} · {methods[metric.method]} · ",
+                    style="yellow" if metric.flagged else "dim" if metric.reason else "cyan")
+        line.append(metric.column, style="bold")
+        if metric.reason:
+            line.append(f": {metric.reason}")
+        else:
+            factor = 100 if metric.method == "missing_rate" else 1
+            unit = " pp" if metric.method == "missing_rate" else ""
+            line.append(f": {metric.score * factor:.6g}{unit} · umbral ≥{metric.threshold * factor:g}{unit}")
+            if metric.baseline_value is not None and metric.current_value is not None:
+                unit = "%" if metric.method == "missing_rate" else ""
+                line.append(f" · {metric.baseline_value * factor:.6g}{unit} → {metric.current_value * factor:.6g}{unit}")
+        line.append(f"\nElegibles: anterior {metric.baseline_eligible:,}/{metric.baseline_rows:,}"
+                    f" · actual {metric.current_eligible:,}/{metric.current_rows:,}")
+        output.print(line)

blink_data_lint-0.1.0.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.5
+Name: blink-data-lint
+Version: 0.1.0
+Summary: Zero-config, read-only data quality diagnostics for CSV and Parquet.
+Project-URL: Homepage, https://github.com/Gianni300x/blink
+Project-URL: Repository, https://github.com/Gianni300x/blink
+Project-URL: Issues, https://github.com/Gianni300x/blink/issues
+Author: Gianni Luigi Messina
+License-Expression: MIT
+License-File: LICENSE
+Keywords: anomaly-detection,cli,csv,data-quality,parquet
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.11
+Requires-Dist: numpy<3,>=2.0
+Requires-Dist: polars<2,>=1.0
+Requires-Dist: rich<15,>=13.9
+Requires-Dist: scikit-learn<2,>=1.5
+Requires-Dist: typer<1,>=0.16
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=8.3; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# blink
+
+**Un diagnóstico de calidad de datos, a un comando de distancia.**
+
+Blink es una herramienta de terminal que analiza archivos CSV y Parquet locales
+y muestra problemas de calidad e indicios de anomalías. No requiere configuración
+previa, no envía datos a servicios externos y no modifica tus archivos.
+
+## Qué hace
+
+- Muestra dimensiones y tipos de las columnas.
+- Detecta nulos, NaN, filas duplicadas y columnas constantes.
+- Señala posibles identificadores de texto.
+- Detecta outliers numéricos con IQR.
+- Advierte sobre columnas de texto mayormente numéricas o de fechas con valores incompatibles.
+- Permite analizar anomalías con IsolationForest mediante `--ml`.
+- Compara columnas, tipos y distribuciones con un archivo anterior mediante `--baseline`.
+
+Los resultados aparecen en tablas de terminal, con conteos, cobertura y motivos
+cuando un análisis se omite. Son indicios para revisar en contexto.
+
+## Instalación
+
+Requiere **Python 3.11 o superior**. Con [uv](https://docs.astral.sh/uv/getting-started/installation/),
+instalá la app en un entorno aislado y comprobá la ayuda:
+
+```bash
+uv tool install blink-data-lint
+blink --help
+```
+
+El paquete se llama **`blink-data-lint`** en PyPI; el comando es **`blink`**.
+Si acabás de instalar uv y la terminal no encuentra `blink`, ejecutá
+`uv tool update-shell` y abrí una terminal nueva.
+
+<details>
+<summary>Alternativas: pip o instalación desde el repositorio</summary>
+
+Con pip, en macOS/Linux:
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install blink-data-lint
+blink --help
+```
+
+En Windows, desde PowerShell:
+
+```powershell
+py -3 -m venv .venv
+.venv\Scripts\Activate.ps1
+python -m pip install blink-data-lint
+blink --help
+```
+
+Mantené el entorno activo. En una terminal nueva, volvé a activarlo con
+`source .venv/bin/activate` (macOS/Linux) o `.venv\Scripts\Activate.ps1` (Windows).
+
+Para trabajar desde el código fuente, necesitás [Git](https://git-scm.com/downloads/):
+
+```bash
+git clone https://github.com/Gianni300x/blink.git
+cd blink
+uv sync
+uv run blink tests/data/sample_dirty.csv
+```
+
+En este caso, usá `uv run blink` en lugar de `blink` en los ejemplos de abajo.
+Con pip desde el repositorio, podés usar `python -m pip install -e .` dentro del
+entorno virtual en lugar de instalar el paquete desde PyPI.
+
+</details>
+
+## Uso
+
+```bash
+blink datos.csv
+blink datos.parquet
+```
+
+Reemplazá `datos.csv` o `datos.parquet` por la ruta de tu archivo. Si tiene
+espacios, escribila entre comillas: `blink "mis datos/ventas.csv"`.
+
+Para habilitar el análisis con ML:
+
+```bash
+blink datos.csv --ml
+```
+
+Para comparar con un archivo anterior y detectar cambios de columnas, tipos,
+medias, distribuciones o proporción de faltantes:
+
+```bash
+blink datos.csv --baseline anterior.csv
+```
+
+Ambos archivos pueden ser CSV o Parquet. Se comparan columnas por nombre;
+un cambio de orden no genera un aviso. Los valores se comparan de forma agregada,
+sin emparejar filas. La salida muestra las métricas, umbrales y cobertura.
+
+Para consultar la ayuda:
+
+```bash
+blink --help
+```
+
+Para desactivar los colores en macOS/Linux: `NO_COLOR=1 blink datos.csv`.
+
+## Límites de uso
+
+- Archivos locales CSV o Parquet que entren en memoria. CSV requiere UTF-8,
+  comas y una primera fila de cabecera; no se adivinan otros separadores.
+- IQR necesita al menos 10 valores numéricos finitos. Si el rango intercuartílico
+  es cero, se omite el detector y se indica el motivo.
+- Los tipos rotos requieren al menos 10 textos no vacíos y una mayoría ≥90 %
+  de números finitos o fechas válidas `YYYY-MM-DD`. No se interpretan fechas
+  locales como `01/02/2026`.
+- ML necesita al menos 32 filas completas y finitas en sus columnas numéricas
+  elegibles. Si hay más de 32 columnas elegibles, se omite. Evalúa hasta 10.000
+  filas; por encima toma una muestra y muestra su cobertura, sin extrapolar conteos.
+- Nombres como `VendorID`, `PULocationID`, `payment_type` o `codigo_postal`
+  indican posibles códigos o etiquetas. Se omiten de IQR y ML; al comparar
+  archivos se usan frecuencias, no medias o distancias numéricas. Es una
+  heurística por nombre y se informa como tal; no demuestra una clave primaria.
+- Una anomalía es un indicio, no una prueba de error. Un análisis omitido tampoco
+  equivale a un resultado sin problemas. Revisá los motivos que muestra la salida.
+- La comparación de valores requiere tipos idénticos y al menos 100 observaciones
+  elegibles por archivo. Avisa si la media se desplaza ≥0.5 desviaciones estándar
+  del archivo anterior, la distancia de distribución es ≥0.2 (KS en números o
+  variación total en categorías), o los faltantes cambian ≥10 puntos porcentuales.
+  Son umbrales de revisión; no son pruebas de significación estadística.
+  Con desviación anterior cero se omite la comparación de medias, pero se compara
+  la distribución. Las categorías se limitan a 50 valores distintos entre ambos
+  archivos; IDs/texto libre y tipos no compatibles pueden omitir ese análisis.
+
+## Integración con otros programas y CI
+
+El uso habitual sigue siendo `blink archivo.csv`. Si necesitás un informe para
+otro programa, agregá `--json`:
+
+```bash
+blink datos.csv --json > informe.json
+```
+
+Para hacer fallar una validación automatizada cuando aparezcan avisos:
+
+```bash
+blink datos.csv --json --exit-code > informe.json
+```
+
+También podés combinarlo con `--baseline anterior.csv` y `--ml`. En un paso de CI,
+el código de salida determina si continúa o falla la validación:
+
+| Código | Significado |
+| --- | --- |
+| `0` | Inspección completada; sin `--exit-code`, los avisos también devuelven `0`. |
+| `1` | Hay avisos y se activó `--exit-code`. |
+| `2` | Error de uso, lectura o análisis, con o sin `--exit-code`. |
+
+Si preferís ver las tablas en el log de CI, usá `--exit-code` sin `--json`.
+
+Se consideran avisos los hallazgos de calidad, cambios de esquema y métricas de
+drift que superan su umbral. Los posibles IDs informativos y los análisis omitidos
+no hacen fallar CI por sí solos. Dos métricas alertadas en una columna cuentan
+como dos avisos. Un aviso sigue siendo un indicio para revisar en contexto.
+
+El JSON usa `schema_version: "1.0"` e incluye `analysis`, `comparison`, `summary`,
+`error` y `exit_code`, además de los archivos y políticas de lectura en `sources`.
+`status: "completed"` indica que la ejecución terminó, no que todos los datos sean
+correctos. Cada detector indica `completed` o `skipped` y su cobertura. Los
+errores de lectura/análisis generan `status: "error"` y un diagnóstico por stderr,
+sin informe parcial. Los errores de sintaxis del comando se muestran por stderr
+sin generar un documento JSON; comprobá siempre el código de salida.
+
+Si clonaste el repositorio, podés reproducir un fallo de validación con su CSV de ejemplo:
+
+```bash
+blink tests/data/sample_dirty.csv --json --exit-code > informe.json
+```
+
+Este ejemplo devuelve `1` porque contiene problemas conocidos; el informe JSON
+queda disponible para revisar los avisos.
+
+Licencia [MIT](https://github.com/Gianni300x/blink/blob/main/LICENSE).

blink_data_lint-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+blink_data_lint/__init__.py,sha256=48jzLSUAoJ3XRh33yAxTV5_Ga4UGHR-zdJaUaIEozq8,64
+blink_data_lint/cli.py,sha256=SOtZPAPbisMwJfV9l8KZqpvSkhvP-a5Eh_-suMvAa9s,4549
+blink_data_lint/core/__init__.py,sha256=D5wYM50tLYl3BqVMNy3zk_rFMNVyFqosL4cbMo0y9uo,74
+blink_data_lint/core/analyzer.py,sha256=HZee1PCd0pG-xuAzZMbYuknTvC-uDcX9k17HiNg80dQ,3969
+blink_data_lint/core/comparison.py,sha256=mSFGXyOmi4XS28o5Ma-5eEDv8GvCDiii0IlB2IHNHDg,1113
+blink_data_lint/core/detectors.py,sha256=9ywsdZs3JyUDdey7Gd_ErZTyDmKC4WQ-aPO9_kRTPN4,7159
+blink_data_lint/core/drift.py,sha256=tOSBPRNhdwohFBjbEk34U-BLdlMUu3cBHk2NdN9V2fE,7094
+blink_data_lint/core/duplicates.py,sha256=e8StoPWhM10kl5L16f_msITzhJZKxc_VdkjDDQAn8FI,627
+blink_data_lint/core/models.py,sha256=3ClxuxRg4xCVqSMRu1Ekw0jv1uHNKQsrI2fX2w63bzc,2302
+blink_data_lint/core/roles.py,sha256=pQDzKsQsl6wi6LgBgjNfTgZjcOQcK4WFdTCURf7JAOo,383
+blink_data_lint/core/summary.py,sha256=NcOm-yGJbcXpdJGyC7luVLvQ7aVwApxKq312G8Q3-Ek,725
+blink_data_lint/io/__init__.py,sha256=SA-l-GOkg-LNZA3x9W9GQgqrXxEuz_agHHXe50Xxk1Q,45
+blink_data_lint/io/loader.py,sha256=2GqG8z-tGZteTgGqAYZxJkUgFT03jfeAOW1_CVbHrf4,1782
+blink_data_lint/io/serializer.py,sha256=C-CvJ8lAdJh1g1g7FcRfQI60SztF6a_GcyUTvCWYaI8,1614
+blink_data_lint/ui/__init__.py,sha256=IeAVCNxf76nXqyAgZt3eOHmze-vvZXeNroa3PjYMYWA,47
+blink_data_lint/ui/reporter.py,sha256=nHU64otqDYZMmVt8VUWYZo6NZ-U6-hIrnC0uCsgHs1I,7334
+blink_data_lint-0.1.0.dist-info/METADATA,sha256=DHC1A-PuJjbFY7Az40P1UKjJSE6FylyEIQlgUQAk2xk,8357
+blink_data_lint-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+blink_data_lint-0.1.0.dist-info/entry_points.txt,sha256=cfrt68J8GprQD2s6Uiw_s3hn8riaRxTYt0vrmbJ2apg,50
+blink_data_lint-0.1.0.dist-info/licenses/LICENSE,sha256=cX8oUqNWFxpctpgUVunNH97LMIj8eCOYWjwkry3XySc,1077
+blink_data_lint-0.1.0.dist-info/RECORD,,

blink_data_lint-0.1.0.dist-info/WHEEL

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

blink_data_lint-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+blink = blink_data_lint.cli:app

blink_data_lint-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gianni Luigi Messina
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.