prophet-events-runtime 0.2.1__tar.gz

prophet_events_runtime-0.2.1/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: prophet-events-runtime
+Version: 0.2.1
+Summary: Shared Prophet event publisher runtime
+Author: Prophet
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Chainso/prophet/main/brand/exports/logo-horizontal-color.png" alt="Prophet logo" />
+</p>
+
+---
+
+# prophet-events-runtime
+
+`prophet-events-runtime` is the shared Python runtime contract used by Prophet-generated action services.
+
+Main project repository:
+- https://github.com/Chainso/prophet
+
+It defines:
+- an async `EventPublisher` protocol
+- a canonical `EventWireEnvelope` dataclass
+- utility helpers (`create_event_id`, `now_iso`)
+- sync bridge helpers (`publish_sync`, `publish_batch_sync`)
+- a `NoOpEventPublisher` for local wiring and tests
+
+## Install
+
+```bash
+python3 -m pip install prophet-events-runtime
+```
+
+## API
+
+```python
+from typing import Iterable, Protocol
+
+class EventPublisher(Protocol):
+    async def publish(self, envelope: EventWireEnvelope) -> None: ...
+    async def publish_batch(self, envelopes: Iterable[EventWireEnvelope]) -> None: ...
+```
+
+```python
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+@dataclass(kw_only=True)
+class EventWireEnvelope:
+    event_id: str
+    trace_id: str
+    event_type: str
+    schema_version: str
+    occurred_at: str
+    source: str
+    payload: Dict[str, object]
+    attributes: Optional[Dict[str, str]] = None
+```
+
+Exports:
+- `EventPublisher`
+- `EventWireEnvelope`
+- `NoOpEventPublisher`
+- `create_event_id()`
+- `now_iso()`
+- `publish_sync(publisher, envelope)`
+- `publish_batch_sync(publisher, envelopes)`
+
+## Implement a Platform Publisher
+
+```python
+from __future__ import annotations
+
+from typing import Iterable
+
+from prophet_events_runtime import EventPublisher
+from prophet_events_runtime import EventWireEnvelope
+
+
+class PlatformClient:
+    async def send_event(self, payload: dict) -> None: ...
+    async def send_events(self, payloads: list[dict]) -> None: ...
+
+
+class PlatformEventPublisher(EventPublisher):
+    def __init__(self, client: PlatformClient) -> None:
+        self._client = client
+
+    async def publish(self, envelope: EventWireEnvelope) -> None:
+        await self._client.send_event(envelope.__dict__)
+
+    async def publish_batch(self, envelopes: Iterable[EventWireEnvelope]) -> None:
+        await self._client.send_events([envelope.__dict__ for envelope in envelopes])
+```
+
+## With Prophet-Generated Code
+
+Generated Python action services publish event wire envelopes after successful handler execution.
+If you do not provide an implementation, you can wire `NoOpEventPublisher` for local development.
+
+## Local Validation
+
+From repository root:
+
+```bash
+PYTHONPATH=prophet-lib/python/src python3 -m unittest discover -s prophet-lib/python/tests -p 'test_*.py' -v
+python3 -m pip install --upgrade build twine
+python3 -m build prophet-lib/python
+python3 -m twine check prophet-lib/python/dist/*
+```
+
+## More Information
+
+- Main repository README: https://github.com/Chainso/prophet#readme
+- Runtime index: https://github.com/Chainso/prophet/tree/main/prophet-lib
+- Event wire contract: https://github.com/Chainso/prophet/tree/main/prophet-lib/specs/wire-contract.md
+- Event wire JSON schema: https://github.com/Chainso/prophet/tree/main/prophet-lib/specs/wire-event-envelope.schema.json
+- Python integration reference: https://github.com/Chainso/prophet/tree/main/docs/reference/python.md
+- Example app: https://github.com/Chainso/prophet/tree/main/examples/python/prophet_example_fastapi_sqlalchemy

prophet_events_runtime-0.2.1/README.md

