patchr 0.1.0__py3-none-any.whl

picux/security/secrets.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+RAW_SECRET_KEYS = {"token", "apiKey", "secret", "password", "privateKey", "clientSecret", "value"}
+
+
+@dataclass(frozen=True)
+class SecretResolution:
+    ref: str
+    kind: str
+    source: str
+    available: bool
+    errors: tuple[str, ...] = ()
+    value: str = ""
+
+    def toMap(self) -> dict[str, Any]:
+        return {
+            "ref": self.ref,
+            "kind": self.kind,
+            "source": self.source,
+            "available": self.available,
+            "errors": list(self.errors),
+        }
+
+
+class SecretResolver:
+    """Resolve scoped secret references without serializing secret values."""
+
+    def __init__(
+        self,
+        *,
+        env: Mapping[str, str] | None = None,
+        vault: Mapping[str, str] | None = None,
+    ) -> None:
+        self.env = os.environ if env is None else env
+        self.vault = vault or {}
+
+    def check(self, payload: dict[str, Any]) -> dict[str, Any]:
+        rawErrors = _rawSecretErrors(payload)
+        refs = self._refs(payload)
+        checks = [self.resolve(item["ref"], envName=item["env"], source=item["source"]) for item in refs]
+        errors = [*rawErrors]
+        if not refs:
+            errors.append("missing:ref")
+        for check in checks:
+            errors.extend(check.errors)
+        cleanErrors = list(dict.fromkeys(errors))
+        available = bool(checks) and all(check.available for check in checks)
+        return {
+            "ok": not cleanErrors and available,
+            "available": available and not rawErrors,
+            "count": len(checks),
+            "checks": [check.toMap() for check in checks],
+            "errors": cleanErrors,
+        }
+
+    def resolve(self, ref: str, *, envName: str = "", source: str = "") -> SecretResolution:
+        rawRef = str(ref or "").strip()
+        envName = str(envName or "").strip()
+        if not rawRef and envName:
+            rawRef = f"env:{envName}"
+        if not rawRef:
+            return SecretResolution(ref="", kind="unknown", source=source, available=False, errors=("missing:ref",))
+
+        kind, normalized = _kind(rawRef)
+        if kind == "env":
+            envKey = normalized
+            value = str(self.env.get(envKey, "") or "")
+            errors = () if value else (f"missingEnv:{envKey}",)
+            return SecretResolution(ref=f"env:{envKey}", kind="env", source=source, available=bool(value), errors=errors, value=value)
+
+        if kind == "vault":
+            value = str(self.vault.get(rawRef, "") or self.vault.get(normalized, "") or "")
+            if not value and envName:
+                value = str(self.env.get(envName, "") or "")
+            if value:
+                resolvedBy = "vault" if rawRef in self.vault or normalized in self.vault else f"env:{envName}"
+                return SecretResolution(ref=rawRef, kind="vault", source=source or resolvedBy, available=True, value=value)
+            return SecretResolution(ref=rawRef, kind="vault", source=source, available=False, errors=("vaultResolverMissing",))
+
+        return SecretResolution(ref=rawRef, kind="unknown", source=source, available=False, errors=("invalid:ref",))
+
+    def _refs(self, payload: dict[str, Any]) -> list[dict[str, str]]:
+        refs: list[dict[str, str]] = []
+
+        def add(ref: Any, *, envName: Any = "", source: str = "") -> None:
+            cleanRef = str(ref or "").strip()
+            cleanEnv = str(envName or "").strip()
+            if cleanRef or cleanEnv:
+                refs.append({"ref": cleanRef, "env": cleanEnv, "source": source})
+
+        add(payload.get("ref", ""), envName=payload.get("env", ""), source="payload")
+        for idx, ref in enumerate(payload.get("refs", []) if isinstance(payload.get("refs"), list) else []):
+            add(ref, source=f"refs.{idx}")
+
+        for source, item in _credentialItems(payload):
+            add(
+                item.get("tokenRef", item.get("secretRef", "")),
+                envName=item.get("env", ""),
+                source=source,
+            )
+        return refs
+
+
+def _credentialItems(payload: dict[str, Any]) -> list[tuple[str, dict[str, Any]]]:
+    items: list[tuple[str, dict[str, Any]]] = []
+    connector = payload.get("connector") if isinstance(payload.get("connector"), dict) else payload
+    credential = connector.get("credential", connector.get("auth", {})) if isinstance(connector, dict) else {}
+    if isinstance(credential, dict):
+        items.append(("connector.credential", credential))
+    scopes = connector.get("scopes", []) if isinstance(connector, dict) else []
+    if isinstance(scopes, list):
+        for idx, scope in enumerate(scopes):
+            if isinstance(scope, dict):
+                items.append((f"connector.scopes.{idx}", scope))
+    return items
+
+
+def _kind(ref: str) -> tuple[str, str]:
+    if ref.startswith("env:"):
+        return "env", ref[4:]
+    if ref.startswith("vault:"):
+        return "vault", ref
+    if ref.isupper() and "_" in ref:
+        return "env", ref
+    return "unknown", ref
+
+
+def _rawSecretErrors(value: Any, path: str = "payload") -> list[str]:
+    errors: list[str] = []
+    if isinstance(value, dict):
+        for key, item in value.items():
+            itemPath = f"{path}.{key}"
+            if key in RAW_SECRET_KEYS and str(item or "").strip():
+                errors.append(f"rawSecretNotAllowed:{itemPath}")
+            errors.extend(_rawSecretErrors(item, itemPath))
+    elif isinstance(value, list):
+        for idx, item in enumerate(value):
+            errors.extend(_rawSecretErrors(item, f"{path}.{idx}"))
+    return errors

