haiku.rag 0.10.2__py3-none-any.whl → 0.19.3__py3-none-any.whl

haiku/rag/store/repositories/settings.py

@@ -1,155 +0,0 @@
-import json
-
-from haiku.rag.config import Config
-from haiku.rag.store.engine import SettingsRecord, Store
-
-
-class ConfigMismatchError(Exception):
-    """Raised when stored config doesn't match current config."""
-
-    pass
-
-
-class SettingsRepository:
-    """Repository for Settings operations."""
-
-    def __init__(self, store: Store) -> None:
-        self.store = store
-
-    async def create(self, entity: dict) -> dict:
-        """Create settings in the database."""
-        settings_record = SettingsRecord(id="settings", settings=json.dumps(entity))
-        self.store.settings_table.add([settings_record])
-        return entity
-
-    async def get_by_id(self, entity_id: str) -> dict | None:
-        """Get settings by ID."""
-        results = list(
-            self.store.settings_table.search()
-            .where(f"id = '{entity_id}'")
-            .limit(1)
-            .to_pydantic(SettingsRecord)
-        )
-
-        if not results:
-            return None
-
-        return json.loads(results[0].settings) if results[0].settings else {}
-
-    async def update(self, entity: dict) -> dict:
-        """Update existing settings."""
-        self.store.settings_table.update(
-            where="id = 'settings'", values={"settings": json.dumps(entity)}
-        )
-        return entity
-
-    async def delete(self, entity_id: str) -> bool:
-        """Delete settings by ID."""
-        self.store.settings_table.delete(f"id = '{entity_id}'")
-        return True
-
-    async def list_all(
-        self, limit: int | None = None, offset: int | None = None
-    ) -> list[dict]:
-        """List all settings."""
-        results = list(self.store.settings_table.search().to_pydantic(SettingsRecord))
-        return [
-            json.loads(record.settings) if record.settings else {} for record in results
-        ]
-
-    def get_current_settings(self) -> dict:
-        """Get the current settings."""
-        results = list(
-            self.store.settings_table.search()
-            .where("id = 'settings'")
-            .limit(1)
-            .to_pydantic(SettingsRecord)
-        )
-
-        if not results:
-            return {}
-
-        return json.loads(results[0].settings) if results[0].settings else {}
-
-    def save_current_settings(self) -> None:
-        """Save the current configuration to the database."""
-        current_config = Config.model_dump(mode="json")
-
-        # Check if settings exist
-        existing = list(
-            self.store.settings_table.search()
-            .where("id = 'settings'")
-            .limit(1)
-            .to_pydantic(SettingsRecord)
-        )
-
-        if existing:
-            # Preserve existing version if present to avoid interfering with upgrade flow
-            try:
-                existing_settings = (
-                    json.loads(existing[0].settings) if existing[0].settings else {}
-                )
-            except Exception:
-                existing_settings = {}
-            if "version" in existing_settings:
-                current_config["version"] = existing_settings["version"]
-
-            # Update existing settings
-            if existing_settings != current_config:
-                self.store.settings_table.update(
-                    where="id = 'settings'",
-                    values={"settings": json.dumps(current_config)},
-                )
-        else:
-            # Create new settings
-            settings_record = SettingsRecord(
-                id="settings", settings=json.dumps(current_config)
-            )
-            self.store.settings_table.add([settings_record])
-
-    def validate_config_compatibility(self) -> None:
-        """Validate that the current configuration is compatible with stored settings."""
-        stored_settings = self.get_current_settings()
-
-        # If no stored settings, this is a new database - save current config and return
-        if not stored_settings:
-            self.save_current_settings()
-            return
-
-        current_config = Config.model_dump(mode="json")
-
-        # Check if embedding provider or model has changed
-        stored_provider = stored_settings.get("EMBEDDINGS_PROVIDER")
-        current_provider = current_config.get("EMBEDDINGS_PROVIDER")
-
-        stored_model = stored_settings.get("EMBEDDINGS_MODEL")
-        current_model = current_config.get("EMBEDDINGS_MODEL")
-
-        stored_vector_dim = stored_settings.get("EMBEDDINGS_VECTOR_DIM")
-        current_vector_dim = current_config.get("EMBEDDINGS_VECTOR_DIM")
-
-        # Check for incompatible changes
-        incompatible_changes = []
-
-        if stored_provider and stored_provider != current_provider:
-            incompatible_changes.append(
-                f"Embedding provider changed from '{stored_provider}' to '{current_provider}'"
-            )
-
-        if stored_model and stored_model != current_model:
-            incompatible_changes.append(
-                f"Embedding model changed from '{stored_model}' to '{current_model}'"
-            )
-
-        if stored_vector_dim and stored_vector_dim != current_vector_dim:
-            incompatible_changes.append(
-                f"Vector dimension changed from {stored_vector_dim} to {current_vector_dim}"
-            )
-
-        if incompatible_changes:
-            error_msg = (
-                "Database configuration is incompatible with current settings:\n"
-                + "\n".join(f"  - {change}" for change in incompatible_changes)
-            )
-            error_msg += "\n\nPlease rebuild the database using: haiku-rag rebuild"
-            raise ConfigMismatchError(error_msg)

