metaspn-entities 0.1.3__tar.gz → 0.1.5__tar.gz

{metaspn_entities-0.1.3 → metaspn_entities-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaspn-entities
-Version: 0.1.3
+Version: 0.1.5
 Summary: Canonical entity resolution, aliasing, and merges for MetaSPN systems
 Author: MetaSPN Contributors
 License-Expression: MIT
@@ -69,3 +69,42 @@ schema-compatible with `metaspn-schemas` entity events.
   - `entity_id`, `alias`, `alias_type`, `added_at`, `schema_version`
 
 Datetime fields are emitted as UTC ISO-8601 strings for deterministic serialization.
+
+## M0 Ingestion Adapter
+
+For worker/runtime integration, use `resolve_normalized_social_signal(...)` with a
+normalized signal envelope.
+
+```python
+from metaspn_entities import EntityResolver, resolve_normalized_social_signal
+
+resolver = EntityResolver()
+signal = {
+    "source": "social.ingest",
+    "payload_type": "SocialPostSeen",
+    "payload": {
+        "platform": "twitter",
+        "author_handle": "@some_handle",
+        "profile_url": "https://example.com/profiles/some-handle",
+    },
+}
+
+result = resolve_normalized_social_signal(resolver, signal)
+print(result.entity_id, result.confidence)
+for event in result.emitted_events:
+    print(event.event_type, event.payload)
+```
+
+Adapter behavior:
+- Extracts deterministic identifier candidates from normalized payloads.
+- Resolves a primary identifier, then adds remaining identifiers as aliases.
+- Returns only events produced during the adapter call.
+
+## M1 Context API
+
+Profiler/router workers can read consolidated context using:
+
+- `resolver.entity_context(entity_id, recent_limit=10)`
+- `resolver.confidence_summary(entity_id)`
+
+Both APIs resolve canonical redirects first, so merged IDs return coherent context.

{metaspn_entities-0.1.3 → metaspn_entities-0.1.5}/README.md

@@ -44,3 +44,42 @@ schema-compatible with `metaspn-schemas` entity events.
   - `entity_id`, `alias`, `alias_type`, `added_at`, `schema_version`
 
 Datetime fields are emitted as UTC ISO-8601 strings for deterministic serialization.
+
+## M0 Ingestion Adapter
+
+For worker/runtime integration, use `resolve_normalized_social_signal(...)` with a
+normalized signal envelope.
+
+```python
+from metaspn_entities import EntityResolver, resolve_normalized_social_signal
+
+resolver = EntityResolver()
+signal = {
+    "source": "social.ingest",
+    "payload_type": "SocialPostSeen",
+    "payload": {
+        "platform": "twitter",
+        "author_handle": "@some_handle",
+        "profile_url": "https://example.com/profiles/some-handle",
+    },
+}
+
+result = resolve_normalized_social_signal(resolver, signal)
+print(result.entity_id, result.confidence)
+for event in result.emitted_events:
+    print(event.event_type, event.payload)
+```
+
+Adapter behavior:
+- Extracts deterministic identifier candidates from normalized payloads.
+- Resolves a primary identifier, then adds remaining identifiers as aliases.
+- Returns only events produced during the adapter call.
+
+## M1 Context API
+
+Profiler/router workers can read consolidated context using:
+
+- `resolver.entity_context(entity_id, recent_limit=10)`
+- `resolver.confidence_summary(entity_id)`
+
+Both APIs resolve canonical redirects first, so merged IDs return coherent context.

metaspn_entities-0.1.5/metaspn_entities/__init__.py

@@ -0,0 +1,17 @@
+from .adapter import SignalResolutionResult, resolve_normalized_social_signal
+from .context import EntityContext, build_confidence_summary
+from .events import EmittedEvent
+from .models import EntityResolution
+from .resolver import EntityResolver
+from .sqlite_backend import SQLiteEntityStore
+
+__all__ = [
+    "resolve_normalized_social_signal",
+    "SignalResolutionResult",
+    "EntityContext",
+    "build_confidence_summary",
+    "EntityResolver",
+    "EntityResolution",
+    "EmittedEvent",
+    "SQLiteEntityStore",
+]

metaspn_entities-0.1.5/metaspn_entities/adapter.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple
+
+from .events import EmittedEvent
+from .models import EntityType
+from .resolver import EntityResolver
+
+
+@dataclass(frozen=True)
+class SignalResolutionResult:
+    entity_id: str
+    confidence: float
+    emitted_events: List[EmittedEvent]
+
+
+def resolve_normalized_social_signal(
+    resolver: EntityResolver,
+    signal_envelope: Mapping[str, Any] | Any,
+    *,
+    default_entity_type: str = EntityType.PERSON,
+    caused_by: str = "m0-ingestion",
+) -> SignalResolutionResult:
+    """Resolve a normalized social signal envelope into a canonical entity.
+
+    The adapter is intentionally deterministic:
+    - Identifier extraction order is fixed.
+    - Primary resolution always uses the highest-priority available identifier.
+    - Remaining identifiers are added as aliases in deterministic order.
+    """
+
+    # Keep adapter call output scoped to actions taken in this invocation only.
+    resolver.drain_events()
+
+    envelope = _coerce_envelope(signal_envelope)
+    payload = _coerce_payload(envelope.get("payload"))
+    source = str(envelope.get("source") or "unknown-source")
+
+    identifiers = _extract_identifiers(payload)
+    if not identifiers:
+        raise ValueError("No resolvable identifiers found in normalized social signal payload")
+
+    primary_type, primary_value, primary_confidence = identifiers[0]
+    resolution = resolver.resolve(
+        primary_type,
+        primary_value,
+        context={
+            "confidence": primary_confidence,
+            "entity_type": default_entity_type,
+            "caused_by": caused_by,
+            "provenance": source,
+        },
+    )
+
+    for alias_type, alias_value, alias_confidence in identifiers[1:]:
+        resolver.add_alias(
+            resolution.entity_id,
+            alias_type,
+            alias_value,
+            confidence=alias_confidence,
+            caused_by=caused_by,
+            provenance=source,
+        )
+
+    emitted = resolver.drain_events()
+    return SignalResolutionResult(
+        entity_id=resolution.entity_id,
+        confidence=resolution.confidence,
+        emitted_events=emitted,
+    )
+
+
+def _coerce_envelope(signal_envelope: Mapping[str, Any] | Any) -> Dict[str, Any]:
+    if isinstance(signal_envelope, Mapping):
+        return dict(signal_envelope)
+    if hasattr(signal_envelope, "to_dict") and callable(signal_envelope.to_dict):
+        return dict(signal_envelope.to_dict())
+    raise TypeError("signal_envelope must be a mapping or provide to_dict()")
+
+
+def _coerce_payload(payload: Any) -> Dict[str, Any]:
+    if payload is None:
+        return {}
+    if isinstance(payload, Mapping):
+        return dict(payload)
+    if hasattr(payload, "to_dict") and callable(payload.to_dict):
+        return dict(payload.to_dict())
+    raise TypeError("signal payload must be a mapping or provide to_dict()")
+
+
+def _extract_identifiers(payload: Dict[str, Any]) -> List[Tuple[str, str, float]]:
+    platform = str(payload.get("platform") or "").strip().lower()
+
+    candidates: List[Tuple[int, str, str, float]] = []
+
+    # Highest confidence identifiers first.
+    if isinstance(payload.get("email"), str) and payload["email"].strip():
+        candidates.append((0, "email", payload["email"].strip(), 0.98))
+
+    for key in ("profile_url", "author_url", "canonical_url"):
+        value = payload.get(key)
+        if isinstance(value, str) and value.strip():
+            candidates.append((1, "canonical_url", value.strip(), 0.96))
+            break
+
+    handle = payload.get("author_handle") or payload.get("handle")
+    if isinstance(handle, str) and handle.strip():
+        handle_type = f"{platform}_handle" if platform else "handle"
+        candidates.append((2, handle_type, handle.strip(), 0.93))
+
+    if isinstance(payload.get("domain"), str) and payload["domain"].strip():
+        candidates.append((3, "domain", payload["domain"].strip(), 0.9))
+
+    for key in ("display_name", "name"):
+        value = payload.get(key)
+        if isinstance(value, str) and value.strip():
+            candidates.append((4, "name", value.strip(), 0.7))
+            break
+
+    # Deduplicate by (identifier_type, raw value) while preserving deterministic order.
+    seen: set[Tuple[str, str]] = set()
+    ordered: List[Tuple[str, str, float]] = []
+    for _, id_type, id_value, confidence in sorted(candidates, key=lambda c: (c[0], c[1], c[2])):
+        key = (id_type, id_value)
+        if key in seen:
+            continue
+        seen.add(key)
+        ordered.append((id_type, id_value, confidence))
+
+    return ordered

metaspn_entities-0.1.5/metaspn_entities/context.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+
+@dataclass(frozen=True)
+class EntityContext:
+    entity_id: str
+    aliases: List[Dict[str, Any]]
+    identifiers: List[Dict[str, Any]]
+    recent_evidence: List[Dict[str, Any]]
+    confidence_summary: Dict[str, Any]
+
+
+def build_confidence_summary(
+    aliases: List[Dict[str, Any]],
+    identifiers: List[Dict[str, Any]],
+    evidence: List[Dict[str, Any]],
+) -> Dict[str, Any]:
+    identifier_confidences = sorted(float(item["confidence"]) for item in identifiers)
+    alias_confidences = sorted(float(item["confidence"]) for item in aliases)
+    source_set = sorted(
+        {
+            str(item.get("provenance"))
+            for item in evidence
+            if item.get("provenance") not in (None, "")
+        }
+    )
+
+    identifier_avg = _avg(identifier_confidences)
+    alias_avg = _avg(alias_confidences)
+    source_diversity = min(1.0, len(source_set) / 3.0)
+
+    overall = min(1.0, (0.65 * identifier_avg) + (0.25 * alias_avg) + (0.10 * source_diversity))
+    by_identifier_type = _rollup_by_identifier_type(identifiers)
+
+    return {
+        "overall_confidence": round(overall, 6),
+        "identifier_confidence_avg": round(identifier_avg, 6),
+        "alias_confidence_avg": round(alias_avg, 6),
+        "unique_source_count": len(source_set),
+        "evidence_count": len(evidence),
+        "by_identifier_type": by_identifier_type,
+    }
+
+
+def _avg(values: List[float]) -> float:
+    if not values:
+        return 0.0
+    return sum(values) / len(values)
+
+
+def _rollup_by_identifier_type(identifiers: List[Dict[str, Any]]) -> Dict[str, Dict[str, float]]:
+    grouped: Dict[str, List[float]] = {}
+    for item in identifiers:
+        key = str(item["identifier_type"])
+        grouped.setdefault(key, []).append(float(item["confidence"]))
+
+    rollup: Dict[str, Dict[str, float]] = {}
+    for key in sorted(grouped):
+        values = sorted(grouped[key])
+        rollup[key] = {
+            "count": float(len(values)),
+            "avg_confidence": round(_avg(values), 6),
+            "max_confidence": round(max(values), 6),
+        }
+    return rollup

{metaspn_entities-0.1.3 → metaspn_entities-0.1.5}/metaspn_entities/resolver.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional
 
+from .context import EntityContext, build_confidence_summary
 from .events import EmittedEvent, EventFactory
 from .models import (
     DEFAULT_MATCH_CONFIDENCE,
@@ -135,6 +136,30 @@ class EntityResolver:
     def aliases_for_entity(self, entity_id: str) -> List[Dict[str, Any]]:
         return self.store.list_aliases_for_entity(entity_id)
 
+    def confidence_summary(self, entity_id: str) -> Dict[str, Any]:
+        canonical_id = self.store.canonical_entity_id(entity_id)
+        aliases = self.store.list_aliases_for_entity(canonical_id)
+        identifiers = self.store.list_identifier_records_for_entity(canonical_id)
+        return build_confidence_summary(aliases, identifiers, identifiers)
+
+    def entity_context(self, entity_id: str, recent_limit: int = 10) -> EntityContext:
+        canonical_id = self.store.canonical_entity_id(entity_id)
+        aliases = self.store.list_aliases_for_entity(canonical_id)
+        identifiers = self.store.list_identifier_records_for_entity(canonical_id)
+        recent_evidence = sorted(
+            identifiers,
+            key=lambda row: (str(row["last_seen_at"]), str(row["identifier_type"]), str(row["normalized_value"])),
+            reverse=True,
+        )[: max(recent_limit, 0)]
+        summary = build_confidence_summary(aliases, identifiers, recent_evidence)
+        return EntityContext(
+            entity_id=canonical_id,
+            aliases=aliases,
+            identifiers=identifiers,
+            recent_evidence=recent_evidence,
+            confidence_summary=summary,
+        )
+
     def export_snapshot(self, output_path: str) -> None:
         self.store.export_snapshot(output_path)
 

{metaspn_entities-0.1.3 → metaspn_entities-0.1.5}/metaspn_entities/sqlite_backend.py

@@ -276,3 +276,37 @@ class SQLiteEntityStore:
                     "normalized_value": row["normalized_value"],
                     "confidence": row["confidence"],
                 }
+
+    def list_identifier_records_for_entity(self, entity_id: str) -> List[Dict[str, Any]]:
+        target = self.canonical_entity_id(entity_id)
+        rows = self.conn.execute(
+            """
+            SELECT
+              a.entity_id,
+              i.identifier_type,
+              i.value,
+              i.normalized_value,
+              i.confidence,
+              i.first_seen_at,
+              i.last_seen_at,
+              i.provenance
+            FROM aliases a
+            JOIN identifiers i
+              ON a.identifier_type = i.identifier_type
+             AND a.normalized_value = i.normalized_value
+            ORDER BY i.identifier_type, i.normalized_value
+            """
+        ).fetchall()
+        return [
+            {
+                "identifier_type": row["identifier_type"],
+                "value": row["value"],
+                "normalized_value": row["normalized_value"],
+                "confidence": row["confidence"],
+                "first_seen_at": row["first_seen_at"],
+                "last_seen_at": row["last_seen_at"],
+                "provenance": row["provenance"],
+            }
+            for row in rows
+            if self.canonical_entity_id(row["entity_id"]) == target
+        ]

{metaspn_entities-0.1.3 → metaspn_entities-0.1.5}/metaspn_entities.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaspn-entities
-Version: 0.1.3
+Version: 0.1.5
 Summary: Canonical entity resolution, aliasing, and merges for MetaSPN systems
 Author: MetaSPN Contributors
 License-Expression: MIT
@@ -69,3 +69,42 @@ schema-compatible with `metaspn-schemas` entity events.
   - `entity_id`, `alias`, `alias_type`, `added_at`, `schema_version`
 
 Datetime fields are emitted as UTC ISO-8601 strings for deterministic serialization.
+
+## M0 Ingestion Adapter
+
+For worker/runtime integration, use `resolve_normalized_social_signal(...)` with a
+normalized signal envelope.
+
+```python
+from metaspn_entities import EntityResolver, resolve_normalized_social_signal
+
+resolver = EntityResolver()
+signal = {
+    "source": "social.ingest",
+    "payload_type": "SocialPostSeen",
+    "payload": {
+        "platform": "twitter",
+        "author_handle": "@some_handle",
+        "profile_url": "https://example.com/profiles/some-handle",
+    },
+}
+
+result = resolve_normalized_social_signal(resolver, signal)
+print(result.entity_id, result.confidence)
+for event in result.emitted_events:
+    print(event.event_type, event.payload)
+```
+
+Adapter behavior:
+- Extracts deterministic identifier candidates from normalized payloads.
+- Resolves a primary identifier, then adds remaining identifiers as aliases.
+- Returns only events produced during the adapter call.
+
+## M1 Context API
+
+Profiler/router workers can read consolidated context using:
+
+- `resolver.entity_context(entity_id, recent_limit=10)`
+- `resolver.confidence_summary(entity_id)`
+
+Both APIs resolve canonical redirects first, so merged IDs return coherent context.

{metaspn_entities-0.1.3 → metaspn_entities-0.1.5}/metaspn_entities.egg-info/SOURCES.txt

@@ -2,6 +2,8 @@ LICENSE
 README.md
 pyproject.toml
 metaspn_entities/__init__.py
+metaspn_entities/adapter.py
+metaspn_entities/context.py
 metaspn_entities/events.py
 metaspn_entities/models.py
 metaspn_entities/normalize.py
@@ -12,5 +14,7 @@ metaspn_entities.egg-info/SOURCES.txt
 metaspn_entities.egg-info/dependency_links.txt
 metaspn_entities.egg-info/requires.txt
 metaspn_entities.egg-info/top_level.txt
+tests/test_adapter.py
+tests/test_context.py
 tests/test_event_contract.py
 tests/test_resolver.py

{metaspn_entities-0.1.3 → metaspn_entities-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "metaspn-entities"
-version = "0.1.3"
+version = "0.1.5"
 description = "Canonical entity resolution, aliasing, and merges for MetaSPN systems"
 readme = "README.md"
 requires-python = ">=3.10"

metaspn_entities-0.1.5/tests/test_adapter.py

@@ -0,0 +1,136 @@
+import importlib
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+from metaspn_entities import SQLiteEntityStore
+from metaspn_entities.adapter import resolve_normalized_social_signal
+from metaspn_entities.resolver import EntityResolver
+
+
+class AdapterTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tempdir = tempfile.TemporaryDirectory()
+        self.db_path = str(Path(self.tempdir.name) / "entities.db")
+        self.store = SQLiteEntityStore(self.db_path)
+        self.resolver = EntityResolver(self.store)
+
+    def tearDown(self) -> None:
+        self.store.close()
+        self.tempdir.cleanup()
+
+    def test_same_author_over_multiple_posts(self) -> None:
+        first_signal = {
+            "source": "social.ingest",
+            "payload_type": "SocialPostSeen",
+            "payload": {
+                "platform": "twitter",
+                "post_id": "p1",
+                "author_handle": "@same_author",
+                "url": "https://x.com/same_author/status/1",
+            },
+        }
+        second_signal = {
+            "source": "social.ingest",
+            "payload_type": "SocialPostSeen",
+            "payload": {
+                "platform": "twitter",
+                "post_id": "p2",
+                "author_handle": "same_author",
+                "url": "https://x.com/same_author/status/2",
+            },
+        }
+
+        first = resolve_normalized_social_signal(self.resolver, first_signal)
+        second = resolve_normalized_social_signal(self.resolver, second_signal)
+
+        self.assertEqual(first.entity_id, second.entity_id)
+
+    def test_cross_platform_identifier_normalization(self) -> None:
+        twitter_signal = {
+            "source": "social.ingest",
+            "payload_type": "SocialPostSeen",
+            "payload": {
+                "platform": "twitter",
+                "post_id": "p100",
+                "author_handle": "alice",
+                "profile_url": "https://example.com/team/alice/",
+            },
+        }
+        linkedin_signal = {
+            "source": "social.ingest",
+            "payload_type": "ProfileSnapshotSeen",
+            "payload": {
+                "platform": "linkedin",
+                "profile_id": "li-77",
+                "handle": "alice-smith",
+                "profile_url": "http://www.example.com/team/alice",
+            },
+        }
+
+        first = resolve_normalized_social_signal(self.resolver, twitter_signal)
+        second = resolve_normalized_social_signal(self.resolver, linkedin_signal)
+
+        self.assertEqual(first.entity_id, second.entity_id)
+
+    def test_idempotent_rerun_behavior(self) -> None:
+        signal = {
+            "source": "social.ingest",
+            "payload_type": "SocialPostSeen",
+            "payload": {
+                "platform": "twitter",
+                "post_id": "idempotent-1",
+                "author_handle": "rerun_author",
+                "profile_url": "https://example.org/rerun_author",
+            },
+        }
+
+        first = resolve_normalized_social_signal(self.resolver, signal)
+        second = resolve_normalized_social_signal(self.resolver, signal)
+
+        self.assertEqual(first.entity_id, second.entity_id)
+        self.assertEqual(
+            [event.event_type for event in second.emitted_events],
+            ["EntityResolved"],
+        )
+
+    def test_emitted_events_parse_with_metaspn_schemas(self) -> None:
+        entities_module = None
+        try:
+            entities_module = importlib.import_module("metaspn_schemas.entities")
+        except Exception:
+            sibling_src = Path(__file__).resolve().parents[2] / "metaspn-schemas" / "src"
+            if sibling_src.exists():
+                sys.path.insert(0, str(sibling_src))
+                entities_module = importlib.import_module("metaspn_schemas.entities")
+
+        if entities_module is None:
+            self.skipTest("metaspn_schemas is unavailable")
+
+        signal = {
+            "source": "social.ingest",
+            "payload_type": "SocialPostSeen",
+            "payload": {
+                "platform": "twitter",
+                "post_id": "schema-1",
+                "author_handle": "schema_user",
+                "profile_url": "https://example.net/schema_user",
+            },
+        }
+
+        result = resolve_normalized_social_signal(self.resolver, signal)
+        for event in result.emitted_events:
+            if event.event_type == "EntityResolved":
+                parsed = entities_module.EntityResolved.from_dict(event.payload)
+                self.assertEqual(parsed.entity_id, result.entity_id)
+            elif event.event_type == "EntityAliasAdded":
+                parsed = entities_module.EntityAliasAdded.from_dict(event.payload)
+                self.assertTrue(parsed.alias)
+            elif event.event_type == "EntityMerged":
+                parsed = entities_module.EntityMerged.from_dict(event.payload)
+                self.assertTrue(parsed.merged_from)
+
+
+if __name__ == "__main__":
+    unittest.main()

metaspn_entities-0.1.5/tests/test_context.py

@@ -0,0 +1,90 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from metaspn_entities import SQLiteEntityStore
+from metaspn_entities.adapter import resolve_normalized_social_signal
+from metaspn_entities.resolver import EntityResolver
+
+
+class ContextTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tempdir = tempfile.TemporaryDirectory()
+        self.db_path = str(Path(self.tempdir.name) / "entities.db")
+        self.store = SQLiteEntityStore(self.db_path)
+        self.resolver = EntityResolver(self.store)
+
+    def tearDown(self) -> None:
+        self.store.close()
+        self.tempdir.cleanup()
+
+    def test_cross_platform_handle_normalization_in_context(self) -> None:
+        twitter = {
+            "source": "social.ingest",
+            "payload": {
+                "platform": "twitter",
+                "author_handle": "Alice_One",
+                "profile_url": "https://example.com/u/alice",
+            },
+        }
+        linkedin = {
+            "source": "social.ingest",
+            "payload": {
+                "platform": "linkedin",
+                "handle": "alice-one",
+                "profile_url": "http://www.example.com/u/alice/",
+            },
+        }
+
+        first = resolve_normalized_social_signal(self.resolver, twitter)
+        second = resolve_normalized_social_signal(self.resolver, linkedin)
+        self.assertEqual(first.entity_id, second.entity_id)
+
+        context = self.resolver.entity_context(first.entity_id)
+        identifier_types = {item["identifier_type"] for item in context.identifiers}
+        self.assertIn("twitter_handle", identifier_types)
+        self.assertIn("linkedin_handle", identifier_types)
+        self.assertIn("canonical_url", identifier_types)
+
+    def test_merged_entity_context_continuity(self) -> None:
+        a = self.resolver.resolve("twitter_handle", "merge_ctx_a")
+        b = self.resolver.resolve("twitter_handle", "merge_ctx_b")
+        self.resolver.add_alias(a.entity_id, "email", "a@example.com", caused_by="manual")
+        self.resolver.add_alias(b.entity_id, "domain", "example.com", caused_by="manual")
+        self.resolver.merge_entities(a.entity_id, b.entity_id, reason="dedupe", caused_by="manual")
+
+        context_from = self.resolver.entity_context(a.entity_id)
+        context_to = self.resolver.entity_context(b.entity_id)
+
+        self.assertEqual(context_from.entity_id, context_to.entity_id)
+        normalized_values = {item["normalized_value"] for item in context_from.aliases}
+        self.assertIn("merge_ctx_a", normalized_values)
+        self.assertIn("merge_ctx_b", normalized_values)
+
+    def test_rerun_stability_for_context_and_confidence(self) -> None:
+        signal = {
+            "source": "social.ingest",
+            "payload": {
+                "platform": "twitter",
+                "author_handle": "stable_ctx",
+                "profile_url": "https://example.org/stable_ctx",
+            },
+        }
+
+        first = resolve_normalized_social_signal(self.resolver, signal)
+        context_1 = self.resolver.entity_context(first.entity_id)
+        summary_1 = self.resolver.confidence_summary(first.entity_id)
+
+        second = resolve_normalized_social_signal(self.resolver, signal)
+        context_2 = self.resolver.entity_context(second.entity_id)
+        summary_2 = self.resolver.confidence_summary(second.entity_id)
+
+        self.assertEqual(first.entity_id, second.entity_id)
+        self.assertEqual(context_1.entity_id, context_2.entity_id)
+        self.assertEqual(context_1.aliases, context_2.aliases)
+        self.assertEqual(context_1.identifiers, context_2.identifiers)
+        self.assertEqual(summary_1, summary_2)
+
+
+if __name__ == "__main__":
+    unittest.main()

metaspn_entities-0.1.3/metaspn_entities/__init__.py

@@ -1,11 +0,0 @@
-from .events import EmittedEvent
-from .models import EntityResolution
-from .resolver import EntityResolver
-from .sqlite_backend import SQLiteEntityStore
-
-__all__ = [
-    "EntityResolver",
-    "EntityResolution",
-    "EmittedEvent",
-    "SQLiteEntityStore",
-]