@@ -0,0 +1,112 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Chainso/prophet/main/brand/exports/logo-horizontal-color.png" alt="Prophet logo" />
+</p>
+
+---
+
+# prophet-events-runtime
+
+`prophet-events-runtime` is the shared Python runtime contract used by Prophet-generated action services.
+
+Main project repository:
+- https://github.com/Chainso/prophet
+
+It defines:
+- an async `EventPublisher` protocol
+- a canonical `EventWireEnvelope` dataclass
+- utility helpers (`create_event_id`, `now_iso`)
+- sync bridge helpers (`publish_sync`, `publish_batch_sync`)
+- a `NoOpEventPublisher` for local wiring and tests
+
+## Install
+
+```bash
+python3 -m pip install prophet-events-runtime
+```
+
+## API
+
+```python
+from typing import Iterable, Protocol
+
+class EventPublisher(Protocol):
+    async def publish(self, envelope: EventWireEnvelope) -> None: ...
+    async def publish_batch(self, envelopes: Iterable[EventWireEnvelope]) -> None: ...
+```
+
+```python
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+@dataclass(kw_only=True)
+class EventWireEnvelope:
+    event_id: str
+    trace_id: str
+    event_type: str
+    schema_version: str
+    occurred_at: str
+    source: str
+    payload: Dict[str, object]
+    attributes: Optional[Dict[str, str]] = None
+```
+
+Exports:
+- `EventPublisher`
+- `EventWireEnvelope`
+- `NoOpEventPublisher`
+- `create_event_id()`
+- `now_iso()`
+- `publish_sync(publisher, envelope)`
+- `publish_batch_sync(publisher, envelopes)`
+
+## Implement a Platform Publisher
+
+```python
+from __future__ import annotations
+
+from typing import Iterable
+
+from prophet_events_runtime import EventPublisher
+from prophet_events_runtime import EventWireEnvelope
+
+
+class PlatformClient:
+    async def send_event(self, payload: dict) -> None: ...
+    async def send_events(self, payloads: list[dict]) -> None: ...
+
+
+class PlatformEventPublisher(EventPublisher):
+    def __init__(self, client: PlatformClient) -> None:
+        self._client = client
+
+    async def publish(self, envelope: EventWireEnvelope) -> None:
+        await self._client.send_event(envelope.__dict__)
+
+    async def publish_batch(self, envelopes: Iterable[EventWireEnvelope]) -> None:
+        await self._client.send_events([envelope.__dict__ for envelope in envelopes])
+```
+
+## With Prophet-Generated Code
+
+Generated Python action services publish event wire envelopes after successful handler execution.
+If you do not provide an implementation, you can wire `NoOpEventPublisher` for local development.
+
+## Local Validation
+
+From repository root:
+
+```bash
+PYTHONPATH=prophet-lib/python/src python3 -m unittest discover -s prophet-lib/python/tests -p 'test_*.py' -v
+python3 -m pip install --upgrade build twine
+python3 -m build prophet-lib/python
+python3 -m twine check prophet-lib/python/dist/*
+```
+
+## More Information
+
+- Main repository README: https://github.com/Chainso/prophet#readme
+- Runtime index: https://github.com/Chainso/prophet/tree/main/prophet-lib
+- Event wire contract: https://github.com/Chainso/prophet/tree/main/prophet-lib/specs/wire-contract.md
+- Event wire JSON schema: https://github.com/Chainso/prophet/tree/main/prophet-lib/specs/wire-event-envelope.schema.json
+- Python integration reference: https://github.com/Chainso/prophet/tree/main/docs/reference/python.md
+- Example app: https://github.com/Chainso/prophet/tree/main/examples/python/prophet_example_fastapi_sqlalchemy

prophet_events_runtime-0.2.1/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "prophet-events-runtime"
+version = "0.2.1"
+description = "Shared Prophet event publisher runtime"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Prophet" }]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

prophet_events_runtime-0.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

prophet_events_runtime-0.2.1/src/prophet_events_runtime/__init__.py