haiku/rag/store/upgrades/__init__.py

@@ -1,62 +0,0 @@
-import logging
-from collections.abc import Callable
-from dataclasses import dataclass
-
-from packaging.version import Version, parse
-
-from haiku.rag.store.engine import Store
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class Upgrade:
-    """Represents a database upgrade step."""
-
-    version: str
-    apply: Callable[[Store], None]
-    description: str = ""
-
-
-# Registry of upgrade steps (ordered by version)
-upgrades: list[Upgrade] = []
-
-
-def run_pending_upgrades(store: Store, from_version: str, to_version: str) -> None:
-    """Run upgrades where from_version < step.version <= to_version."""
-    v_from: Version = parse(from_version)
-    v_to: Version = parse(to_version)
-
-    # Ensure that tests/development run available code upgrades even if the
-    # installed package version hasn't been bumped to include them yet.
-    if upgrades:
-        highest_step_version: Version = max(parse(u.version) for u in upgrades)
-        if highest_step_version > v_to:
-            v_to = highest_step_version
-
-    # Determine applicable steps
-    sorted_steps = sorted(upgrades, key=lambda u: parse(u.version))
-    applicable = [s for s in sorted_steps if v_from < parse(s.version) <= v_to]
-    if applicable:
-        logger.info("%d upgrade step(s) pending", len(applicable))
-
-    # Apply in ascending order
-    for idx, step in enumerate(applicable, start=1):
-        logger.info(
-            "Applying upgrade %s: %s (%d/%d)",
-            step.version,
-            step.description or "",
-            idx,
-            len(applicable),
-        )
-        step.apply(store)
-        logger.info("Completed upgrade %s", step.version)
-
-
-from .v0_9_3 import upgrade_fts_phrase as upgrade_0_9_3_fts  # noqa: E402
-from .v0_9_3 import upgrade_order as upgrade_0_9_3_order  # noqa: E402
-from .v0_10_1 import upgrade_add_title as upgrade_0_10_1_add_title  # noqa: E402
-
-upgrades.append(upgrade_0_9_3_order)
-upgrades.append(upgrade_0_9_3_fts)
-upgrades.append(upgrade_0_10_1_add_title)

haiku/rag/store/upgrades/v0_10_1.py

