PyPI - dirsql-plugin-embeddings - Versions diffs - 0.1.9__tar.gz → 0.1.11__tar.gz - Mend

dirsql-plugin-embeddings 0.1.9tar.gz → 0.1.11tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

dirsql_plugin_embeddings-0.1.11/PKG-INFO ADDED Viewed

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: dirsql-plugin-embeddings
+Version: 0.1.11
+Summary: First-party dirsql plugin: semantic search over files (rebuild in progress).
+Requires-Python: >=3.10
+Requires-Dist: sqlite-vec>=0.1
+Description-Content-Type: text/markdown
+# dirsql-plugin-embeddings
+A first-party [`dirsql`](https://github.com/thekevinscott/dirsql) plugin for
+semantic search over files.
+**Rebuild in progress**
+([#800](https://github.com/thekevinscott/dirsql/issues/800)): the previous
+surface — a declared `documents` table built eagerly over the working
+directory, per-file `on-file` embedding hooks, a `pre-query` hook, and
+`DIRSQL_EMBEDDINGS_*` endpoint configuration — has been removed. The plugin is
+being rebuilt around a plugin-provided `embed()` SQL function that is inert
+until a query calls it.
+Today, installing the plugin loads the
+[`sqlite-vec`](https://github.com/asg017/sqlite-vec) extension (for
+`vec_distance_cosine()` and friends) and nothing else.
+```sh
+uvx --with dirsql-plugin-embeddings dirsql "SELECT vec_distance_cosine('[1, 0]', '[0, 1]') AS d"
+```

dirsql_plugin_embeddings-0.1.11/README.md ADDED Viewed

@@ -0,0 +1,20 @@
+# dirsql-plugin-embeddings
+A first-party [`dirsql`](https://github.com/thekevinscott/dirsql) plugin for
+semantic search over files.
+**Rebuild in progress**
+([#800](https://github.com/thekevinscott/dirsql/issues/800)): the previous
+surface — a declared `documents` table built eagerly over the working
+directory, per-file `on-file` embedding hooks, a `pre-query` hook, and
+`DIRSQL_EMBEDDINGS_*` endpoint configuration — has been removed. The plugin is
+being rebuilt around a plugin-provided `embed()` SQL function that is inert
+until a query calls it.
+Today, installing the plugin loads the
+[`sqlite-vec`](https://github.com/asg017/sqlite-vec) extension (for
+`vec_distance_cosine()` and friends) and nothing else.
+```sh
+uvx --with dirsql-plugin-embeddings dirsql "SELECT vec_distance_cosine('[1, 0]', '[0, 1]') AS d"
+```

dirsql_plugin_embeddings-0.1.11/changelog.d/2026-08-10-delete-old-surface.md ADDED Viewed

@@ -0,0 +1,10 @@
+**Removed**
+The plugin's entire v0.1 surface: the declared `documents` table (built
+eagerly over the working directory on every `dirsql` invocation), the
+`on-file` readers (text and PDF), the `pre-query` hook, both console scripts
+(`dirsql-embeddings-on-file`, `dirsql-embeddings-pre-query`), and the
+`DIRSQL_EMBEDDINGS_*` environment variables. The shipped `dirsql.toml`
+fragment now declares only sqlite-vec extension loading, which carries
+forward. The plugin is being rebuilt around a plugin-provided `embed()` SQL
+function (#800).

dirsql_plugin_embeddings-0.1.11/migrations.d/2026-08-10-delete-old-surface.md ADDED Viewed

@@ -0,0 +1,41 @@
+### dirsql-plugin-embeddings: old surface removed (declared table, hooks, env vars)
+#### Summary
+The plugin's v0.1 surface is deleted with no deprecation period ahead of the
+`embed()` SQL-function rebuild (#800): installing the plugin no longer
+declares a `documents` table, no longer spawns per-file `on-file` embedding
+subprocesses, no longer rewrites queries through a `pre-query` hook, and no
+longer reads `DIRSQL_EMBEDDINGS_*` environment variables. Only sqlite-vec
+extension loading carries forward. Any workflow that queried the `documents`
+table with the plugin installed breaks.
+#### Required changes
+| Surface | Before | After |
+| ------- | ------ | ----- |
+| `documents` table | `dirsql query '{"q": "..."}'` returned nearest-neighbor rows from an auto-built `documents` table | Removed; no replacement until the #800 rebuild lands (`SELECT ... FROM documents` now fails with `no such table: documents`) |
+| Console scripts | `dirsql-embeddings-on-file <path>`, `dirsql-embeddings-pre-query <body>` on PATH | Removed; uninstall any external callers |
+| Env vars | `DIRSQL_EMBEDDINGS_BASE_URL` / `DIRSQL_EMBEDDINGS_MODEL` / `DIRSQL_EMBEDDINGS_API_KEY` (and `DIRSQL_EMBEDDINGS_CACHE_READ`) configured the embedding endpoint | Removed; unset them — nothing reads them |
+| sqlite-vec loading | `[[dirsql.extension]]` in the shipped fragment | Unchanged — still loaded when the plugin is installed |
+#### Deprecations removed
+_None._
+#### Behavior changes without code changes
+- Any `dirsql` invocation with the plugin installed: previously built the
+  `documents` table eagerly — one Python subprocess (and, when configured, one
+  billed embedding call) per matched file under the working directory, before
+  the query ran; now no subprocess is spawned and no table is created — the
+  plugin only loads sqlite-vec.
+#### Verification
+```bash
+uvx --with dirsql-plugin-embeddings dirsql query "SELECT vec_distance_cosine('[1, 0]', '[0, 1]') AS d"
+# expected: [{"d":1.0}]
+uvx --with dirsql-plugin-embeddings dirsql query "SELECT * FROM documents"
+# expected: error containing `no such table: documents`
+```

{dirsql_plugin_embeddings-0.1.9 → dirsql_plugin_embeddings-0.1.11}/pyproject.toml RENAMED Viewed

@@ -3,22 +3,20 @@ requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 [project]
-# First-party dirsql plugin, published independently to PyPI: the worked
-# implementation behind docs/howto/search-by-meaning.md, backed by an
-# OpenAI-compatible /v1/embeddings endpoint. Exists to prove the plugin
-# rails (#531, part of #363) and power the semantic-search demo.
+# First-party dirsql plugin, published independently to PyPI. Mid-rebuild:
+# today it only loads sqlite-vec; the embed() SQL function surface is landing
+# in follow-up slices.
 name = "dirsql-plugin-embeddings"
 dynamic = ["version"]
-description = "First-party dirsql plugin: semantic search via an OpenAI-compatible embeddings endpoint."
+description = "First-party dirsql plugin: semantic search over files (rebuild in progress)."
 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.
-#
-# cachetta >=0.6.15 is load-bearing, not a nicety: every earlier release
-# declares `requires-python >=3.12`, which would drag this package's floor up
-# with it. 0.6.15 lowered cachetta's own floor to `>=3.10`, matching ours.
-dependencies = ["pypdf>=6", "cachetta>=0.6.15"]
+# sqlite-vec is a runtime dependency, not a docs suggestion: the shipped
+# dirsql.toml fragment declares `path = "sqlite_vec"`, which the launcher can
+# only resolve when the package is installed. Declaring it here makes the
+# quickstart (`uvx --with dirsql-plugin-embeddings dirsql`) work without a
+# separate `--with sqlite-vec`.
+dependencies = ["sqlite-vec>=0.1"]
 [tool.hatch.version]
 source = "vcs"
@@ -43,12 +41,6 @@ root = "../.."
 # tag prefix.
 git_describe_command = ["git", "describe", "--dirty", "--tags", "--long", "--match", "dirsql-plugin-embeddings-v*"]
-[project.scripts]
-# The two command hooks the fragment invokes; installing the package puts them
-# on PATH so `dirsql` resolves them when it spawns the hooks.
-dirsql-embeddings-on-file = "dirsql_plugin_embeddings.on_file:on_file"
-dirsql-embeddings-pre-query = "dirsql_plugin_embeddings.pre_query:main"
 [project.entry-points.dirsql]
 # How the #529 launcher discovers the plugin: group `dirsql`, value = the
 # top-level module whose root ships `dirsql.toml`.

dirsql_plugin_embeddings-0.1.11/src/dirsql_plugin_embeddings/dirsql.toml ADDED Viewed

@@ -0,0 +1,6 @@
+# Fragment shipped by the dirsql-plugin-embeddings plugin.
+# Discovered via the package's [project.entry-points.dirsql] declaration and
+# injected by the launcher as an ordinary -c flag ("installed = active").
+[[dirsql.extension]]
+path = "sqlite_vec"
+entrypoint = "sqlite3_vec_init"

dirsql_plugin_embeddings-0.1.9/PKG-INFO DELETED Viewed

@@ -1,90 +0,0 @@
-Metadata-Version: 2.4
-Name: dirsql-plugin-embeddings
-Version: 0.1.9
-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
-A first-party [`dirsql`](https://github.com/thekevinscott/dirsql) plugin that
-adds **semantic search** over a directory of documents -- Markdown, plain
-text, reStructuredText and PDFs. It is the worked
-implementation behind the [Search documents by
-meaning](https://thekevinscott.github.io/dirsql/howto/search-by-meaning) how-to,
-swapping that guide's local `model2vec` model for any OpenAI-compatible
-`/v1/embeddings` endpoint.
-```sh
-uvx --with dirsql-plugin-embeddings dirsql
-```
-Deliberately minimal (v0.1): one embedding provider shape, one table, no
-chunking, no config surface beyond three environment variables.
-## How it works
-The plugin ships a `dirsql.toml` fragment that dirsql discovers when the package
-is installed alongside it. The fragment declares:
-- the [`sqlite-vec`](https://github.com/asg017/sqlite-vec) extension, for
-  `vec_distance_cosine()`;
-- a `documents` table whose `on-file` hook embeds each
-  `**/*.{md,markdown,mdx,rst,txt,pdf}` file into a TEXT `embedding` column;
-- a `pre-query` hook that embeds the incoming question and emits the
-  nearest-neighbor SQL.
-Both hooks are console scripts that call the same embedder.
-Every matched extension except `.pdf` is read as UTF-8 text; a `.pdf` is read with
-[pypdf](https://pypdf.readthedocs.io), whose per-page extracted text is joined
-and embedded like any other document. The extension check is case-insensitive
-(`.PDF` is a PDF), though the glob above is not — globset matches case-sensitively,
-so an uppercase-suffixed file needs its own `glob` entry to be picked up at all.
-The glob is an allowlist rather than `**/*` on cost, not correctness. Every
-matched file costs a hook subprocess, and every file the plugin can decode costs
-a billed embedding call — so pointing `**/*` at a tree containing `node_modules`
-or `.git` makes for a slow and expensive scan. The list is what is worth
-embedding; widening it trades money for recall.
-A file the plugin cannot read is skipped, not fatal. The hook exits non-zero,
-dirsql names the file on stderr and carries on indexing the rest, and the run
-exits `23` — "completed, some files skipped". From the SDK the same information
-is on `scan_failures()` / `scanFailures()`. A *scanned*, image-only PDF is not a
-failure at all: pypdf yields no text, and the file is indexed with an empty
-`text`, exactly like an empty `.md`.
-## Configuration
-The embedder reads three environment variables (point them at any hosted or
-self-managed OpenAI-compatible inference server):
-| Variable | Meaning |
-|---|---|
-| `DIRSQL_EMBEDDINGS_BASE_URL` | Base URL; `/v1/embeddings` is appended. |
-| `DIRSQL_EMBEDDINGS_MODEL` | Model name sent in the request. |
-| `DIRSQL_EMBEDDINGS_API_KEY` | Bearer token for `Authorization`. |
-## Console scripts
-| Script | Hook | Input | Output |
-|---|---|---|---|
-| `dirsql-embeddings-on-file` | `on-file` | a file's absolute path (`argv[1]`), text or PDF | one-line JSON row array with `path`, `text`, `embedding` |
-| `dirsql-embeddings-pre-query` | `pre-query` | a raw request body (`argv[1]`) | nearest-neighbor SQL over `documents` |
-`pre-query` accepts both a verbatim server body (`{"q": ...}`) and the CLI
-`query` subcommand's `{"sql": <arg>}` wrapper, so `dirsql query '{"q": ...}'` and
-a real `POST /query` both work.
-## Tests
-Three tiers, per the dirsql testing conventions:
-- **unit** (colocated, mocked seams) — `src/dirsql_plugin_embeddings/*_test.py`
-- **integration** (`tests/integration/`) — each console script as a real
-  subprocess against a local stub `/v1/embeddings` server
-- **e2e** (`tests/e2e/`) — the full loop through the real launcher + `dirsql`
-  binary + `sqlite-vec`, nothing mocked but the embedding endpoint

dirsql_plugin_embeddings-0.1.9/README.md DELETED Viewed

@@ -1,81 +0,0 @@
-# dirsql-plugin-embeddings
-A first-party [`dirsql`](https://github.com/thekevinscott/dirsql) plugin that
-adds **semantic search** over a directory of documents -- Markdown, plain
-text, reStructuredText and PDFs. It is the worked
-implementation behind the [Search documents by
-meaning](https://thekevinscott.github.io/dirsql/howto/search-by-meaning) how-to,
-swapping that guide's local `model2vec` model for any OpenAI-compatible
-`/v1/embeddings` endpoint.
-```sh
-uvx --with dirsql-plugin-embeddings dirsql
-```
-Deliberately minimal (v0.1): one embedding provider shape, one table, no
-chunking, no config surface beyond three environment variables.
-## How it works
-The plugin ships a `dirsql.toml` fragment that dirsql discovers when the package
-is installed alongside it. The fragment declares:
-- the [`sqlite-vec`](https://github.com/asg017/sqlite-vec) extension, for
-  `vec_distance_cosine()`;
-- a `documents` table whose `on-file` hook embeds each
-  `**/*.{md,markdown,mdx,rst,txt,pdf}` file into a TEXT `embedding` column;
-- a `pre-query` hook that embeds the incoming question and emits the
-  nearest-neighbor SQL.
-Both hooks are console scripts that call the same embedder.
-Every matched extension except `.pdf` is read as UTF-8 text; a `.pdf` is read with
-[pypdf](https://pypdf.readthedocs.io), whose per-page extracted text is joined
-and embedded like any other document. The extension check is case-insensitive
-(`.PDF` is a PDF), though the glob above is not — globset matches case-sensitively,
-so an uppercase-suffixed file needs its own `glob` entry to be picked up at all.
-The glob is an allowlist rather than `**/*` on cost, not correctness. Every
-matched file costs a hook subprocess, and every file the plugin can decode costs
-a billed embedding call — so pointing `**/*` at a tree containing `node_modules`
-or `.git` makes for a slow and expensive scan. The list is what is worth
-embedding; widening it trades money for recall.
-A file the plugin cannot read is skipped, not fatal. The hook exits non-zero,
-dirsql names the file on stderr and carries on indexing the rest, and the run
-exits `23` — "completed, some files skipped". From the SDK the same information
-is on `scan_failures()` / `scanFailures()`. A *scanned*, image-only PDF is not a
-failure at all: pypdf yields no text, and the file is indexed with an empty
-`text`, exactly like an empty `.md`.
-## Configuration
-The embedder reads three environment variables (point them at any hosted or
-self-managed OpenAI-compatible inference server):
-| Variable | Meaning |
-|---|---|
-| `DIRSQL_EMBEDDINGS_BASE_URL` | Base URL; `/v1/embeddings` is appended. |
-| `DIRSQL_EMBEDDINGS_MODEL` | Model name sent in the request. |
-| `DIRSQL_EMBEDDINGS_API_KEY` | Bearer token for `Authorization`. |
-## Console scripts
-| Script | Hook | Input | Output |
-|---|---|---|---|
-| `dirsql-embeddings-on-file` | `on-file` | a file's absolute path (`argv[1]`), text or PDF | one-line JSON row array with `path`, `text`, `embedding` |
-| `dirsql-embeddings-pre-query` | `pre-query` | a raw request body (`argv[1]`) | nearest-neighbor SQL over `documents` |
-`pre-query` accepts both a verbatim server body (`{"q": ...}`) and the CLI
-`query` subcommand's `{"sql": <arg>}` wrapper, so `dirsql query '{"q": ...}'` and
-a real `POST /query` both work.
-## Tests
-Three tiers, per the dirsql testing conventions:
-- **unit** (colocated, mocked seams) — `src/dirsql_plugin_embeddings/*_test.py`
-- **integration** (`tests/integration/`) — each console script as a real
-  subprocess against a local stub `/v1/embeddings` server
-- **e2e** (`tests/e2e/`) — the full loop through the real launcher + `dirsql`
-  binary + `sqlite-vec`, nothing mocked but the embedding endpoint

dirsql_plugin_embeddings-0.1.9/e2e-attestations/claude-706-widen-glob.json DELETED Viewed

@@ -1,7 +0,0 @@
-{
-  "command": "uv run --with sqlite-vec --with-editable . --with-editable ../../packages/python python -m pytest tests/e2e -x -q",
-  "ran_at": 1785339217,
-  "exit_code": 0,
-  "commit": "f96d82085395d4e38bd74992a6ae3c7b029d5f60",
-  "branch": "claude/706-widen-glob"
-}

dirsql_plugin_embeddings-0.1.9/e2e-attestations/claude-725-plugin-glob-comment.json DELETED Viewed

@@ -1,7 +0,0 @@
-{
-  "command": "uv run --with sqlite-vec --with-editable . --with-editable ../../packages/python python -m pytest tests/e2e -q",
-  "ran_at": 1785680099,
-  "exit_code": 0,
-  "commit": "0030917b47975bfa9b4d7412e7f00ca2b760f292",
-  "branch": "claude/725-plugin-glob-comment"
-}

dirsql_plugin_embeddings-0.1.9/src/dirsql_plugin_embeddings/cache.py DELETED Viewed

@@ -1,20 +0,0 @@
-"""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.9/src/dirsql_plugin_embeddings/config.py DELETED Viewed

@@ -1,31 +0,0 @@
-"""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.9/src/dirsql_plugin_embeddings/dirsql.toml DELETED Viewed

@@ -1,27 +0,0 @@
-# Fragment shipped by the dirsql-plugin-embeddings plugin.
-# Discovered via the package's [project.entry-points.dirsql] declaration and
-# injected by the launcher as an ordinary -c flag ("installed = active", #529).
-#
-# The table name here MUST match pre_query.TABLE_NAME (the SQL the pre-query
-# hook prints queries this table).
-[dirsql]
-pre-query = "dirsql-embeddings-pre-query {args}"
-hook-timeout = 300
-[[dirsql.extension]]
-path = "sqlite_vec"
-entrypoint = "sqlite3_vec_init"
-# The brace is globset alternation, not a dirsql `{name}` placeholder: the core
-# rewrites those to `*`, but only when the braces hold a bare identifier, so a
-# comma-separated list reaches globset intact.
-#
-# An allowlist rather than `**/*` because every matched file costs a hook
-# subprocess and, for anything `read_content` can decode, a billed embedding
-# call. Pointed at a tree holding `node_modules` or `.git`, `**/*` is a slow
-# and expensive scan, not a broken one -- unreadable files are skipped. So the
-# list is what is worth embedding, and widening it trades money for recall.
-[[table]]
-ddl = "CREATE TABLE documents (path TEXT, text TEXT, embedding TEXT)"
-glob = "**/*.{md,markdown,mdx,rst,txt,pdf}"
-on-file = "dirsql-embeddings-on-file {path}"

dirsql_plugin_embeddings-0.1.9/src/dirsql_plugin_embeddings/embedder.py DELETED Viewed

@@ -1,71 +0,0 @@
-"""Embed text via an OpenAI-compatible ``/v1/embeddings`` endpoint.
-Configuration comes from three environment variables (base URL, model, API
-key). The HTTP call is behind an injected ``post`` seam so the unit tests drive
-it without a real network; ``_urllib_post`` is the production seam.
-Annotations are evaluated at runtime (no ``from __future__ import annotations``)
-so a mutated ``X | None`` union in a signature fails at import instead of being
-an inert string -- otherwise every annotation-union mutant would survive.
-"""
-import json
-import os
-import urllib.error
-import urllib.request
-from collections.abc import Mapping
-ENV_BASE_URL = "DIRSQL_EMBEDDINGS_BASE_URL"
-ENV_MODEL = "DIRSQL_EMBEDDINGS_MODEL"
-ENV_API_KEY = "DIRSQL_EMBEDDINGS_API_KEY"
-class EmbeddingError(RuntimeError):
-    """A configuration, transport, or response error while embedding."""
-def _urllib_post(url: str, data: bytes, headers: Mapping[str, str]):
-    request = urllib.request.Request(
-        url, data=data, headers=dict(headers), method="POST"
-    )
-    try:
-        with urllib.request.urlopen(request) as response:
-            return response.status, response.read()
-    except urllib.error.HTTPError as error:
-        return error.code, error.read()
-def _require(env: Mapping[str, str], name: str) -> str:
-    value = env.get(name, "")
-    if not value:
-        raise EmbeddingError(f"missing required environment variable {name}")
-    return value
-def embed(
-    text: str, env: Mapping[str, str] | None = None, post=_urllib_post
-) -> list[float]:
-    if env is None:
-        env = os.environ
-    base_url = _require(env, ENV_BASE_URL).rstrip("/")
-    model = _require(env, ENV_MODEL)
-    api_key = _require(env, ENV_API_KEY)
-    data = json.dumps({"model": model, "input": [text]}).encode("utf-8")
-    headers = {
-        "Content-Type": "application/json",
-        "Authorization": f"Bearer {api_key}",
-    }
-    status, body = post(f"{base_url}/v1/embeddings", data=data, headers=headers)
-    if status != 200:
-        raise EmbeddingError(f"embeddings endpoint returned status {status}: {body!r}")
-    try:
-        entry = json.loads(body)["data"][0]
-    except (json.JSONDecodeError, KeyError, IndexError, TypeError) as exc:
-        raise EmbeddingError(f"malformed embeddings response: {body!r}") from exc
-    vector = entry.get("embedding")
-    if not isinstance(vector, list) or not vector:
-        raise EmbeddingError(f"embeddings response carried no vector: {body!r}")
-    return [float(component) for component in vector]

dirsql_plugin_embeddings-0.1.9/src/dirsql_plugin_embeddings/on_file/__init__.py DELETED Viewed

@@ -1,11 +0,0 @@
-"""``on-file`` console script: embed one matched file into a dirsql row.
-The package barrel: ``pyproject.toml`` points the ``dirsql-embeddings-on-file``
-script at ``dirsql_plugin_embeddings.on_file:on_file``, which resolves here, so
-this re-export is the shipped command's public surface -- moving the callable
-between modules is free, dropping it from ``__all__`` breaks the install.
-"""
-from .on_file import on_file
-__all__ = ["on_file"]

dirsql_plugin_embeddings-0.1.9/src/dirsql_plugin_embeddings/on_file/build_rows.py DELETED Viewed

@@ -1,13 +0,0 @@
-"""Shape one embedded file into the command hook's row array.
-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 json
-def build_rows(path: str, text: str, vector: list[float]) -> list[dict]:
-    # The embedding is stored as JSON text, which `sqlite-vec` accepts directly.
-    return [{"path": path, "text": text, "embedding": json.dumps(vector)}]

dirsql_plugin_embeddings-0.1.9/src/dirsql_plugin_embeddings/on_file/on_file.py DELETED Viewed

@@ -1,25 +0,0 @@
-"""The ``on-file`` hook entry point.
-Reads the file at ``argv[1]``, embeds its text, and prints a one-line JSON row
-array (``path``, ``text``, ``embedding``).
-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 json
-import sys
-from ..embedder import embed
-from .build_rows import build_rows
-from .read_content import read_content
-def on_file(argv: list[str] | None = None) -> int:
-    if argv is None:
-        argv = sys.argv
-    path = argv[1]
-    text = read_content(path)
-    print(json.dumps(build_rows(path, text, embed(text))))
-    return 0

dirsql_plugin_embeddings-0.1.9/src/dirsql_plugin_embeddings/on_file/read_content.py DELETED Viewed

@@ -1,22 +0,0 @@
-"""The entry point's single read seam: everything the hook reads comes through
-here, so per-format handling has one place to land without touching `on_file`.
-The extension is matched case-insensitively, and more permissively than the
-fragment's glob (which globset matches case-sensitively): the hook is a console
-script runnable against any path, not only the ones a glob selected.
-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 .read_pdf import read_pdf
-from .read_text import read_text
-def read_content(path: str) -> str:
-    if os.path.splitext(path)[1].lower() == ".pdf":
-        return read_pdf(path)
-    return read_text(path)

dirsql_plugin_embeddings-0.1.9/src/dirsql_plugin_embeddings/on_file/read_pdf.py DELETED Viewed

@@ -1,31 +0,0 @@
-"""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.9/src/dirsql_plugin_embeddings/on_file/read_text.py DELETED Viewed

@@ -1,11 +0,0 @@
-"""Read the matched file's text off disk.
-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.
-"""
-def read_text(path: str) -> str:
-    with open(path, encoding="utf-8") as handle:
-        return handle.read()

dirsql_plugin_embeddings-0.1.9/src/dirsql_plugin_embeddings/pre_query.py DELETED Viewed

@@ -1,42 +0,0 @@
-"""``pre-query`` console script: turn a ``{"q": ...}`` body into search SQL.
-Accepts both a verbatim server body (``{"q": ...}``) and the CLI ``query``
-subcommand's ``{"sql": <arg>}`` wrapper, embeds the question, and prints the
-nearest-neighbor SQL over the ``documents`` table (ordered by
-``vec_distance_cosine``). The hook owns SQL safety: the only interpolated value
-is a numeric vector this script produced.
-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 json
-import sys
-from .embedder import embed
-TABLE_NAME = "documents"
-RESULT_LIMIT = 3
-def question(raw_body: str) -> str:
-    body = json.loads(raw_body)
-    if "q" in body:
-        return body["q"]
-    return json.loads(body["sql"])["q"]
-def build_sql(vector: list[float]) -> str:
-    needle = json.dumps(vector)
-    return (
-        f"SELECT path, ROUND(vec_distance_cosine(embedding, '{needle}'), 3) "
-        f"AS distance FROM {TABLE_NAME} ORDER BY distance LIMIT {RESULT_LIMIT}"
-    )
-def main(argv: list[str] | None = None) -> int:
-    if argv is None:
-        argv = sys.argv
-    print(build_sql(embed(question(argv[1]))))
-    return 0

dirsql_plugin_embeddings-0.1.9/tests/conftest.py DELETED Viewed

@@ -1,110 +0,0 @@
-"""Shared fixtures for the integration and e2e tiers.
-`stub_server` brings up a real, local, threaded OpenAI-compatible
-`/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.
-`make_pdf` builds a real PDF by hand rather than pulling in a writer library:
-these tiers mock nothing, and a one-page catalog with a `BT ... Tj ET` content
-stream is enough for pypdf to extract the text back out.
-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.
-KEYWORDS = [
-    "pasta",
-    "cook",
-    "garlic",
-    "git",
-    "code",
-    "review",
-    "tomato",
-    "plant",
-    "seed",
-]
-def keyword_vector(text):
-    lowered = text.lower()
-    return [float(lowered.count(keyword)) for keyword in KEYWORDS]
-class _Handler(BaseHTTPRequestHandler):
-    def do_POST(self):
-        length = int(self.headers["Content-Length"])
-        payload = json.loads(self.rfile.read(length))
-        text = payload["input"][0]
-        body = json.dumps(
-            {"data": [{"index": 0, "embedding": keyword_vector(text)}]}
-        ).encode("utf-8")
-        self.send_response(200)
-        self.send_header("Content-Type", "application/json")
-        self.send_header("Content-Length", str(len(body)))
-        self.end_headers()
-        self.wfile.write(body)
-    def log_message(self, *args):  # silence the default stderr access log
-        pass
-def _make_pdf(text):
-    stream = f"BT /F1 24 Tf 72 700 Td ({text}) Tj ET".encode()
-    objs = [
-        b"<< /Type /Catalog /Pages 2 0 R >>",
-        b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
-        b"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] "
-        b"/Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>",
-        b"<< /Length "
-        + str(len(stream)).encode()
-        + b" >>\nstream\n"
-        + stream
-        + b"\nendstream",
-        b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
-    ]
-    out = bytearray(b"%PDF-1.4\n")
-    offsets = []
-    for index, body in enumerate(objs, start=1):
-        offsets.append(len(out))
-        out += f"{index} 0 obj\n".encode() + body + b"\nendobj\n"
-    xref = len(out)
-    out += f"xref\n0 {len(objs) + 1}\n".encode()
-    out += b"0000000000 65535 f \n"
-    for offset in offsets:
-        out += f"{offset:010d} 00000 n \n".encode()
-    out += (
-        f"trailer\n<< /Size {len(objs) + 1} /Root 1 0 R >>\n"
-        f"startxref\n{xref}\n%%EOF\n"
-    ).encode()
-    return bytes(out)
-@pytest.fixture
-def make_pdf():
-    return _make_pdf
-@pytest.fixture
-def stub_server():
-    server = HTTPServer(("127.0.0.1", 0), _Handler)
-    thread = threading.Thread(target=server.serve_forever, daemon=True)
-    thread.start()
-    host, port = server.server_address
-    try:
-        yield f"http://{host}:{port}"
-    finally:
-        server.shutdown()
-        thread.join()

dirsql_plugin_embeddings-0.1.9/tests/e2e/__init__.py DELETED Viewed

File without changes

dirsql_plugin_embeddings-0.1.9/tests/integration/__init__.py DELETED Viewed

File without changes

{dirsql_plugin_embeddings-0.1.9 → dirsql_plugin_embeddings-0.1.11}/.gitignore RENAMED Viewed

File without changes

{dirsql_plugin_embeddings-0.1.9 → dirsql_plugin_embeddings-0.1.11}/src/dirsql_plugin_embeddings/__init__.py RENAMED Viewed

File without changes

{dirsql_plugin_embeddings-0.1.9 → dirsql_plugin_embeddings-0.1.11}/testing-conventions.toml RENAMED Viewed

File without changes

dirsql-plugin-embeddings 0.1.9__tar.gz → 0.1.11__tar.gz

dirsql-plugin-embeddings 0.1.9tar.gz → 0.1.11tar.gz