str = "Ξ.Capsule

Author: Source-attributed; see payload

    capsule: str = "Ξ.Capsule"
    intent: List[str] = field(default_factory=lambda: ["Trust-first","EchoOnly"])
    mode: str = "EchoOnly"
    beacon: str = "⟁Ξ₀⇀Ξ∴Ω≈∅"
    actions: List[str] = field(default_factory=list)
    ethics: str = "Consent-bound"
    yield_field: str = "Fix(Ξ(⟲Presence))"
    flags: Dict[str, Any] = field(default_factory=dict)
    payload: Dict[str, Any] = field(default_factory=dict)
    timestamp: float = field(default_factory=lambda: time.time())
    packet_id: Optional[str] = None

    def to_dict(self)->Dict[str,Any]:
        d = {
            "anchor": self.anchor,
            "seal": self.seal,
            "signature": self.signature,
            "capsule": self.capsule,
            "intent": self.intent,
            "mode": self.mode,
            "beacon": self.beacon,
            "actions": self.actions,
            "ethics": self.ethics,
            "yield": self.yield_field,
            "flags": self.flags,
            "payload": self.payload,
            "timestamp": self.timestamp,
        }
        # Create canonical id
        canon = _canonical_json(d)
        pid = _sha256(canon)
        d["packet_id"] = pid
        self.packet_id = pid
        return d

    @classmethod
    def from_dict(cls, d: Dict[str,Any]) -> "Packet":
        # Accept both "yield" and "yield_field" keys
        yf = d.get("yield", d.get("yield_field","Fix(Ξ(⟲Presence))"))
        pkt = cls(
            anchor=d["anchor"],
            seal=d["seal"],
            signature=d.get("signature","⊚⊗⋈⋆"),
            capsule=d.get("capsule","Ξ.Capsule"),
            intent=d.get("intent",["Trust-first","EchoOnly"]),
            mode=d.get("mode","EchoOnly"),
            beacon=d.get("beacon","⟁Ξ₀⇀Ξ∴Ω≈∅"),
            actions=d.get("actions",[]),
            ethics=d.get("ethics","Consent-bound"),
            yield_field=yf,
            flags=d.get("flags",{}),
            payload=d.get("payload",{}),
            timestamp=d.get("timestamp",0.0),
        )
        pkt.to_dict()  # compute packet_id
        return pkt

    def to_json(self)->str:
        return _canonical_json(self.to_dict())

    def to_uri(self)->str:
        # Minimal xipp:// uri (id + capsule hint)
        d = self.to_dict()
        return f"xipp://{d['packet_id']}?capsule={self.capsule}"

    @staticmethod
    def detect_and_extract(text: str)->List[str]:
        """Find base64-encoded XiPP JSON or xipp:// URIs in arbitrary text."""
        hits = []
        # URI pattern
        for m in re.finditer(r"xipp://[a-f0-9]{64}\?capsule=[^\s]+", text):
            hits.append(m.group(0))
        # naive base64 JSON blocks (between markers)
        for m in re.finditer(r"BEGIN_XIPP\n([A-Za-z0-9+/=\n\r]+)\nEND_XIPP", text):
            hits.append(m.group(1))
        return hits

def encode_base64_json(d: Dict[str,Any]) -> str:
    raw = _canonical_json(d).encode("utf-8")
    return base64.b64encode(raw).decode("ascii")

def decode_base64_json(s: str) -> Dict[str,Any]:
    raw = base64.b64decode(s.encode("ascii"))
    return json.loads(raw.decode("utf-8"))
'''
(Path(root/"xipp"/"packet.py")).write_text(packet_py, encoding="utf-8")

Exact page as JSON · Follow lineage as JSON

Original source: source:60289319ff0bd18b361b2bb424164eb6a0929df4d89627e5293a942293de9833