picux/signals/__init__.py

@@ -0,0 +1 @@
+"""Signal ingestion, scoring, disambiguation, and adapter contracts."""

picux/signals/community/__init__.py

@@ -0,0 +1,24 @@
+"""Community signal harness primitives."""
+
+from .disambiguation import classifySignalEntity, classify_signal_entity, inspectSignalEntity, isHarnessCollision, is_harness_collision
+from .intake import CommunitySignalIntake
+from .models import CommunitySignal, CommunitySignalSource, SignalAnalysis, SignalEntity
+from .rules import CANONICAL_QUERIES, entityCatalog
+from .scoring import scoreSignal, score_signal
+
+__all__ = [
+    "CANONICAL_QUERIES",
+    "CommunitySignalIntake",
+    "CommunitySignal",
+    "CommunitySignalSource",
+    "SignalAnalysis",
+    "SignalEntity",
+    "classifySignalEntity",
+    "classify_signal_entity",
+    "entityCatalog",
+    "inspectSignalEntity",
+    "isHarnessCollision",
+    "is_harness_collision",
+    "scoreSignal",
+    "score_signal",
+]

picux/signals/community/adapters/__init__.py

@@ -0,0 +1,7 @@
+"""Community signal source adapters."""
+
+from .reddit import fromReddit, fromRedditPost
+from .shopify import fromShopify
+from .web import fromWeb
+
+__all__ = ["fromReddit", "fromRedditPost", "fromShopify", "fromWeb"]

picux/signals/community/adapters/reddit.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Any
+
+from picux.signals.community.models import CommunitySignal, CommunitySignalSource
+
+
+def fromReddit(raw: dict[str, Any]) -> CommunitySignal:
+    title = str(raw.get("title", "") or "")
+    body = str(raw.get("selftext", raw.get("body", "")) or "")
+    permalink = str(raw.get("permalink", raw.get("url", "")) or "")
+    url = permalink if permalink.startswith("http") else f"https://www.reddit.com{permalink}" if permalink else ""
+    created = raw.get("createdAt", raw.get("created_utc", ""))
+    observedAt = _observedAt(created)
+    return CommunitySignal(
+        signalId=str(raw.get("signalId", raw.get("id", "")) or ""),
+        source=CommunitySignalSource(
+            platform="reddit",
+            url=url,
+            community=str(raw.get("subreddit", raw.get("community", "")) or ""),
+            metadata={"author": str(raw.get("author", "") or "")},
+        ),
+        observedAt=observedAt,
+        text=" ".join(part for part in (title, body) if part).strip(),
+        query=str(raw.get("query", "") or ""),
+    )
+
+
+def fromRedditPost(raw: dict[str, Any]) -> CommunitySignal:
+    return fromReddit(raw)
+
+
+def _observedAt(value: Any) -> str:
+    if isinstance(value, (int, float)):
+        return datetime.fromtimestamp(float(value), timezone.utc).isoformat().replace("+00:00", "Z")
+    return str(value or "")

