chaskiwasi 0.2.0__py3-none-any.whl

chaskiwasi/chunking/chunk_tokenizer.py

@@ -0,0 +1,43 @@
+# dantesito/chasky/chunking/chunk_tokenizer.py
+
+from typing import List
+
+import tiktoken
+
+from chaskiwasi.config.settings import Settings
+
+
+class ChunkTokenizer:
+    """Divide textos en fragmentos mediante ventanas de tokens de tiktoken."""
+
+    def __init__(self) -> None:
+        self._encoding = tiktoken.get_encoding(Settings.TIKTOKEN_ENCODING)
+
+    def split_text(self, text: str) -> List[str]:
+        """Divide el texto en chunks determinados exclusivamente por tokens."""
+        if not isinstance(text, str) or not text:
+            return []
+
+        tokens: List[int] = self._encoding.encode(text)
+
+        if not tokens:
+            return []
+
+        chunk_size: int = Settings.CHUNK_SIZE
+        step: int = Settings.CHUNK_SIZE - Settings.CHUNK_OVERLAP
+
+        chunks: List[str] = []
+        start: int = 0
+        total_tokens: int = len(tokens)
+
+        while start < total_tokens:
+            end: int = min(start + chunk_size, total_tokens)
+            chunk_tokens: List[int] = tokens[start:end]
+            chunks.append(self._encoding.decode(chunk_tokens))
+
+            if end >= total_tokens:
+                break
+
+            start += step
+
+        return chunks

chaskiwasi/classification/cascade_factory.py

@@ -0,0 +1,68 @@
+import logging
+from typing import Any, List, Optional, Tuple
+
+from chaskiwasi.classification.strategies.base_strategy import BaseStrategy
+
+logger = logging.getLogger(__name__)
+
+class CascadeFactory:
+    """
+    Fábrica y orquestador de clasificación en cascada agnóstico para chaskywasi.
+    Aplica una arquitectura de enrutamiento por estrategias ordenadas jerárquicamente.
+    """
+
+    def __init__(
+        self,
+        strategies: Optional[List[BaseStrategy]] = None,
+        default_source: Optional[Any] = None,
+        default_section: Optional[Any] = None,
+    ) -> None:
+        self._strategies: List[BaseStrategy] = strategies or []
+        self.default_source = default_source
+        self.default_section = default_section
+
+    def process_chunk(
+        self,
+        text: Optional[str],
+        current_source: Optional[Any] = None,
+    ) -> Tuple[Optional[Any], Optional[Any]]:
+        """Procesa un fragmento individual de texto iterando sobre la lista de estrategias."""
+        effective_default_source = current_source or self.default_source
+
+        if not text or not text.strip():
+            return effective_default_source, self.default_section
+
+        for strategy in self._strategies:
+            try:
+                src_res, sec_res = strategy.classify(
+                    text, current_source=effective_default_source
+                )
+
+                if sec_res is not None:
+                    final_source = src_res or effective_default_source
+                    return final_source, sec_res
+            except Exception as e:
+                logger.warning(
+                    "Estrategia %s falló durante la clasificación: %s",
+                    strategy.__class__.__name__,
+                    str(e),
+                )
+
+        return effective_default_source, self.default_section
+
+    def process_chunks_batch(
+        self,
+        chunks: List[str],
+        current_source: Optional[Any] = None,
+    ) -> List[Tuple[Optional[Any], Optional[Any]]]:
+        """Procesa una lista de fragmentos secuencialmente manteniendo el contexto actual."""
+        results = []
+        active_source = current_source or self.default_source
+        
+        for chunk in chunks:
+            src, sec = self.process_chunk(chunk, current_source=active_source)
+            if src is not None:
+                active_source = src
+            results.append((src, sec))
+            
+        return results

chaskiwasi/classification/strategies/base_strategy.py