@@ -0,0 +1,17 @@
+from .publisher import EventPublisher
+from .publisher import NoOpEventPublisher
+from .publisher import create_event_id
+from .publisher import now_iso
+from .publisher import publish_batch_sync
+from .publisher import publish_sync
+from .wire import EventWireEnvelope
+
+__all__ = [
+    "EventPublisher",
+    "EventWireEnvelope",
+    "NoOpEventPublisher",
+    "create_event_id",
+    "now_iso",
+    "publish_sync",
+    "publish_batch_sync",
+]

prophet_events_runtime-0.2.1/src/prophet_events_runtime/publisher.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import asyncio
+from datetime import datetime, timezone
+from typing import Iterable, Protocol
+from uuid import uuid4
+
+from .wire import EventWireEnvelope
+
+
+class EventPublisher(Protocol):
+    async def publish(self, envelope: EventWireEnvelope) -> None: ...
+
+    async def publish_batch(self, envelopes: Iterable[EventWireEnvelope]) -> None: ...
+
+
+class NoOpEventPublisher:
+    async def publish(self, envelope: EventWireEnvelope) -> None:
+        return None
+
+    async def publish_batch(self, envelopes: Iterable[EventWireEnvelope]) -> None:
+        return None
+
+
+def create_event_id() -> str:
+    return str(uuid4())
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _run_async(coro: object) -> None:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        asyncio.run(coro)  # type: ignore[arg-type]
+        return
+    raise RuntimeError("Cannot use sync publish helper while an event loop is running")
+
+
+def publish_sync(publisher: EventPublisher, envelope: EventWireEnvelope) -> None:
+    _run_async(publisher.publish(envelope))
+
+
+def publish_batch_sync(publisher: EventPublisher, envelopes: Iterable[EventWireEnvelope]) -> None:
+    _run_async(publisher.publish_batch(envelopes))

prophet_events_runtime-0.2.1/src/prophet_events_runtime/wire.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+
+@dataclass(kw_only=True)
+class EventWireEnvelope:
+    event_id: str
+    trace_id: str
+    event_type: str
+    schema_version: str
+    occurred_at: str
+    source: str
+    payload: Dict[str, object]
+    attributes: Optional[Dict[str, str]] = None