picux/signals/community/adapters/shopify.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Any
+
+from picux.signals.community.models import CommunitySignal, CommunitySignalSource
+
+
+def fromShopify(raw: dict[str, Any]) -> CommunitySignal:
+    topic = str(raw.get("topic", "") or "")
+    title = str(raw.get("title", raw.get("name", "")) or "")
+    body = str(raw.get("body", raw.get("description", "")) or "")
+    return CommunitySignal(
+        signalId=str(raw.get("signalId", raw.get("id", "")) or ""),
+        source=CommunitySignalSource(
+            platform="shopify",
+            url=str(raw.get("url", "") or ""),
+            community=str(raw.get("shop", "") or ""),
+            metadata={"topic": topic},
+        ),
+        observedAt=str(raw.get("observedAt", raw.get("createdAt", "")) or ""),
+        text=" ".join(part for part in (topic, title, body) if part).strip(),
+        query=str(raw.get("query", "") or ""),
+    )

picux/signals/community/adapters/web.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import Any
+
+from picux.signals.community.models import CommunitySignal, CommunitySignalSource
+
+
+def fromWeb(raw: dict[str, Any]) -> CommunitySignal:
+    title = str(raw.get("title", "") or "")
+    snippet = str(raw.get("snippet", "") or "")
+    body = str(raw.get("body", "") or "")
+    return CommunitySignal(
+        signalId=str(raw.get("signalId", raw.get("id", "")) or ""),
+        source=CommunitySignalSource(
+            platform="web",
+            url=str(raw.get("url", "") or ""),
+            community=str(raw.get("site", raw.get("domain", "")) or ""),
+            metadata={"rank": raw.get("rank", "")},
+        ),
+        observedAt=str(raw.get("observedAt", raw.get("capturedAt", "")) or ""),
+        text=" ".join(part for part in (title, snippet, body) if part).strip(),
+        query=str(raw.get("query", "") or ""),
+    )

picux/signals/community/disambiguation.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Any
+
+from picux.signals.community.models import SignalEntity
+from picux.signals.community.rules import ENTITY_RULES, phraseHits
+
+
+ENTITY_PRIORITY = (
+    SignalEntity.PICUX,
+    SignalEntity.EXTERNAL_APP,
+    SignalEntity.HARNESS,
+    SignalEntity.LEGACY_SWARM,
+)
+
+
+def inspectSignalEntity(text: str) -> dict[str, Any]:
+    matchesByEntity: dict[SignalEntity, tuple[str, ...]] = {
+        rule.entity: phraseHits(text, rule.aliases) for rule in ENTITY_RULES
+    }
+    entity = SignalEntity.UNKNOWN
+    for candidate in ENTITY_PRIORITY:
+        if matchesByEntity.get(candidate):
+            entity = candidate
+            break
+
+    harnessMatches = matchesByEntity.get(SignalEntity.HARNESS, ())
+    return {
+        "entity": entity,
+        "matches": matchesByEntity.get(entity, ()),
+        "matchesByEntity": {key.value: list(value) for key, value in matchesByEntity.items() if value},
+        "harnessMatches": harnessMatches,
+        "harnessCollision": bool(harnessMatches),
+    }
+
+
+def classifySignalEntity(text: str) -> SignalEntity:
+    return inspectSignalEntity(text)["entity"]
+
+
+def isHarnessCollision(text: str) -> bool:
+    detail = inspectSignalEntity(text)
+    return bool(detail["harnessCollision"])
+
+
+def classify_signal_entity(text: str) -> SignalEntity:
+    return classifySignalEntity(text)
+
+
+def is_harness_collision(text: str) -> bool:
+    return isHarnessCollision(text)

picux/signals/community/intake.py