@@ -0,0 +1,43 @@
+# dantesito/chasky/classification/strategies/base_strategy.py
+from abc import ABC, abstractmethod
+from typing import Tuple, Optional, Any
+
+# 🚀 CONTRATO ACTIVO: Importación obligatoria para control de tipos dinámicos
+from chaskiwasi.config.taxonomy_registry import TaxonomyRegistry
+
+
+class BaseStrategy(ABC):
+    """
+    Interfaz contractual agnóstica para todas las estrategias de inferencia semántica.
+    
+    Expone de forma segura las clases de Enums inyectadas por el cliente mediante
+    propiedades dinámicas de solo lectura, eliminando la fragilidad de constructores.
+    """
+
+    @property
+    def source_enum_class(self) -> Any:
+        """
+        Devuelve de forma dinámica la clase SourceEnum del cliente.
+        🛡️ CORTAFUEGOS EN CALIENTE: Lanza RuntimeError si no fue inyectada al arrancar.
+        """
+        return TaxonomyRegistry.get_source_enum()
+
+    @property
+    def section_enum_class(self) -> Any:
+        """
+        Devuelve de forma dinámica la clase SectionEnum del cliente.
+        🛡️ CORTAFUEGOS EN CALIENTE: Lanza RuntimeError si no fue inyectada al arrancar.
+        """
+        return TaxonomyRegistry.get_section_enum()
+
+    @abstractmethod
+    def classify(self, chunk: str, current_source: Optional[str] = None) -> Tuple[Optional[Any], Optional[Any]]:
+        """
+        Analiza un fragmento y devuelve una tupla conteniendo las instancias
+        de los Enums dinámicos del cliente (SourceEnum, SectionEnum).
+
+        :param chunk: Fragmento de texto Markdown a evaluar.
+        :param current_source: Contexto de origen acumulado o arrastrado.
+        :return: Tupla conteniendo (Instancia de SourceEnum, Instancia de SectionEnum)
+        """
+        pass

chaskiwasi/classification/strategies/context_overlap_strategy.py

@@ -0,0 +1,21 @@
+# dantesito/chasky/classification/strategies/context_overlap_strategy.py
+
+from typing import Optional, Tuple
+
+from chaskiwasi.classification.strategies.base_strategy import BaseStrategy
+from chaskiwasi.config.taxonomy_registry import SectionEnum, SourceEnum
+
+
+class ContextOverlapStrategy(BaseStrategy):
+    """Arrastra la fuente institucional desde el contexto del chunk anterior."""
+
+    def classify(
+        self,
+        chunk_text: str,
+        current_source: Optional[SourceEnum] = None,
+    ) -> Tuple[Optional[SourceEnum], Optional[SectionEnum]]:
+        """Mantiene la fuente previa sin inspeccionar el contenido del chunk."""
+        if current_source is not None:
+            return current_source, None
+
+        return None, None

chaskiwasi/classification/strategies/cpu_regex_strategy.py

