okf-ingest 0.1.0__tar.gz

okf_ingest-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: okf-ingest
+Version: 0.1.0
+Summary: Unified ingestion tool for Open Knowledge Format (OKF) bundles — validate, load into a portable DuckDB catalog, and semantically search.
+Author-email: Travis Jakel <travis.s.jakel@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/travisjakel/okf-ingest
+Project-URL: Repository, https://github.com/travisjakel/okf-ingest
+Project-URL: OKF Specification, https://github.com/GoogleCloudPlatform/knowledge-catalog
+Keywords: okf,open-knowledge-format,knowledge,rag,duckdb,agents
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml>=6
+Requires-Dist: duckdb>=1.0
+
+# okf (Python binding)
+
+Python binding of **okf-ingest** — a unified ingestion tool for
+[Open Knowledge Format](https://github.com/GoogleCloudPlatform/knowledge-catalog)
+(OKF) bundles. Validate a bundle, load it into a portable DuckDB catalog, and
+semantically search it.
+
+```bash
+pip install okf-ingest
+okf validate ./bundle
+okf ingest   ./bundle --db catalog.duckdb
+okf embed    catalog.duckdb            # uses local Ollama nomic-embed-text by default
+okf rag      catalog.duckdb --query "how is revenue computed?" -k 5
+```
+
+```python
+import okf
+con, summary = okf.ingest("./bundle", db_path="catalog.duckdb")
+okf.embed(con)                         # pluggable embedder
+okf.rag_search(con, "revenue", k=5)
+```
+
+The catalog format is shared with the R binding (`okf` on CRAN-style install),
+so you can ingest/embed in one language and query from the other. See the
+[project README](https://github.com/travisjakel/okf-ingest) and `docs/` for the
+full spec-conformance notes and architecture.

okf_ingest-0.1.0/README.md

@@ -0,0 +1,26 @@
+# okf (Python binding)
+
+Python binding of **okf-ingest** — a unified ingestion tool for
+[Open Knowledge Format](https://github.com/GoogleCloudPlatform/knowledge-catalog)
+(OKF) bundles. Validate a bundle, load it into a portable DuckDB catalog, and
+semantically search it.
+
+```bash
+pip install okf-ingest
+okf validate ./bundle
+okf ingest   ./bundle --db catalog.duckdb
+okf embed    catalog.duckdb            # uses local Ollama nomic-embed-text by default
+okf rag      catalog.duckdb --query "how is revenue computed?" -k 5
+```
+
+```python
+import okf
+con, summary = okf.ingest("./bundle", db_path="catalog.duckdb")
+okf.embed(con)                         # pluggable embedder
+okf.rag_search(con, "revenue", k=5)
+```
+
+The catalog format is shared with the R binding (`okf` on CRAN-style install),
+so you can ingest/embed in one language and query from the other. See the
+[project README](https://github.com/travisjakel/okf-ingest) and `docs/` for the
+full spec-conformance notes and architecture.

okf_ingest-0.1.0/okf/__init__.py

@@ -0,0 +1,9 @@
+"""okf — Open Knowledge Format ingestion (Python binding)."""
+from .okf import read_bundle, validate, links, ingest, search, Bundle, Concept
+# Note: import the function as `rag_search` so it does not shadow the `okf.rag`
+# submodule (i.e. `import okf.rag` keeps returning the module, not this fn).
+from .rag import chunk_body, ollama_embedder, embed
+from .rag import rag as rag_search
+
+__all__ = ["read_bundle", "validate", "links", "ingest", "search", "Bundle", "Concept",
+           "chunk_body", "ollama_embedder", "embed", "rag_search"]

okf_ingest-0.1.0/okf/__main__.py

@@ -0,0 +1,4 @@
+import sys
+from .cli import main
+
+sys.exit(main())

okf_ingest-0.1.0/okf/cli.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""okf — command-line interface (Python). Mirrors r/okf/bin/okf.R.
+
+  okf validate <bundle> [--strict] [--json]
+  okf ingest   <bundle> --db <path> [--id <id>] [--json]
+  okf query    <db> [--sql "..."] [--search <term>] [--concepts] [--links] [--findings] [--json]
+
+Exit codes: 0 ok · 1 conformance failure · 2 usage error.
+"""
+import argparse, json, os, sys
+
+# allow running as `python py/okf/cli.py ...` (put the package parent on path)
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+import okf.okf as okf  # noqa: E402
+from okf.rag import embed as rag_embed, rag as rag_search, ollama_embedder  # noqa: E402
+
+import duckdb  # noqa: E402
+
+
+def _print(rows, cols, as_json):
+    if as_json:
+        print(json.dumps([dict(zip(cols, r)) for r in rows], indent=2, default=str))
+    else:
+        print(" | ".join(cols))
+        for r in rows:
+            print(" | ".join("" if v is None else str(v) for v in r))
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="okf", add_help=True)
+    sub = p.add_subparsers(dest="cmd")
+
+    v = sub.add_parser("validate"); v.add_argument("bundle")
+    v.add_argument("--strict", action="store_true"); v.add_argument("--json", action="store_true")
+
+    i = sub.add_parser("ingest"); i.add_argument("bundle")
+    i.add_argument("--db", default=":memory:"); i.add_argument("--id", default=None)
+    i.add_argument("--json", action="store_true")
+
+    q = sub.add_parser("query"); q.add_argument("db")
+    q.add_argument("--sql"); q.add_argument("--search")
+    q.add_argument("--concepts", action="store_true"); q.add_argument("--links", action="store_true")
+    q.add_argument("--findings", action="store_true"); q.add_argument("--json", action="store_true")
+
+    e = sub.add_parser("embed"); e.add_argument("db")
+    e.add_argument("--model", default="nomic-embed-text"); e.add_argument("--json", action="store_true")
+
+    r = sub.add_parser("rag"); r.add_argument("db"); r.add_argument("--query", required=True)
+    r.add_argument("-k", type=int, default=5); r.add_argument("--model", default="nomic-embed-text")
+    r.add_argument("--json", action="store_true")
+
+    a = p.parse_args(argv)
+    if not a.cmd:
+        p.print_help(); return 2
+
+    if a.cmd == "validate":
+        b = okf.read_bundle(a.bundle)
+        val = okf.validate(b)
+        nerr = sum(1 for f in val if f["severity"] == "error")
+        nwarn = sum(1 for f in val if f["severity"] == "warn")
+        conf = nerr == 0
+        if a.json:
+            print(json.dumps({"bundle": a.bundle, "conformant": conf, "errors": nerr,
+                              "warnings": nwarn, "findings": val}, indent=2))
+        else:
+            print(f"bundle: {a.bundle}\nconformant: {conf}  (errors: {nerr}, warnings: {nwarn})")
+            for f in val:
+                print(f"  [{f['severity']:<5}] {f['rule']:<22} {f['path']} — {f['message']}")
+        return 1 if (not conf or (a.strict and nwarn > 0)) else 0
+
+    if a.cmd == "ingest":
+        con, s = okf.ingest(a.bundle, db_path=a.db, bundle_id=a.id)
+        con.close()
+        if a.json:
+            print(json.dumps({"bundle": a.bundle, "db": a.db, **s}, indent=2))
+        else:
+            print(f"ingested {a.bundle} -> {a.db}\n  concepts={s['n_concepts']} "
+                  f"conformant={s['n_conformant']} ({s['conformant']}) errors={s['errors']} "
+                  f"warnings={s['warnings']} links={s['links_total']} broken={s['links_broken']}")
+        return 0 if s["conformant"] else 1
+
+    if a.cmd == "query":
+        con = duckdb.connect(a.db, read_only=True)
+        try:
+            if a.sql:
+                cur = con.execute(a.sql)
+            elif a.search:
+                cur = con.execute("SELECT path,type,title FROM okf_concept WHERE body ILIKE ? ORDER BY path",
+                                  [f"%{a.search}%"])
+            elif a.links:
+                cur = con.execute("SELECT * FROM okf_link")
+            elif a.findings:
+                cur = con.execute("SELECT * FROM okf_validation ORDER BY severity, path")
+            else:
+                cur = con.execute("SELECT path,reserved,type,title FROM okf_concept ORDER BY path")
+            cols = [d[0] for d in cur.description]
+            _print(cur.fetchall(), cols, a.json)
+        finally:
+            con.close()
+        return 0
+
+    if a.cmd == "embed":
+        con = duckdb.connect(a.db)
+        try:
+            n = rag_embed(con, embedder=ollama_embedder(a.model))
+        finally:
+            con.close()
+        print(json.dumps({"db": a.db, "chunks": n}) if a.json else f"embedded {n} chunks into {a.db}")
+        return 0
+
+    if a.cmd == "rag":
+        con = duckdb.connect(a.db, read_only=True)
+        try:
+            rows = rag_search(con, a.query, embedder=ollama_embedder(a.model), k=a.k)
+        finally:
+            con.close()
+        if a.json:
+            cols = ["path", "title", "chunk_id", "score", "text"]
+            print(json.dumps([dict(zip(cols, r)) for r in rows], indent=2, default=str))
+        else:
+            for path, title, cid, score, text in rows:
+                print(f"[{score:.3f}] {path}#{cid} — {title}\n    {text[:160].replace(chr(10),' ')}")
+        return 0
+
+    p.print_help(); return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

okf_ingest-0.1.0/okf/okf.py

@@ -0,0 +1,264 @@
+"""okf — Open Knowledge Format ingestion (Python binding).
+
+Mirrors the R reference binding (r/okf/R/okf.R) and writes a byte-compatible
+DuckDB catalog against the same schema (schema/catalog.sql), so a bundle
+ingested by either language yields the same catalog. Implements OKF v0.1
+permissive consumption: never rejects a bundle for recommended-field issues.
+
+Public API:
+    read_bundle(root)            -> Bundle (concepts + raw links)
+    validate(bundle)             -> list[Finding]
+    links(bundle)                -> list[Link]
+    ingest(root, db_path)        -> (duckdb.Connection, summary dict)
+    search(con, term)            -> rows
+"""
+from __future__ import annotations
+import os, re, json, hashlib, datetime
+from dataclasses import dataclass, field
+from typing import Any, Optional
+import yaml
+import duckdb
+
+RESERVED = {"index.md", "log.md"}
+
+
+class _OKFLoader(yaml.SafeLoader):
+    """SafeLoader that leaves ISO timestamps as plain strings (matching the R
+    binding) instead of coercing them to datetime — keeps `timestamp` verbatim
+    and frontmatter JSON-serializable."""
+    pass
+
+
+_OKFLoader.yaml_implicit_resolvers = {
+    k: [(tag, rx) for tag, rx in v if tag != "tag:yaml.org,2002:timestamp"]
+    for k, v in yaml.SafeLoader.yaml_implicit_resolvers.items()
+}
+_ISO = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$")
+_LINK = re.compile(r"\]\(\s*([^)\s]+)")
+_SCHEME = re.compile(r"^[a-zA-Z][a-zA-Z0-9+.-]*:")
+
+# Mirror of schema/catalog.sql (that file is canonical; keep in sync).
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS okf_bundle (bundle_id TEXT PRIMARY KEY, root TEXT,
+  okf_version TEXT, source_kind TEXT, ingested_at TEXT, n_concepts INTEGER,
+  n_conformant INTEGER, conformant BOOLEAN);
+CREATE TABLE IF NOT EXISTS okf_concept (bundle_id TEXT, path TEXT, reserved BOOLEAN,
+  type TEXT, title TEXT, description TEXT, resource TEXT, tags TEXT, timestamp TEXT,
+  body TEXT, frontmatter TEXT, parse_error TEXT, content_hash TEXT,
+  PRIMARY KEY (bundle_id, path));
+CREATE TABLE IF NOT EXISTS okf_link (bundle_id TEXT, src_path TEXT, dst_raw TEXT,
+  dst_path TEXT, resolved BOOLEAN);
+CREATE TABLE IF NOT EXISTS okf_validation (bundle_id TEXT, path TEXT, severity TEXT,
+  rule TEXT, message TEXT);
+CREATE TABLE IF NOT EXISTS okf_chunk (bundle_id TEXT, path TEXT, chunk_id INTEGER,
+  text TEXT, embedding FLOAT[]);
+"""
+
+
+@dataclass
+class Concept:
+    path: str
+    reserved: bool
+    type: Optional[str]
+    title: Optional[str]
+    description: Optional[str]
+    resource: Optional[str]
+    tags: Any
+    timestamp: Optional[str]
+    body: str
+    frontmatter: Optional[dict]
+    parse_error: Optional[str]
+    links_raw: list
+    content_hash: str
+
+
+@dataclass
+class Bundle:
+    bundle_id: str
+    root: str
+    okf_version: Optional[str]
+    source_kind: str
+    concepts: list = field(default_factory=list)
+    known: set = field(default_factory=set)
+
+
+def _s(x):
+    if x is None:
+        return None
+    if isinstance(x, (list, dict)):
+        return None
+    return str(x)
+
+
+def parse_file(path: str) -> dict:
+    with open(path, "r", encoding="utf-8") as fh:
+        raw = fh.read().split("\n")
+    txt = "\n".join(raw)
+    i = 0
+    while i < len(raw) and raw[i].strip() == "":
+        i += 1
+    if i >= len(raw) or not re.match(r"^---\s*$", raw[i]):
+        return {"meta": None, "body": txt, "err": "no_frontmatter"}
+    fences = [j for j, ln in enumerate(raw) if re.match(r"^---\s*$", ln)]
+    opn = next(f for f in fences if f >= i)
+    after = [f for f in fences if f > opn]
+    if not after:
+        return {"meta": None, "body": txt, "err": "unclosed_frontmatter"}
+    close = after[0]
+    fm = "\n".join(raw[opn + 1:close])
+    body = "\n".join(raw[close + 1:]) if close < len(raw) - 1 else ""
+    try:
+        meta = yaml.load(fm, Loader=_OKFLoader)
+    except Exception:
+        meta = None
+    if meta is None or not isinstance(meta, dict):
+        return {"meta": None, "body": body, "err": "yaml_parse_error"}
+    return {"meta": meta, "body": body, "err": None}
+
+
+def extract_links(body: str) -> list:
+    return _LINK.findall(body)
+
+
+def _norm(p: str) -> str:
+    out = []
+    for s in p.replace("\\", "/").split("/"):
+        if s in ("", "."):
+            continue
+        if s == "..":
+            if out:
+                out.pop()
+            continue
+        out.append(s)
+    return "/".join(out)
+
+
+def _is_external(raw: str) -> bool:
+    return bool(_SCHEME.match(raw.split("#", 1)[0]))
+
+
+def resolve_link(raw: str, src_rel: str, known: set) -> Optional[str]:
+    t = raw.split("#", 1)[0]
+    if t.startswith("/"):
+        cand = t[1:]
+    else:
+        d = os.path.dirname(src_rel)
+        cand = t if d == "" else f"{d}/{t}"
+    cand = _norm(cand)
+    return cand if cand in known else None
+
+
+def read_bundle(root: str, bundle_id: Optional[str] = None, source_kind: str = "dir") -> Bundle:
+    root = os.path.realpath(root).replace("\\", "/")
+    files = []
+    for dp, _, fns in os.walk(root):
+        for fn in fns:
+            if fn.endswith(".md"):
+                files.append(os.path.join(dp, fn))
+    files.sort()
+    concepts = []
+    for f in files:
+        rel = os.path.relpath(f, root).replace("\\", "/")
+        p = parse_file(f)
+        meta = p["meta"] or {}
+        concepts.append(Concept(
+            path=rel, reserved=os.path.basename(f) in RESERVED,
+            type=_s(meta.get("type")), title=_s(meta.get("title")),
+            description=_s(meta.get("description")), resource=_s(meta.get("resource")),
+            tags=meta.get("tags"), timestamp=_s(meta.get("timestamp")),
+            body=p["body"], frontmatter=p["meta"], parse_error=p["err"],
+            links_raw=extract_links(p["body"]),
+            content_hash=hashlib.sha1(p["body"].encode("utf-8")).hexdigest()))
+    known = {c.path for c in concepts}
+    idx = [c for c in concepts if c.path == "index.md"]
+    okf_version = _s((idx[0].frontmatter or {}).get("okf_version")) if idx else None
+    if bundle_id is None:
+        bundle_id = hashlib.sha1(root.encode("utf-8")).hexdigest()
+    return Bundle(bundle_id, root, okf_version, source_kind, concepts, known)
+
+
+def links(b: Bundle) -> list:
+    out = []
+    for c in b.concepts:
+        for raw in c.links_raw:
+            if _is_external(raw):
+                continue
+            dst = resolve_link(raw, c.path, b.known)
+            out.append({"src_path": c.path, "dst_raw": raw,
+                        "dst_path": dst, "resolved": dst is not None})
+    return out
+
+
+def validate(b: Bundle) -> list:
+    out = []
+    def add(path, sev, rule, msg):
+        out.append({"path": path, "severity": sev, "rule": rule, "message": msg})
+    for c in b.concepts:
+        if c.reserved:
+            continue
+        if c.parse_error is not None:
+            add(c.path, "error", "frontmatter_unparseable",
+                f"no parseable frontmatter ({c.parse_error})")
+            continue
+        if not c.type:
+            add(c.path, "error", "missing_type", "frontmatter has no non-empty type")
+        if c.title is None:
+            add(c.path, "warn", "missing_title", "recommended field title absent")
+        if c.description is None:
+            add(c.path, "warn", "missing_description", "recommended field description absent")
+        if c.timestamp is None:
+            add(c.path, "warn", "missing_timestamp", "recommended field timestamp absent")
+        elif not _ISO.match(c.timestamp):
+            add(c.path, "warn", "timestamp_not_iso8601", f"timestamp not ISO-8601: {c.timestamp}")
+    for lk in links(b):
+        if not lk["resolved"]:
+            add(lk["src_path"], "warn", "broken_link", f"unresolved link: {lk['dst_raw']}")
+    return out
+
+
+def ingest(root, db_path: str = ":memory:", ingested_at: Optional[str] = None,
+           bundle_id: Optional[str] = None, source_kind: str = "dir"):
+    b = root if isinstance(root, Bundle) else read_bundle(root, bundle_id, source_kind)
+    val = validate(b)
+    lk = links(b)
+    if ingested_at is None:
+        ingested_at = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    err_paths = {f["path"] for f in val if f["severity"] == "error"}
+    non_reserved = [c for c in b.concepts if not c.reserved]
+    n_conf = sum(1 for c in non_reserved if c.path not in err_paths)
+
+    con = duckdb.connect(db_path)
+    for stmt in (s.strip() for s in SCHEMA.split(";") if s.strip()):
+        con.execute(stmt)
+
+    con.execute("INSERT INTO okf_bundle VALUES (?,?,?,?,?,?,?,?)",
+                [b.bundle_id, b.root, b.okf_version, b.source_kind, ingested_at,
+                 len(non_reserved), n_conf, len(err_paths) == 0])
+    for c in b.concepts:
+        con.execute("INSERT INTO okf_concept VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                    [b.bundle_id, c.path, c.reserved, c.type, c.title, c.description,
+                     c.resource, None if c.tags is None else json.dumps(c.tags),
+                     c.timestamp, c.body, json.dumps(c.frontmatter or {}),
+                     c.parse_error, c.content_hash])
+    for lk_ in lk:
+        con.execute("INSERT INTO okf_link VALUES (?,?,?,?,?)",
+                    [b.bundle_id, lk_["src_path"], lk_["dst_raw"], lk_["dst_path"], lk_["resolved"]])
+    for f in val:
+        con.execute("INSERT INTO okf_validation VALUES (?,?,?,?,?)",
+                    [b.bundle_id, f["path"], f["severity"], f["rule"], f["message"]])
+
+    summary = {
+        "n_files": len(b.concepts), "n_concepts": len(non_reserved), "n_conformant": n_conf,
+        "conformant": len(err_paths) == 0,
+        "errors": sum(1 for f in val if f["severity"] == "error"),
+        "warnings": sum(1 for f in val if f["severity"] == "warn"),
+        "links_total": len(lk), "links_broken": sum(1 for x in lk if not x["resolved"]),
+    }
+    return con, summary
+
+
+def search(con, term: str):
+    return con.execute(
+        "SELECT path, type, title FROM okf_concept WHERE body ILIKE ? ORDER BY path",
+        [f"%{term}%"]).fetchall()

okf_ingest-0.1.0/okf/rag.py

@@ -0,0 +1,78 @@
+"""okf RAG layer (Python) — mirrors the R binding's embeddings/RAG functions.
+
+Pluggable embedder (default: local Ollama nomic-embed-text); brute-force cosine
+search via DuckDB's native list_cosine_similarity. An embedder is a callable
+texts:list[str] -> list[list[float]].
+"""
+from __future__ import annotations
+import os, re, json, urllib.request
+from typing import Callable, Optional
+
+
+def chunk_body(body: str, target_chars: int = 600) -> list:
+    paras = [p.strip() for p in re.split(r"\n[ \t]*\n", body or "") if p.strip()]
+    chunks, cur = [], ""
+    for p in paras:
+        if not cur:
+            cur = p
+        elif len(cur) + len(p) + 2 <= target_chars:
+            cur = f"{cur}\n\n{p}"
+        else:
+            chunks.append(cur); cur = p
+    if cur:
+        chunks.append(cur)
+    return chunks
+
+
+def ollama_embedder(model: str = "nomic-embed-text",
+                    url: Optional[str] = None) -> Callable:
+    url = url or os.environ.get("OLLAMA_URL", "http://localhost:11434")
+
+    def embed(texts):
+        out = []
+        for t in texts:
+            req = urllib.request.Request(
+                f"{url}/api/embeddings",
+                data=json.dumps({"model": model, "prompt": t}).encode("utf-8"),
+                headers={"Content-Type": "application/json"})
+            with urllib.request.urlopen(req, timeout=120) as r:
+                out.append(json.loads(r.read())["embedding"])
+        return out
+    return embed
+
+
+def _vec_lit(v) -> str:
+    return "[" + ",".join(f"{float(z):.8g}" for z in v) + "]::FLOAT[]"
+
+
+def embed(con, embedder: Optional[Callable] = None, target_chars: int = 600) -> int:
+    embedder = embedder or ollama_embedder()
+    con.execute("CREATE TABLE IF NOT EXISTS okf_chunk (bundle_id TEXT, path TEXT, "
+                "chunk_id INTEGER, text TEXT, embedding FLOAT[])")
+    rows = con.execute(
+        "SELECT bundle_id, path, body FROM okf_concept WHERE reserved = FALSE ORDER BY path"
+    ).fetchall()
+    con.execute("DELETE FROM okf_chunk")
+    n = 0
+    for bundle_id, path, body in rows:
+        chs = chunk_body(body, target_chars)
+        if not chs:
+            continue
+        embs = embedder(chs)
+        for k, (text, vec) in enumerate(zip(chs, embs), start=1):
+            con.execute(
+                f"INSERT INTO okf_chunk VALUES (?,?,?,?, {_vec_lit(vec)})",
+                [bundle_id, path, k, text])
+            n += 1
+    return n
+
+
+def rag(con, query: str, embedder: Optional[Callable] = None, k: int = 5):
+    embedder = embedder or ollama_embedder()
+    qv = embedder([query])[0]
+    return con.execute(
+        f"""SELECT ch.path, c.title, ch.chunk_id,
+                   list_cosine_similarity(ch.embedding, {_vec_lit(qv)}) AS score, ch.text
+            FROM okf_chunk ch JOIN okf_concept c USING (bundle_id, path)
+            WHERE ch.embedding IS NOT NULL ORDER BY score DESC LIMIT {int(k)}"""
+    ).fetchall()

okf_ingest-0.1.0/okf_ingest.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: okf-ingest
+Version: 0.1.0
+Summary: Unified ingestion tool for Open Knowledge Format (OKF) bundles — validate, load into a portable DuckDB catalog, and semantically search.
+Author-email: Travis Jakel <travis.s.jakel@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/travisjakel/okf-ingest
+Project-URL: Repository, https://github.com/travisjakel/okf-ingest
+Project-URL: OKF Specification, https://github.com/GoogleCloudPlatform/knowledge-catalog
+Keywords: okf,open-knowledge-format,knowledge,rag,duckdb,agents
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pyyaml>=6
+Requires-Dist: duckdb>=1.0
+
+# okf (Python binding)
+
+Python binding of **okf-ingest** — a unified ingestion tool for
+[Open Knowledge Format](https://github.com/GoogleCloudPlatform/knowledge-catalog)
+(OKF) bundles. Validate a bundle, load it into a portable DuckDB catalog, and
+semantically search it.
+
+```bash
+pip install okf-ingest
+okf validate ./bundle
+okf ingest   ./bundle --db catalog.duckdb
+okf embed    catalog.duckdb            # uses local Ollama nomic-embed-text by default
+okf rag      catalog.duckdb --query "how is revenue computed?" -k 5
+```
+
+```python
+import okf
+con, summary = okf.ingest("./bundle", db_path="catalog.duckdb")
+okf.embed(con)                         # pluggable embedder
+okf.rag_search(con, "revenue", k=5)
+```
+
+The catalog format is shared with the R binding (`okf` on CRAN-style install),
+so you can ingest/embed in one language and query from the other. See the
+[project README](https://github.com/travisjakel/okf-ingest) and `docs/` for the
+full spec-conformance notes and architecture.

okf_ingest-0.1.0/okf_ingest.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+okf/__init__.py
+okf/__main__.py
+okf/cli.py
+okf/okf.py
+okf/rag.py
+okf_ingest.egg-info/PKG-INFO
+okf_ingest.egg-info/SOURCES.txt
+okf_ingest.egg-info/dependency_links.txt
+okf_ingest.egg-info/entry_points.txt
+okf_ingest.egg-info/requires.txt
+okf_ingest.egg-info/top_level.txt

okf_ingest-0.1.0/okf_ingest.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

okf_ingest-0.1.0/okf_ingest.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+okf = okf.cli:main

okf_ingest-0.1.0/okf_ingest.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pyyaml>=6
+duckdb>=1.0

okf_ingest-0.1.0/okf_ingest.egg-info/top_level.txt

@@ -0,0 +1 @@
+okf

okf_ingest-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "okf-ingest"
+version = "0.1.0"
+description = "Unified ingestion tool for Open Knowledge Format (OKF) bundles — validate, load into a portable DuckDB catalog, and semantically search."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+authors = [{ name = "Travis Jakel", email = "travis.s.jakel@gmail.com" }]
+keywords = ["okf", "open-knowledge-format", "knowledge", "rag", "duckdb", "agents"]
+dependencies = ["pyyaml>=6", "duckdb>=1.0"]
+
+[project.urls]
+Homepage = "https://github.com/travisjakel/okf-ingest"
+Repository = "https://github.com/travisjakel/okf-ingest"
+"OKF Specification" = "https://github.com/GoogleCloudPlatform/knowledge-catalog"
+
+[project.scripts]
+okf = "okf.cli:main"
+
+[tool.setuptools]
+packages = ["okf"]

okf_ingest-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+