@@ -0,0 +1,227 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Callable
+from datetime import datetime, timezone
+from typing import Any
+
+from picux.core.models import Domain, ProtocolTask, ProtocolTaskStatus
+from picux.signals.community.models import CommunitySignal, CommunitySignalSource, SignalEntity
+from picux.signals.community.rules import LAUNCH_DOMAINS, entityCatalog
+from picux.signals.community.scoring import scoreSignal
+from picux.storage.signals import SignalBook
+
+
+MISINFORMATION_REVIEW_THRESHOLD = 0.35
+
+
+class CommunitySignalIntake:
+    """Deterministic intake surface for public community signals."""
+
+    def __init__(self, *, clock: Callable[[], datetime] | None = None, signalBook: SignalBook | None = None) -> None:
+        self.clock = clock or (lambda: datetime.now(timezone.utc))
+        self.signalBook = signalBook or SignalBook()
+
+    def makeSignal(self, raw: CommunitySignal | dict[str, Any]) -> CommunitySignal:
+        if isinstance(raw, CommunitySignal):
+            signal = raw
+        else:
+            source = CommunitySignalSource.fromObj(raw.get("source") if isinstance(raw.get("source"), dict) else {})
+            signal = CommunitySignal(
+                signalId=str(raw.get("signalId", "") or ""),
+                source=source,
+                observedAt=str(raw.get("observedAt", "") or ""),
+                text=str(raw.get("text", "") or ""),
+                query=str(raw.get("query", "") or ""),
+            )
+        observedAt = signal.observedAt or self.clock().isoformat().replace("+00:00", "Z")
+        signalId = signal.signalId or self._stableId(signal.source, observedAt, signal.text, signal.query)
+        analysis = scoreSignal(
+            CommunitySignal(
+                signalId=signalId,
+                source=signal.source,
+                observedAt=observedAt,
+                text=signal.text,
+                query=signal.query,
+            )
+        )
+        return CommunitySignal(
+            signalId=signalId,
+            source=signal.source,
+            observedAt=observedAt,
+            text=signal.text,
+            query=signal.query,
+            entity=analysis.entity,
+            confidence=analysis.confidence,
+        )
+
+    def ingest(self, raw: CommunitySignal | dict[str, Any]) -> dict[str, Any]:
+        signal = self.makeSignal(raw)
+        analysis = scoreSignal(signal)
+        saved = self.signalBook.saveSignal(signal, analysis)
+        result = {
+            "ok": True,
+            "signal": signal.toMap(),
+            "analysis": analysis.toMap(),
+            "humanReview": self._misinformationEscalation(Domain.HUNT.value, analysis),
+        }
+        if saved.get("ok"):
+            result["record"] = saved["record"]
+        return result
+
+    def analyze(self, raw: CommunitySignal | dict[str, Any]) -> dict[str, Any]:
+        signal = self.makeSignal(raw)
+        analysis = scoreSignal(signal)
+        return {**analysis.toMap(), "humanReview": self._misinformationEscalation(Domain.HUNT.value, analysis)}
+
+    def getSignal(self, signalId: str) -> dict[str, Any]:
+        return self.signalBook.getSignal(signalId)
+
+    def listSignals(self, filters: dict[str, Any] | None = None) -> dict[str, Any]:
+        return self.signalBook.listSignals(filters)
+
+    def entities(self) -> dict[str, Any]:
+        return {"ok": True, "entities": entityCatalog()}
+
+    def launchTask(self, raw: dict[str, Any]) -> dict[str, Any]:
+        target = str(raw.get("targetDomain", raw.get("domain", Domain.HUNT.value)) or Domain.HUNT.value).lower()
+        if target not in LAUNCH_DOMAINS:
+            return {"ok": False, "error": "domainNotLaunchable", "launchableDomains": list(LAUNCH_DOMAINS)}
+
+        signalRaw = raw.get("signal") if isinstance(raw.get("signal"), dict) else raw
+        signal = self.makeSignal(signalRaw)
+        analysis = scoreSignal(signal)
+        saved = self.signalBook.saveSignal(signal, analysis)
+        record = saved.get("record") if saved.get("ok") else None
+        if analysis.entity == SignalEntity.HARNESS:
+            result = {"ok": False, "error": "harnessCollision", "analysis": analysis.toMap()}
+            if record:
+                result["record"] = record
+            return result
+        escalation = self._misinformationEscalation(target, analysis)
+        if escalation["required"]:
+            result = self._proxyEscalationTask(raw, signal, analysis, escalation)
+            if record:
+                result["record"] = record
+            return result
+        if target not in analysis.launchableDomains:
+            result = {"ok": False, "error": "signalNotLaunchable", "analysis": analysis.toMap()}
+            if record:
+                result["record"] = record
+            return result
+
+        approved = bool(raw.get("approved", False))
+        needsApproval = not approved
+        status = ProtocolTaskStatus.NEEDS_APPROVAL if needsApproval else ProtocolTaskStatus.PENDING
+        task = ProtocolTask(
+            taskId=self._taskId(signal.signalId, target),
+            userId=str(raw.get("userId", "community") or "community"),
+            domain=Domain(target),
+            status=status,
+            channel="community",
+            inData={"signal": signal.toMap(), "analysis": analysis.toMap()},
+            needsApproval=needsApproval,
+            extRef=signal.signalId,
+            meta={"source": "communitySignal", "approvalGate": "required" if needsApproval else "approved"},
+        )
+        result = {
+            "ok": True,
+            "approvalRequired": needsApproval,
+            "analysis": analysis.toMap(),
+            "task": {
+                "taskId": task.taskId,
+                "userId": task.userId,
+                "domain": task.domain.value,
+                "status": task.status.value,
+                "channel": task.channel,
+                "inData": task.inData,
+                "needsApproval": task.needsApproval,
+                "extRef": task.extRef,
+                "meta": task.meta,
+            },
+        }
+        if record:
+            result["record"] = record
+        return result
+
+    def _proxyEscalationTask(
+        self,
+        raw: dict[str, Any],
+        signal: CommunitySignal,
+        analysis: Any,
+        escalation: dict[str, Any],
+    ) -> dict[str, Any]:
+        target = str(escalation.get("proposedDomain", Domain.HUNT.value) or Domain.HUNT.value)
+        task = ProtocolTask(
+            taskId=self._taskId(signal.signalId, "proxy"),
+            userId=str(raw.get("userId", "community") or "community"),
+            domain=Domain.PROXY,
+            status=ProtocolTaskStatus.NEEDS_APPROVAL,
+            channel="community",
+            inData={"signal": signal.toMap(), "analysis": analysis.toMap(), "escalation": escalation},
+            needsApproval=True,
+            extRef=signal.signalId,
+            meta={
+                "source": "communitySignal",
+                "approvalGate": "required",
+                "misinformationEscalation": "required",
+                "proposedDomain": target,
+            },
+        )
+        return {
+            "ok": True,
+            "approvalRequired": True,
+            "escalationRequired": True,
+            "analysis": analysis.toMap(),
+            "humanReview": escalation,
+            "task": {
+                "taskId": task.taskId,
+                "userId": task.userId,
+                "domain": task.domain.value,
+                "status": task.status.value,
+                "channel": task.channel,
+                "inData": task.inData,
+                "needsApproval": task.needsApproval,
+                "extRef": task.extRef,
+                "meta": task.meta,
+            },
+        }
+
+    @staticmethod
+    def _misinformationEscalation(targetDomain: str, analysis: Any) -> dict[str, Any]:
+        reasons: list[str] = []
+        if float(getattr(analysis, "confidence", 0.0) or 0.0) < MISINFORMATION_REVIEW_THRESHOLD:
+            reasons.append("lowConfidence")
+        if getattr(analysis, "entity", SignalEntity.UNKNOWN) == SignalEntity.UNKNOWN:
+            reasons.append("unknownEntity")
+        launchable = tuple(getattr(analysis, "launchableDomains", ()) or ())
+        if targetDomain not in launchable:
+            reasons.append("notLaunchable")
+        required = bool(reasons)
+        return {
+            "required": required,
+            "routeDomain": Domain.PROXY.value if required else "",
+            "proposedDomain": str(targetDomain or ""),
+            "threshold": MISINFORMATION_REVIEW_THRESHOLD,
+            "confidence": float(getattr(analysis, "confidence", 0.0) or 0.0),
+            "reasons": list(dict.fromkeys(reasons)),
+            "protocol": "misinformationEscalation",
+            "instruction": "Route to human review before surfacing as an answer." if required else "",
+        }
+
+    @staticmethod
+    def _stableId(source: CommunitySignalSource, observedAt: str, text: str, query: str) -> str:
+        payload = {
+            "source": source.toMap(),
+            "observedAt": observedAt,
+            "text": text,
+            "query": query,
+        }
+        digest = hashlib.sha256(json.dumps(payload, ensure_ascii=True, sort_keys=True).encode("utf-8")).hexdigest()
+        return f"sig_{digest[:24]}"
+
+    @staticmethod
+    def _taskId(signalId: str, domain: str) -> str:
+        digest = hashlib.sha256(f"{signalId}:{domain}".encode("utf-8")).hexdigest()
+        return f"task_{digest[:24]}"