@@ -1,64 +0,0 @@
-import json
-
-from lancedb.pydantic import LanceModel
-from pydantic import Field
-
-from haiku.rag.store.engine import Store
-from haiku.rag.store.upgrades import Upgrade
-
-
-def _apply_add_document_title(store: Store) -> None:
-    """Add a nullable 'title' column to the documents table."""
-
-    # Read existing rows using Arrow for schema-agnostic access
-    try:
-        docs_arrow = store.documents_table.search().to_arrow()
-        rows = docs_arrow.to_pylist()
-    except Exception:
-        rows = []
-
-    class DocumentRecordV2(LanceModel):
-        id: str
-        content: str
-        uri: str | None = None
-        title: str | None = None
-        metadata: str = Field(default="{}")
-        created_at: str = Field(default_factory=lambda: "")
-        updated_at: str = Field(default_factory=lambda: "")
-
-    # Drop and recreate documents table with the new schema
-    try:
-        store.db.drop_table("documents")
-    except Exception:
-        pass
-
-    store.documents_table = store.db.create_table("documents", schema=DocumentRecordV2)
-
-    # Reinsert previous rows with title=None
-    if rows:
-        backfilled = []
-        for row in rows:
-            backfilled.append(
-                DocumentRecordV2(
-                    id=row.get("id"),
-                    content=row.get("content", ""),
-                    uri=row.get("uri"),
-                    title=None,
-                    metadata=(
-                        row.get("metadata")
-                        if isinstance(row.get("metadata"), str)
-                        else json.dumps(row.get("metadata") or {})
-                    ),
-                    created_at=row.get("created_at", ""),
-                    updated_at=row.get("updated_at", ""),
-                )
-            )
-
-        store.documents_table.add(backfilled)
-
-
-upgrade_add_title = Upgrade(
-    version="0.10.1",
-    apply=_apply_add_document_title,
-    description="Add nullable 'title' column to documents table",
-)

haiku/rag/store/upgrades/v0_9_3.py

@@ -1,112 +0,0 @@
-import json
-
-from lancedb.pydantic import LanceModel, Vector
-from pydantic import Field
-
-from haiku.rag.store.engine import Store
-from haiku.rag.store.upgrades import Upgrade
-
-
-def _infer_vector_dim(store: Store) -> int:
-    """Infer vector dimension from existing data; fallback to embedder config."""
-    try:
-        arrow = store.chunks_table.search().limit(1).to_arrow()
-        rows = arrow.to_pylist()
-        if rows:
-            vec = rows[0].get("vector")
-            if isinstance(vec, list) and vec:
-                return len(vec)
-    except Exception:
-        pass
-    # Fallback to configured embedder vector dim
-    return getattr(store.embedder, "_vector_dim", 1024)
-
-
-def _apply_chunk_order(store: Store) -> None:
-    """Add integer 'order' column to chunks and backfill from metadata."""
-
-    vector_dim = _infer_vector_dim(store)
-
-    class ChunkRecordV2(LanceModel):
-        id: str
-        document_id: str
-        content: str
-        metadata: str = Field(default="{}")
-        order: int = Field(default=0)
-        vector: Vector(vector_dim) = Field(  # type: ignore
-            default_factory=lambda: [0.0] * vector_dim
-        )
-
-    # Read existing chunks
-    try:
-        chunks_arrow = store.chunks_table.search().to_arrow()
-        rows = chunks_arrow.to_pylist()
-    except Exception:
-        rows = []
-
-    new_chunk_records: list[ChunkRecordV2] = []
-    for row in rows:
-        md_raw = row.get("metadata") or "{}"
-        try:
-            md = json.loads(md_raw) if isinstance(md_raw, str) else md_raw
-        except Exception:
-            md = {}
-        # Extract and normalize order
-        order_val = 0
-        try:
-            if isinstance(md, dict) and "order" in md:
-                order_val = int(md["order"])  # type: ignore[arg-type]
-        except Exception:
-            order_val = 0
-
-        if isinstance(md, dict) and "order" in md:
-            md = {k: v for k, v in md.items() if k != "order"}
-
-        vec = row.get("vector") or [0.0] * vector_dim
-
-        new_chunk_records.append(
-            ChunkRecordV2(
-                id=row.get("id"),
-                document_id=row.get("document_id"),
-                content=row.get("content", ""),
-                metadata=json.dumps(md),
-                order=order_val,
-                vector=vec,
-            )
-        )
-
-    # Recreate chunks table with new schema
-    try:
-        store.db.drop_table("chunks")
-    except Exception:
-        pass
-
-    store.chunks_table = store.db.create_table("chunks", schema=ChunkRecordV2)
-    store.chunks_table.create_fts_index("content", replace=True)
-
-    if new_chunk_records:
-        store.chunks_table.add(new_chunk_records)
-
-
-upgrade_order = Upgrade(
-    version="0.9.3",
-    apply=_apply_chunk_order,
-    description="Add 'order' column to chunks and backfill from metadata",
-)
-
-
-def _apply_fts_phrase_support(store: Store) -> None:
-    """Recreate FTS index with phrase query support and no stop-word removal."""
-    try:
-        store.chunks_table.create_fts_index(
-            "content", replace=True, with_position=True, remove_stop_words=False
-        )
-    except Exception:
-        pass
-
-
-upgrade_fts_phrase = Upgrade(
-    version="0.9.3",
-    apply=_apply_fts_phrase_support,
-    description="Enable FTS phrase queries (with positions) and keep stop-words",
-)

