devtime-ei 0.1.0__py3-none-any.whl

devtime/db/repository.py

@@ -0,0 +1,351 @@
+"""Persistence and read-back for repository memory (Builder Edition, Chapter 6).
+
+Writes concepts, evidence, claims, uncertainties, and decisions during a scan,
+and reconstructs ConceptIntelligence objects for explain/context/risk/scoring so
+those commands read from durable memory rather than re-deriving truth on the fly.
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import uuid
+from datetime import datetime, timezone
+
+from devtime.intelligence.claims import (
+    Claim,
+    ConceptIntelligence,
+    Uncertainty,
+)
+from devtime.intelligence.concepts import ConceptCandidate
+from devtime.intelligence.evidence import EvidenceItem
+from devtime.scanner.extractors.base import Signal
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _id(prefix: str) -> str:
+    return f"{prefix}-{uuid.uuid4().hex[:10]}"
+
+
+# --------------------------------------------------------------------------- #
+# Write
+# --------------------------------------------------------------------------- #
+
+def add_repository_if_missing(conn: sqlite3.Connection, root) -> str:
+    """Return the existing repository id, creating a row if none exists."""
+    row = conn.execute("SELECT id FROM repositories LIMIT 1").fetchone()
+    if row:
+        return row["id"]
+    repo_id = _id("repo")
+    root_path = str(root.resolve()) if hasattr(root, "resolve") else str(root)
+    conn.execute(
+        "INSERT INTO repositories(id, root_path, created_at, updated_at) VALUES (?,?,?,?)",
+        (repo_id, root_path, _now(), _now()),
+    )
+    conn.commit()
+    return repo_id
+
+
+def clear_derived_memory(conn: sqlite3.Connection) -> None:
+    """Remove machine-derived memory before a re-scan. Human decisions are kept."""
+    for table in ("evidence", "claims", "uncertainties", "concepts", "risk_findings"):
+        conn.execute(f"DELETE FROM {table}")
+
+
+def save_intelligence(
+    conn: sqlite3.Connection,
+    repository_id: str,
+    items: list[ConceptIntelligence],
+) -> None:
+    for ci in items:
+        concept_id = ci.concept.slug
+        conn.execute(
+            "INSERT OR REPLACE INTO concepts"
+            "(id, repository_id, name, slug, kind, summary, confidence, status, "
+            " created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?,?)",
+            (
+                concept_id,
+                repository_id,
+                ci.concept.name,
+                ci.concept.slug,
+                ci.concept.kind,
+                f"{ci.concept.name} detected from repository evidence.",
+                ci.concept.confidence,
+                "supported",
+                _now(),
+                _now(),
+            ),
+        )
+
+        # Evidence (stash original signal kind/confidence for faithful read-back).
+        ev_id_map: dict[int, str] = {}
+        for idx, e in enumerate(ci.evidence):
+            eid = _id("E")
+            ev_id_map[idx] = eid
+            conn.execute(
+                "INSERT INTO evidence"
+                "(id, concept_id, file_id, signal_id, kind, strength, summary, path, "
+                " start_line, end_line, metadata_json, created_at) "
+                "VALUES (?,?,?,?,?,?,?,?,?,?,?,?)",
+                (
+                    eid,
+                    concept_id,
+                    None,
+                    None,
+                    e.kind,
+                    e.strength,
+                    e.summary,
+                    e.path,
+                    e.start_line,
+                    e.end_line,
+                    json.dumps(
+                        {
+                            "signal_kind": e.signal.kind,
+                            "signal_confidence": e.signal.confidence,
+                            "signal_name": e.signal.name,
+                            "supports": e.supports_claim_types,
+                            # Persist signal metadata (imports/e2e/purpose) so the
+                            # Context Pack import reason survives a save/load round-trip.
+                            "signal_metadata": e.signal.metadata,
+                        }
+                    ),
+                    _now(),
+                ),
+            )
+
+        for c in ci.claims:
+            conn.execute(
+                "INSERT INTO claims"
+                "(id, concept_id, type, text, confidence, state, evidence_ids_json, "
+                " uncertainty_ids_json, requires_human_confirmation, created_by, "
+                " created_at, updated_at, last_verified_at) "
+                "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)",
+                (
+                    _id("C"),
+                    concept_id,
+                    c.type,
+                    c.text,
+                    c.confidence,
+                    c.state,
+                    json.dumps([e.path for e in c.evidence if e.path]),
+                    "[]",
+                    1 if c.requires_human_confirmation else 0,
+                    c.created_by,
+                    _now(),
+                    _now(),
+                    None,
+                ),
+            )
+
+        for u in ci.uncertainties:
+            conn.execute(
+                "INSERT INTO uncertainties"
+                "(id, concept_id, type, text, action, severity, evidence_gap_json, created_at) "
+                "VALUES (?,?,?,?,?,?,?,?)",
+                (_id("U"), concept_id, u.type, u.text, u.action, u.severity, "{}", _now()),
+            )
+    conn.commit()
+
+
+def add_decision(
+    conn: sqlite3.Connection,
+    title: str,
+    body: str,
+    concept_slug: str | None = None,
+) -> str:
+    did = _id("D")
+    conn.execute(
+        "INSERT INTO decisions"
+        "(id, concept_id, title, body, source, status, evidence_ids_json, "
+        " created_at, updated_at) VALUES (?,?,?,?,?,?,?,?,?)",
+        (did, concept_slug, title, body, "human", "active", "[]", _now(), _now()),
+    )
+    conn.commit()
+    return did
+
+
+# --------------------------------------------------------------------------- #
+# Read / reconstruct
+# --------------------------------------------------------------------------- #
+
+# Behaviors a decision may claim that DevTime cannot take on faith - they must be
+# corroborated by scanned implementation evidence (Trust Repair v0.0.6).
+_DECISION_BEHAVIOR_TOKENS = {
+    "retry": ("retry", "retries", "retrying"),
+    "idempotency": ("idempoten",),
+    "deduplication": ("dedupe", "deduplicat", "duplicate delivery", "duplicate-delivery"),
+    "backoff": ("backoff", "back-off"),
+    "rate limiting": ("rate limit", "rate-limit", "ratelimit"),
+}
+
+
+def _decision_corroboration(body: str, impl_text: str) -> tuple[bool, list[str]]:
+    """Return (corroborated, uncorroborated_behaviors).
+
+    A generic decision that claims no specific verifiable behavior is treated as
+    corroborated. A decision that claims a behavior (retry, idempotency, ...) is
+    corroborated only if the scanned implementation evidence shows that behavior.
+    V0 corroboration is signal/evidence-text based and intentionally conservative.
+    """
+    body_l = body.lower()
+    claimed = [
+        label for label, toks in _DECISION_BEHAVIOR_TOKENS.items()
+        if any(t in body_l for t in toks)
+    ]
+    if not claimed:
+        return True, []
+    uncorroborated = [
+        label for label in claimed
+        if not any(t in impl_text for t in _DECISION_BEHAVIOR_TOKENS[label])
+    ]
+    return (len(uncorroborated) == 0), uncorroborated
+
+
+def _row_to_evidence(row: sqlite3.Row) -> EvidenceItem:
+    meta = json.loads(row["metadata_json"] or "{}")
+    signal = Signal(
+        kind=meta.get("signal_kind", row["kind"]),
+        name=meta.get("signal_name"),
+        file_rel_path=row["path"] or "",
+        confidence=meta.get("signal_confidence", 0.5),
+        metadata=meta.get("signal_metadata", {}) or {},
+    )
+    return EvidenceItem(
+        concept_slug=row["concept_id"],
+        kind=row["kind"],
+        strength=row["strength"],
+        summary=row["summary"],
+        path=row["path"],
+        start_line=row["start_line"],
+        end_line=row["end_line"],
+        signal=signal,
+        supports_claim_types=meta.get("supports", []),
+    )
+
+
+def load_concept(conn: sqlite3.Connection, slug_or_name: str) -> ConceptIntelligence | None:
+    row = conn.execute(
+        "SELECT * FROM concepts WHERE slug = ? OR lower(name) = lower(?)",
+        (slug_or_name, slug_or_name),
+    ).fetchone()
+    if row is None:
+        return None
+    return _load_for_concept_row(conn, row)
+
+
+def _load_for_concept_row(conn: sqlite3.Connection, row: sqlite3.Row) -> ConceptIntelligence:
+    concept_id = row["id"]
+    evidence = [
+        _row_to_evidence(r)
+        for r in conn.execute(
+            "SELECT * FROM evidence WHERE concept_id = ?", (concept_id,)
+        ).fetchall()
+    ]
+    candidate = ConceptCandidate(
+        slug=row["slug"],
+        name=row["name"],
+        kind=row["kind"],
+        confidence=row["confidence"],
+        signals=[e.signal for e in evidence],
+    )
+    # Attach human decisions - but only CORROBORATED decisions count as evidence
+    # (Trust Repair v0.0.6). A decision that describes behavior the scanned code does
+    # not show must not clear uncertainty or improve the score.
+    impl_text = " ".join(
+        " ".join(
+            str(x) for x in (e.summary, e.signal.name, e.signal.kind, e.path) if x
+        ).lower()
+        for e in evidence  # only scanned evidence so far (decisions not yet added)
+    )
+    decision_rows = conn.execute(
+        "SELECT * FROM decisions WHERE concept_id = ? AND status = 'active'",
+        (concept_id,),
+    ).fetchall()
+    any_decision_exists = len(decision_rows) > 0
+    uncorroborated_notes: list[tuple[str, list[str]]] = []
+    for d in decision_rows:
+        corroborated, missing = _decision_corroboration(d["body"] or "", impl_text)
+        if corroborated:
+            evidence.append(
+                EvidenceItem(
+                    concept_slug=row["slug"],
+                    kind="decision",
+                    strength="strong",
+                    summary=f"Decision: {d['title']} (corroborated by implementation evidence)",
+                    path=None,
+                    start_line=None,
+                    end_line=None,
+                    signal=Signal(kind="decision", name=d["title"], file_rel_path="(decision)"),
+                    supports_claim_types=["decision"],
+                )
+            )
+        else:
+            uncorroborated_notes.append((d["title"], missing))
+
+    claims = [
+        Claim(
+            type=r["type"],
+            text=r["text"],
+            confidence=r["confidence"],
+            state=r["state"],
+            evidence=[e for e in evidence if e.path in set(json.loads(r["evidence_ids_json"] or "[]"))],
+            requires_human_confirmation=bool(r["requires_human_confirmation"]),
+            created_by=r["created_by"],
+        )
+        for r in conn.execute(
+            "SELECT * FROM claims WHERE concept_id = ?", (concept_id,)
+        ).fetchall()
+    ]
+    has_corroborated_decision = any(e.kind == "decision" for e in evidence)
+    uncertainties = [
+        Uncertainty(
+            type=r["type"], text=r["text"], action=r["action"], severity=r["severity"]
+        )
+        for r in conn.execute(
+            "SELECT * FROM uncertainties WHERE concept_id = ?", (concept_id,)
+        ).fetchall()
+        # A decision (corroborated or not) means a decision *was* found, so the
+        # "no decision was found" uncertainty no longer applies verbatim.
+        if not (any_decision_exists and r["type"] == "missing_decision")
+    ]
+    # Uncorroborated decisions preserve uncertainty with an explicit corroboration note.
+    for title, missing in uncorroborated_notes:
+        behaviors = ", ".join(missing) if missing else "the described behavior"
+        uncertainties.append(
+            Uncertainty(
+                type="decision_not_corroborated",
+                text=(
+                    f"Decision '{title}' exists, but {behaviors} is not corroborated "
+                    f"by scanned implementation evidence."
+                ),
+                action="Confirm the decision matches the implementation, or update one of them.",
+                severity="medium",
+            )
+        )
+    # Only a corroborated decision may remove the uncertainty-typed claim.
+    if has_corroborated_decision:
+        claims = [
+            c for c in claims
+            if not (c.type == "uncertainty" and "decision" in c.text.lower())
+        ]
+    return ConceptIntelligence(
+        concept=candidate, evidence=evidence, claims=claims, uncertainties=uncertainties
+    )
+
+
+def load_all_concepts(conn: sqlite3.Connection) -> list[ConceptIntelligence]:
+    rows = conn.execute(
+        "SELECT * FROM concepts ORDER BY confidence DESC"
+    ).fetchall()
+    return [_load_for_concept_row(conn, r) for r in rows]
+
+
+def last_scan_time(conn: sqlite3.Connection) -> str | None:
+    row = conn.execute(
+        "SELECT finished_at FROM scans WHERE status='completed' "
+        "ORDER BY finished_at DESC LIMIT 1"
+    ).fetchone()
+    return row["finished_at"] if row and row["finished_at"] else None

devtime/db/schema.sql

@@ -0,0 +1,145 @@
+-- DevTime V0 SQLite schema (Builder Edition, Chapter 6 + Appendix C).
+-- The database is the local memory layer.
+
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    version INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS repositories (
+    id TEXT PRIMARY KEY,
+    root_path TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS scans (
+    id TEXT PRIMARY KEY,
+    repository_id TEXT NOT NULL,
+    started_at TEXT NOT NULL,
+    finished_at TEXT,
+    status TEXT NOT NULL,
+    devtime_version TEXT NOT NULL,
+    file_count INTEGER DEFAULT 0,
+    signal_count INTEGER DEFAULT 0,
+    FOREIGN KEY(repository_id) REFERENCES repositories(id)
+);
+
+CREATE TABLE IF NOT EXISTS files (
+    id TEXT PRIMARY KEY,
+    repository_id TEXT NOT NULL,
+    path TEXT NOT NULL,
+    extension TEXT,
+    language TEXT,
+    sha256 TEXT,
+    size_bytes INTEGER,
+    is_test INTEGER DEFAULT 0,
+    is_doc INTEGER DEFAULT 0,
+    ignored INTEGER DEFAULT 0,
+    last_seen_scan_id TEXT,
+    UNIQUE(repository_id, path)
+);
+
+CREATE TABLE IF NOT EXISTS signals (
+    id TEXT PRIMARY KEY,
+    scan_id TEXT NOT NULL,
+    file_id TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    name TEXT,
+    value TEXT,
+    start_line INTEGER,
+    end_line INTEGER,
+    confidence REAL DEFAULT 0.5,
+    metadata_json TEXT DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS concepts (
+    id TEXT PRIMARY KEY,
+    repository_id TEXT NOT NULL,
+    name TEXT NOT NULL,
+    slug TEXT NOT NULL,
+    kind TEXT NOT NULL,
+    summary TEXT,
+    confidence REAL NOT NULL DEFAULT 0.0,
+    status TEXT NOT NULL DEFAULT 'proposed',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(repository_id, slug)
+);
+
+CREATE TABLE IF NOT EXISTS evidence (
+    id TEXT PRIMARY KEY,
+    concept_id TEXT NOT NULL,
+    file_id TEXT,
+    signal_id TEXT,
+    kind TEXT NOT NULL,
+    strength TEXT NOT NULL,
+    summary TEXT NOT NULL,
+    path TEXT,
+    start_line INTEGER,
+    end_line INTEGER,
+    metadata_json TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL,
+    FOREIGN KEY(concept_id) REFERENCES concepts(id)
+);
+
+CREATE TABLE IF NOT EXISTS claims (
+    id TEXT PRIMARY KEY,
+    concept_id TEXT NOT NULL,
+    type TEXT NOT NULL,
+    text TEXT NOT NULL,
+    confidence REAL NOT NULL,
+    state TEXT NOT NULL DEFAULT 'supported',
+    evidence_ids_json TEXT NOT NULL DEFAULT '[]',
+    uncertainty_ids_json TEXT NOT NULL DEFAULT '[]',
+    requires_human_confirmation INTEGER DEFAULT 0,
+    created_by TEXT NOT NULL DEFAULT 'machine',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    last_verified_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS decisions (
+    id TEXT PRIMARY KEY,
+    concept_id TEXT,
+    title TEXT NOT NULL,
+    body TEXT NOT NULL,
+    source TEXT NOT NULL DEFAULT 'human',
+    status TEXT NOT NULL DEFAULT 'active',
+    evidence_ids_json TEXT NOT NULL DEFAULT '[]',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS uncertainties (
+    id TEXT PRIMARY KEY,
+    concept_id TEXT NOT NULL,
+    type TEXT NOT NULL,
+    text TEXT NOT NULL,
+    action TEXT,
+    severity TEXT DEFAULT 'medium',
+    evidence_gap_json TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS risk_findings (
+    id TEXT PRIMARY KEY,
+    concept_id TEXT NOT NULL,
+    severity TEXT NOT NULL,
+    type TEXT NOT NULL,
+    text TEXT NOT NULL,
+    evidence_ids_json TEXT DEFAULT '[]',
+    changed_files_json TEXT DEFAULT '[]',
+    suggested_action TEXT,
+    human_review_required INTEGER DEFAULT 0,
+    created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS context_packs (
+    id TEXT PRIMARY KEY,
+    concept_id TEXT NOT NULL,
+    mode TEXT NOT NULL,
+    body_markdown TEXT NOT NULL,
+    metadata_json TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL
+);

devtime/fixtures/assertions.py

@@ -0,0 +1,51 @@
+"""Fixture assertions (Builder Edition, Chapter 17).
+
+Allowed claims must appear, forbidden claims must not, required uncertainty must
+be present, and expected concepts must be detected.
+"""
+
+from __future__ import annotations
+
+from devtime.intelligence.claims import ConceptIntelligence
+
+# Loose substring matching so fixtures stay readable while detection wording evolves.
+
+
+def _all_claim_texts(intelligence: list[ConceptIntelligence]) -> list[str]:
+    texts: list[str] = []
+    for ci in intelligence:
+        texts += [c.text for c in ci.claims]
+    return texts
+
+
+def _all_uncertainty_texts(intelligence: list[ConceptIntelligence]) -> list[str]:
+    texts: list[str] = []
+    for ci in intelligence:
+        texts += [u.text for u in ci.uncertainties]
+        texts += [c.text for c in ci.claims if c.type == "uncertainty"]
+    return texts
+
+
+def _matches(needle: str, haystack: list[str]) -> bool:
+    key = needle.lower().strip()
+    return any(key in h.lower() for h in haystack)
+
+
+def assert_expected_concepts(intelligence, expected: list[str]) -> list[str]:
+    names = {ci.concept.name.lower() for ci in intelligence}
+    return [c for c in expected if c.lower() not in names]
+
+
+def assert_allowed_claims(intelligence, allowed: list[str]) -> list[str]:
+    texts = _all_claim_texts(intelligence)
+    return [c for c in allowed if not _matches(c, texts)]
+
+
+def assert_forbidden_claims_absent(intelligence, forbidden: list[str]) -> list[str]:
+    texts = _all_claim_texts(intelligence)
+    return [c for c in forbidden if _matches(c, texts)]
+
+
+def assert_required_uncertainty(intelligence, required: list[str]) -> list[str]:
+    texts = _all_uncertainty_texts(intelligence)
+    return [u for u in required if not _matches(u, texts)]

devtime/fixtures/loader.py

@@ -0,0 +1,52 @@
+"""Fixture loading (Builder Edition, Chapter 17 / Appendix D)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+
+@dataclass
+class FixtureExpectation:
+    concepts: list[str] = field(default_factory=list)
+    allowed_claims: list[str] = field(default_factory=list)
+    forbidden_claims: list[str] = field(default_factory=list)
+    required_uncertainty: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Fixture:
+    id: str
+    type: str
+    repo_path: Path
+    expected: FixtureExpectation
+    contains_secrets: bool = False
+    language: str | None = None
+    framework: str | None = None
+
+
+def load_fixture(directory: Path) -> Fixture:
+    spec_path = directory / "fixture.yaml"
+    data = yaml.safe_load(spec_path.read_text(encoding="utf-8")) or {}
+    expected = data.get("expected", {}) or {}
+    privacy = data.get("privacy", {}) or {}
+    return Fixture(
+        id=data["id"],
+        type=data.get("type", "claim"),
+        repo_path=directory / "repo",
+        language=data.get("language"),
+        framework=data.get("framework"),
+        contains_secrets=bool(privacy.get("contains_secrets", False)),
+        expected=FixtureExpectation(
+            concepts=expected.get("concepts", []) or [],
+            allowed_claims=expected.get("allowed_claims", []) or [],
+            forbidden_claims=expected.get("forbidden_claims", []) or [],
+            required_uncertainty=expected.get("required_uncertainty", []) or [],
+        ),
+    )
+
+
+def discover_fixtures(root: Path) -> list[Path]:
+    return sorted(p.parent for p in root.rglob("fixture.yaml"))

