wikifier 4.5.4__tar.gz → 4.5.6__tar.gz

{wikifier-4.5.4/wikifier.egg-info → wikifier-4.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wikifier
-Version: 4.5.4
+Version: 4.5.6
 Summary: Zero-dependency agent-to-agent codebase wiki for LLMs and AI agents. Autonomously maintained via record-change and mark-green for token-efficient lookup of files, dependencies, health, and summaries — across tiny scripts to 50k+ monorepos. Optional MCP server with rich tools for agents.
 Author-email: Aron Amos <aron@example.com>
 Maintainer: Aron Amos

wikifier-4.5.6/tests/test_gap_closure.py

@@ -0,0 +1,274 @@
+"""Gap-closure regressions (G4 ACS actionable, G5 health module, G7 ghosts/deletion)."""
+
+import importlib
+import unittest
+
+from tests._base import TempProjectTestCase
+
+from wikifier import import_cache as ic
+from wikifier import cli
+
+
+class TestHealthModuleImportG5(unittest.TestCase):
+    def test_importlib_health_is_module_with_get_summary(self):
+        mod = importlib.import_module("wikifier.health")
+        self.assertTrue(hasattr(mod, "get_summary"))
+        self.assertTrue(hasattr(mod, "find_ghost_entries"))
+        self.assertTrue(callable(mod.get_summary))
+
+    def test_health_module_alias_on_package(self):
+        import wikifier
+        self.assertTrue(hasattr(wikifier, "health_module"))
+        self.assertTrue(hasattr(wikifier.health_module, "get_summary"))
+        # Convenience function still exported as wikifier.health
+        self.assertTrue(callable(wikifier.health))
+
+
+class TestAcsActionableG4(TempProjectTestCase):
+    def test_external_noise_excluded_from_actionable_low_conf(self):
+        cache = {}
+        # Project-internal low-conf edge
+        ic.update_file_data(
+            cache,
+            "app.py",
+            mtime=1,
+            imports=["./util"],
+            resolved_pairs=[{
+                "raw": "./util",
+                "resolved": "util.py",
+                "resolved_path": "util.py",
+                "confidence_score": 0.4,
+                "confidence_reasons": ["base:low", "via_barrel"],
+                "confidence_explanation": "Base low. Recommendation: Review project edge.",
+                "diagnostic": {"category": "project"},
+                "resolution_metadata": {"strategy": "relative-fs"},
+            }],
+        )
+        # External/stdlib-style edge (noise)
+        ic.update_file_data(
+            cache,
+            "app.py",
+            mtime=1,
+            imports=["json", "./util"],
+            resolved_pairs=[
+                {
+                    "raw": "./util",
+                    "resolved": "util.py",
+                    "resolved_path": "util.py",
+                    "confidence_score": 0.4,
+                    "confidence_reasons": ["base:low"],
+                    "confidence_explanation": "Project low. Recommendation: Review.",
+                    "resolution_metadata": {"strategy": "relative-fs"},
+                },
+                {
+                    "raw": "json",
+                    "resolved": "json",
+                    "resolved_path": "",
+                    "confidence_score": 0.48,
+                    "confidence_reasons": ["base:medium", "no_resolved_path"],
+                    "confidence_explanation": "stdlib. Recommendation: harden import.",
+                    "diagnostic": {"category": "external_or_bare"},
+                    "resolution_metadata": {"strategy": "python-bare-or-external"},
+                },
+            ],
+        )
+        # Note: update_file_data may replace pairs — set explicitly
+        cache["app.py"]["resolved_pairs"] = [
+            {
+                "raw": "./util",
+                "resolved": "util.py",
+                "resolved_path": "util.py",
+                "confidence_score": 0.4,
+                "confidence_reasons": ["base:low"],
+                "confidence_explanation": "Project low. Recommendation: Review.",
+                "resolution_metadata": {"strategy": "relative-fs"},
+            },
+            {
+                "raw": "json",
+                "resolved": "json",
+                "confidence_score": 0.48,
+                "confidence_reasons": ["base:medium"],
+                "confidence_explanation": "stdlib noise. Recommendation: ignore.",
+                "diagnostic": {"category": "external_or_bare"},
+                "resolution_metadata": {"strategy": "python-bare-or-external"},
+            },
+        ]
+        summary = ic.compute_acs_summary(cache)
+        self.assertGreaterEqual(summary["low_conf_edges"], 1)
+        self.assertEqual(summary["actionable_low_conf_edges"], 1)
+        self.assertGreaterEqual(summary["external_noise_edges"], 1)
+        action = ic.get_low_confidence_edges(cache, actionable_only=True)
+        self.assertTrue(all(
+            (p.get("diagnostic") or {}).get("category") != "external_or_bare"
+            for p in action
+        ))
+
+
+class TestGhostAndDeletionG7(TempProjectTestCase):
+    def test_find_ghost_and_record_deletion(self):
+        health_mod = importlib.import_module("wikifier.health")
+        self.write("keep.py", "x=1\n")
+        self.write("gone.py", "y=1\n")
+        health_mod.upsert_entry(self.root, "keep.py", "🟢 Green", "ok")
+        health_mod.upsert_entry(self.root, "gone.py", "🟢 Green", "ok")
+        (self.root / "gone.py").unlink()
+
+        ghosts = health_mod.find_ghost_entries(self.root)
+        self.assertIn("gone.py", ghosts)
+        self.assertNotIn("keep.py", ghosts)
+
+        res = cli.record_deletion("gone.py", "removed in cleanup", project_root=self.root)
+        self.assertTrue(res.get("success"))
+        entries = health_mod.load_health(self.root)["entries"]
+        self.assertIn("🔴", entries["gone.py"]["status"])
+        self.assertIn("DELETED", entries["gone.py"]["reason"])
+
+    def test_record_deletion_rejects_flag_paths(self):
+        res = cli.record_deletion("--help", "oops", project_root=self.root)
+        self.assertFalse(res.get("success"))
+        self.assertIn("flag", (res.get("error") or "").lower())
+
+
+class TestPendingAndPollutionHygiene(TempProjectTestCase):
+    def test_pending_empty_marker_not_counted_and_no_dual_state(self):
+        health_mod = importlib.import_module("wikifier.health")
+        # Dual-state pollution (historical bug): empty marker + real items
+        p = self.root / "pending_updates.md"
+        p.write_text(
+            "# Pending Updates\n\n(no active items)\n- src/a.py: review\n",
+            encoding="utf-8",
+        )
+        self.assertEqual(health_mod.count_pending(self.root), 1)
+        # Normalize via remove of the only item → empty marker only
+        health_mod.remove_from_pending(self.root, "src/a.py")
+        text = p.read_text(encoding="utf-8")
+        self.assertIn("no pending", text.lower())
+        self.assertNotIn("- src/a.py", text)
+        self.assertEqual(health_mod.count_pending(self.root), 0)
+        # Add clears empty marker
+        health_mod.add_to_pending(self.root, "src/b.py", "need wiki")
+        text2 = p.read_text(encoding="utf-8")
+        self.assertIn("- src/b.py:", text2)
+        self.assertNotIn("no pending", text2.lower())
+        self.assertNotIn("no active", text2.lower())
+        self.assertEqual(health_mod.count_pending(self.root), 1)
+        summary = health_mod.get_summary(self.root)
+        self.assertEqual(summary["pending_updates"], 1)
+
+    def test_superseded_and_flag_deleted_keys_pruned(self):
+        health_mod = importlib.import_module("wikifier.health")
+        # Inject pollution keys directly then save
+        data = {
+            "version": 2,
+            "last_updated": "2026-01-01",
+            "entries": {
+                "M5.3 Cycle1 evidence append: 3 subs spawned": {
+                    "status": "🔴 Red",
+                    "reason": "DELETED — Historical early M5.3 launch note",
+                    "last_updated": "2026-01-01",
+                },
+                "--help": {
+                    "status": "🔴 Red",
+                    "reason": "DELETED — removed",
+                    "last_updated": "2026-01-01",
+                },
+                "real.py": {
+                    "status": "🟢 Green",
+                    "reason": "ok",
+                    "last_updated": "2026-01-01",
+                },
+            },
+        }
+        health_mod.save_health(self.root, data)
+        entries = health_mod.load_health(self.root)["entries"]
+        self.assertNotIn("M5.3 Cycle1 evidence append: 3 subs spawned", entries)
+        self.assertNotIn("--help", entries)
+        self.assertIn("real.py", entries)
+        # Real path DELETED audit is kept
+        health_mod.upsert_entry(self.root, "gone_real.py", "🔴 Red", "DELETED — intentional")
+        entries2 = health_mod.load_health(self.root)["entries"]
+        self.assertIn("gone_real.py", entries2)
+
+
+class TestMapFirstHealthAndValidate(TempProjectTestCase):
+    def test_deep_relative_keys_are_under_root(self):
+        """Regression: deep monorepo rel paths must not be treated as abs pollution."""
+        health_mod = importlib.import_module("wikifier.health")
+        deep = "airflow-core/src/airflow/api/client/local_client.py"
+        self.assertTrue(health_mod._entry_is_under_root(self.root, deep))
+        self.assertTrue(health_mod._entry_is_under_root(self.root, "pkg/a.py"))
+
+    def test_seed_health_from_map_creates_stubs(self):
+        health_mod = importlib.import_module("wikifier.health")
+        from wikifier import import_cache as ic
+
+        self.write("pkg/a.py", "import b\n")
+        self.write("pkg/b.py", "x=1\n")
+        self.write("README.md", "# hi\n")
+        cache = {}
+        ic.update_file_data(cache, "pkg/a.py", mtime=1, imports=["b"], resolved_pairs=[])
+        ic.update_file_data(cache, "pkg/b.py", mtime=1, imports=[], resolved_pairs=[])
+        ic.save_cache(self.root, cache)
+
+        # No health file yet
+        self.assertFalse((self.root / "file_health.json").exists())
+        res = health_mod.seed_health_from_map(self.root)
+        self.assertTrue(res.get("success"))
+        self.assertGreaterEqual(res.get("seeded"), 2)
+        entries = health_mod.load_health(self.root)["entries"]
+        self.assertIn("pkg/a.py", entries)
+        self.assertIn("pkg/b.py", entries)
+        self.assertTrue(entries["pkg/a.py"]["status"].startswith("🟡"))
+
+    def test_validate_ignores_non_source_and_reports_mapped_gaps(self):
+        health_mod = importlib.import_module("wikifier.health")
+        from wikifier import import_cache as ic
+
+        self.write("src/app.py", "print(1)\n")
+        self.write("src/notes.md", "docs\n")
+        self.write("src/logo.png", "x")
+        (self.root / "monitored_paths.txt").write_text("src\n", encoding="utf-8")
+        cache = {}
+        ic.update_file_data(cache, "src/app.py", mtime=1, imports=[], resolved_pairs=[])
+        ic.update_file_data(cache, "src/other.py", mtime=1, imports=[], resolved_pairs=[])
+        ic.save_cache(self.root, cache)
+
+        # No health yet — in-scope mapped + monitored parseable gaps
+        v = health_mod.validate_health(self.root)
+        self.assertTrue(v.get("map_first"))
+        self.assertGreaterEqual(v.get("mapped_in_scope_without_health_count", 0), 1)
+        self.assertGreaterEqual(v.get("missing_count", 0), 1)
+        # notes.md / logo.png must not appear as monitored-source gaps
+        mon_missing = v.get("missing_monitored_source") or []
+        self.assertTrue(all(not m.endswith(".md") and not m.endswith(".png") for m in mon_missing))
+
+        health_mod.seed_health_from_map(self.root)  # only_monitored default
+        # Seed in-scope map keys; app.py on disk + mapped in-scope covered
+        v2 = health_mod.validate_health(self.root)
+        self.assertEqual(v2.get("mapped_in_scope_without_health_count"), 0)
+        # missing_count may still include on-disk sources not in map (ok if 0 after seed of map keys only)
+        self.assertEqual(v2.get("mapped_in_scope_without_health_count"), 0)
+
+    def test_prune_pending_and_health_to_monitored(self):
+        health_mod = importlib.import_module("wikifier.health")
+        (self.root / "monitored_paths.txt").write_text("src\n", encoding="utf-8")
+        self.write("src/keep.py", "k=1\n")
+        self.write("other/out.py", "o=1\n")
+        health_mod.upsert_entry(self.root, "src/keep.py", "🟡 Yellow", "in scope")
+        health_mod.upsert_entry(self.root, "other/out.py", "🟡 Yellow", "out of scope")
+        health_mod.add_to_pending(self.root, "src/keep.py", "need wiki")
+        health_mod.add_to_pending(self.root, "other/out.py", "noise")
+
+        pr = health_mod.prune_pending_to_monitored(self.root)
+        self.assertEqual(pr.get("removed"), 1)
+        self.assertEqual(health_mod.count_pending(self.root), 1)
+
+        hr = health_mod.prune_health_outside_monitored(self.root)
+        self.assertEqual(hr.get("removed"), 1)
+        entries = health_mod.load_health(self.root)["entries"]
+        self.assertIn("src/keep.py", entries)
+        self.assertNotIn("other/out.py", entries)
+
+
+if __name__ == "__main__":
+    unittest.main()

{wikifier-4.5.4 → wikifier-4.5.6}/wikifier/__init__.py

@@ -71,4 +71,4 @@ from .contracts import (
     compute_acs_confidence,
 )
 
-__version__ = "4.5.4"
+__version__ = "4.5.6"

{wikifier-4.5.4 → wikifier-4.5.6}/wikifier/cli.py

@@ -616,23 +616,6 @@ def run_full_update(
             result["parse_errors"] = parse_errors[:10]
             result["parse_error_count"] = len(parse_errors)
 
-        # Seed health stubs for newly parsed files (map-first wiki: agents fill prose later)
-        health_seeded = 0
-        if _health_mod is not None and new_entries:
-            try:
-                existing = (_health_mod.load_health(root) or {}).get("entries") or {}
-                for rel in new_entries:
-                    if rel in existing:
-                        continue
-                    _health_mod.upsert_entry(
-                        root, rel, "🟡 Yellow",
-                        "Initial stub — parsed into map; agent should wiki + mark-green when editing"
-                    )
-                    health_seeded += 1
-            except Exception:
-                health_seeded = 0
-        result["health_stubs_seeded"] = health_seeded
-
         # === 4. Persist (single save; reload first to pick up the barrel flush) ===
         cache = ic.load_cache(root) or {}
         cache.update(new_entries)
@@ -669,6 +652,27 @@ def run_full_update(
         except Exception:
             pass
 
+        # === 5b. Map-first health stubs (always backfill; warm cache safe) ===
+        # 0-dirty incremental runs never used to create file_health.json — fixed here.
+        health_seeded = 0
+        if _health_mod is not None and hasattr(_health_mod, "seed_health_from_map"):
+            try:
+                max_seed = int(os.environ.get("WIKIFIER_HEALTH_SEED_MAX", "20000") or "20000")
+                map_keys = [k for k in cache if isinstance(k, str) and k and not k.startswith("_")]
+                seed_res = _health_mod.seed_health_from_map(
+                    root, map_keys=map_keys, max_new=max_seed,
+                )
+                health_seeded = int(seed_res.get("seeded") or 0)
+                if hasattr(_health_mod, "seed_health_for_monitored_sources"):
+                    disk_res = _health_mod.seed_health_for_monitored_sources(
+                        root, max_new=max_seed,
+                    )
+                    health_seeded += int(disk_res.get("seeded") or 0)
+            except Exception as se:
+                result["health_seed_error"] = str(se)
+                health_seeded = 0
+        result["health_stubs_seeded"] = health_seeded
+
         # === 6. library.md (atomic; pure Python) ===
         try:
             from .library import write_library_md
@@ -805,16 +809,40 @@ def main():
                 if res.get("message"):
                     print(res["message"])
                 return 0 if res.get("success", True) else 1
-            if _cmd0 == "record-change" and len(_args) >= 2:
+            if _cmd0 == "record-change":
+                if not _args or _args[0] in ("--help", "-h", "help"):
+                    print('Usage: wikifier record-change <file> "<reason>"')
+                    return 0
+                if _args[0].startswith("-") or len(_args) < 2:
+                    print('Usage: wikifier record-change <file> "<reason>"', file=sys.stderr)
+                    return 1
                 res = record_change(_args[0], " ".join(_args[1:]), project_root=project_root)
                 print(res.get("message") or res)
                 return 0 if res.get("success") else 1
-            if _cmd0 == "mark-green" and len(_args) >= 1:
+            if _cmd0 == "mark-green":
+                if not _args or _args[0] in ("--help", "-h", "help"):
+                    print("Usage: wikifier mark-green <file> [reason]")
+                    return 0
+                if _args[0].startswith("-"):
+                    print("Usage: wikifier mark-green <file> [reason]", file=sys.stderr)
+                    return 1
                 reason = " ".join(_args[1:]) if len(_args) > 1 else ""
                 res = mark_green(_args[0], reason, project_root=project_root)
                 print(res.get("message") or res)
                 return 0 if res.get("success") else 1
-            if _cmd0 == "record-deletion" and len(_args) >= 1:
+            if _cmd0 == "record-deletion":
+                # Guard: `record-deletion --help` must not treat `--help` as a file path
+                # (that polluted health with a 🔴 DELETED "--help" key).
+                if not _args or _args[0] in ("--help", "-h", "help"):
+                    print('Usage: wikifier record-deletion <file> "<reason>"')
+                    return 0
+                if _args[0].startswith("-"):
+                    print(
+                        'Usage: wikifier record-deletion <file> "<reason>"\n'
+                        "  <file> must be a project path, not a flag.",
+                        file=sys.stderr,
+                    )
+                    return 1
                 reason = " ".join(_args[1:]) if len(_args) > 1 else "removed"
                 res = record_deletion(_args[0], reason, project_root=project_root)
                 print(res.get("message") or res)
@@ -833,13 +861,40 @@ def main():
                 if _health_mod is not None:
                     root = _get_effective_root(project_root)
                     res = _health_mod.validate_health(root)
-                    ghosts = []
-                    if hasattr(_health_mod, "find_ghost_entries"):
-                        ghosts = _health_mod.find_ghost_entries(root)
-                    res["ghost_count"] = len(ghosts)
-                    res["ghosts"] = ghosts[:50]
                     print(_json.dumps(res, indent=2, default=str))
+                    # Map-first: exit 0 when map is covered (or no map + no monitored source gaps)
                     return 0 if res.get("missing_count", 0) == 0 else 1
+            if _cmd0 in ("seed-health", "seed-health-from-map"):
+                import json as _json
+                if _health_mod is None:
+                    print("[wikifier] health module unavailable", file=sys.stderr)
+                    return 1
+                root = _get_effective_root(project_root)
+                res = _health_mod.seed_health_from_map(root)
+                if hasattr(_health_mod, "seed_health_for_monitored_sources"):
+                    disk = _health_mod.seed_health_for_monitored_sources(root)
+                    res["disk_seeded"] = disk.get("seeded")
+                    res["seeded_total"] = int(res.get("seeded") or 0) + int(disk.get("seeded") or 0)
+                print(_json.dumps(res, indent=2, default=str))
+                return 0 if res.get("success") else 1
+            if _cmd0 in ("prune-pending", "prune-pending-monitored"):
+                import json as _json
+                if _health_mod is None:
+                    print("[wikifier] health module unavailable", file=sys.stderr)
+                    return 1
+                root = _get_effective_root(project_root)
+                res = _health_mod.prune_pending_to_monitored(root)
+                print(_json.dumps(res, indent=2, default=str))
+                return 0 if res.get("success") else 1
+            if _cmd0 in ("prune-health-monitored", "prune-health"):
+                import json as _json
+                if _health_mod is None:
+                    print("[wikifier] health module unavailable", file=sys.stderr)
+                    return 1
+                root = _get_effective_root(project_root)
+                res = _health_mod.prune_health_outside_monitored(root)
+                print(_json.dumps(res, indent=2, default=str))
+                return 0 if res.get("success") else 1
         except Exception as e:
             print(f"[wikifier] Python-primary {_cmd0} failed: {e}", file=sys.stderr)
             return 1
@@ -1039,8 +1094,14 @@ def _ensure_journal_entry(root: Path, action: str, file: str, reason: str) -> No
 
 
 def _add_to_pending(root: Path, file: str, msg: str) -> None:
-    """Pure-Py pending_updates.md appender (skeleton, matches sh add_pending)."""
+    """Append to pending_updates.md via health helpers (normalized empty/items)."""
     try:
+        if _health_mod is not None and hasattr(_health_mod, "add_to_pending"):
+            # Caller may already hold project lock (re-entrant).
+            _health_mod._do_add_to_pending(root, file, msg) if hasattr(
+                _health_mod, "_do_add_to_pending"
+            ) else _health_mod.add_to_pending(root, file, msg)
+            return
         p = root / "pending_updates.md"
         line = f"- {file}: {msg}\n"
         with open(p, "a", encoding="utf-8") as f:
@@ -1050,8 +1111,14 @@ def _add_to_pending(root: Path, file: str, msg: str) -> None:
 
 
 def _remove_from_pending(root: Path, file: str) -> None:
-    """Best-effort removal (used by mark_green skeleton)."""
+    """Best-effort removal (used by mark_green). Prefers health normalizer."""
     try:
+        if _health_mod is not None and hasattr(_health_mod, "_do_remove_from_pending"):
+            _health_mod._do_remove_from_pending(root, file)
+            return
+        if _health_mod is not None and hasattr(_health_mod, "remove_from_pending"):
+            _health_mod.remove_from_pending(root, file)
+            return
         p = root / "pending_updates.md"
         if p.exists():
             lines = [ln for ln in p.read_text(encoding="utf-8").splitlines() if file not in ln]
@@ -1161,6 +1228,8 @@ def check_changes(project_root: Optional[Union[str, Path]] = None) -> Dict[str,
             ghosts_marked = 0
             if _health_mod is not None:
                 root_res = root.resolve()
+                # Prefer unlocked helpers while we already hold project lock
+                _upsert = getattr(_health_mod, "_do_upsert_entry", None) or _health_mod.upsert_entry
                 for p in dirty_batch:
                     try:
                         pr = Path(p).resolve()
@@ -1169,13 +1238,20 @@ def check_changes(project_root: Optional[Union[str, Path]] = None) -> Dict[str,
                         rel = str(pr.relative_to(root_res))
                     except Exception:
                         continue
-                    _health_mod.upsert_entry(
+                    _upsert(
                         root, rel, "🟡 Yellow",
                         "mtime changed since last check-changes (Python primary auto-detected)"
                     )
                     _add_to_pending(root, rel, "Auto-detected modification — review and run mark-green after wiki update")
                     _ensure_journal_entry(root, "auto-detected", rel, "File mtime changed (check_changes Python primary)")
                     changed_count += 1
+                # Keep pending queue aligned with lean monitored_paths (no flood outside scope)
+                if hasattr(_health_mod, "prune_pending_to_monitored"):
+                    try:
+                        pr = _health_mod.prune_pending_to_monitored(root)
+                        result["pending_pruned"] = pr.get("removed", 0)
+                    except Exception:
+                        pass
 
                 # G7: surface ghost health entries (tracked path missing on disk, not already DELETED)
                 try:
@@ -1265,9 +1341,13 @@ def record_deletion(file: str, reason: str, project_root: Optional[Union[str, Pa
 
     G7: marks 🔴 DELETED, pending + journal, and best-effort prunes barrel cache
     references so deleted paths do not keep invalidating importers forever.
+    Rejects flag-like paths (`--help`) so CLI misuse cannot pollute health.
     """
     root = _get_effective_root(project_root)
     result: Dict[str, Any] = {"success": False, "file": file, "project_root": str(root), "action": "deletion"}
+    if not file or str(file).startswith("-") or str(file) in ("--help", "-h", "help"):
+        result["error"] = "file must be a project path, not a flag/empty string"
+        return result
     try:
         lock_ctx = (locking.file_lock(root) if locking is not None else _nullcontext())
         with lock_ctx:
@@ -1279,7 +1359,11 @@ def record_deletion(file: str, reason: str, project_root: Optional[Union[str, Pa
             except Exception:
                 rel = file
             if _health_mod is not None:
-                _health_mod.upsert_entry(root, rel, "🔴 Red", f"DELETED — {reason}")
+                # Prefer unlocked upsert when we already hold the project lock.
+                if hasattr(_health_mod, "_do_upsert_entry"):
+                    _health_mod._do_upsert_entry(root, rel, "🔴 Red", f"DELETED — {reason}")
+                else:
+                    _health_mod.upsert_entry(root, rel, "🔴 Red", f"DELETED — {reason}")
             _add_to_pending(root, rel, f"File was deleted. Consider wiki archival. {reason}")
             _ensure_journal_entry(root, "record-deletion", rel, reason or "No reason provided.")
             prune_stats: Dict[str, Any] = {}