haiku/rag/utils.py

@@ -1,199 +0,0 @@
-import asyncio
-import importlib
-import importlib.util
-import sys
-from collections.abc import Callable
-from functools import wraps
-from importlib import metadata
-from io import BytesIO
-from pathlib import Path
-from types import ModuleType
-
-from packaging.version import Version, parse
-
-
-def debounce(wait: float) -> Callable:
-    """
-    A decorator to debounce a function, ensuring it is called only after a specified delay
-    and always executes after the last call.
-
-    Args:
-        wait (float): The debounce delay in seconds.
-
-    Returns:
-        Callable: The decorated function.
-    """
-
-    def decorator(func: Callable) -> Callable:
-        last_call = None
-        task = None
-
-        @wraps(func)
-        async def debounced(*args, **kwargs):
-            nonlocal last_call, task
-            last_call = asyncio.get_event_loop().time()
-
-            if task:
-                task.cancel()
-
-            async def call_func():
-                await asyncio.sleep(wait)
-                if asyncio.get_event_loop().time() - last_call >= wait:  # type: ignore
-                    await func(*args, **kwargs)
-
-            task = asyncio.create_task(call_func())
-
-        return debounced
-
-    return decorator
-
-
-def get_default_data_dir() -> Path:
-    """Get the user data directory for the current system platform.
-
-    Linux: ~/.local/share/haiku.rag
-    macOS: ~/Library/Application Support/haiku.rag
-    Windows: C:/Users/<USER>/AppData/Roaming/haiku.rag
-
-    Returns:
-        User Data Path.
-    """
-    home = Path.home()
-
-    system_paths = {
-        "win32": home / "AppData/Roaming/haiku.rag",
-        "linux": home / ".local/share/haiku.rag",
-        "darwin": home / "Library/Application Support/haiku.rag",
-    }
-
-    data_path = system_paths[sys.platform]
-    return data_path
-
-
-async def is_up_to_date() -> tuple[bool, Version, Version]:
-    """Check whether haiku.rag is current.
-
-    Returns:
-        A tuple containing a boolean indicating whether haiku.rag is current,
-        the running version and the latest version.
-    """
-
-    # Lazy import to avoid pulling httpx (and its deps) on module import
-    import httpx
-
-    async with httpx.AsyncClient() as client:
-        running_version = parse(metadata.version("haiku.rag"))
-        try:
-            response = await client.get("https://pypi.org/pypi/haiku.rag/json")
-            data = response.json()
-            pypi_version = parse(data["info"]["version"])
-        except Exception:
-            # If no network connection, do not raise alarms.
-            pypi_version = running_version
-    return running_version >= pypi_version, running_version, pypi_version
-
-
-def text_to_docling_document(text: str, name: str = "content.md"):
-    """Convert text content to a DoclingDocument.
-
-    Args:
-        text: The text content to convert.
-        name: The name to use for the document stream (defaults to "content.md").
-
-    Returns:
-        A DoclingDocument created from the text content.
-    """
-    # Lazy import docling deps to keep import-time light
-    from docling.document_converter import DocumentConverter  # type: ignore
-    from docling_core.types.io import DocumentStream  # type: ignore
-
-    bytes_io = BytesIO(text.encode("utf-8"))
-    doc_stream = DocumentStream(name=name, stream=bytes_io)
-    converter = DocumentConverter()
-    result = converter.convert(doc_stream)
-    return result.document
-
-
-def load_callable(path: str):
-    """Load a callable from a dotted path or file path.
-
-    Supported formats:
-    - "package.module:func" or "package.module.func"
-    - "path/to/file.py:func"
-
-    Returns the loaded callable. Raises ValueError on failure.
-    """
-    if not path:
-        raise ValueError("Empty callable path provided")
-
-    module_part = None
-    func_name = None
-
-    if ":" in path:
-        module_part, func_name = path.split(":", 1)
-    else:
-        # split by last dot for module.attr
-        if "." in path:
-            module_part, func_name = path.rsplit(".", 1)
-        else:
-            raise ValueError(
-                "Invalid callable path format. Use 'module:func' or 'module.func' or 'file.py:func'."
-            )
-
-    # Try file path first
-    mod: ModuleType | None = None
-    module_path = Path(module_part)
-    if module_path.suffix == ".py" and module_path.exists():
-        spec = importlib.util.spec_from_file_location(module_path.stem, module_path)
-        if spec and spec.loader:
-            mod = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(mod)
-    else:
-        # Import as a module path
-        try:
-            mod = importlib.import_module(module_part)
-        except Exception as e:
-            raise ValueError(f"Failed to import module '{module_part}': {e}")
-
-    if not hasattr(mod, func_name):
-        raise ValueError(f"Callable '{func_name}' not found in module '{module_part}'")
-    func = getattr(mod, func_name)
-    if not callable(func):
-        raise ValueError(
-            f"Attribute '{func_name}' in module '{module_part}' is not callable"
-        )
-    return func
-
-
-def prefetch_models():
-    """Prefetch runtime models (Docling + Ollama as configured)."""
-    import httpx
-    from docling.utils.model_downloader import download_models
-
-    from haiku.rag.config import Config
-
-    download_models()
-
-    # Collect Ollama models from config
-    required_models: set[str] = set()
-    if Config.EMBEDDINGS_PROVIDER == "ollama":
-        required_models.add(Config.EMBEDDINGS_MODEL)
-    if Config.QA_PROVIDER == "ollama":
-        required_models.add(Config.QA_MODEL)
-    if Config.RESEARCH_PROVIDER == "ollama":
-        required_models.add(Config.RESEARCH_MODEL)
-    if Config.RERANK_PROVIDER == "ollama":
-        required_models.add(Config.RERANK_MODEL)
-
-    if not required_models:
-        return
-
-    base_url = Config.OLLAMA_BASE_URL
-
-    with httpx.Client(timeout=None) as client:
-        for model in sorted(required_models):
-            with client.stream(
-                "POST", f"{base_url}/api/pull", json={"model": model}
-            ) as r:
-                for _ in r.iter_lines():
-                    pass