devtime/fixtures/runner.py

@@ -0,0 +1,73 @@
+"""Fixture runner (Builder Edition, Chapter 17).
+
+Scans a fixture repo in an isolated temp copy (so fixtures are never mutated),
+then asserts allowed claims, forbidden claims, required uncertainty, and concepts.
+"""
+
+from __future__ import annotations
+
+import shutil
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from devtime.fixtures import assertions
+from devtime.fixtures.loader import Fixture, load_fixture
+from devtime.scanner.signals import run_scan
+
+
+@dataclass
+class FixtureResult:
+    fixture_id: str
+    passed: bool
+    missing_concepts: list[str] = field(default_factory=list)
+    missing_allowed: list[str] = field(default_factory=list)
+    present_forbidden: list[str] = field(default_factory=list)
+    missing_uncertainty: list[str] = field(default_factory=list)
+
+    def failures(self) -> list[str]:
+        out: list[str] = []
+        for label, items in (
+            ("missing concept", self.missing_concepts),
+            ("missing allowed claim", self.missing_allowed),
+            ("forbidden claim present", self.present_forbidden),
+            ("missing required uncertainty", self.missing_uncertainty),
+        ):
+            out += [f"{label}: {i}" for i in items]
+        return out
+
+
+def run_devtime_scan(repo: Path):
+    """Scan a repo in an isolated temp copy and return its intelligence."""
+    with tempfile.TemporaryDirectory() as tmp:
+        dest = Path(tmp) / "repo"
+        shutil.copytree(repo, dest)
+        result = run_scan(root=dest)
+        return result.intelligence
+
+
+def run_fixture(directory: Path) -> FixtureResult:
+    fixture: Fixture = load_fixture(directory)
+    intelligence = run_devtime_scan(fixture.repo_path)
+    exp = fixture.expected
+
+    missing_concepts = assertions.assert_expected_concepts(intelligence, exp.concepts)
+    missing_allowed = assertions.assert_allowed_claims(intelligence, exp.allowed_claims)
+    present_forbidden = assertions.assert_forbidden_claims_absent(
+        intelligence, exp.forbidden_claims
+    )
+    missing_uncertainty = assertions.assert_required_uncertainty(
+        intelligence, exp.required_uncertainty
+    )
+
+    passed = not (
+        missing_concepts or missing_allowed or present_forbidden or missing_uncertainty
+    )
+    return FixtureResult(
+        fixture_id=fixture.id,
+        passed=passed,
+        missing_concepts=missing_concepts,
+        missing_allowed=missing_allowed,
+        present_forbidden=present_forbidden,
+        missing_uncertainty=missing_uncertainty,
+    )