email-tagger 0.2.0__py3-none-any.whl

email_tagger/cache.py

@@ -0,0 +1,97 @@
+"""
+email_tagger.cache — Lokalny cache wyników klasyfikacji.
+
+Unika wielokrotnego wysyłania tych samych danych do API.
+Klucz cache: hash znormalizowanych danych wejściowych.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import sqlite3
+from pathlib import Path
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class ClassificationCache:
+    """
+    SQLite-based cache dla wyników klasyfikacji.
+
+    Przechowuje hash payloadu -> wynik TagResult jako JSON.
+    Domyślnie w ~/.email-tagger/cache.db z TTL 30 dni.
+    """
+
+    def __init__(self, sciezka: Optional[Path] = None) -> None:
+        if sciezka is None:
+            sciezka = Path.home() / ".email-tagger" / "cache.db"
+        self.sciezka = sciezka
+        self.sciezka.parent.mkdir(parents=True, exist_ok=True)
+        self._conn: Optional[sqlite3.Connection] = None
+
+    @property
+    def conn(self) -> sqlite3.Connection:
+        if self._conn is None:
+            self._conn = sqlite3.connect(str(self.sciezka))
+            self._conn.execute(
+                """CREATE TABLE IF NOT EXISTS cache (
+                    klucz TEXT PRIMARY KEY,
+                    wynik TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )"""
+            )
+            self._conn.execute("CREATE INDEX IF NOT EXISTS idx_cache_created ON cache(created_at)")
+            self._conn.commit()
+        return self._conn
+
+    def klucz(self, payload: dict[str, Any]) -> str:
+        """Generuje klucz cache z payloadu."""
+        raw = json.dumps(payload, sort_keys=True, ensure_ascii=False)
+        return hashlib.sha256(raw.encode()).hexdigest()
+
+    def pobierz(self, payload: dict[str, Any]) -> Optional[dict[str, Any]]:
+        """Próbuje pobrać wynik z cache."""
+        k = self.klucz(payload)
+        row = self.conn.execute("SELECT wynik FROM cache WHERE klucz = ?", (k,)).fetchone()
+        if row:
+            logger.debug("Cache HIT: %s", k[:12])
+            return json.loads(row[0])
+        logger.debug("Cache MISS: %s", k[:12])
+        return None
+
+    def zapisz(self, payload: dict[str, Any], wynik: dict[str, Any]) -> None:
+        """Zapisuje wynik do cache."""
+        k = self.klucz(payload)
+        self.conn.execute(
+            "INSERT OR REPLACE INTO cache (klucz, wynik) VALUES (?, ?)",
+            (k, json.dumps(wynik, ensure_ascii=False)),
+        )
+        self.conn.commit()
+
+    def czysc_stare(self, dni: int = 30) -> int:
+        """Usuwa wpisy starsze niż N dni. Zwraca liczbę usuniętych."""
+        usuniete = self.conn.execute(
+            "DELETE FROM cache WHERE created_at < datetime('now', ?)",
+            (f"-{dni} days",),
+        ).rowcount
+        self.conn.commit()
+        if usuniete:
+            logger.info("Wyczyszczono %d starych wpisów cache", usuniete)
+        return usuniete
+
+    def statystyki(self) -> dict:
+        """Zwraca statystyki cache."""
+        total = self.conn.execute("SELECT COUNT(*) FROM cache").fetchone()[0]
+        return {
+            "sciezka": str(self.sciezka),
+            "wpisy": total,
+            "rozmiar_mb": round(self.sciezka.stat().st_size / 1_000_000, 2) if self.sciezka.exists() else 0,
+        }
+
+    def zamknij(self) -> None:
+        if self._conn:
+            self._conn.close()
+            self._conn = None

email_tagger/checkpoint.py

@@ -0,0 +1,71 @@
+"""
+email_tagger.checkpoint — Przyrostowy checkpoint i resume.
+
+Zapisuje postęp po każdym batchu, pozwala wznowić po przerwaniu.
+Krytyczne dla produkcyjnego użycia — bez tego każdy crash = strata całej pracy.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class Checkpoint:
+    """
+    Checkpoint dla przyrostowego przetwarzania batchy.
+
+    Zapisuje do pliku JSON:
+    - indeks ostatniego przetworzonego wiersza
+    - całkowitą liczbę wierszy
+    - timestamp i model
+    """
+
+    def __init__(self, sciezka: Path) -> None:
+        self.sciezka = sciezka
+        self._dane: dict[str, Any] = {}
+
+    def wczytaj(self) -> Optional[dict[str, Any]]:
+        """Wczytuje checkpoint z pliku. Zwraca None jeśli nie istnieje."""
+        if not self.sciezka.exists():
+            return None
+        try:
+            with open(self.sciezka) as f:
+                self._dane = json.load(f)
+            logger.info("Wczytano checkpoint: %s", self.sciezka)
+            return self._dane
+        except (json.JSONDecodeError, OSError) as e:
+            logger.warning("Nie można wczytać checkpointu: %s", e)
+            return None
+
+    def zapisz(self, indeks: int, ogolem: int, **extra) -> None:
+        """Zapisuje checkpoint."""
+        self._dane = {
+            "indeks": indeks,
+            "ogolem": ogolem,
+            "procent": round(indeks / ogolem * 100, 1) if ogolem > 0 else 0,
+            **extra,
+        }
+        self.sciezka.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.sciezka, "w") as f:
+            json.dump(self._dane, f, indent=2, ensure_ascii=False)
+        logger.info("Checkpoint: %d/%d (%.1f%%)", indeks, ogolem, self._dane["procent"])
+
+    @property
+    def ostatni_indeks(self) -> int:
+        """Zwraca indeks ostatniego przetworzonego wiersza."""
+        return self._dane.get("indeks", -1)
+
+    @property
+    def czy_istnieje(self) -> bool:
+        return self.sciezka.exists()
+
+    def usun(self) -> None:
+        """Usuwa plik checkpointu — po zakończonym runie."""
+        if self.sciezka.exists():
+            self.sciezka.unlink()
+            logger.info("Usunięto checkpoint: %s", self.sciezka)