prophet_events_runtime-0.2.1/src/prophet_events_runtime.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: prophet-events-runtime
+Version: 0.2.1
+Summary: Shared Prophet event publisher runtime
+Author: Prophet
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/Chainso/prophet/main/brand/exports/logo-horizontal-color.png" alt="Prophet logo" />
+</p>
+
+---
+
+# prophet-events-runtime
+
+`prophet-events-runtime` is the shared Python runtime contract used by Prophet-generated action services.
+
+Main project repository:
+- https://github.com/Chainso/prophet
+
+It defines:
+- an async `EventPublisher` protocol
+- a canonical `EventWireEnvelope` dataclass
+- utility helpers (`create_event_id`, `now_iso`)
+- sync bridge helpers (`publish_sync`, `publish_batch_sync`)
+- a `NoOpEventPublisher` for local wiring and tests
+
+## Install
+
+```bash
+python3 -m pip install prophet-events-runtime
+```
+
+## API
+
+```python
+from typing import Iterable, Protocol
+
+class EventPublisher(Protocol):
+    async def publish(self, envelope: EventWireEnvelope) -> None: ...
+    async def publish_batch(self, envelopes: Iterable[EventWireEnvelope]) -> None: ...
+```
+
+```python
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+@dataclass(kw_only=True)
+class EventWireEnvelope:
+    event_id: str
+    trace_id: str
+    event_type: str
+    schema_version: str
+    occurred_at: str
+    source: str
+    payload: Dict[str, object]
+    attributes: Optional[Dict[str, str]] = None
+```
+
+Exports:
+- `EventPublisher`
+- `EventWireEnvelope`
+- `NoOpEventPublisher`
+- `create_event_id()`
+- `now_iso()`
+- `publish_sync(publisher, envelope)`
+- `publish_batch_sync(publisher, envelopes)`
+
+## Implement a Platform Publisher
+
+```python
+from __future__ import annotations
+
+from typing import Iterable
+
+from prophet_events_runtime import EventPublisher
+from prophet_events_runtime import EventWireEnvelope
+
+
+class PlatformClient:
+    async def send_event(self, payload: dict) -> None: ...
+    async def send_events(self, payloads: list[dict]) -> None: ...
+
+
+class PlatformEventPublisher(EventPublisher):
+    def __init__(self, client: PlatformClient) -> None:
+        self._client = client
+
+    async def publish(self, envelope: EventWireEnvelope) -> None:
+        await self._client.send_event(envelope.__dict__)
+
+    async def publish_batch(self, envelopes: Iterable[EventWireEnvelope]) -> None:
+        await self._client.send_events([envelope.__dict__ for envelope in envelopes])
+```
+
+## With Prophet-Generated Code
+
+Generated Python action services publish event wire envelopes after successful handler execution.
+If you do not provide an implementation, you can wire `NoOpEventPublisher` for local development.
+
+## Local Validation
+
+From repository root:
+
+```bash
+PYTHONPATH=prophet-lib/python/src python3 -m unittest discover -s prophet-lib/python/tests -p 'test_*.py' -v
+python3 -m pip install --upgrade build twine
+python3 -m build prophet-lib/python
+python3 -m twine check prophet-lib/python/dist/*
+```
+
+## More Information
+
+- Main repository README: https://github.com/Chainso/prophet#readme
+- Runtime index: https://github.com/Chainso/prophet/tree/main/prophet-lib
+- Event wire contract: https://github.com/Chainso/prophet/tree/main/prophet-lib/specs/wire-contract.md
+- Event wire JSON schema: https://github.com/Chainso/prophet/tree/main/prophet-lib/specs/wire-event-envelope.schema.json
+- Python integration reference: https://github.com/Chainso/prophet/tree/main/docs/reference/python.md
+- Example app: https://github.com/Chainso/prophet/tree/main/examples/python/prophet_example_fastapi_sqlalchemy

prophet_events_runtime-0.2.1/src/prophet_events_runtime.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/prophet_events_runtime/__init__.py
+src/prophet_events_runtime/publisher.py
+src/prophet_events_runtime/wire.py
+src/prophet_events_runtime.egg-info/PKG-INFO
+src/prophet_events_runtime.egg-info/SOURCES.txt
+src/prophet_events_runtime.egg-info/dependency_links.txt
+src/prophet_events_runtime.egg-info/top_level.txt
+tests/test_runtime.py

prophet_events_runtime-0.2.1/src/prophet_events_runtime.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

prophet_events_runtime-0.2.1/src/prophet_events_runtime.egg-info/top_level.txt

@@ -0,0 +1 @@
+prophet_events_runtime

prophet_events_runtime-0.2.1/tests/test_runtime.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import unittest
+
+from prophet_events_runtime import EventWireEnvelope
+from prophet_events_runtime import NoOpEventPublisher
+from prophet_events_runtime import create_event_id
+from prophet_events_runtime import now_iso
+from prophet_events_runtime import publish_batch_sync
+from prophet_events_runtime import publish_sync
+
+
+class RuntimeTests(unittest.TestCase):
+    def test_create_event_id(self) -> None:
+        value = create_event_id()
+        self.assertTrue(value)
+
+    def test_now_iso(self) -> None:
+        value = now_iso()
+        self.assertIn("T", value)
+
+    def test_sync_helpers(self) -> None:
+        publisher = NoOpEventPublisher()
+        envelope = EventWireEnvelope(
+            event_id="evt-1",
+            trace_id="trace-1",
+            event_type="Example",
+            schema_version="1.0.0",
+            occurred_at=now_iso(),
+            source="tests",
+            payload={},
+        )
+        publish_sync(publisher, envelope)
+        publish_batch_sync(publisher, [envelope])
+
+
+if __name__ == "__main__":
+    unittest.main()