@@ -0,0 +1,62 @@
+import re
+from dataclasses import dataclass, field
+from typing import Any, List, Optional, Pattern, Tuple
+from chaskiwasi.classification.strategies.base_strategy import BaseStrategy
+
+
+@dataclass
+class RegexRule:
+    """Estructura de datos para definir reglas de clasificación por Regex."""
+    source: Any
+    section: Any
+    patterns: List[str]
+    flags: int = re.IGNORECASE | re.DOTALL
+    compiled_patterns: List[Pattern[str]] = field(init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        compiled: List[Pattern[str]] = []
+        for pattern in self.patterns:
+            try:
+                compiled.append(re.compile(pattern, self.flags))
+            except re.error as err:
+                raise ValueError(
+                    f"Patrón Regex inválido '{pattern}' para la regla ({self.source}, {self.section}): {err}"
+                ) from err
+        self.compiled_patterns = compiled
+
+
+class CPURegexStrategy(BaseStrategy):
+    """Estrategia genérica que ejecuta reglas Regex inyectadas."""
+
+    def __init__(self, rules: Optional[List[RegexRule]] = None) -> None:
+        self.rules: List[RegexRule] = list(rules) if rules else []
+
+    def add_rule(self, rule: RegexRule) -> None:
+        """Permite registrar reglas dinámicamente."""
+        self.rules.append(rule)
+
+    def classify(
+        self,
+        chunk_text: str,
+        current_source: Optional[Any] = None,
+    ) -> Tuple[Optional[Any], Optional[Any]]:
+        if not isinstance(chunk_text, str) or not chunk_text:
+            return None, None
+
+        # Evaluación con preferencia contextual por current_source si aplica
+        for rule in self.rules:
+            if current_source and rule.source != current_source:
+                continue
+                
+            if any(pattern.search(chunk_text) for pattern in rule.compiled_patterns):
+                return rule.source, rule.section
+
+        # Segunda pasada para reglas generales si no coincidió en el contexto actual
+        if current_source:
+            for rule in self.rules:
+                if rule.source == current_source:
+                    continue
+                if any(pattern.search(chunk_text) for pattern in rule.compiled_patterns):
+                    return rule.source, rule.section
+
+        return None, None

chaskiwasi/classification/strategies/gemini_streamer.py

@@ -0,0 +1,99 @@
+import logging
+import os
+from typing import Any, Dict, Optional, Tuple
+
+from google import genai
+from google.genai import types
+
+from chaskiwasi.classification.strategies.base_strategy import BaseStrategy
+
+logging.getLogger("google.genai").setLevel(logging.ERROR)
+logging.getLogger("google.genai._api_client").setLevel(logging.ERROR)
+
+logger = logging.getLogger(__name__)
+
+
+class GeminiStreamer(BaseStrategy):
+    """Estrategia de inferencia remota en la nube totalmente agnóstica al dominio."""
+
+    def __init__(
+        self,
+        system_instruction: str,
+        label_mapping: Dict[str, Any],
+    ) -> None:
+        self.system_instruction = system_instruction
+        self.label_mapping = label_mapping
+        
+        api_key = ""
+        env_key = os.environ.get("GEMINI_API_KEY", "").strip()
+        if env_key:
+            api_key = env_key
+
+        if not api_key:
+            env_path = ".env"
+            if os.path.exists(env_path):
+                with open(env_path, "r", encoding="utf-8") as f:
+                    for line in f:
+                        clean_line = line.strip()
+                        if clean_line.startswith("GEMINI_API_KEY"):
+                            try:
+                                parsed_tokens = clean_line.split("=", 1)
+                                if len(parsed_tokens) == 2:
+                                    parsed_key = parsed_tokens[1].strip().strip('"').strip("'")
+                                    if parsed_key:
+                                        api_key = parsed_key
+                                        break
+                            except Exception:
+                                pass
+
+        if not api_key or not (api_key.startswith("AIzaSy") or api_key.startswith("AQ.")):
+            raise ValueError(
+                "🚨 ERROR CRÍTICO DE CONFIGURACIÓN: La variable 'GEMINI_API_KEY' "
+                "no está definida en el entorno ni en el archivo .env raíz."
+            )
+
+        self.client = genai.Client(api_key=api_key)
+        self.model_name = "gemini-3.5-flash-lite"
+
+    def classify(
+        self, chunk_text: str, current_source: Optional[Any] = None
+    ) -> Tuple[Optional[Any], Optional[Any]]:
+        if not chunk_text or not chunk_text.strip():
+            return None, None
+
+        try:
+            response = self.client.models.generate_content(
+                model=self.model_name,
+                contents=chunk_text,
+                config=types.GenerateContentConfig(
+                    system_instruction=self.system_instruction,
+                    temperature=0.1,
+                ),
+            )
+
+            if not response or not hasattr(response, "text") or not response.text:
+                logger.warning("Respuesta vacía o no válida recibida de la API de Gemini.")
+                return None, None
+
+            label = response.text.strip().lower()
+
+            if label == "desconocido":
+                return None, None
+
+            section_enum = self.label_mapping.get(label)
+            if section_enum is None:
+                logger.warning(
+                    "Etiqueta desconocida o fuera de taxonomía devuelta por Gemini: '%s'", label
+                )
+                return None, None
+
+            # Asumimos que Gemini por ahora solo devuelve la sección, manteniendo la firma original
+            return None, section_enum
+
+        except Exception as e:
+            logger.error(
+                "Error durante la inferencia remota con el cliente Google GenAI: %s",
+                str(e),
+                exc_info=True,
+            )
+            return None, None

chaskiwasi/classification/strategies/llm_router_strategy.py

@@ -0,0 +1,71 @@
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+import requests
+
+from chaskiwasi.classification.strategies.base_strategy import BaseStrategy
+from chaskiwasi.config.settings import settings
+
+logger = logging.getLogger(__name__)
+
+
+class LLMRouterStrategy(BaseStrategy):
+    """Estrategia agnóstica de clasificación de respaldo mediante Ollama local."""
+
+    def __init__(
+        self,
+        system_prompt: str,
+        label_mapping: Dict[str, Any],
+        endpoint: str = "http://localhost:11434/api/generate",
+        model_name: Optional[str] = None,
+        keep_alive: Optional[int] = None,
+        timeout: int = 10,
+    ) -> None:
+        self.system_prompt = system_prompt
+        self.label_mapping = label_mapping
+        self.endpoint = endpoint
+        self.model_name = model_name or settings.LLM_MODEL_NAME
+        self.keep_alive = keep_alive if keep_alive is not None else settings.OLLAMA_KEEP_ALIVE
+        self.timeout = timeout
+
+    def classify(
+        self,
+        chunk_text: str,
+        current_source: Optional[Any] = None,
+    ) -> Tuple[Optional[Any], Optional[Any]]:
+        """Clasifica el fragmento mediante el modelo local de Ollama."""
+        if not isinstance(chunk_text, str) or not chunk_text.strip():
+            return None, None
+
+        payload: Dict[str, Any] = {
+            "model": self.model_name,
+            "prompt": f"{self.system_prompt}\n\n{chunk_text}",
+            "stream": False,
+            "keep_alive": self.keep_alive,
+            "options": {
+                "num_predict": 10,
+            },
+        }
+
+        try:
+            response = requests.post(
+                self.endpoint,
+                json=payload,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            response_data: Dict[str, Any] = response.json()
+        except (requests.RequestException, ValueError, TypeError) as err:
+            logger.error("Error en inferencia remota con Ollama: %s", err)
+            return None, None
+
+        raw_result = str(response_data.get("response", "")).strip().upper()
+
+        if "DESCONOCIDO" in raw_result or not raw_result:
+            return None, None
+
+        for label_key, mapped_enum in self.label_mapping.items():
+            if label_key.upper() in raw_result:
+                return None, mapped_enum
+
+        return None, None

chaskiwasi/config/settings.py

@@ -0,0 +1,19 @@
+# dantesito/chasky/config/settings.py
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Settings:
+    """
+    Configuración global inmutable para el motor dantesito-chasky.
+    Diseñada con restricciones estrictas de bajo consumo en memoria RAM.
+    """
+    CHUNK_SIZE: int = 256
+    CHUNK_OVERLAP: int = 60
+    TIKTOKEN_ENCODING: str = "cl100k_base"
+    LLM_MODEL_NAME: str = "llama3.2:1b"
+    OLLAMA_KEEP_ALIVE: int = 0
+    CHROMA_PERSISTENT_PATH: str = "./data/chroma_db"
+
+
+settings = Settings()

chaskiwasi/config/taxonomy_registry.py

@@ -0,0 +1,55 @@
+# dantesito/chasky/config/taxonomy_registry.py
+import logging
+from typing import Any, Optional
+
+logger = logging.getLogger(__name__)
+
+# Contenedores en RAM que guardarán las clases reales provistas por dantesito-quipu o los mocks de test
+_SourceEnumClass: Optional[Any] = None
+_SectionEnumClass: Optional[Any] = None
+
+
+class TaxonomyRegistry:
+    """
+    Registro y validador agnóstico de taxonomías para PyPI.
+    Permite que la aplicación inyecte sus Enums en caliente al arrancar.
+    """
+
+    @classmethod
+    def inject_taxonomies(cls, source_enum_class: Any, section_enum_class: Any) -> None:
+        """Inyecta de forma segura las clases de enums del cliente en el core."""
+        global _SourceEnumClass, _SectionEnumClass
+        _SourceEnumClass = source_enum_class
+        _SectionEnumClass = section_enum_class
+        logger.info("[CHASKY-REGISTRY] Taxonomías del cliente inyectadas con éxito.")
+
+    @classmethod
+    def get_source_enum(cls) -> Any:
+        """Devuelve la clase SourceEnum activa o un Fallback si no fue inyectada."""
+        global _SourceEnumClass
+        if _SourceEnumClass is None:
+            raise RuntimeError("Falta inyectar la clase SourceEnum al arrancar la aplicación.")
+        return _SourceEnumClass
+
+    @classmethod
+    def get_section_enum(cls) -> Any:
+        """Devuelve la clase SectionEnum activa o un Fallback si no fue inyectada."""
+        global _SectionEnumClass
+        if _SectionEnumClass is None:
+            raise RuntimeError("Falta inyectar la clase SectionEnum al arrancar la aplicación.")
+        return _SectionEnumClass
+
+
+# =====================================================================
+# 🚀 INTERCEPTOR DE ATRIBUTOS A NIVEL DE MÓDULO (EL SECRETO DEL ÉXITO)
+# =====================================================================
+def __getattr__(name: str) -> Any:
+    """
+    Simula de forma polimórfica la existencia de SourceEnum y SectionEnum.
+    Resuelve el ImportError interceptando los 'from taxonomy_registry import ...'
+    """
+    if name == "SourceEnum":
+        return TaxonomyRegistry.get_source_enum()
+    if name == "SectionEnum":
+        return TaxonomyRegistry.get_section_enum()
+    raise AttributeError(f"El módulo '{__name__}' no posee el atributo '{name}'")

chaskiwasi/consolidation/consolidator.py

@@ -0,0 +1,158 @@
+import gc
+import io
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from docling.datamodel.base_models import DocumentStream
+from docling.document_converter import DocumentConverter
+
+from chaskiwasi.classification.cascade_factory import CascadeFactory
+
+logger = logging.getLogger(__name__)
+
+
+class ChaskyConsolidator:
+    """
+    Motor core agnóstico de consolidación y clasificación de legajos RAG.
+    
+    No posee acoplamiento con taxonomías fijas. Procesa flujos dinámicos en RAM (bytes)
+    o archivos en disco, delegando la estrategia de clasificación al `CascadeFactory` inyectado.
+    """
+
+    def __init__(
+        self,
+        cascade_factory: Optional[CascadeFactory] = None,
+        converter: Optional[DocumentConverter] = None,
+    ) -> None:
+        self._cascade_factory = cascade_factory or CascadeFactory()
+        self._converter = converter or DocumentConverter()
+
+    def build_master_expediente(
+        self,
+        global_id: str,
+        data_sources: Dict[str, Union[str, Path, bytes]],
+        output_json_path: Union[str, Path],
+    ) -> None:
+        """
+        Construye el reporte maestro consolidado procesando múltiples fuentes de datos.
+        """
+        logger.info(f"🚀 [CHASKY-CORE] Inicializando pipeline agnóstico para el lote: {global_id}")
+
+        master_data: Dict[str, Any] = {
+            "global_id": global_id,
+            "metadatos_proceso": {"total_fuentes": len(data_sources)},
+        }
+
+        for key_fuente, source_data in data_sources.items():
+            logger.info(f"[CHASKY-CORE] Procesando canal de información: '{key_fuente}'")
+
+            is_json_bytes = isinstance(source_data, bytes) and source_data.lstrip().startswith((b"[", b"{"))
+
+            if "json" in key_fuente.lower() or is_json_bytes:
+                master_data[key_fuente] = self._ingest_json_generic(source_data)
+            else:
+                master_data[key_fuente] = self._ingest_document_batch(source_data, key_fuente)
+
+        output_path = Path(output_json_path)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+
+        with open(output_path, "w", encoding="utf-8") as f:
+            json.dump(master_data, f, ensure_ascii=False, indent=2)
+
+        logger.info(f"💾 Reporte Maestro consolidado guardado con éxito en: {output_json_path}")
+
+        del master_data
+        gc.collect()
+
+    def _ingest_json_generic(self, json_source: Union[str, Path, bytes]) -> Dict[str, Any]:
+        """Procesa flujos JSON estructurados mediante streaming con ijson."""
+        import ijson
+
+        items = []
+        file_name = "stream_ram.json" if isinstance(json_source, bytes) else Path(json_source).name
+
+        try:
+            if isinstance(json_source, bytes):
+                with io.BytesIO(json_source) as stream:
+                    parser = ijson.items(stream, "item")
+                    for item in parser:
+                        items.append(item)
+                return {"file": file_name, "records": items}
+
+            json_path = Path(json_source)
+            if not json_path.exists():
+                return {"file": json_path.name, "records": []}
+
+            with open(json_path, "rb") as stream:
+                parser = ijson.items(stream, "item")
+                for item in parser:
+                    items.append(item)
+            return {"file": json_path.name, "records": items}
+
+        except Exception as err:
+            logger.error(f"Error en extracción genérica JSON para {file_name}: {err}")
+            return {"file": file_name, "records": []}
+
+    def _ingest_document_batch(
+        self,
+        doc_source: Union[str, Path, bytes],
+        source_label: str,
+    ) -> Dict[str, Any]:
+        """Extrae y clasifica fragmentos de documentos por lotes (Batching)."""
+        file_name = "stream_ram.pdf" if isinstance(doc_source, bytes) else Path(doc_source).name
+
+        try:
+            lista_completa_chunks = self._extract_pdf_chunks(doc_source)
+            if not lista_completa_chunks:
+                return {"file": file_name, "sections": []}
+
+            sections_found: List[Dict[str, Any]] = []
+
+            resultados_batch = self._cascade_factory.process_chunks_batch(
+                lista_completa_chunks,
+                current_source=source_label,
+            )
+
+            active_context = source_label
+            for i, chunk in enumerate(lista_completa_chunks):
+                detected_source, section = resultados_batch[i]
+
+                if detected_source is not None:
+                    active_context = getattr(detected_source, "value", str(detected_source))
+
+                section_value = getattr(section, "value", str(section)) if section is not None else None
+
+                sections_found.append({
+                    "chunk": chunk,
+                    "source": active_context,
+                    "section": section_value,
+                })
+
+            return {"file": file_name, "sections": sections_found}
+
+        except Exception as err:
+            logger.error(f"Error en procesamiento masivo del documento {file_name}: {err}")
+            return {"file": file_name, "sections": []}
+
+    def _extract_pdf_chunks(self, doc_source: Union[str, Path, bytes]) -> List[str]:
+        """Extrae texto plano Markdown utilizando Docling alimentándose de memoria o disco."""
+        chunks: List[str] = []
+        try:
+            if isinstance(doc_source, bytes):
+                with io.BytesIO(doc_source) as stream:
+                    doc_stream = DocumentStream(name="stream_in_memory.pdf", stream=stream)
+                    doc_result = self._converter.convert(doc_stream)
+            else:
+                doc_result = self._converter.convert(str(doc_source))
+
+            markdown_text = doc_result.document.export_to_markdown()
+            if markdown_text:
+                chunks = [c.strip() for c in markdown_text.split("\n\n") if c.strip()]
+
+            del doc_result
+        except Exception as err:
+            logger.warning(f"No se pudo extraer el contenido vía Docling: {err}")
+
+        return chunks

chaskiwasi/ingestion/docling_parser.py

@@ -0,0 +1,64 @@
+# dantesito/chasky/ingestion/docling_parser.py
+from pathlib import Path
+from typing import Optional
+
+from docling.document_converter import DocumentConverter, ConversionResult
+
+
+class DoclingParser:
+    """
+    Orquestador de extracción de documentos para dantesito-chasky.
+    Procesa PDFs mediante el pipeline de Docling y persiste el resultado en Markdown
+    directamente a disco para minimizar el impacto en memoria volátil (RAM).
+    """
+
+    def __init__(self, converter: Optional[DocumentConverter] = None) -> None:
+        """
+        Inicializa el convertidor de Docling. Permite la inyección de una instancia
+        personalizada para facilitación de pruebas unitarias o configuraciones avanzadas.
+        """
+        self._converter: DocumentConverter = converter or DocumentConverter()
+
+    def parse_to_markdown(self, pdf_path: str, output_md_path: str) -> str:
+        """
+        Procesa un archivo PDF en `pdf_path`, extrae su estructura en formato Markdown
+        y la escribe inmediatamente en el archivo físico en `output_md_path`.
+
+        Args:
+            pdf_path: Ruta del archivo PDF de entrada.
+            output_md_path: Ruta del archivo Markdown de salida.
+
+        Returns:
+            str: Contenido extraído en formato Markdown.
+
+        Raises:
+            FileNotFoundError: Si el archivo PDF especificado no existe.
+            ValueError: Si la ruta de entrada no es un PDF o el documento no se puede procesar.
+        """
+        input_path = Path(pdf_path)
+        output_path = Path(output_md_path)
+
+        if not input_path.is_file():
+            raise FileNotFoundError(f"El archivo PDF no existe en la ruta: {pdf_path}")
+
+        if input_path.suffix.lower() != ".pdf":
+            raise ValueError(f"El archivo especificado no es un PDF válido: {pdf_path}")
+
+        try:
+            result: ConversionResult = self._converter.convert(str(input_path))
+            markdown_content: str = result.document.export_to_markdown()
+
+            # Asegurar la creación del directorio padre si no existe
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Volcado directo a disco para mantener un footprint mínimo de memoria
+            output_path.write_text(markdown_content, encoding="utf-8")
+
+            return markdown_content
+
+        except Exception as e:
+            if isinstance(e, (FileNotFoundError, ValueError)):
+                raise
+            raise ValueError(
+                f"Error al procesar y convertir el archivo PDF '{pdf_path}': {str(e)}"
+            ) from e

chaskiwasi/query_engine/cross_filter.py

@@ -0,0 +1,74 @@
+import importlib.metadata
+import logging
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class IntentRule:
+    """Define una regla de enrutamiento basada en palabras clave."""
+    keywords: List[str]
+    metadata_filter: Dict[str, Any]
+
+
+class CrossQueryFilter:
+    """Generador dinámico de filtros cruzados para ChromaDB compatible con Entry Points."""
+
+    def __init__(
+        self,
+        load_plugins: bool = True,
+        custom_rules: Optional[List[IntentRule]] = None,
+    ) -> None:
+        """
+        Inicializa el filtro con reglas inyectadas manualmente o descubiertas vía plugins.
+        """
+        self.rules: List[IntentRule] = custom_rules or []
+        
+        if load_plugins:
+            self._load_rules_from_entry_points()
+
+    def _load_rules_from_entry_points(self) -> None:
+        """
+        Escanea el entorno de Python buscando plugins registrados bajo 'chaskywasi.query_rules'.
+        """
+        try:
+            # Compatibilidad nativa para Python 3.10+
+            entry_points = importlib.metadata.entry_points(group="chaskywasi.query_rules")
+            for ep in entry_points:
+                try:
+                    plugin_callable = ep.load()
+                    plugin_rules = plugin_callable()
+                    
+                    if isinstance(plugin_rules, list):
+                        self.rules.extend(plugin_rules)
+                        logger.info("Plugin de reglas cargado exitosamente: '%s'", ep.name)
+                except Exception as e:
+                    logger.warning("Fallo al cargar el plugin de reglas '%s': %s", ep.name, e)
+        except KeyError:
+            # No hay plugins instalados para este grupo
+            pass
+
+    def generate_where_clause(self, query_text: str, doc_id: str) -> Dict[str, Any]:
+        """
+        Analiza el texto iterando sobre las reglas dinámicas y genera el diccionario
+        de metadatos bajo las restricciones de la API de ChromaDB.
+        """
+        base_filter = {"id_documento": doc_id}
+
+        if not query_text or not isinstance(query_text, str) or not query_text.strip():
+            return base_filter
+
+        query_lower = query_text.lower()
+
+        for rule in self.rules:
+            if any(w in query_lower for w in rule.keywords):
+                return {
+                    "$and": [
+                        base_filter,
+                        rule.metadata_filter
+                    ]
+                }
+
+        return base_filter

chaskiwasi/query_engine/ollama_streamer.py

@@ -0,0 +1,64 @@
+# dantesito/chasky/query_engine/ollama_streamer.py
+
+import json
+from typing import Any, Dict, Iterator, Optional
+
+import requests
+
+from chaskiwasi.config.settings import Settings
+
+
+class OllamaStreamer:
+    """Cliente HTTP para consumir respuestas de Ollama mediante streaming."""
+
+    _DEFAULT_ENDPOINT: str = "http://localhost:11434/api/generate"
+    _CONNECTION_ERROR_MESSAGE: str = "[ERROR] No se pudo conectar con Ollama."
+
+    def __init__(self, endpoint: str = _DEFAULT_ENDPOINT) -> None:
+        self._endpoint: str = endpoint
+
+    def stream_response(
+        self,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+    ) -> Iterator[str]:
+        """Genera incrementalmente la respuesta del LLM mediante streaming."""
+        payload: Dict[str, Any] = {
+            "model": Settings.LLM_MODEL_NAME,
+            "prompt": prompt,
+            "stream": True,
+            "keep_alive": Settings.OLLAMA_KEEP_ALIVE,
+        }
+
+        if system_prompt is not None:
+            payload["system"] = system_prompt
+
+        try:
+            response: requests.Response = requests.post(
+                self._endpoint,
+                json=payload,
+                stream=True,
+            )
+            response.raise_for_status()
+
+            for line in response.iter_lines():
+                if not line:
+                    continue
+
+                try:
+                    decoded_line: str = (
+                        line.decode("utf-8")
+                        if isinstance(line, bytes)
+                        else str(line)
+                    )
+                    data: Dict[str, Any] = json.loads(decoded_line)
+                except (UnicodeDecodeError, json.JSONDecodeError):
+                    continue
+
+                fragment: Any = data.get("response")
+
+                if isinstance(fragment, str):
+                    yield fragment
+
+        except requests.exceptions.ConnectionError:
+            yield self._CONNECTION_ERROR_MESSAGE

chaskiwasi/storage/chroma_persistent.py

@@ -0,0 +1,67 @@
+# dantesito/chasky/storage/chroma_persistent.py
+
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import chromadb
+from chromadb.api.models.Collection import Collection
+
+from chaskiwasi.config.settings import Settings
+from chaskiwasi.config.taxonomy_registry import SectionEnum, SourceEnum
+
+
+class ChromaPersistentManager:
+    """Gestiona el almacenamiento persistente de fragmentos en ChromaDB."""
+
+    def __init__(
+        self,
+        persistence_path: Optional[str] = None,
+    ) -> None:
+        path: str = (
+            persistence_path
+            if persistence_path is not None
+            else Settings.CHROMA_PERSISTENT_PATH
+        )
+
+        Path(path).mkdir(parents=True, exist_ok=True)
+        self._client = chromadb.PersistentClient(path=path)
+
+    def get_or_create_collection(self, collection_name: str) -> Collection:
+        """Obtiene o crea una colección usando la configuración nativa de ChromaDB."""
+        return self._client.get_or_create_collection(
+            name=collection_name,
+        )
+
+    def add_chunks(
+        self,
+        collection_name: str,
+        doc_id: str,
+        source: SourceEnum,
+        chunks: List[Tuple[SectionEnum, str]],
+    ) -> None:
+        """Agrega fragmentos y su taxonomía estricta a una colección."""
+        if not chunks:
+            return
+
+        collection: Collection = self.get_or_create_collection(collection_name)
+
+        documents: List[str] = []
+        metadatas: List[dict[str, str]] = []
+        ids: List[str] = []
+
+        for idx, (section, text) in enumerate(chunks):
+            documents.append(text)
+            metadatas.append(
+                {
+                    "id_documento": doc_id,
+                    "fuente": source.value,
+                    "tipo_seccion": section.value,
+                }
+            )
+            ids.append(f"{doc_id}_{idx}")
+
+        collection.add(
+            documents=documents,
+            metadatas=metadatas,
+            ids=ids,
+        )

chaskiwasi-0.2.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.5
+Name: chaskiwasi
+Version: 0.2.0
+Summary: Sistema de consulta semántica para fuentes jurídicas.
+Project-URL: Homepage, https://github.com/Maorda/chaskywasi
+Project-URL: Issues, https://github.com/Maorda/chaskywasi/issues
+Author-email: Luis Maurtua <luis.maurtua@ejemplo.com>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+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
+Requires-Python: >=3.10
+Requires-Dist: chromadb>=0.5.0
+Requires-Dist: docling>=2.0.0
+Requires-Dist: google-genai>=0.1.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: ijson>=3.3.0
+Requires-Dist: requests>=2.32.0
+Requires-Dist: streamlit>=1.30.0
+Requires-Dist: tiktoken>=0.7.0
+Provides-Extra: dev
+Requires-Dist: anyio>=4.0.0; extra == 'dev'
+Requires-Dist: faker>=20.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+GOLA

chaskiwasi-0.2.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+chaskiwasi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chaskiwasi/chunking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chaskiwasi/chunking/chunk_tokenizer.py,sha256=xEJm1K5hqhiUIbHFI1gzYDUP0TwhJ1fYTe4vCBe_Qmg,1187
+chaskiwasi/classification/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chaskiwasi/classification/cascade_factory.py,sha256=-H3aCHHlRAaUwSBN1Li2CvyYO4NFwhsxo7USLPp7BOM,2440
+chaskiwasi/classification/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chaskiwasi/classification/strategies/base_strategy.py,sha256=xvFmcSVrVUuBoKbT5lBLAJrICSjXqopf2Obt3yI9qfE,1719
+chaskiwasi/classification/strategies/context_overlap_strategy.py,sha256=Ac7NKilkW3xRYN0RzclSYkFeUmJGy539TFREegv6Kx0,743
+chaskiwasi/classification/strategies/cpu_regex_strategy.py,sha256=eg8VeFTCoYCfjUIPVvXs1DLPv5P1Pwj8uv4mIhpywHQ,2295
+chaskiwasi/classification/strategies/gemini_streamer.py,sha256=j5qLhJRmi4xNRsYtCth5mzn0t81ANemO8JGThUb252I,3626
+chaskiwasi/classification/strategies/llm_router_strategy.py,sha256=VLJH6UnkpBNlO840fJH5SIsB2qu-bFyRMbhy9MK8eSE,2375
+chaskiwasi/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chaskiwasi/config/settings.py,sha256=0YOUJoiAkWuWVMoAmomKAOiYXfoxa50QRSKM5DWbIj0,516
+chaskiwasi/config/taxonomy_registry.py,sha256=mAvjH1jqAf-yO_VTSb3HJwj5N582R1DGYhV5DjMlSxw,2271
+chaskiwasi/consolidation/consolidator.py,sha256=QLPSnn5dxDJmFwQGAd7kG02QjGRM_3wtZwqPZXcf_BA,6129
+chaskiwasi/ingestion/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chaskiwasi/ingestion/docling_parser.py,sha256=UNEwot3LOYJrZcbhnnEI94UDm6DvM13w_jKjFUTII4U,2563
+chaskiwasi/query_engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chaskiwasi/query_engine/cross_filter.py,sha256=PvpAMnuyM8aiw-F_PUI8Mac775Yircgo6XOKY63xMDk,2551
+chaskiwasi/query_engine/ollama_streamer.py,sha256=V2UsffssQ5Zy4EEsSxPQQQ4lrcN-ktcVe4xa-FXRqjw,1977
+chaskiwasi/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+chaskiwasi/storage/chroma_persistent.py,sha256=2cJlLZc0kmktVG65DYpYv1ZUCU3hsqQ3rXU5bTxWgt0,2000
+chaskiwasi-0.2.0.dist-info/METADATA,sha256=-nGWk4TDNGbkhYcl-ajKACwUwruWvgKIuMrUiC9sgp0,1136
+chaskiwasi-0.2.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+chaskiwasi-0.2.0.dist-info/RECORD,,

chaskiwasi-0.2.0.dist-info/WHEEL

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