ragless 0.1.0__py3-none-any.whl

ragless/__init__.py

@@ -0,0 +1,32 @@
+"""ragless: file-based retrieval for RAG, no vector database required."""
+
+from ragless.chunking import Chunker, LineChunker
+from ragless.core import Retriever
+from ragless.embedders.base import Embedder
+from ragless.exceptions import MissingDependencyError, RaglessError, UnknownRetrieverError
+from ragless.fusion import reciprocal_rank_fusion
+from ragless.rerank import CrossEncoderReranker, Reranker
+from ragless.retrievers import BaseRetriever, BM25Retriever, FuzzyRetriever, SemanticRetriever
+from ragless.types import Chunk, SearchResult
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "Retriever",
+    "Chunk",
+    "SearchResult",
+    "Chunker",
+    "LineChunker",
+    "BaseRetriever",
+    "BM25Retriever",
+    "FuzzyRetriever",
+    "SemanticRetriever",
+    "Embedder",
+    "reciprocal_rank_fusion",
+    "CrossEncoderReranker",
+    "Reranker",
+    "RaglessError",
+    "MissingDependencyError",
+    "UnknownRetrieverError",
+    "__version__",
+]

ragless/cache.py

@@ -0,0 +1,100 @@
+"""On-disk embedding cache: plain sidecar files, no database.
+
+Each cached source file gets two sidecar files inside the cache directory:
+a ``.npy`` holding the embedding matrix and a ``.json`` holding the metadata
+needed to validate the cache (which embedder produced it, the source file's
+mtime/size, and the exact chunk ids it covers). There is no cache index or
+manifest to keep in sync -- each file's validity is self-contained, and a
+changed source file simply gets new sidecar files on its next embed.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from ragless.types import Chunk
+
+if TYPE_CHECKING:
+    from ragless.embedders.base import Embedder
+
+FileSignature = tuple[float, int]
+
+
+def file_signature(path: Path) -> FileSignature:
+    """A cheap (mtime, size) signature used to detect that a file changed."""
+    stat = path.stat()
+    return stat.st_mtime, stat.st_size
+
+
+def _cache_key(source_path: str, embedder_name: str) -> str:
+    digest = hashlib.sha256(f"{source_path}::{embedder_name}".encode()).hexdigest()
+    return digest[:24]
+
+
+class EmbeddingCache:
+    """Caches per-file chunk embeddings on disk as ``.npy`` + ``.json`` pairs."""
+
+    def __init__(self, cache_dir: str | Path) -> None:
+        self.cache_dir = Path(cache_dir)
+
+    def _paths_for(self, source_path: str, embedder_name: str) -> tuple[Path, Path]:
+        key = _cache_key(source_path, embedder_name)
+        return self.cache_dir / f"{key}.npy", self.cache_dir / f"{key}.json"
+
+    def get(
+        self,
+        source_path: str,
+        signature: FileSignature,
+        embedder: Embedder,
+        chunks: Sequence[Chunk],
+    ) -> np.ndarray | None:
+        """Return cached embeddings for ``chunks`` if the cache entry is still valid."""
+        npy_path, json_path = self._paths_for(source_path, embedder.name)
+        if not npy_path.exists() or not json_path.exists():
+            return None
+        try:
+            meta = json.loads(json_path.read_text())
+        except (OSError, json.JSONDecodeError):
+            return None
+
+        if meta.get("embedder") != embedder.name or meta.get("dim") != embedder.dim:
+            return None
+        if tuple(meta.get("signature", ())) != tuple(signature):
+            return None
+        if meta.get("chunk_ids") != [c.id for c in chunks]:
+            return None
+
+        try:
+            vectors = np.load(npy_path)
+        except (OSError, ValueError):
+            return None
+        if vectors.shape != (len(chunks), embedder.dim):
+            return None
+        return vectors
+
+    def put(
+        self,
+        source_path: str,
+        signature: FileSignature,
+        embedder: Embedder,
+        chunks: Sequence[Chunk],
+        vectors: np.ndarray,
+    ) -> None:
+        """Persist ``vectors`` (aligned with ``chunks``) for ``source_path``."""
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        npy_path, json_path = self._paths_for(source_path, embedder.name)
+        np.save(npy_path, vectors)
+        meta = {
+            "path": source_path,
+            "embedder": embedder.name,
+            "dim": embedder.dim,
+            "signature": list(signature),
+            "chunk_ids": [c.id for c in chunks],
+        }
+        json_path.write_text(json.dumps(meta))

ragless/chunking.py

@@ -0,0 +1,88 @@
+"""Pluggable chunkers that split document text into retrievable :class:`Chunk` objects."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from ragless.types import Chunk
+
+
+class Chunker(ABC):
+    """Base class for splitting a document's text into chunks.
+
+    Implementations must preserve enough information to report the original
+    ``start_line``/``end_line`` span for every chunk they produce.
+    """
+
+    @abstractmethod
+    def chunk(
+        self,
+        text: str,
+        *,
+        path: str | None,
+        chunk_id_prefix: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> list[Chunk]:
+        """Split ``text`` into a list of :class:`Chunk`.
+
+        ``chunk_id_prefix`` should be used to build globally unique chunk ids,
+        e.g. ``f"{chunk_id_prefix}:{index}"``.
+        """
+        raise NotImplementedError
+
+
+class LineChunker(Chunker):
+    """Splits text into fixed-size, overlapping windows of lines.
+
+    This is the default chunker. It is format-agnostic (works for source code,
+    markdown, plain text, ...) and always keeps track of the 1-indexed
+    ``start_line``/``end_line`` range each chunk came from.
+    """
+
+    def __init__(self, lines_per_chunk: int = 40, overlap: int = 5) -> None:
+        if lines_per_chunk <= 0:
+            raise ValueError("lines_per_chunk must be positive")
+        if overlap < 0 or overlap >= lines_per_chunk:
+            raise ValueError("overlap must be in [0, lines_per_chunk)")
+        self.lines_per_chunk = lines_per_chunk
+        self.overlap = overlap
+
+    def chunk(
+        self,
+        text: str,
+        *,
+        path: str | None,
+        chunk_id_prefix: str,
+        metadata: dict[str, Any] | None = None,
+    ) -> list[Chunk]:
+        lines = text.splitlines()
+        if not lines:
+            return []
+
+        meta = dict(metadata or {})
+        step = self.lines_per_chunk - self.overlap
+        chunks: list[Chunk] = []
+        index = 0
+        start = 0
+        n = len(lines)
+        while start < n:
+            end = min(start + self.lines_per_chunk, n)
+            chunk_lines = lines[start:end]
+            chunk_text = "\n".join(chunk_lines)
+            if chunk_text.strip():
+                chunks.append(
+                    Chunk(
+                        id=f"{chunk_id_prefix}:{index}",
+                        text=chunk_text,
+                        path=path,
+                        start_line=start + 1,
+                        end_line=end,
+                        metadata=meta,
+                    )
+                )
+                index += 1
+            if end == n:
+                break
+            start += step
+        return chunks

ragless/core.py

@@ -0,0 +1,365 @@
+"""The library's main entry point: :class:`Retriever`."""
+
+from __future__ import annotations
+
+import fnmatch
+import os
+from collections.abc import Callable, Mapping, Sequence
+from pathlib import Path
+from typing import Any
+
+from ragless.cache import EmbeddingCache, FileSignature, file_signature
+from ragless.chunking import Chunker, LineChunker
+from ragless.embedders.base import Embedder
+from ragless.exceptions import UnknownRetrieverError
+from ragless.fusion import reciprocal_rank_fusion
+from ragless.rerank import Reranker
+from ragless.retrievers.base import BaseRetriever
+from ragless.retrievers.bm25 import BM25Retriever
+from ragless.retrievers.fuzzy import FuzzyRetriever
+from ragless.retrievers.semantic import SemanticRetriever
+from ragless.types import Chunk, SearchResult
+
+DEFAULT_ENGINES: tuple[str, ...] = ("bm25", "fuzzy")
+
+_SKIP_DIRS = {
+    ".git",
+    "__pycache__",
+    ".ragless_cache",
+    "node_modules",
+    ".venv",
+    "venv",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+    ".eggs",
+    "dist",
+    "build",
+}
+
+MetadataSource = Mapping[str, Any] | Callable[[str | None], Mapping[str, Any]] | None
+EngineSpec = Sequence[str] | Mapping[str, BaseRetriever] | None
+Filters = Mapping[str, Any | Callable[[Any], bool]] | None
+PathFilter = str | Sequence[str] | None
+
+
+class Retriever:
+    """Index a directory (or in-memory text) and search it with no vector DB.
+
+    Three retrieval strategies -- BM25 keyword search, fuzzy string matching,
+    and (optionally) semantic embedding search -- are combined with
+    Reciprocal Rank Fusion. Everything is pluggable: chunker, retrievers,
+    and embedder can all be swapped out.
+
+    Examples:
+        >>> r = Retriever("./docs")
+        >>> results = r.search("installation steps", mode="hybrid")
+
+        >>> r = Retriever(["first note", "second note about pandas"])
+        >>> results = r.search("pandas")
+    """
+
+    def __init__(
+        self,
+        source: str | Path | Sequence[str] | None = None,
+        *,
+        texts: Sequence[str] | None = None,
+        chunker: Chunker | None = None,
+        engines: EngineSpec = None,
+        embedder: Embedder | None = None,
+        cache_dir: str | Path | None = None,
+        include: Sequence[str] | None = None,
+        exclude: Sequence[str] | None = None,
+        metadata: MetadataSource = None,
+        encoding: str = "utf-8",
+        rrf_k: int = 60,
+        weights: Mapping[str, float] | None = None,
+    ) -> None:
+        """
+        Args:
+            source: A directory path, a single file path, or a sequence of
+                raw in-memory strings (each treated as one document).
+            texts: Additional in-memory strings to index alongside ``source``.
+            chunker: Splits document text into :class:`~ragless.types.Chunk`.
+                Defaults to :class:`~ragless.chunking.LineChunker`.
+            engines: Which retrievers to build and query. Either a sequence
+                of names from ``{"bm25", "fuzzy", "semantic"}`` (default
+                ``("bm25", "fuzzy")``), or a mapping of name to a pre-built
+                :class:`~ragless.retrievers.base.BaseRetriever` for full
+                control over pluggable retrievers.
+            embedder: Embedding backend used by the ``"semantic"`` engine.
+                Defaults to :class:`~ragless.embedders.fastembed_embedder.FastEmbedEmbedder`,
+                which requires ``pip install ragless[semantic]``.
+            cache_dir: Directory to store the semantic embedding cache
+                (sidecar ``.npy``/``.json`` files). Only files on disk are
+                cached; in-memory text is always re-embedded.
+            include: Glob patterns (matched against each file's relative
+                POSIX path); only matching files are indexed.
+            exclude: Glob patterns for files to skip.
+            metadata: Either a constant mapping applied to every chunk, or a
+                callable ``path -> mapping`` for per-document metadata (used
+                by ``filters=`` in :meth:`search`). ``path`` is ``None`` for
+                in-memory text.
+            encoding: Text encoding used to read files. Files that fail to
+                decode, or contain null bytes, are treated as binary and
+                skipped.
+            rrf_k: The ``k`` constant in Reciprocal Rank Fusion.
+            weights: Optional per-engine weights used during fusion, e.g.
+                ``{"bm25": 1.0, "semantic": 2.0}``.
+        """
+        self.chunker = chunker or LineChunker()
+        self.rrf_k = rrf_k
+        self.weights = weights
+        self._cache_dir = cache_dir
+        self._reranker: Reranker | None = None
+
+        documents = _load_documents(
+            source, texts, include=include, exclude=exclude, encoding=encoding
+        )
+
+        self._chunks: list[Chunk] = []
+        self._chunk_by_id: dict[str, Chunk] = {}
+        self._file_signatures: dict[str, FileSignature] = {}
+
+        mem_index = 0
+        for path, text in documents:
+            if path is None:
+                prefix = f"mem:{mem_index}"
+                mem_index += 1
+            else:
+                prefix = path
+                self._file_signatures[path] = file_signature(Path(path))
+
+            chunk_metadata = _resolve_metadata(metadata, path)
+            for chunk in self.chunker.chunk(
+                text, path=path, chunk_id_prefix=prefix, metadata=chunk_metadata
+            ):
+                self._chunks.append(chunk)
+                self._chunk_by_id[chunk.id] = chunk
+
+        self._retrievers: dict[str, BaseRetriever] = {}
+        if isinstance(engines, Mapping):
+            self._retrievers.update(engines)
+        else:
+            for name in engines if engines is not None else DEFAULT_ENGINES:
+                self._retrievers[name] = self._build_engine(name, embedder, cache_dir)
+
+        for _name, retriever in self._retrievers.items():
+            if isinstance(retriever, SemanticRetriever):
+                retriever.index_with_signatures(self._chunks, self._file_signatures)
+            else:
+                retriever.index(self._chunks)
+
+    def _build_engine(
+        self, name: str, embedder: Embedder | None, cache_dir: str | Path | None
+    ) -> BaseRetriever:
+        if name == "bm25":
+            return BM25Retriever()
+        if name == "fuzzy":
+            return FuzzyRetriever()
+        if name == "semantic":
+            resolved_embedder = embedder or _default_embedder()
+            cache = EmbeddingCache(cache_dir) if cache_dir is not None else None
+            return SemanticRetriever(resolved_embedder, cache=cache)
+        raise UnknownRetrieverError(
+            f"Unknown retriever engine {name!r}; expected one of "
+            f"'bm25', 'fuzzy', 'semantic', or an engines= mapping with a custom retriever."
+        )
+
+    def search(
+        self,
+        query: str,
+        *,
+        mode: str = "hybrid",
+        top_k: int = 10,
+        filters: Filters = None,
+        path_filter: PathFilter = None,
+        rerank: bool | Reranker = False,
+        fetch_k: int | None = None,
+    ) -> list[SearchResult]:
+        """Search the indexed corpus.
+
+        Args:
+            query: The search query.
+            mode: ``"hybrid"`` fuses every configured engine; or the name of
+                a single configured engine (e.g. ``"bm25"``).
+            top_k: Maximum number of results to return.
+            filters: Mapping of metadata key to either an exact value or a
+                predicate ``value -> bool``; a chunk must satisfy all of them.
+            path_filter: One or more glob patterns; a chunk's path must match
+                at least one. In-memory chunks (``path is None``) never match.
+            rerank: ``True`` to rerank fused candidates with the default
+                :class:`~ragless.rerank.CrossEncoderReranker` (requires
+                ``pip install ragless[semantic]``), or a custom object
+                implementing the :class:`~ragless.rerank.Reranker` protocol.
+            fetch_k: How many results to fetch from each engine before fusion
+                and filtering. Defaults to ``max(top_k * 5, 25)``.
+
+        Returns:
+            Up to ``top_k`` :class:`~ragless.types.SearchResult`, best first.
+        """
+        if not self._chunks or not query or not query.strip():
+            return []
+
+        engine_names = self._resolve_mode(mode)
+        effective_fetch_k = fetch_k if fetch_k is not None else max(top_k * 5, 25)
+
+        rankings = {}
+        for name in engine_names:
+            rankings[name] = self._retrievers[name].query(query, effective_fetch_k)
+
+        fused = reciprocal_rank_fusion(rankings, k=self.rrf_k, weights=self.weights)
+        candidates = [
+            (chunk_id, score, raw)
+            for chunk_id, score, raw in fused
+            if self._passes_filters(self._chunk_by_id[chunk_id], filters, path_filter)
+        ]
+
+        if rerank:
+            return self._rerank(query, candidates, rerank, top_k)
+
+        return [
+            SearchResult(chunk=self._chunk_by_id[chunk_id], score=score, scores=raw)
+            for chunk_id, score, raw in candidates[:top_k]
+        ]
+
+    def _rerank(
+        self,
+        query: str,
+        candidates: list[tuple[str, float, dict[str, float]]],
+        rerank: bool | Reranker,
+        top_k: int,
+    ) -> list[SearchResult]:
+        reranker = rerank if hasattr(rerank, "rerank") else self._get_default_reranker()
+        pool = candidates[: max(top_k * 3, 20)]
+        pool_chunks = [self._chunk_by_id[chunk_id] for chunk_id, _, _ in pool]
+        raw_by_id = {chunk_id: raw for chunk_id, _, raw in pool}
+
+        reranked = reranker.rerank(query, pool_chunks, top_k=top_k)
+        return [
+            SearchResult(
+                chunk=self._chunk_by_id[chunk_id],
+                score=score,
+                scores={**raw_by_id.get(chunk_id, {}), "rerank": score},
+            )
+            for chunk_id, score in reranked
+        ]
+
+    def _get_default_reranker(self) -> Reranker:
+        if self._reranker is None:
+            from ragless.rerank import CrossEncoderReranker
+
+            self._reranker = CrossEncoderReranker()
+        return self._reranker
+
+    def _resolve_mode(self, mode: str) -> list[str]:
+        if mode == "hybrid":
+            return list(self._retrievers.keys())
+        if mode in self._retrievers:
+            return [mode]
+        raise UnknownRetrieverError(
+            f"Unknown search mode {mode!r}; configured engines are "
+            f"{list(self._retrievers.keys())} (plus 'hybrid')."
+        )
+
+    def _passes_filters(self, chunk: Chunk, filters: Filters, path_filter: PathFilter) -> bool:
+        if filters:
+            for key, expected in filters.items():
+                actual = chunk.metadata.get(key)
+                if callable(expected):
+                    if not expected(actual):
+                        return False
+                elif actual != expected:
+                    return False
+        if path_filter:
+            if chunk.path is None:
+                return False
+            patterns = [path_filter] if isinstance(path_filter, str) else list(path_filter)
+            if not any(fnmatch.fnmatch(chunk.path, pattern) for pattern in patterns):
+                return False
+        return True
+
+    def __len__(self) -> int:
+        return len(self._chunks)
+
+
+def _resolve_metadata(metadata: MetadataSource, path: str | None) -> dict[str, Any]:
+    if metadata is None:
+        return {}
+    if callable(metadata):
+        return dict(metadata(path) or {})
+    return dict(metadata)
+
+
+def _default_embedder() -> Embedder:
+    from ragless.embedders.fastembed_embedder import FastEmbedEmbedder
+
+    return FastEmbedEmbedder()
+
+
+def _is_text_sequence(source: Any) -> bool:
+    return isinstance(source, (list, tuple)) and not isinstance(source, (str, bytes))
+
+
+def _read_text_file(path: Path, encoding: str) -> str | None:
+    try:
+        raw = path.read_bytes()
+    except OSError:
+        return None
+    if b"\x00" in raw[:8192]:
+        return None
+    try:
+        return raw.decode(encoding)
+    except UnicodeDecodeError:
+        return None
+
+
+def _iter_files(
+    root: Path, include: Sequence[str] | None, exclude: Sequence[str] | None
+) -> list[Path]:
+    matches: list[Path] = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = sorted(d for d in dirnames if d not in _SKIP_DIRS and not d.startswith("."))
+        for filename in sorted(filenames):
+            file_path = Path(dirpath) / filename
+            rel = file_path.relative_to(root).as_posix()
+            if include and not any(fnmatch.fnmatch(rel, pattern) for pattern in include):
+                continue
+            if exclude and any(fnmatch.fnmatch(rel, pattern) for pattern in exclude):
+                continue
+            matches.append(file_path)
+    return matches
+
+
+def _load_documents(
+    source: str | Path | Sequence[str] | None,
+    texts: Sequence[str] | None,
+    *,
+    include: Sequence[str] | None,
+    exclude: Sequence[str] | None,
+    encoding: str,
+) -> list[tuple[str | None, str]]:
+    documents: list[tuple[str | None, str]] = []
+
+    if source is not None:
+        if _is_text_sequence(source):
+            documents.extend((None, t) for t in source)
+        else:
+            path = Path(source)
+            if path.is_file():
+                content = _read_text_file(path, encoding)
+                if content is not None:
+                    documents.append((str(path), content))
+            elif path.is_dir():
+                for file_path in _iter_files(path, include, exclude):
+                    content = _read_text_file(file_path, encoding)
+                    if content is not None:
+                        documents.append((str(file_path), content))
+            else:
+                raise FileNotFoundError(f"Source path does not exist: {path}")
+
+    if texts:
+        documents.extend((None, t) for t in texts)
+
+    return documents

ragless/embedders/__init__.py

@@ -0,0 +1,3 @@
+from ragless.embedders.base import Embedder
+
+__all__ = ["Embedder"]

ragless/embedders/base.py

@@ -0,0 +1,26 @@
+"""Base interface implemented by every embedding backend."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+
+import numpy as np
+
+
+class Embedder(ABC):
+    """A pluggable text-embedding backend.
+
+    ``name`` must uniquely identify the model (and any settings that affect
+    its output vectors) since it is part of the embedding cache key: changing
+    models invalidates cached embeddings rather than silently reusing stale
+    ones.
+    """
+
+    name: str
+    dim: int
+
+    @abstractmethod
+    def embed(self, texts: Sequence[str]) -> np.ndarray:
+        """Embed ``texts`` into a ``(len(texts), self.dim)`` float32 array."""
+        raise NotImplementedError

ragless/embedders/fastembed_embedder.py

@@ -0,0 +1,41 @@
+"""Default semantic embedder: a small local model served via fastembed (ONNX runtime).
+
+Requires the ``semantic`` extra: ``pip install ragless[semantic]``.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+
+from ragless.embedders.base import Embedder
+from ragless.exceptions import MissingDependencyError
+
+DEFAULT_MODEL = "BAAI/bge-small-en-v1.5"
+
+
+class FastEmbedEmbedder(Embedder):
+    """Wraps :mod:`fastembed` to produce dense vectors with a small local model.
+
+    No GPU or external service is required; models run locally via ONNX
+    runtime and are cached on disk by fastembed after the first download.
+    """
+
+    def __init__(self, model_name: str = DEFAULT_MODEL) -> None:
+        try:
+            from fastembed import TextEmbedding
+        except ImportError as exc:  # pragma: no cover - exercised without extra installed
+            raise MissingDependencyError("Semantic search", "semantic") from exc
+
+        self.model_name = model_name
+        self.name = f"fastembed:{model_name}"
+        self._model = TextEmbedding(model_name=model_name)
+        probe = next(iter(self._model.embed(["dimension probe"])))
+        self.dim = int(np.asarray(probe).shape[0])
+
+    def embed(self, texts: Sequence[str]) -> np.ndarray:
+        if not texts:
+            return np.zeros((0, self.dim), dtype=np.float32)
+        vectors = list(self._model.embed(list(texts)))
+        return np.asarray(vectors, dtype=np.float32)

ragless/exceptions.py

@@ -0,0 +1,21 @@
+"""Exceptions raised by ragless."""
+
+from __future__ import annotations
+
+
+class RaglessError(Exception):
+    """Base class for all ragless errors."""
+
+
+class MissingDependencyError(RaglessError):
+    """Raised when an optional extra is required but not installed."""
+
+    def __init__(self, feature: str, extra: str) -> None:
+        super().__init__(
+            f"{feature} requires the '{extra}' extra. "
+            f"Install it with: pip install 'ragless[{extra}]'"
+        )
+
+
+class UnknownRetrieverError(RaglessError):
+    """Raised when an unrecognised retriever name is requested."""

ragless/fusion.py

@@ -0,0 +1,39 @@
+"""Reciprocal Rank Fusion: combines multiple rankings using rank, not raw scores.
+
+RRF sidesteps the problem that BM25, fuzzy, and cosine-similarity scores live
+on incomparable scales -- it only looks at each result's position within its
+own ranking.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+
+
+def reciprocal_rank_fusion(
+    rankings: Mapping[str, Sequence[tuple[str, float]]],
+    *,
+    k: int = 60,
+    weights: Mapping[str, float] | None = None,
+) -> list[tuple[str, float, dict[str, float]]]:
+    """Fuse named rankings of ``(chunk_id, score)`` pairs into one ranking.
+
+    Each ranking's contribution to item ``chunk_id`` is ``weight / (k + rank)``
+    where ``rank`` is its 1-indexed position in that ranking. Items absent
+    from a ranking simply get no contribution from it.
+
+    Returns ``(chunk_id, fused_score, raw_scores)`` tuples sorted by
+    ``fused_score`` descending, where ``raw_scores`` maps retriever name to
+    that retriever's original (unfused) score for this chunk.
+    """
+    fused: dict[str, float] = {}
+    raw_scores: dict[str, dict[str, float]] = {}
+
+    for retriever_name, ranking in rankings.items():
+        weight = 1.0 if weights is None else weights.get(retriever_name, 1.0)
+        for rank, (chunk_id, score) in enumerate(ranking, start=1):
+            fused[chunk_id] = fused.get(chunk_id, 0.0) + weight / (k + rank)
+            raw_scores.setdefault(chunk_id, {})[retriever_name] = score
+
+    ordered = sorted(fused.items(), key=lambda item: item[1], reverse=True)
+    return [(chunk_id, score, raw_scores.get(chunk_id, {})) for chunk_id, score in ordered]

ragless/rerank.py

@@ -0,0 +1,51 @@
+"""Optional cross-encoder reranking of fused search results."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Protocol
+
+from ragless.exceptions import MissingDependencyError
+from ragless.types import Chunk
+
+DEFAULT_RERANK_MODEL = "Xenova/ms-marco-MiniLM-L-6-v2"
+
+
+class Reranker(Protocol):
+    """Interface a reranker must satisfy to plug into :class:`ragless.Retriever`."""
+
+    def rerank(
+        self, query: str, chunks: Sequence[Chunk], top_k: int | None = None
+    ) -> list[tuple[str, float]]:
+        """Return ``(chunk_id, score)`` pairs for ``chunks``, best first."""
+        ...
+
+
+class CrossEncoderReranker:
+    """Reranks candidates with a small local cross-encoder via fastembed.
+
+    Unlike the bi-encoder used for semantic search, a cross-encoder scores
+    the query and each candidate jointly, which is slower but typically more
+    accurate -- it is meant to be applied only to the top handful of fused
+    candidates, not the whole corpus. Requires ``pip install ragless[semantic]``.
+    """
+
+    def __init__(self, model_name: str = DEFAULT_RERANK_MODEL) -> None:
+        try:
+            from fastembed.rerank.cross_encoder import TextCrossEncoder
+        except ImportError as exc:  # pragma: no cover - exercised without extra installed
+            raise MissingDependencyError("Cross-encoder reranking", "semantic") from exc
+
+        self.model_name = model_name
+        self._model = TextCrossEncoder(model_name=model_name)
+
+    def rerank(
+        self, query: str, chunks: Sequence[Chunk], top_k: int | None = None
+    ) -> list[tuple[str, float]]:
+        if not chunks:
+            return []
+        texts = [c.text for c in chunks]
+        scores = [float(s) for s in self._model.rerank(query, texts)]
+        pairs = list(zip((c.id for c in chunks), scores, strict=True))
+        pairs.sort(key=lambda pair: pair[1], reverse=True)
+        return pairs[:top_k] if top_k is not None else pairs

ragless/retrievers/__init__.py

@@ -0,0 +1,6 @@
+from ragless.retrievers.base import BaseRetriever
+from ragless.retrievers.bm25 import BM25Retriever
+from ragless.retrievers.fuzzy import FuzzyRetriever
+from ragless.retrievers.semantic import SemanticRetriever
+
+__all__ = ["BaseRetriever", "BM25Retriever", "FuzzyRetriever", "SemanticRetriever"]

ragless/retrievers/base.py

@@ -0,0 +1,34 @@
+"""Base interface implemented by every retrieval backend."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+
+from ragless.types import Chunk
+
+
+class BaseRetriever(ABC):
+    """A pluggable retrieval strategy.
+
+    A retriever is given the full set of chunks once (:meth:`index`) and can
+    then be queried repeatedly (:meth:`query`). Implementations should not
+    mutate chunks; they only need to produce relevance rankings.
+    """
+
+    name: str
+
+    @abstractmethod
+    def index(self, chunks: Sequence[Chunk]) -> None:
+        """Build the retriever's internal index over ``chunks``."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def query(self, query: str, top_k: int) -> list[tuple[str, float]]:
+        """Return up to ``top_k`` ``(chunk_id, score)`` pairs, best first.
+
+        Scores are retriever-specific and not necessarily comparable across
+        retrievers; fusion (see :mod:`ragless.fusion`) only relies on rank
+        order, not on the raw magnitudes.
+        """
+        raise NotImplementedError

ragless/retrievers/bm25.py

@@ -0,0 +1,81 @@
+"""BM25 (Okapi) keyword retriever."""
+
+from __future__ import annotations
+
+import math
+import re
+from collections import Counter
+from collections.abc import Sequence
+
+import numpy as np
+
+from ragless.retrievers.base import BaseRetriever
+from ragless.types import Chunk
+
+_TOKEN_RE = re.compile(r"[A-Za-z0-9_]+")
+
+
+def _tokenize(text: str) -> list[str]:
+    return _TOKEN_RE.findall(text.lower())
+
+
+class BM25Retriever(BaseRetriever):
+    """Classic Okapi BM25 ranking over tokenized chunk text.
+
+    Pure NumPy implementation; no external search engine or index server.
+    """
+
+    name = "bm25"
+
+    def __init__(self, k1: float = 1.5, b: float = 0.75) -> None:
+        self.k1 = k1
+        self.b = b
+        self._chunk_ids: list[str] = []
+        self._doc_term_freqs: list[Counter[str]] = []
+        self._doc_lens = np.zeros(0, dtype=np.float64)
+        self._avgdl = 0.0
+        self._idf: dict[str, float] = {}
+
+    def index(self, chunks: Sequence[Chunk]) -> None:
+        self._chunk_ids = [c.id for c in chunks]
+        tokenized = [_tokenize(c.text) for c in chunks]
+        self._doc_term_freqs = [Counter(toks) for toks in tokenized]
+        self._doc_lens = np.array([len(toks) for toks in tokenized], dtype=np.float64)
+        self._avgdl = float(self._doc_lens.mean()) if len(self._doc_lens) else 0.0
+
+        n_docs = len(tokenized)
+        doc_freq: Counter[str] = Counter()
+        for toks in tokenized:
+            doc_freq.update(set(toks))
+        self._idf = {
+            term: math.log(1 + (n_docs - freq + 0.5) / (freq + 0.5))
+            for term, freq in doc_freq.items()
+        }
+
+    def query(self, query: str, top_k: int) -> list[tuple[str, float]]:
+        if top_k <= 0 or not self._chunk_ids:
+            return []
+        q_tokens = _tokenize(query)
+        if not q_tokens:
+            return []
+
+        n = len(self._chunk_ids)
+        scores = np.zeros(n, dtype=np.float64)
+        avgdl = self._avgdl or 1.0
+        norm_lens = self.k1 * (1 - self.b + self.b * self._doc_lens / avgdl)
+
+        for term in q_tokens:
+            idf = self._idf.get(term)
+            if idf is None:
+                continue
+            tf = np.array([freqs.get(term, 0) for freqs in self._doc_term_freqs], dtype=np.float64)
+            denom = tf + norm_lens
+            denom = np.where(denom == 0, 1.0, denom)
+            scores += idf * (tf * (self.k1 + 1)) / denom
+
+        hits = np.nonzero(scores > 0)[0]
+        if hits.size == 0:
+            return []
+        k = min(top_k, hits.size)
+        ranked = hits[np.argsort(-scores[hits])][:k]
+        return [(self._chunk_ids[i], float(scores[i])) for i in ranked]

ragless/retrievers/fuzzy.py

@@ -0,0 +1,35 @@
+"""Fuzzy string-similarity retriever backed by rapidfuzz."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+from rapidfuzz import fuzz, process
+
+from ragless.retrievers.base import BaseRetriever
+from ragless.types import Chunk
+
+
+class FuzzyRetriever(BaseRetriever):
+    """Ranks chunks by fuzzy string similarity to the query.
+
+    Good at catching typos, partial matches, and near-duplicate phrasing that
+    exact keyword search (BM25) would miss.
+    """
+
+    name = "fuzzy"
+
+    def __init__(self, scorer: Callable[..., float] = fuzz.WRatio) -> None:
+        self.scorer = scorer
+        self._chunk_ids: list[str] = []
+        self._texts: list[str] = []
+
+    def index(self, chunks: Sequence[Chunk]) -> None:
+        self._chunk_ids = [c.id for c in chunks]
+        self._texts = [c.text for c in chunks]
+
+    def query(self, query: str, top_k: int) -> list[tuple[str, float]]:
+        if top_k <= 0 or not self._texts or not query.strip():
+            return []
+        matches = process.extract(query, self._texts, scorer=self.scorer, limit=top_k)
+        return [(self._chunk_ids[index], float(score)) for _, score, index in matches if score > 0]

ragless/retrievers/semantic.py

@@ -0,0 +1,100 @@
+"""Semantic (embedding) retriever: NumPy cosine similarity, no vector DB."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import numpy as np
+
+from ragless.cache import EmbeddingCache, FileSignature
+from ragless.embedders.base import Embedder
+from ragless.retrievers.base import BaseRetriever
+from ragless.types import Chunk
+
+
+class SemanticRetriever(BaseRetriever):
+    """Ranks chunks by cosine similarity between dense embeddings.
+
+    Embeddings are plain NumPy arrays held in memory for search; there is no
+    vector database involved. When an :class:`~ragless.cache.EmbeddingCache`
+    is supplied, embeddings for unchanged files are loaded from disk instead
+    of being recomputed.
+    """
+
+    name = "semantic"
+
+    def __init__(self, embedder: Embedder, cache: EmbeddingCache | None = None) -> None:
+        self.embedder = embedder
+        self.cache = cache
+        self._chunk_ids: list[str] = []
+        self._vectors = np.zeros((0, embedder.dim), dtype=np.float32)
+
+    def index(self, chunks: Sequence[Chunk]) -> None:
+        """Index ``chunks`` without per-file cache invalidation signatures.
+
+        Used when a retriever is built standalone. :meth:`ragless.Retriever`
+        instead calls :meth:`index_with_signatures` so unchanged files reuse
+        cached embeddings.
+        """
+        self.index_with_signatures(chunks, {})
+
+    def index_with_signatures(
+        self,
+        chunks: Sequence[Chunk],
+        signatures: dict[str, FileSignature],
+    ) -> None:
+        if not chunks:
+            self._chunk_ids = []
+            self._vectors = np.zeros((0, self.embedder.dim), dtype=np.float32)
+            return
+
+        groups: dict[str | None, list[Chunk]] = {}
+        order: list[str | None] = []
+        for c in chunks:
+            if c.path not in groups:
+                groups[c.path] = []
+                order.append(c.path)
+            groups[c.path].append(c)
+
+        all_ids: list[str] = []
+        all_vectors: list[np.ndarray] = []
+        for path in order:
+            group_chunks = groups[path]
+            signature = signatures.get(path) if path is not None else None
+            vectors: np.ndarray | None = None
+            if self.cache is not None and path is not None and signature is not None:
+                vectors = self.cache.get(path, signature, self.embedder, group_chunks)
+            if vectors is None:
+                vectors = self.embedder.embed([c.text for c in group_chunks])
+                if self.cache is not None and path is not None and signature is not None:
+                    self.cache.put(path, signature, self.embedder, group_chunks, vectors)
+            all_ids.extend(c.id for c in group_chunks)
+            all_vectors.append(vectors)
+
+        matrix = np.concatenate(all_vectors, axis=0).astype(np.float32)
+        self._vectors = _normalize_rows(matrix)
+        self._chunk_ids = all_ids
+
+    def query(self, query: str, top_k: int) -> list[tuple[str, float]]:
+        if top_k <= 0 or not self._chunk_ids or not query.strip():
+            return []
+        q_vec = self.embedder.embed([query])[0].astype(np.float32)
+        norm = float(np.linalg.norm(q_vec))
+        if norm == 0.0:
+            return []
+        q_vec = q_vec / norm
+
+        scores = self._vectors @ q_vec
+        k = min(top_k, scores.shape[0])
+        if k < scores.shape[0]:
+            idx = np.argpartition(-scores, k - 1)[:k]
+        else:
+            idx = np.arange(scores.shape[0])
+        idx = idx[np.argsort(-scores[idx])]
+        return [(self._chunk_ids[i], float(scores[i])) for i in idx]
+
+
+def _normalize_rows(matrix: np.ndarray) -> np.ndarray:
+    norms = np.linalg.norm(matrix, axis=1, keepdims=True)
+    norms[norms == 0] = 1.0
+    return matrix / norms

ragless/types.py

@@ -0,0 +1,49 @@
+"""Core data types shared across ragless."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Chunk:
+    """A unit of retrievable text, tied back to its source location."""
+
+    id: str
+    text: str
+    path: str | None
+    """Source file path, or ``None`` for in-memory text that has no file."""
+    start_line: int
+    end_line: int
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class SearchResult:
+    """A single scored hit returned from :meth:`ragless.Retriever.search`."""
+
+    chunk: Chunk
+    score: float
+    scores: dict[str, float] = field(default_factory=dict)
+    """Per-retriever contribution, e.g. ``{"bm25": 0.8, "fuzzy": 0.4}``."""
+
+    @property
+    def path(self) -> str | None:
+        return self.chunk.path
+
+    @property
+    def text(self) -> str:
+        return self.chunk.text
+
+    @property
+    def start_line(self) -> int:
+        return self.chunk.start_line
+
+    @property
+    def end_line(self) -> int:
+        return self.chunk.end_line
+
+    @property
+    def metadata(self) -> dict[str, Any]:
+        return self.chunk.metadata

ragless-0.1.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.5
+Name: ragless
+Version: 0.1.0
+Summary: File-based retrieval for RAG, no vector database required
+Project-URL: Homepage, https://github.com/mohmdqasim/ragless
+Project-URL: Repository, https://github.com/mohmdqasim/ragless
+Project-URL: Issues, https://github.com/mohmdqasim/ragless/issues
+Project-URL: Changelog, https://github.com/mohmdqasim/ragless/blob/main/CHANGELOG.md
+Author-email: Qasim Arshad <mohmdqasim0@gmail.com>
+Maintainer-email: Qasim Arshad <mohmdqasim0@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bm25,embeddings,information-retrieval,rag,retrieval,search
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Indexing
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: rapidfuzz>=3.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1; extra == 'dev'
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: semantic
+Requires-Dist: fastembed>=0.3; extra == 'semantic'
+Description-Content-Type: text/markdown
+
+# ragless
+
+File-based retrieval for RAG, with no vector database.
+
+`ragless` indexes a folder of text files (or in-memory strings) and lets you
+search them with BM25 keyword search, fuzzy string matching, and optional
+local semantic embeddings -- combined with Reciprocal Rank Fusion. Everything
+lives on disk as plain files (or in memory): no Postgres/pgvector, no
+Pinecone/Weaviate/Chroma server, nothing to run.
+
+```python
+from ragless import Retriever
+
+r = Retriever("./docs")
+for hit in r.search("how do I configure retries", mode="hybrid"):
+    print(f"{hit.path}:{hit.start_line}-{hit.end_line}  score={hit.score:.3f}")
+    print(hit.text)
+```
+
+## Install
+
+```bash
+pip install ragless                # BM25 + fuzzy (no heavy deps)
+pip install 'ragless[semantic]'    # + local embeddings and cross-encoder rerank
+```
+
+## Quickstart
+
+```python
+from ragless import Retriever
+
+# Index a directory of files.
+r = Retriever("./docs")
+results = r.search("installation steps", mode="hybrid", top_k=5)
+
+# Or index in-memory text directly -- no files required.
+r = Retriever(
+    [
+        "ragless indexes folders of text files for retrieval.",
+        "BM25, fuzzy matching, and semantic search are combined with RRF.",
+    ]
+)
+results = r.search("how are results combined?")
+
+for hit in results:
+    print(hit.path, hit.start_line, hit.end_line, hit.score)
+    print(hit.text)
+```
+
+### Search modes
+
+```python
+r.search("query", mode="hybrid")  # fuse every configured engine (default)
+r.search("query", mode="bm25")  # keyword search only
+r.search("query", mode="fuzzy")  # fuzzy string matching only
+r.search("query", mode="semantic")  # embeddings only (requires the extra)
+```
+
+### Semantic search and caching
+
+```python
+from ragless import Retriever
+
+r = Retriever(
+    "./docs",
+    engines=["bm25", "fuzzy", "semantic"],
+    cache_dir="./.ragless_cache",  # embeddings cached here as .npy/.json
+)
+r.search("query", mode="hybrid")
+```
+
+Embeddings are cached per source file, keyed by the file's mtime/size and the
+embedder's name. Editing one file only re-embeds that file's chunks on the
+next run; untouched files are loaded straight from the cache.
+
+### Cross-encoder rerank
+
+```python
+r.search("query", mode="hybrid", rerank=True)
+```
+
+Reranking takes the top fused candidates and rescoring them with a small
+local cross-encoder (also via `fastembed`, under the `semantic` extra) for
+higher precision at the top of the list.
+
+### Filters
+
+```python
+# Only chunks whose metadata says category="guide"
+r.search("query", filters={"category": "guide"})
+
+# Only chunks from markdown files
+r.search("query", path_filter="*.md")
+
+# Per-document metadata, assigned when building the index
+r = Retriever(
+    "./docs",
+    metadata=lambda path: {"category": "guide"} if path and "guide" in path else {},
+)
+```
+
+### Pluggable components
+
+Chunkers, retrievers, and embedders are all swappable:
+
+```python
+from ragless import Retriever, Chunker, BaseRetriever
+from ragless.chunking import LineChunker
+
+r = Retriever("./docs", chunker=LineChunker(lines_per_chunk=60, overlap=10))
+
+# Bring your own retriever/embedder implementation:
+r = Retriever("./docs", engines={"bm25": MyRetriever(), "fuzzy": FuzzyRetriever()})
+```
+
+Implement `ragless.chunking.Chunker`, `ragless.retrievers.base.BaseRetriever`,
+or `ragless.embedders.base.Embedder` to plug in your own.
+
+## Why
+
+Most "RAG" tutorials reach for a vector database before checking whether they
+need one. For a folder of a few thousand files, plain keyword search (BM25),
+fuzzy matching, and a small local embedding model get you most of the way
+there, with:
+
+- No server to run, no API keys, no network calls (semantic search runs a
+  small model locally via [fastembed](https://github.com/qdrant/fastembed)).
+- No ingestion pipeline: point it at a directory and it chunks and indexes on
+  construction.
+- Caching as plain sidecar files (`.npy` + `.json`) next to your index, not a
+  database you have to back up and migrate.
+- Every result keeps the file path and line range it came from.
+
+| | ragless | vector DB (Pinecone/Chroma/pgvector) |
+|---|---|---|
+| Infra | none | a running database/service |
+| Setup | `Retriever("./docs")` | provision, configure, ingest |
+| Keyword search | built in (BM25) | usually bolted on separately |
+| Fuzzy/typo tolerance | built in | usually absent |
+| Good for | a few thousand files, local tools, CLIs, CI | large, constantly-changing, multi-tenant corpora |
+| Cold start | instant | needs the service up and reachable |
+
+If you need to search tens of millions of chunks with concurrent writers
+across a fleet of machines, use a vector database. If you need to search the
+docs folder sitting next to your code, `ragless` is simpler.
+
+## How it works
+
+1. **Load** -- read files from a directory (or accept raw in-memory strings).
+   Binary files and undecodable text are skipped automatically.
+2. **Chunk** -- split each document into overlapping line-based windows,
+   keeping the file path and 1-indexed `start_line`/`end_line` for every
+   chunk (`ragless.chunking.LineChunker`, pluggable).
+3. **Index** -- each configured engine builds its own index over the chunks:
+   - `BM25Retriever`: classic Okapi BM25 over tokenized text (NumPy).
+   - `FuzzyRetriever`: `rapidfuzz` string similarity.
+   - `SemanticRetriever`: dense embeddings (`fastembed`) with cosine
+     similarity (NumPy), cached to disk as `.npy`/`.json` sidecar files.
+4. **Search** -- query every configured engine, fuse their rankings with
+   [Reciprocal Rank Fusion](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf),
+   apply metadata/path filters, and optionally rerank the top candidates with
+   a cross-encoder.
+
+## Status
+
+0.1.0 -- the API may still shift. Feedback and issues welcome.
+
+## License
+
+MIT

ragless-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+ragless/__init__.py,sha256=69ndwdapG4IBFMTHae5xt1hVKwJjRUyAvCswnJ_1v5o,943
+ragless/cache.py,sha256=f90UYUnv9d4R-sWOzxM_MDt_bRlvcKbfGlZpqOhYfN8,3383
+ragless/chunking.py,sha256=n4-_rM897oee9hznpuF8cHQW0oDGsv0zKKk_gerkF9M,2714
+ragless/core.py,sha256=0DzGdxTdOorEEwiRLxupaRZznLxI9BTrBQmfNIK5Lc8,14007
+ragless/exceptions.py,sha256=jVW3yvBIRTwJj8n51l05UzHXlEz7tJm20dI67gkh_g8,593
+ragless/fusion.py,sha256=_DoYMcMQCavqoiYaeCeCerYI30ocECiGdqO-z4mtQeg,1648
+ragless/rerank.py,sha256=YAZ6ffZR1X5SZ2azN2HulBbyiljza-OhaLR3XmoXenc,1972
+ragless/types.py,sha256=exU4pm517LF1DP3xefgth3a5TUFAckMD1-3XOlnKjS0,1184
+ragless/embedders/__init__.py,sha256=lSDIW967LnKrarDrihNx-k-JJI0Qy1SKXS41bo_O8rM,68
+ragless/embedders/base.py,sha256=QSbr56iMFiW9yHeXkBTAYCdBJfM0KCmLjsHWzrkfVpU,725
+ragless/embedders/fastembed_embedder.py,sha256=omxnoxryb-EctLsXcn2akVho86xhAQZv1Faj7SSrWDU,1477
+ragless/retrievers/__init__.py,sha256=UItt2W1I-iJDJWFvP7O9Ts1tDJ0i3NaVGWkSOlMTQbo,295
+ragless/retrievers/base.py,sha256=DHGeBH0P5DhnT4taRLWrVxt1GaUfSHFDoJimuLKXn68,1097
+ragless/retrievers/bm25.py,sha256=-4BXYKCn5dJdgg1TbRtQcdusiRh8nj6AHSWKWzUF2qQ,2646
+ragless/retrievers/fuzzy.py,sha256=-lFeKDnOOU1FEXiz9FNaVPZDWmwVx7jCEJFDSKt77pg,1194
+ragless/retrievers/semantic.py,sha256=4pZO-LyDLgE7BwmHHGfjYFgRZxQBfDFhqZ_5u_qgP3Q,3770
+ragless-0.1.0.dist-info/METADATA,sha256=IiEnyYIPMjvFBwxJ9CkPMIB_zue82xNBfw96Ho6tC90,7292
+ragless-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+ragless-0.1.0.dist-info/licenses/LICENSE,sha256=5MI5V3ka3qwyD7Pcub8_OUihTgWnrMzYjvzai4bVbzM,1077
+ragless-0.1.0.dist-info/RECORD,,

ragless-0.1.0.dist-info/WHEEL

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

ragless-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ragless contributors
+
+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.