continuum-local 0.1.0__py3-none-any.whl

continuum_local/__init__.py

@@ -0,0 +1,4 @@
+from .resolver import load_semantics, resolve, to_semantic_contract
+
+__all__ = ["load_semantics", "resolve", "to_semantic_contract"]
+

continuum_local/cli.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import argparse
+import json
+from typing import Any, Dict
+
+from .resolver import load_semantics, resolve, to_semantic_contract
+
+
+def _json_arg(raw: str) -> Dict[str, Any]:
+    raw = (raw or "").strip()
+    if not raw:
+        return {}
+    obj = json.loads(raw)
+    if not isinstance(obj, dict):
+        raise ValueError("context must be a JSON object")
+    return obj
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(prog="continuum-local")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    r = sub.add_parser("resolve", help="Resolve query against local semantics")
+    r.add_argument("--semantics", required=True, help="YAML/JSON semantics file path")
+    r.add_argument("--query", required=True, help="Natural language query")
+    r.add_argument("--context", default="{}", help="JSON object (e.g. '{\"team\":\"marketing\"}')")
+
+    args = p.parse_args()
+    if args.cmd == "resolve":
+        doc = load_semantics(args.semantics)
+        ctx = _json_arg(args.context)
+        out = resolve(doc, query=args.query, context=ctx)
+        print(json.dumps(out, indent=2, sort_keys=True))
+        if out.get("status") == "resolved":
+            contract = to_semantic_contract(out, context=ctx)
+            print("\n--- semantic_contract ---")
+            print(json.dumps(contract, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()
+

continuum_local/resolver.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import yaml
+
+SemanticsDoc = Dict[str, Any]
+
+
+@dataclass(frozen=True)
+class Candidate:
+    metric_id: str
+    canonical_name: str
+    description: str
+    tags: Tuple[str, ...] = ()
+
+
+def load_semantics(path: Union[str, Path]) -> SemanticsDoc:
+    """
+    Load a tiny YAML/JSON semantics file.
+
+    Expected shape (minimal):
+      metrics:
+        - metric_id: revenue
+          canonical_name: Revenue
+          description: Net revenue excluding refunds
+          tags: [finance, marketing]
+    """
+    p = Path(path)
+    raw = p.read_text(encoding="utf-8")
+    if p.suffix.lower() in {".json"}:
+        doc = json.loads(raw)
+    else:
+        doc = yaml.safe_load(raw)
+    if not isinstance(doc, dict):
+        raise ValueError("semantics file must be an object")
+    return doc
+
+
+def _candidates(doc: SemanticsDoc) -> List[Candidate]:
+    out: List[Candidate] = []
+    for m in (doc.get("metrics") or []):
+        if not isinstance(m, dict):
+            continue
+        metric_id = str(m.get("metric_id") or "").strip()
+        if not metric_id:
+            continue
+        canonical_name = str(m.get("canonical_name") or metric_id)
+        description = str(m.get("description") or canonical_name)
+        tags = tuple(str(t) for t in (m.get("tags") or []) if str(t).strip())
+        out.append(Candidate(metric_id=metric_id, canonical_name=canonical_name, description=description, tags=tags))
+    return out
+
+
+def resolve(doc: SemanticsDoc, *, query: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """
+    Deterministic, no-ML resolver.
+
+    Rules:
+    - normalize query to tokens
+    - score candidates by substring/token overlap
+    - boost if context['team'] matches candidate tag
+    - return {status: resolved|ambiguous|no_match}
+    """
+    q = (query or "").strip().lower()
+    ctx = context or {}
+    team = str(ctx.get("team") or "").strip().lower()
+
+    cands = _candidates(doc)
+    if not q or not cands:
+        return {"status": "no_match", "reason": "empty query or no candidates"}
+
+    tokens = [t for t in q.replace("/", " ").replace("_", " ").split() if t]
+
+    scored: List[Tuple[float, Candidate]] = []
+    for c in cands:
+        hay = " ".join([c.metric_id, c.canonical_name, c.description]).lower()
+        score = 0.0
+        if q in hay:
+            score += 2.0
+        for t in tokens:
+            if t in hay:
+                score += 1.0
+        if team and team in {t.lower() for t in c.tags}:
+            score += 1.5
+        scored.append((score, c))
+
+    scored.sort(key=lambda x: (-x[0], x[1].metric_id))
+    best_score = scored[0][0]
+    if best_score <= 0:
+        return {"status": "no_match", "reason": "no overlap with any metric"}
+
+    top = [c for s, c in scored if s == best_score]
+    if len(top) == 1:
+        return {
+            "status": "resolved",
+            "resolved_metric": {
+                "metric_id": top[0].metric_id,
+                "canonical_name": top[0].canonical_name,
+                "description": top[0].description,
+            },
+            "confidence": min(1.0, 0.6 + 0.1 * best_score),
+            "reason": "deterministic match",
+        }
+
+    candidates = top[:5]
+    return {
+        "status": "ambiguous",
+        "candidates": [
+            {"metric_id": c.metric_id, "canonical_name": c.canonical_name, "description": c.description}
+            for c in candidates
+        ],
+        "confidence": 0.55,
+        "reason": "multiple metrics match equally well",
+    }
+
+
+def to_semantic_contract(resolution: Dict[str, Any], *, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+    """
+    Convert a resolved metric into a minimal, stable 'SemanticContract' dict.
+    """
+    ctx = context or {}
+    if resolution.get("status") != "resolved":
+        raise ValueError("resolution must be status=resolved to build a contract")
+
+    m = resolution.get("resolved_metric") or {}
+    metric_id = m.get("metric_id")
+    definition = {"display": m.get("canonical_name") or metric_id, "description": m.get("description") or ""}
+    return {
+        "identity": {"metric_id": metric_id},
+        "definition": definition,
+        "context": ctx,
+        "source": {"system": "continuum_local"},
+    }
+

continuum_local-0.1.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: continuum-local
+Version: 0.1.0
+Summary: Local, no-backend resolver for Continuum demos
+Author: Continuum
+License: Apache License
+        Version 2.0, January 2004
+        http://www.apache.org/licenses/
+        
+        This package is licensed under the Apache License, Version 2.0.
+        See the repository root `LICENSE` for the full text.
+        
+        
+Project-URL: Homepage, https://getcontinuum.ai
+Project-URL: Documentation, https://docs.getcontinuum.ai
+Project-URL: Repository, https://github.com/get-continuum/continuum
+Project-URL: Issues, https://github.com/get-continuum/continuum/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: pyyaml>=6.0.0
+Dynamic: license-file
+
+# Continuum Local (Python)
+
+Local (no-backend) semantic resolver for demos/tests.
+
+## Install
+
+```bash
+pip install continuum-local
+```
+
+## CLI
+
+```bash
+continuum-local resolve --semantics demo/semantics.yaml --query "revenue" --context '{"team":"marketing"}'
+```
+
+## Library
+
+```python
+from continuum_local import load_semantics, resolve, to_semantic_contract
+
+doc = load_semantics("demo/semantics.yaml")
+out = resolve(doc, query="revenue", context={"team": "marketing"})
+print(out)
+
+if out.get("status") == "resolved":
+    print(to_semantic_contract(out, context={"team": "marketing"}))
+```
+

continuum_local-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+continuum_local/__init__.py,sha256=AOVj1L5wrMkL9Q7DpTf7YXCHz9v2Oih_obREZvhSfUg,134
+continuum_local/cli.py,sha256=3lw5ljOAPAnH7vrM9CYk6sU7l7tVNrOR0HhPHs6khGA,1397
+continuum_local/resolver.py,sha256=fS6ddw1Hkd-NPwjFUC262DVEAaCPNlb8apTmFl_BE2M,4378
+continuum_local-0.1.0.dist-info/licenses/LICENSE,sha256=NvsPqSrcQawz2VDnrHb8f-ztZ-gNQSl_9YV5DL5wUEY,192
+continuum_local-0.1.0.dist-info/licenses/NOTICE,sha256=xZNJ82mX2vdADocownkFWzlek_Q1QjXxnyTel_wblOc,40
+continuum_local-0.1.0.dist-info/METADATA,sha256=66FNvCLh1QQD9TKNesaZpfuYKeU7z-12v0VfQ2M26CQ,1385
+continuum_local-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+continuum_local-0.1.0.dist-info/entry_points.txt,sha256=ygfmZzk2rYzigfpbInaJDpfqX8jLgnw4RavFB1Ac1KQ,61
+continuum_local-0.1.0.dist-info/top_level.txt,sha256=n5nzvPD_96ybFgOV3V09DUZ7MyQ4tHC9A9FBl-RzSAQ,16
+continuum_local-0.1.0.dist-info/RECORD,,

continuum_local-0.1.0.dist-info/WHEEL

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

continuum_local-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+continuum-local = continuum_local.cli:main

continuum_local-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+This package is licensed under the Apache License, Version 2.0.
+See the repository root `LICENSE` for the full text.
+

continuum_local-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,3 @@
+Continuum OSS
+Copyright 2026 Continuum
+

continuum_local-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+continuum_local