email_tagger/classifiers/contact_classifier.py

@@ -0,0 +1,144 @@
+"""
+email_tagger.classifiers.contact_classifier — Główna logika klasyfikacji.
+
+Łączy: dane wejściowe -> redakcja PII -> provider AI -> walidacja -> wynik.
+To jedyna klasa która "wie" o całym przepływie.
+
+Każdy kontakt jest przetwarzany TYLKO z dozwolonymi polami,
+zgodnie z profilem prywatności.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any, Optional
+
+from email_tagger.cache import ClassificationCache
+from email_tagger.models import ClassifiedContact, TagResult
+from email_tagger.privacy.payload_builder import (
+    sformatuj_payload_dla_prompta,
+    zbuduj_payload,
+)
+from email_tagger.providers.base import BaseProvider
+from email_tagger.types import PrivacyProfile
+
+logger = logging.getLogger(__name__)
+
+
+class ContactClassifier:
+    """
+    Klasyfikator kontaktów.
+
+    Dla każdego kontaktu:
+    1. Buduje bezpieczny payload (redakcja PII, polityka prywatności)
+    2. Sprawdza cache
+    3. Wysyła do providera AI
+    4. Waliduje wynik
+    5. Zwraca ClassifiedContact
+    """
+
+    def __init__(
+        self,
+        provider: BaseProvider,
+        profil: PrivacyProfile = "cloud-minimized",
+        cache: Optional[ClassificationCache] = None,
+    ) -> None:
+        self.provider = provider
+        self.profil = profil
+        self.cache = cache
+
+    def klasyfikuj(self, kontakt: dict[str, Any]) -> ClassifiedContact:
+        """
+        Klasyfikuje pojedynczy kontakt.
+
+        Args:
+            kontakt: Słownik z danymi kontaktu (z CSV).
+
+        Returns:
+            ClassifiedContact z tagami.
+        """
+        email = kontakt.get("email", "").strip()
+
+        # Krok 1: Zbuduj bezpieczny payload
+        payload, ostrzezenia = zbuduj_payload(kontakt, self.profil)
+
+        # Jeśli payload jest pusty — pomiń
+        if not payload:
+            return ClassifiedContact(
+                email=email,
+                status="skipped",
+                blad="Brak danych do klasyfikacji po redakcji PII",
+            )
+
+        # Krok 2: Sprawdź cache
+        if self.cache:
+            cached = self.cache.pobierz(payload)
+            if cached:
+                return ClassifiedContact(
+                    email=email,
+                    first_name=kontakt.get("first_name"),
+                    last_name=kontakt.get("last_name"),
+                    name=kontakt.get("name"),
+                    company=kontakt.get("company"),
+                    position=kontakt.get("position"),
+                    industry=kontakt.get("industry"),
+                    tag_branza=cached.get("branza", "nieznane"),
+                    tag_rola=cached.get("rola", "nieznane"),
+                    tag_intencja=cached.get("intencja", "nieokreslona"),
+                    tag_pewnosc=cached.get("pewnosc", 0.0),
+                    status="ok",
+                    blad=None,
+                )
+
+        # Krok 3: Sformatuj dla prompta
+        dane_dla_ai = sformatuj_payload_dla_prompta(payload)
+
+        # Krok 4: Wywołaj provider
+        start = time.time()
+        try:
+            wynik: TagResult = self.provider.klasyfikuj(dane_dla_ai)
+            (time.time() - start) * 1000
+        except Exception as e:
+            (time.time() - start) * 1000
+            logger.error("Błąd klasyfikacji %s: %s", email, str(e)[:100])
+            return ClassifiedContact(
+                email=email,
+                tag_branza="nieznane",
+                tag_rola="nieznane",
+                tag_intencja="nieznane",
+                tag_pewnosc=0.0,
+                status="error",
+                blad=str(e)[:200],
+            )
+
+        # Krok 5: Zapisz w cache
+        wynik_dict = {
+            "branza": wynik.branza.value,
+            "rola": wynik.rola.value,
+            "intencja": wynik.intencja.value,
+            "pewnosc": wynik.pewnosc,
+        }
+        if self.cache:
+            self.cache.zapisz(payload, wynik_dict)
+
+        # Krok 6: Zwróć rezultat
+        return ClassifiedContact(
+            email=email,
+            first_name=kontakt.get("first_name"),
+            last_name=kontakt.get("last_name"),
+            name=kontakt.get("name"),
+            company=kontakt.get("company"),
+            position=kontakt.get("position") or kontakt.get("title"),
+            industry=kontakt.get("industry"),
+            notes=kontakt.get("notes"),
+            website=kontakt.get("website"),
+            city=kontakt.get("city"),
+            country=kontakt.get("country"),
+            tag_branza=wynik.branza.value,
+            tag_rola=wynik.rola.value,
+            tag_intencja=wynik.intencja.value,
+            tag_pewnosc=wynik.pewnosc,
+            status="ok",
+            blad=None,
+        )