cjm-capability-graph-sqlite 0.0.26__py3-none-any.whl

cjm_capability_graph_sqlite/query_translation.py

@@ -0,0 +1,313 @@
+"""The per-backend translation of the typed query expressions (pass-2 Thread 5; stage 4): NodeQuery/EdgeQuery -> parameterized SQLite SQL over the nodes/edges schema. THIS module is what makes the typed surface portable - the expression is domain- and backend-neutral; every backend tool owns a translation like this one (the ratified stage-4 split: backend owns translation; the adapter stays generic). Pure functions, unit-tested against an in-memory DB with the production schema - no capability runtime needed.
+
+Translation rules:
+
+- **Predicates** compile to `json_extract(properties, $.<path>)` comparisons
+  with bound parameters (values NEVER interpolated). Property paths are dotted
+  (`payload.document_id`) and validated against `[A-Za-z0-9_]` segments —
+  paths are interpolated into the JSON-path literal, so validation is the
+  injection guard for the path position.
+- **`contains` is case-INSENSITIVE by definition** (P12): `lower(col) LIKE ...
+  ESCAPE` with `%`/`_`/`\\` escaped in the value. Both sides use SQLite
+  `lower()` (ASCII-range folding) — consistent, but non-ASCII case folding is
+  NOT performed (recorded; a unicode-folding consumer would be the promotion
+  evidence).
+- **Id lists** bind as ONE JSON-array parameter via `json_each(?)` — no SQL
+  parameter-count limits at corpus scale (13k+ ids).
+- **Relation / endpoint constraints** compile to correlated `EXISTS`
+  subqueries (never JOINs) — no row multiplication, so `count` needs no
+  DISTINCT and rows need no GROUP BY.
+- **`SourcePredicate`** translates content-hash-primary (`json_each(sources)`);
+  a locator constraint raises (unsupported — use `find_nodes_by_source`, which
+  does Python-side locator equality; a recurring need here is promotion
+  evidence).
+- **Modes**: `count` > `project` > full (mirrors the result DTO contract).
+  Projected node rows always carry `id` (+ `label` projectable structurally;
+  `sources` projectable as parsed ref dicts); edge rows always carry
+  `id`/`source_id`/`target_id` (+ `relation_type` projectable)."""
+
+import json
+import re
+from typing import Any, List, Optional, Tuple
+
+from cjm_context_graph_primitives.query import (EdgeQuery, NodeQuery, PropertyPredicate,
+                                                RelationPredicate, SourcePredicate)
+from cjm_substrate.core.errors import CapabilityInputError
+
+_PROP_PATH_RE = re.compile(r"^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$")  # Dotted-path guard (paths are interpolated; values are bound)
+
+
+def _json_path(
+    prop: str,  # Property name or dotted path (e.g. "payload.document_id")
+) -> str:  # SQL string literal for json_extract's path argument
+    """Validate a dotted property path and render the JSON-path literal."""
+    if not _PROP_PATH_RE.match(prop or ""):
+        raise CapabilityInputError(
+            f"Invalid property path {prop!r} (segments must be [A-Za-z0-9_])",
+            fields_invalid=["prop"],
+        )
+    return "'$." + prop + "'"
+
+
+def _escape_like(
+    value: str,  # Raw substring the caller wants matched literally
+) -> str:  # Value with LIKE wildcards escaped (ESCAPE '\\')
+    """Escape `%` / `_` / `\\` so `contains` matches literally, never as wildcards."""
+    return value.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_")
+
+
+def _predicate_sql(
+    pred: PropertyPredicate,  # One typed property predicate
+    props_col: str,  # SQL expression for the properties JSON column (e.g. "n.properties")
+) -> Tuple[str, List[Any]]:  # (SQL fragment, bound params)
+    """Compile one property predicate to a parameterized SQL fragment."""
+    col = f"json_extract({props_col}, {_json_path(pred.prop)})"
+    op = pred.op
+    if op == "eq":
+        return f"{col} = ?", [pred.value]
+    if op == "ne":
+        return f"{col} != ?", [pred.value]
+    if op == "lt":
+        return f"{col} < ?", [pred.value]
+    if op == "le":
+        return f"{col} <= ?", [pred.value]
+    if op == "gt":
+        return f"{col} > ?", [pred.value]
+    if op == "ge":
+        return f"{col} >= ?", [pred.value]
+    if op == "in":
+        if not isinstance(pred.value, (list, tuple)):
+            raise CapabilityInputError(
+                f"Op 'in' requires a list value (got {type(pred.value).__name__})",
+                fields_invalid=["value"],
+            )
+        return (f"{col} IN (SELECT value FROM json_each(?))",
+                [json.dumps(list(pred.value))])
+    if op == "contains":
+        if not isinstance(pred.value, str):
+            raise CapabilityInputError(
+                f"Op 'contains' requires a string value (got {type(pred.value).__name__})",
+                fields_invalid=["value"],
+            )
+        # Defined case-INSENSITIVE (P12). Both sides through SQLite's lower()
+        # (ASCII folding); wildcards escaped so the match is literal.
+        return (f"lower({col}) LIKE '%' || lower(?) || '%' ESCAPE '\\'",
+                [_escape_like(pred.value)])
+    if op == "is_null":
+        return f"{col} IS NULL", []
+    if op == "not_null":
+        return f"{col} IS NOT NULL", []
+    raise CapabilityInputError(
+        f"Predicate op {pred.op!r} not supported by the sqlite translation",
+        fields_invalid=["op"],
+    )
+
+
+def _source_match_sql(
+    sp: SourcePredicate,  # Provenance match (content-hash-primary per CR-19)
+    sources_expr: str,  # SQL expression for the sources JSON column (e.g. "n.sources")
+) -> Tuple[str, List[Any]]:  # (EXISTS fragment, bound params)
+    """Compile a source predicate to an EXISTS over the sources array.
+
+    Content-hash-primary (identity field = the stable query surface, C19).
+    A locator constraint RAISES — unsupported in the typed translation
+    (use `find_nodes_by_source` for locator equality; recurring need here
+    is the promotion evidence the raw-escape posture wants recorded).
+    """
+    if sp.locator is not None:
+        raise CapabilityInputError(
+            "SourcePredicate.locator is not supported by the sqlite typed "
+            "translation (content-hash-primary); use find_nodes_by_source",
+            fields_invalid=["locator"],
+        )
+    return (f"EXISTS (SELECT 1 FROM json_each({sources_expr}) AS src "
+            f"WHERE json_extract(src.value, '$.content_hash') = ?)",
+            [sp.content_hash])
+
+
+def _relation_exists_sql(
+    rel: RelationPredicate,  # One-hop relation constraint (+ far-end constraints)
+    node_expr: str,  # SQL expression for the candidate node id (e.g. "n.id", "e.source_id")
+) -> Tuple[str, List[Any]]:  # (EXISTS fragment, bound params)
+    """Compile a relation predicate to a correlated EXISTS (no row multiplication).
+
+    Far-end constraints (stage-4 promotions): `node_id` / `node_ids` pin the
+    far node; `node_source` nests a provenance EXISTS on the far node.
+    Subquery scoping keeps the fixed aliases (r / fn / src) collision-free.
+    """
+    params: List[Any] = [rel.relation_type]
+    if rel.direction == "out":
+        join_cond = f"r.source_id = {node_expr}"
+        far = "r.target_id"
+    elif rel.direction == "in":
+        join_cond = f"r.target_id = {node_expr}"
+        far = "r.source_id"
+    else:  # both
+        join_cond = f"(r.source_id = {node_expr} OR r.target_id = {node_expr})"
+        far = (f"(CASE WHEN r.source_id = {node_expr} "
+               f"THEN r.target_id ELSE r.source_id END)")
+    conds = [join_cond, "r.relation_type = ?"]
+    if rel.node_id is not None:
+        conds.append(f"{far} = ?")
+        params.append(rel.node_id)
+    if rel.node_ids is not None:
+        conds.append(f"{far} IN (SELECT value FROM json_each(?))")
+        params.append(json.dumps(list(rel.node_ids)))
+    if rel.node_source is not None:
+        src_frag, src_params = _source_match_sql(rel.node_source, "fn.sources")
+        conds.append(
+            f"EXISTS (SELECT 1 FROM nodes AS fn WHERE fn.id = {far} AND {src_frag})")
+        params.extend(src_params)
+    return f"EXISTS (SELECT 1 FROM edges AS r WHERE {' AND '.join(conds)})", params
+
+
+NODE_FULL_COLUMNS = "n.id, n.label, n.properties, n.sources, n.created_at, n.updated_at"  # Matches _row_to_node order
+EDGE_FULL_COLUMNS = "e.id, e.source_id, e.target_id, e.relation_type, e.properties, e.created_at, e.updated_at"  # Matches _row_to_edge order
+
+
+def _order_limit_sql(
+    query,  # NodeQuery or EdgeQuery (order_by / limit / offset fields)
+    props_col: str,  # Properties column expression for ORDER BY paths
+    params: List[Any],  # Bound-params list (appended in place)
+) -> str:  # ORDER BY / LIMIT / OFFSET tail
+    """Compile the shared ordering + paging tail."""
+    tail = ""
+    if query.order_by is not None:
+        tail += (f" ORDER BY json_extract({props_col}, "
+                 f"{_json_path(query.order_by.prop)})"
+                 + (" DESC" if query.order_by.descending else " ASC"))
+    if query.limit is not None or query.offset:
+        tail += " LIMIT ?"
+        params.append(query.limit if query.limit is not None else -1)
+        if query.offset:
+            tail += " OFFSET ?"
+            params.append(query.offset)
+    return tail
+
+
+def translate_node_query(
+    q: NodeQuery,  # Typed node query
+) -> Tuple[str, List[Any], str, Optional[List[str]]]:  # (sql, params, mode, row keys)
+    """Translate a `NodeQuery` to parameterized SQLite SQL.
+
+    mode: "count" | "rows" | "full" (count > project > full, mirroring the
+    result DTO's exactly-one-populated contract). For "rows", the returned
+    keys list zips against each cursor row ("id" always first; "label"
+    projects structurally; "sources" projects as the raw JSON column for the
+    caller to parse).
+    """
+    where: List[str] = []
+    params: List[Any] = []
+    if q.ids is not None:
+        where.append("n.id IN (SELECT value FROM json_each(?))")
+        params.append(json.dumps(list(q.ids)))
+    if q.label is not None:
+        where.append("n.label = ?")
+        params.append(q.label)
+    for pred in q.where:
+        frag, ps = _predicate_sql(pred, "n.properties")
+        where.append(frag)
+        params.extend(ps)
+    if q.source is not None:
+        frag, ps = _source_match_sql(q.source, "n.sources")
+        where.append(frag)
+        params.extend(ps)
+    if q.related is not None:
+        frag, ps = _relation_exists_sql(q.related, "n.id")
+        where.append(frag)
+        params.extend(ps)
+    where_sql = (" WHERE " + " AND ".join(where)) if where else ""
+
+    if q.count:
+        return (f"SELECT COUNT(*) FROM nodes AS n{where_sql}", params, "count", None)
+
+    if q.project is not None:
+        keys = ["id"]
+        select_parts = ["n.id"]
+        for name in q.project:
+            if name == "id":
+                continue
+            if name == "label":
+                select_parts.append("n.label")
+                keys.append("label")
+            elif name == "sources":
+                select_parts.append("n.sources")
+                keys.append("sources")
+            else:
+                select_parts.append(f"json_extract(n.properties, {_json_path(name)})")
+                keys.append(name)
+        tail = _order_limit_sql(q, "n.properties", params)
+        return (f"SELECT {', '.join(select_parts)} FROM nodes AS n{where_sql}{tail}",
+                params, "rows", keys)
+
+    tail = _order_limit_sql(q, "n.properties", params)
+    return (f"SELECT {NODE_FULL_COLUMNS} FROM nodes AS n{where_sql}{tail}",
+            params, "full", None)
+
+
+def translate_edge_query(
+    q: EdgeQuery,  # Typed edge query
+) -> Tuple[str, List[Any], str, Optional[List[str]]]:  # (sql, params, mode, row keys)
+    """Translate an `EdgeQuery` to parameterized SQLite SQL.
+
+    Same mode contract as `translate_node_query`. Projected rows always carry
+    `id`/`source_id`/`target_id`; `relation_type` projects structurally.
+    Endpoint constraints (`source_related`/`target_related` — the D13
+    NEXT-chain count) compile to correlated EXISTS on the endpoint node.
+    """
+    where: List[str] = []
+    params: List[Any] = []
+    if q.ids is not None:
+        where.append("e.id IN (SELECT value FROM json_each(?))")
+        params.append(json.dumps(list(q.ids)))
+    if q.relation_type is not None:
+        where.append("e.relation_type = ?")
+        params.append(q.relation_type)
+    if q.source_id is not None:
+        where.append("e.source_id = ?")
+        params.append(q.source_id)
+    if q.target_id is not None:
+        where.append("e.target_id = ?")
+        params.append(q.target_id)
+    if q.source_ids is not None:
+        where.append("e.source_id IN (SELECT value FROM json_each(?))")
+        params.append(json.dumps(list(q.source_ids)))
+    if q.target_ids is not None:
+        where.append("e.target_id IN (SELECT value FROM json_each(?))")
+        params.append(json.dumps(list(q.target_ids)))
+    if q.source_related is not None:
+        frag, ps = _relation_exists_sql(q.source_related, "e.source_id")
+        where.append(frag)
+        params.extend(ps)
+    if q.target_related is not None:
+        frag, ps = _relation_exists_sql(q.target_related, "e.target_id")
+        where.append(frag)
+        params.extend(ps)
+    for pred in q.where:
+        frag, ps = _predicate_sql(pred, "e.properties")
+        where.append(frag)
+        params.extend(ps)
+    where_sql = (" WHERE " + " AND ".join(where)) if where else ""
+
+    if q.count:
+        return (f"SELECT COUNT(*) FROM edges AS e{where_sql}", params, "count", None)
+
+    if q.project is not None:
+        keys = ["id", "source_id", "target_id"]
+        select_parts = ["e.id", "e.source_id", "e.target_id"]
+        for name in q.project:
+            if name in ("id", "source_id", "target_id"):
+                continue
+            if name == "relation_type":
+                select_parts.append("e.relation_type")
+                keys.append("relation_type")
+            else:
+                select_parts.append(f"json_extract(e.properties, {_json_path(name)})")
+                keys.append(name)
+        tail = _order_limit_sql(q, "e.properties", params)
+        return (f"SELECT {', '.join(select_parts)} FROM edges AS e{where_sql}{tail}",
+                params, "rows", keys)
+
+    tail = _order_limit_sql(q, "e.properties", params)
+    return (f"SELECT {EDGE_FULL_COLUMNS} FROM edges AS e{where_sql}{tail}",
+            params, "full", None)