haiku_rag-0.10.2.dist-info/RECORD

@@ -1,54 +0,0 @@
-haiku/rag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-haiku/rag/app.py,sha256=-nhri6MLIZvp8DEndfeixTCVj6kutWwfLguyAcNe9S4,18023
-haiku/rag/chunker.py,sha256=PVe6ysv8UlacUd4Zb3_8RFWIaWDXnzBAy2VDJ4TaUsE,1555
-haiku/rag/cli.py,sha256=wreAxyXSRnn7f09t9SGe4uAXQjlieUQIpNpOapJT7y8,12910
-haiku/rag/client.py,sha256=iUaa6YUac3CXFniIm8DsaaNsiyHsi4cp8-fPhF5XuVU,22925
-haiku/rag/config.py,sha256=SEV2OzaKavYwHZ0LmRzBj-0dbI6YFIRuNiTw9el7SO0,2307
-haiku/rag/logging.py,sha256=dm65AwADpcQsH5OAPtRA-4hsw0w5DK-sGOvzYkj6jzw,1720
-haiku/rag/mcp.py,sha256=H7XibtSNUviFeaJVsXzHiRqUm0nJCpA7A1QHuBv6SKQ,5057
-haiku/rag/migration.py,sha256=zm0-60PiS1hIQnZz65B7qfsgM7GwZVXFqMFowjpVBs8,11058
-haiku/rag/monitor.py,sha256=r386nkhdlsU8UECwIuVwnrSlgMk3vNIuUZGNIzkZuec,2770
-haiku/rag/reader.py,sha256=qkPTMJuQ_o4sK-8zpDl9WFYe_MJ7aL_gUw6rczIpW-g,3274
-haiku/rag/utils.py,sha256=dBzhKaOHI9KRiJqHErcXUnqtnXY2AgOK8PCLA3rhO0A,6115
-haiku/rag/embeddings/__init__.py,sha256=44IfDITGIFTflGT6UEmiYOwpWFVbYv5smLY59D0YeCs,1419
-haiku/rag/embeddings/base.py,sha256=BnSviKrlzjv3L0sZJs_T-pxfawd-bcTak-rsX-D2f3A,497
-haiku/rag/embeddings/ollama.py,sha256=LuLlHH6RGoO9_gFCIlbmesuXOj017gTw6z-p8Ez0CfE,595
-haiku/rag/embeddings/openai.py,sha256=fIFCk-jpUtaW0xsnrQnJ824O0UCjaGG2sgvBzREhilc,503
-haiku/rag/embeddings/vllm.py,sha256=vhaUnCn6VMkfSluLhWKtSV-sekFaPsp4pKo2N7-SBCY,626
-haiku/rag/embeddings/voyageai.py,sha256=UW-MW4tJKnPB6Fs2P7A3yt-ZeRm46H9npckchSriPX8,661
-haiku/rag/qa/__init__.py,sha256=Sl7Kzrg9CuBOcMF01wc1NtQhUNWjJI0MhIHfCWrb8V4,434
-haiku/rag/qa/agent.py,sha256=rtUkEmnD8lMHIxpPPVY6TdmF4aSlZnLjad5eDefrlBw,3145
-haiku/rag/qa/prompts.py,sha256=Lqwn3m4zCsu_CJiC4s9cLsuPNbb9nq6j2PqEF3lw1eA,3380
-haiku/rag/reranking/__init__.py,sha256=IRXHs4qPu6VbGJQpzSwhgtVWWumURH_vEoVFE-extlo,894
-haiku/rag/reranking/base.py,sha256=LM9yUSSJ414UgBZhFTgxGprlRqzfTe4I1vgjricz2JY,405
-haiku/rag/reranking/cohere.py,sha256=1iTdiaa8vvb6oHVB2qpWzUOVkyfUcimVSZp6Qr4aq4c,1049
-haiku/rag/reranking/mxbai.py,sha256=uveGFIdmNmepd2EQsvYr64wv0ra2_wB845hdSZXy5Cw,908
-haiku/rag/reranking/vllm.py,sha256=xVGH9ss-ISWdJ5SKUUHUbTqBo7PIEmA_SQv0ScdJ6XA,1479
-haiku/rag/research/__init__.py,sha256=t4JAmIXcKaWqvpFGX5yaehsNrfblskEMn-4mDmdKn9c,502
-haiku/rag/research/common.py,sha256=EUnsA6VZ3-WMweXESuUYezH1ALit8N38064bsZFqtBE,1688
-haiku/rag/research/dependencies.py,sha256=ZiSQdV6jHti4DuUp4WCaJL73TqYDr5vC8ppB34M2cNg,1639
-haiku/rag/research/graph.py,sha256=m3vDP1nPXWzfS7VeTQzmTOk-lFpoaTvKHvRIF2mbxvs,798
-haiku/rag/research/models.py,sha256=Q92oxBNq3qp3DyUzTim9YGDOBtGzXH25K_mmfLAA7Y8,2329
-haiku/rag/research/prompts.py,sha256=0_EMA5CS7O37QhKJM7OCDdrdgMcoF2DgehBHR4L7xmk,5103
-haiku/rag/research/state.py,sha256=vFwO8c2JmwwfkELE5Mwjt9Oat-bHn5tayf31MIG2SRs,623
-haiku/rag/research/nodes/evaluate.py,sha256=Cp2J-jXYZothiQV3zRZFaCsBLaUU0Tm_-ri-hlgQQII,2897
-haiku/rag/research/nodes/plan.py,sha256=9AkTls01Q3zTLKGgIgSCX9X4VYC8IWjEWii8A_f77YQ,2439
-haiku/rag/research/nodes/search.py,sha256=2ioc5Ba3ciq2zpFxgzoGkZOvVsJ1TBX9zseURLDJpBg,3591
-haiku/rag/research/nodes/synthesize.py,sha256=4acKduqWnE11ML7elUksKLozxzWJTkBLSJ2li_YMxgY,1736
-haiku/rag/store/__init__.py,sha256=R2IRcxtkFDxqa2sgMirqLq3l2-FPdWr6ydYStaqm5OQ,104
-haiku/rag/store/engine.py,sha256=BceAeTpDgV92B1A3GVcjsTwlD-c0cZPPvGiXW2Gola0,10215
-haiku/rag/store/models/__init__.py,sha256=kc7Ctf53Jr483tk4QTIrcgqBbXDz4ZoeYSkFXfPnpks,89
-haiku/rag/store/models/chunk.py,sha256=3EuZav4QekJIeHBCub48EM8SjNX8HEJ6wVDXGot4PEQ,421
-haiku/rag/store/models/document.py,sha256=cZXy_jEti-hnhq7FKhuhCfd99ccY9fIHMLovB_Thbb8,425
-haiku/rag/store/repositories/__init__.py,sha256=Olv5dLfBQINRV3HrsfUpjzkZ7Qm7goEYyMNykgo_DaY,291
-haiku/rag/store/repositories/chunk.py,sha256=UfajEWf5VmMuSozGRDlWBjJNR0ngvOVFDrp6_augzBg,15217
-haiku/rag/store/repositories/document.py,sha256=C9GbIl8sa2-Djaml4hlaPTtjV2HwHaz_Wzs35sdbdhg,7876
-haiku/rag/store/repositories/settings.py,sha256=7XMBMavU8zRgdBoQzQg0Obfa7UKjuVnBugidTC6sEW0,5548
-haiku/rag/store/upgrades/__init__.py,sha256=RQ8A6rEXBASLb5PD9vdDnEas_m_GgRzzdVu4B88Snqc,1975
-haiku/rag/store/upgrades/v0_10_1.py,sha256=qNGnxj6hoHaHJ1rKTiALfw0c9NQOi0KAK-VZCD_073A,1959
-haiku/rag/store/upgrades/v0_9_3.py,sha256=NrjNilQSgDtFWRbL3ZUtzQzJ8tf9u0dDRJtnDFwwbdw,3322
-haiku_rag-0.10.2.dist-info/METADATA,sha256=Q-yJHHYbis9EtHkAW6I9IhATxh8a2XOinzLj6Z40NZY,5973
-haiku_rag-0.10.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-haiku_rag-0.10.2.dist-info/entry_points.txt,sha256=G1U3nAkNd5YDYd4v0tuYFbriz0i-JheCsFuT9kIoGCI,48
-haiku_rag-0.10.2.dist-info/licenses/LICENSE,sha256=eXZrWjSk9PwYFNK9yUczl3oPl95Z4V9UXH7bPN46iPo,1065
-haiku_rag-0.10.2.dist-info/RECORD,,