dirsql-plugin-embeddings 0.1.5__tar.gz → 0.1.6__tar.gz

{dirsql_plugin_embeddings-0.1.5 → dirsql_plugin_embeddings-0.1.6}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: dirsql-plugin-embeddings
-Version: 0.1.5
+Version: 0.1.6
 Summary: First-party dirsql plugin: semantic search via an OpenAI-compatible embeddings endpoint.
 Requires-Python: >=3.10
+Requires-Dist: cachetta>=0.6.15
 Requires-Dist: pypdf>=6
 Description-Content-Type: text/markdown
 

dirsql_plugin_embeddings-0.1.5/e2e-attestations/claude-699-read-pdf.json → dirsql_plugin_embeddings-0.1.6/e2e-attestations/claude-701-cache-pdf.json

@@ -1,7 +1,7 @@
 {
   "command": "uv run --with sqlite-vec --with-editable . --with-editable ../../packages/python python -m pytest tests/e2e -x -q",
-  "ran_at": 1785327111,
+  "ran_at": 1785337806,
   "exit_code": 0,
-  "commit": "b59ad4bf5dce929e2172cde15888918de9d277fd",
-  "branch": "claude/699-read-pdf"
+  "commit": "43a5ab7f9e72cde7f55e943649f4e24b85d7fe69",
+  "branch": "claude/701-cache-pdf"
 }

{dirsql_plugin_embeddings-0.1.5 → dirsql_plugin_embeddings-0.1.6}/pyproject.toml

@@ -14,7 +14,11 @@ readme = "README.md"
 requires-python = ">=3.10"
 # pypdf, not pymupdf: pymupdf is AGPL-3.0, and a runtime dependency of this
 # MIT-licensed package propagates to everyone who installs it.
-dependencies = ["pypdf>=6"]
+#
+# cachetta >=0.6.15 is load-bearing, not a nicety: every earlier release
+# declares `requires-python >=3.12`, which would drag this package's `>=3.11`
+# floor up with it. 0.6.15 lowered it to `>=3.10`.
+dependencies = ["pypdf>=6", "cachetta>=0.6.15"]
 
 [tool.hatch.version]
 source = "vcs"

dirsql_plugin_embeddings-0.1.6/src/dirsql_plugin_embeddings/cache.py

@@ -0,0 +1,20 @@
+"""The plugin's one configured cache.
+
+Every cached function derives its own sub-cache from this singleton with
+cachetta's ``cache / 'name'``, which keeps the defaults and appends a
+subdirectory. Naming that subdirectory after the function is what keeps caches
+apart: cachetta hashes the *arguments* of a call, not the identity of the
+function, so two cached functions sharing a directory would collide as soon as
+their argument shapes matched.
+"""
+
+from cachetta import Cachetta
+
+from .config import CACHE_DIR, CACHE_DURATION, CACHE_READ
+
+cache = Cachetta(
+    path=CACHE_DIR,
+    hashed=True,
+    duration=CACHE_DURATION,
+    read=CACHE_READ,
+)

dirsql_plugin_embeddings-0.1.6/src/dirsql_plugin_embeddings/config.py

@@ -0,0 +1,31 @@
+"""Cache configuration: what the plugin caches, where, and for how long.
+
+Annotations are evaluated at runtime (no ``from __future__ import
+annotations``) so a mutated ``X | None`` union in a signature fails at import
+rather than surviving as an inert string.
+"""
+
+import os
+from datetime import timedelta
+from pathlib import Path
+
+PLUGIN_NAME = "dirsql-plugin-embeddings"
+
+CACHE_DIR = Path.home() / ".cache" / PLUGIN_NAME
+
+# Every cache here keys on the source file's mtime, so a hit can never be
+# stale and expiry would only re-do work for a file nothing has touched.
+# cachetta's own default is 7 days.
+CACHE_DURATION = timedelta(days=365)
+
+# Set to "0" to make every call recompute. Writes still happen -- it is reads
+# that would otherwise let one test run's leftovers decide the next one's
+# result, and the hooks are subprocesses, so an inherited environment variable
+# is what reaches them.
+ENV_CACHE_READ = "DIRSQL_EMBEDDINGS_CACHE_READ"
+CACHE_READ_OFF = frozenset({"0"})
+
+# Membership rather than `!= "0"`: CPython interns single-character strings, so
+# for any value the environment can hold, `x == "0"` and `x is "0"` agree --
+# which makes the equality form's identity variant untestable in one direction.
+CACHE_READ = os.environ.get(ENV_CACHE_READ, "1") not in CACHE_READ_OFF

dirsql_plugin_embeddings-0.1.6/src/dirsql_plugin_embeddings/on_file/read_pdf.py

@@ -0,0 +1,31 @@
+"""Extract a PDF's text, once per version of the file.
+
+pypdf rather than pymupdf: pymupdf is AGPL-3.0, and a runtime dependency of
+this MIT-licensed package propagates to everyone who installs it.
+
+Extraction is the expensive step of a scan and a scan re-reads every matched
+file, so the result is persisted to disk. The cache key is the pair
+``(path, mtime)``: an edited PDF gets a different key rather than a stale hit.
+
+Annotations are evaluated at runtime (no ``from __future__ import
+annotations``) so a mutated ``X | None`` union in a signature fails at import
+rather than surviving as an inert string.
+"""
+
+import os
+
+from pypdf import PdfReader
+
+from ..cache import cache
+
+
+@cache / "extract"
+def extract(path: str, mtime: float) -> str:
+    # `mtime` is unread on purpose: it is what makes an edited PDF a cache
+    # miss, since cachetta derives the key from the arguments it is called with.
+    reader = PdfReader(path)
+    return "\n".join(page.extract_text() for page in reader.pages)
+
+
+def read_pdf(path: str) -> str:
+    return extract(path, os.path.getmtime(path))

{dirsql_plugin_embeddings-0.1.5 → dirsql_plugin_embeddings-0.1.6}/tests/conftest.py

@@ -4,12 +4,20 @@
 `/v1/embeddings` endpoint. Its embedding is a deterministic keyword-count
 vector, so nearest-neighbor search over the fixtures is reproducible without a
 real model or network.
+
+Cache reads are switched off for both tiers. These tiers run the hooks as
+subprocesses, which no in-process mock can reach, so a cached extraction from an
+earlier run would otherwise decide this one's result. Writes are left alone --
+they are harmless, and it is only the read that leaks state between runs.
 """
 
 import json
+import os
 import threading
 from http.server import BaseHTTPRequestHandler, HTTPServer
 
+os.environ["DIRSQL_EMBEDDINGS_CACHE_READ"] = "0"
+
 import pytest
 
 # One dimension per keyword; the embedding of a text is the per-keyword count.

dirsql_plugin_embeddings-0.1.5/src/dirsql_plugin_embeddings/on_file/read_pdf.py

@@ -1,16 +0,0 @@
-"""Extract a PDF's text.
-
-pypdf rather than pymupdf: pymupdf is AGPL-3.0, and a runtime dependency of
-this MIT-licensed package propagates to everyone who installs it.
-
-Annotations are evaluated at runtime (no ``from __future__ import
-annotations``) so a mutated ``X | None`` union in a signature fails at import
-rather than surviving as an inert string.
-"""
-
-from pypdf import PdfReader
-
-
-def read_pdf(path: str) -> str:
-    reader = PdfReader(path)
-    return "\n".join(page.extract_text() for page in reader.pages)