cjm_capability_graph_sqlite-0.0.26.dist-info/METADATA

@@ -0,0 +1,50 @@
+Metadata-Version: 2.4
+Name: cjm-capability-graph-sqlite
+Version: 0.0.26
+Summary: A local, file-backed context-graph storage capability for the cjm-substrate runtime that implements graph storage, traversal, and querying using SQLite.
+Author-email: "Christian J. Mills" <9126128+cj-mills@users.noreply.github.com>
+License: Apache-2.0
+Project-URL: Repository, https://github.com/cj-mills/cjm-capability-graph-sqlite
+Keywords: python
+Classifier: Natural Language :: English
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cjm-substrate>=0.0.51
+Requires-Dist: cjm-context-graph-primitives>=0.0.12
+Dynamic: license-file
+
+# cjm-capability-graph-sqlite
+
+<!-- generated from the context graph by `cjm-context-graph readme` — do not edit by hand; edit the graph (the urge to hand-edit = move it on-graph) -->
+
+A local, file-backed context-graph storage capability for the cjm-substrate runtime that implements graph storage, traversal, and querying using SQLite.
+
+## Modules
+
+- **`cjm_capability_graph_sqlite.capability`** — Capability implementation for Context Graph using SQLite.
+- **`cjm_capability_graph_sqlite.query_translation`** — The per-backend translation of the typed query expressions (pass-2 Thread 5; stage 4): NodeQuery/EdgeQuery -> parameterized SQLite SQL over the nodes/edges schema. THIS module is what makes the typed surface portable - the expression is domain- and backend-neutral; every backend tool owns a translation like this one (the ratified stage-4 split: backend owns translation; the adapter stays generic). Pure functions, unit-tested against an in-memory DB with the production schema - no capability runtime needed.
+
+## API
+
+### `cjm_capability_graph_sqlite.capability`
+
+- `SQLiteGraphCapability` _class_ — Local, file-backed Context Graph implementation using SQLite.
+- `SQLiteGraphCapabilityConfig` _class_ — Configuration for SQLite Graph Capability.
+- `integrity_check` _function_ — Backend self-check (stage 4; the G3 corruption find institutionalized):
+- `query_edges` _function_ — Execute a typed edge query (stage 4) — same contract as `query_nodes`.
+- `query_nodes` _function_ — Execute a typed node query (stage 4) — translated to parameterized SQL
+- `raw_query` _function_ — Execute the raw escape — refuses backend mismatches (non-portable by
+
+### `cjm_capability_graph_sqlite.query_translation`
+
+- `translate_edge_query` _function_ — Translate an `EdgeQuery` to parameterized SQLite SQL.
+- `translate_node_query` _function_ — Translate a `NodeQuery` to parameterized SQLite SQL.
+
+## Dependencies
+
+**Depends on:** `cjm-context-graph-primitives`, `cjm-substrate`

cjm_capability_graph_sqlite-0.0.26.dist-info/RECORD

@@ -0,0 +1,8 @@
+cjm_capability_graph_sqlite/__init__.py,sha256=Uo7fyxQsD_ez-4T9Di7e8J56WgMQ2DYHGASt3lnRdUY,23
+cjm_capability_graph_sqlite/capability.py,sha256=ngJhjqIgKb_1f1IS3EpaFLlFCFksKP62Dm8g8a57INo,38024
+cjm_capability_graph_sqlite/query_translation.py,sha256=w5jZrKtIrVNDduARWMIvNvxjzbl7gXzUzwN0UQ78Wgk,14218
+cjm_capability_graph_sqlite-0.0.26.dist-info/licenses/LICENSE,sha256=xV8xoN4VOL0uw9X8RSs2IMuD_Ss_a9yAbtGNeBWZwnw,11337
+cjm_capability_graph_sqlite-0.0.26.dist-info/METADATA,sha256=hL7LPQE6pmSmRHwuWARrwR7ayLOawaViUxo5AgPU4gc,2873
+cjm_capability_graph_sqlite-0.0.26.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+cjm_capability_graph_sqlite-0.0.26.dist-info/top_level.txt,sha256=zMuwCou7YR7_N4_jmBrVO8LIY4LgaF3KXma9MBSnEYY,28
+cjm_capability_graph_sqlite-0.0.26.dist-info/RECORD,,

cjm_capability_graph_sqlite-0.0.26.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cjm_capability_graph_sqlite-0.0.26.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2022, fastai
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

cjm_capability_graph_sqlite-0.0.26.dist-info/top_level.txt

@@ -0,0 +1 @@
+cjm_capability_graph_sqlite