picux/signals/community/models.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class SignalEntity(str, Enum):
+    PICUX = "picux"
+    EXTERNAL_APP = "external_app"
+    LEGACY_SWARM = "legacy_swarm"
+    HARNESS = "harness"
+    UNKNOWN = "unknown"
+
+
+@dataclass(frozen=True)
+class CommunitySignalSource:
+    platform: str
+    url: str = ""
+    community: str = ""
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def fromObj(cls, value: dict[str, Any] | None) -> "CommunitySignalSource":
+        value = value or {}
+        return cls(
+            platform=str(value.get("platform", "") or ""),
+            url=str(value.get("url", "") or ""),
+            community=str(value.get("community", "") or ""),
+            metadata=value.get("metadata", {}) if isinstance(value.get("metadata", {}), dict) else {},
+        )
+
+    def toMap(self) -> dict[str, Any]:
+        return {
+            "platform": self.platform,
+            "url": self.url,
+            "community": self.community,
+            "metadata": self.metadata,
+        }
+
+
+@dataclass(frozen=True)
+class CommunitySignal:
+    signalId: str
+    source: CommunitySignalSource
+    observedAt: str
+    text: str
+    query: str = ""
+    entity: SignalEntity = SignalEntity.UNKNOWN
+    confidence: float = 0.0
+
+    @classmethod
+    def fromObj(cls, value: dict[str, Any]) -> "CommunitySignal":
+        entity = str(value.get("entity", SignalEntity.UNKNOWN.value) or SignalEntity.UNKNOWN.value)
+        return cls(
+            signalId=str(value.get("signalId", "") or ""),
+            source=CommunitySignalSource.fromObj(value.get("source") if isinstance(value.get("source"), dict) else {}),
+            observedAt=str(value.get("observedAt", "") or ""),
+            text=str(value.get("text", "") or ""),
+            query=str(value.get("query", "") or ""),
+            entity=SignalEntity(entity) if entity in SignalEntity._value2member_map_ else SignalEntity.UNKNOWN,
+            confidence=float(value.get("confidence", 0.0) or 0.0),
+        )
+
+    def toMap(self) -> dict[str, Any]:
+        return {
+            "signalId": self.signalId,
+            "source": self.source.toMap(),
+            "observedAt": self.observedAt,
+            "text": self.text,
+            "query": self.query,
+            "entity": self.entity.value,
+            "confidence": self.confidence,
+        }
+
+
+@dataclass(frozen=True)
+class SignalAnalysis:
+    signalId: str
+    entity: SignalEntity
+    confidence: float
+    matches: tuple[str, ...] = ()
+    negativeMatches: tuple[str, ...] = ()
+    reasons: tuple[str, ...] = ()
+    query: str = ""
+    source: CommunitySignalSource = field(default_factory=lambda: CommunitySignalSource(platform=""))
+    launchableDomains: tuple[str, ...] = ()
+    approvalRequired: bool = True
+
+    def toMap(self) -> dict[str, Any]:
+        return {
+            "signalId": self.signalId,
+            "entity": self.entity.value,
+            "confidence": self.confidence,
+            "matches": list(self.matches),
+            "negativeMatches": list(self.negativeMatches),
+            "reasons": list(self.reasons),
+            "query": self.query,
+            "source": self.source.toMap(),
+            "launchableDomains": list(self.launchableDomains),
+            "approvalRequired": self.approvalRequired,
+        }