eventhook 0.1.0__tar.gz

eventhook-0.1.0/.gitignore

@@ -0,0 +1,22 @@
+# Build artifacts
+dist/
+*.egg-info/
+
+# Virtual environments
+.venv/
+
+# Python bytecode
+__pycache__/
+*.pyc
+*.pyo
+
+# Test and debug artifacts
+.pytest_cache/
+FAILURE_ANALYSIS.md
+*.log
+
+# Generated proto stubs (regenerate with generate_proto.sh)
+eventhook/_proto/
+
+# Packaging lock file (not for libraries)
+uv.lock

eventhook-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: eventhook
+Version: 0.1.0
+Summary: Receive provider events in your app without exposing a public endpoint
+Project-URL: Homepage, https://eventhook.dev
+Project-URL: Repository, https://github.com/iyifr/eventhook
+Project-URL: Issues, https://github.com/iyifr/eventhook/issues
+License: MIT
+Keywords: event-driven,events,grpc,real-time,webhooks
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: cachetools<6,>=5.0
+Requires-Dist: grpcio<3,>=1.60.0
+Requires-Dist: protobuf<7,>=6.33.5

eventhook-0.1.0/eventhook/__init__.py

@@ -0,0 +1,5 @@
+from ._client import EventHooks
+from ._event import Ack, Event
+
+__version__ = "0.1.0"
+__all__ = ["EventHooks", "Ack", "Event", "__version__"]

eventhook-0.1.0/eventhook/_backoff.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import random
+
+
+class ExponentialBackoff:
+    """Full-jitter exponential backoff — never hammers the gateway on reconnect."""
+
+    def __init__(self, base: float = 1.0, cap: float = 60.0) -> None:
+        self._base = base
+        self._cap = cap
+        self._attempt = 0
+
+    def next(self) -> float:
+        ceiling = min(self._cap, self._base * (2 ** self._attempt))
+        self._attempt += 1
+        return random.uniform(0, ceiling)  # full jitter
+
+    def reset(self) -> None:
+        self._attempt = 0

eventhook-0.1.0/eventhook/_client.py

@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import hmac
+import inspect
+import logging
+import threading
+import time
+from typing import Callable
+
+import grpc
+import grpc.aio
+
+from ._backoff import ExponentialBackoff
+from ._dedup import DedupCache
+from ._event import Ack, Event
+from ._proto.eventbridge import eventbridge_pb2 as pb
+from ._proto.eventbridge import eventbridge_pb2_grpc as pb_grpc
+
+logger = logging.getLogger("eventhook")
+
+# Pre-resolved once at import time — avoids a dict alloc + proto enum lookup per event.
+_ACK_STATUS = {
+    Ack.SUCCESS: pb.Ack.Status.Value("DELIVERED"),
+    Ack.RETRY: pb.Ack.Status.Value("RETRYING"),
+    Ack.FAILED: pb.Ack.Status.Value("DEAD_LETTERED"),
+}
+
+# Keep the TCP connection alive through idle periods (long-running handlers,
+# silent stretches between events). Without this, NATs and load balancers
+# silently drop the connection and the stream appears open while being dead.
+_KEEPALIVE_OPTIONS = [
+    ("grpc.keepalive_time_ms", 20_000),
+    ("grpc.keepalive_timeout_ms", 5_000),
+    ("grpc.keepalive_permit_without_calls", True),
+]
+
+
+class EventHooks:
+    def __init__(
+        self,
+        *,
+        provider_id: str,
+        app_name: str,
+        api_key: str,
+        gateway_url: str = "localhost:50051",
+        tls: bool = False,
+        max_retries: int = 3,
+    ) -> None:
+        self._provider_id = provider_id
+        self._app_name = app_name
+        self._api_key = api_key
+        self._gateway_url = gateway_url
+        self._tls = tls
+        self._max_retries = max_retries
+
+        self._handlers: dict[str, Callable] = {}
+        self._wildcards: list[
+            tuple[str, Callable]
+        ] = []  # (prefix, handler) pre-sliced at registration
+        self._dedup = DedupCache()
+        self._backoff = ExponentialBackoff()
+        self._running = False
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._task: asyncio.Task | None = None
+        # Derived once from the raw api_key — mirrors what the ingest service stores at provisioning.
+        # Used to verify every event's HMAC before the handler is invoked.
+        self._signing_key: bytes = hmac.new(
+            api_key.encode(), b"eventhook-signing-v1", hashlib.sha256
+        ).digest()
+
+    # ── Handler registration ──────────────────────────────────────────────────
+
+    def on(self, event_type: str) -> Callable:
+        """
+        Register a handler for an event type. Supports exact match and
+        prefix wildcard (e.g. "invoice.*").
+
+        The decorated function may be sync or async. Sync handlers run in a
+        thread pool so they never block the event loop.
+
+            @hooks.on("payment.succeeded")
+            def handle(event: Event) -> Ack:
+                ...
+                return Ack.SUCCESS
+
+            @hooks.on("invoice.*")
+            async def handle(event: Event) -> Ack:
+                await some_coroutine()
+                return Ack.RETRY
+        """
+
+        def decorator(fn: Callable) -> Callable:
+            if event_type.endswith(".*"):
+                self._wildcards.append((event_type[:-1], fn))
+            else:
+                self._handlers[event_type] = fn
+            return fn
+
+        return decorator
+
+    # ── Entry points ──────────────────────────────────────────────────────────
+
+    def run(self) -> None:
+        """
+        Blocking entry point — creates its own event loop.
+        Use this for standalone scripts and Django management commands.
+
+            if __name__ == "__main__":
+                hooks.run()
+        """
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        self._run_loop(loop)
+
+    def run_in_thread(self) -> threading.Thread:
+        """
+        Starts the agent in a daemon thread with its own event loop.
+        Returns immediately. Use this for Flask and sync Django in-process.
+
+            hooks.run_in_thread()
+            app.run(port=8000)
+
+        Call stop() then join() the returned thread to ensure the session is
+        fully torn down before starting another one on the same credentials.
+        """
+
+        def _target():
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            self._run_loop(loop)
+
+        t = threading.Thread(target=_target, daemon=True, name="eventhook")
+        t.start()
+        return t
+
+    def _run_loop(self, loop: asyncio.AbstractEventLoop) -> None:
+        """Run start() on loop, then drain any tasks left pending by gRPC
+        internals before closing — mirrors what asyncio.run() does internally.
+
+        Without the drain step, gRPC's _AioCall._handle_status_once_received
+        tasks outlive the stream cancellation and emit 'Task was destroyed but
+        it is pending!' when the loop closes.
+        """
+        self._loop = loop
+        try:
+            loop.run_until_complete(self.start())
+        except asyncio.CancelledError:
+            pass
+        finally:
+            try:
+                pending = asyncio.all_tasks(loop)
+                if pending:
+                    for t in pending:
+                        t.cancel()
+                    loop.run_until_complete(
+                        asyncio.gather(*pending, return_exceptions=True)
+                    )
+            finally:
+                self._loop = None
+                loop.close()
+
+    async def start(self) -> None:
+        """
+        Async entry point — runs inside an existing event loop.
+        Use this for FastAPI lifespan, Quart, and other async frameworks.
+
+            # FastAPI
+            @asynccontextmanager
+            async def lifespan(app):
+                task = asyncio.create_task(hooks.start())
+                yield
+                hooks.stop()
+                await task
+        """
+        self._running = True
+        self._task = asyncio.current_task()
+        while self._running:
+            try:
+                await self._run_session()
+            except asyncio.CancelledError:
+                break
+            except Exception as exc:
+                if not self._running:
+                    break
+                wait = self._backoff.next()
+                logger.warning("Disconnected (%s) — reconnecting in %.1fs", exc, wait)
+                await asyncio.sleep(wait)
+
+    def stop(self) -> None:
+        """Stop the agent. Cancels the running session immediately."""
+        self._running = False
+        loop, task = self._loop, self._task
+        if loop is not None and task is not None:
+            loop.call_soon_threadsafe(task.cancel)
+
+    # ── Session lifecycle ─────────────────────────────────────────────────────
+
+    async def _run_session(self) -> None:
+        creds = (
+            grpc.ssl_channel_credentials()
+            if self._tls
+            else grpc.local_channel_credentials()
+        )
+        channel_options = _KEEPALIVE_OPTIONS
+
+        async with grpc.aio.secure_channel(
+            self._gateway_url, creds, options=channel_options
+        ) as channel:
+            stub = pb_grpc.EventBridgeStub(channel)
+            metadata = [
+                ("api_key", self._api_key),
+                ("provider_id", self._provider_id),
+                ("app_name", self._app_name),
+            ]
+            stream = stub.Subscribe(metadata=metadata)
+
+            all_subscribed = list(self._handlers.keys()) + [
+                p + "*" for p, _ in self._wildcards
+            ]
+            await stream.write(
+                pb.ClientMessage(
+                    subscribe=pb.SubscribeRequest(event_types=all_subscribed)
+                )
+            )
+
+            self._backoff.reset()
+            logger.info(
+                "Connected to %s — subscribed to %s",
+                self._gateway_url,
+                all_subscribed or ["(all)"],
+            )
+
+            while True:
+                proto_event = await stream.read()
+                if proto_event == grpc.aio.EOF:
+                    logger.info("Stream closed by gateway")
+                    break
+
+                sig_header = proto_event.metadata.get("eh-sig", "")
+                if not self._verify_signature(sig_header, proto_event.payload):
+                    logger.warning(
+                        "Signature verification failed for event %s — dead-lettering",
+                        proto_event.event_id,
+                    )
+                    await stream.write(
+                        pb.ClientMessage(
+                            ack=pb.Ack(
+                                event_id=proto_event.event_id,
+                                status=pb.Ack.Status.Value("DEAD_LETTERED"),
+                            )
+                        )
+                    )
+                    continue
+
+                event = Event._from_proto(proto_event)
+                ack = await self._dispatch(event)
+                proto_status = _ACK_STATUS[ack]
+
+                await stream.write(
+                    pb.ClientMessage(
+                        ack=pb.Ack(
+                            event_id=event.event_id,
+                            status=proto_status,
+                        )
+                    )
+                )
+
+    # Signature verification
+    def _verify_signature(self, header: str, payload: bytes) -> bool:
+        """Return True only if header carries a fresh, valid HMAC for payload."""
+        if not header:
+            return False
+        try:
+            parts = dict(kv.split("=", 1) for kv in header.split(","))
+            ts = int(parts["t"])
+            v1 = parts["v1"]
+        except (KeyError, ValueError):
+            return False
+
+        # Reject signatures outside the 5-minute replay window.
+        # Use the timestamp from the header (not event.timestamp) because it is
+        # the value that was included in the signed content.
+        age_ms = time.time() * 1000 - ts
+        if not (0 <= age_ms <= 5 * 60 * 1000):
+            return False
+
+        to_sign = f"{ts}".encode() + b"." + payload
+        expected = hmac.new(self._signing_key, to_sign, hashlib.sha256).hexdigest()
+        return hmac.compare_digest(expected, v1)
+
+    # Execute handler for event
+
+    async def _dispatch(self, event: Event) -> Ack:
+        if self._dedup.seen(event.event_id):
+            logger.debug("Duplicate event %s — skipping", event.event_id)
+            return Ack.SUCCESS
+
+        handler = self._match_handler(event.event_type)
+        if handler is None:
+            logger.warning(
+                "No handler for '%s' (event %s) — dead lettering",
+                event.event_type,
+                event.event_id,
+            )
+            return Ack.FAILED
+
+        try:
+            result = (
+                await handler(event)
+                if inspect.iscoroutinefunction(handler)
+                else await asyncio.get_running_loop().run_in_executor(
+                    None, handler, event
+                )
+            )
+            if not isinstance(result, Ack):
+                raise TypeError(f"Handler must return Ack, got {type(result).__name__}")
+        except Exception as exc:
+            logger.error(
+                "Handler for '%s' raised %s: %s",
+                event.event_type,
+                type(exc).__name__,
+                exc,
+            )
+            return self._schedule_retry(event)
+
+        if result == Ack.SUCCESS:
+            return Ack.SUCCESS
+
+        if result == Ack.FAILED:
+            return Ack.FAILED
+
+        # Ack.RETRY returned directly (internal path) — same retry budget as exception.
+        return self._schedule_retry(event)
+
+    def _schedule_retry(self, event: Event) -> Ack:
+        # Durable retry tracking
+        attempt = int(event.metadata.get("eh-retry-count", "0"))
+        if attempt < self._max_retries:
+            self._dedup.evict(
+                event.event_id
+            )  # allow the retry delivery to reach the handler
+            logger.warning(
+                "Handler failed for '%s' (attempt %d/%d) — retrying",
+                event.event_type,
+                attempt + 1,
+                self._max_retries,
+            )
+            return Ack.RETRY
+        logger.error(
+            "Handler failed for '%s' after %d attempts — dead lettering",
+            event.event_type,
+            attempt + 1,
+        )
+        return Ack.FAILED
+
+    def _match_handler(self, event_type: str) -> Callable | None:
+        if event_type in self._handlers:
+            return self._handlers[event_type]
+        for prefix, handler in self._wildcards:
+            if event_type.startswith(prefix):
+                return handler
+        return None

eventhook-0.1.0/eventhook/_dedup.py

@@ -0,0 +1,29 @@
+import time
+from collections.abc import Callable
+from cachetools import TTLCache
+
+
+class DedupCache:
+    """
+    Deduplicates events by event_id using an LRU+TTL cache.
+    Protects against at-least-once redelivery reaching the handler twice.
+    """
+
+    def __init__(
+        self,
+        maxsize: int = 2000,
+        ttl: float = 300.0,
+        timer: Callable[[], float] = time.monotonic,
+    ) -> None:
+        self._cache: TTLCache = TTLCache(maxsize=maxsize, ttl=ttl, timer=timer)
+
+    def seen(self, event_id: str) -> bool:
+        """Return True if this event_id was already seen (duplicate). Records it if not."""
+        if event_id in self._cache:
+            return True
+        self._cache[event_id] = True
+        return False
+
+    def evict(self, event_id: str) -> None:
+        """Remove event_id so a retry can reach the handler."""
+        self._cache.pop(event_id, None)

eventhook-0.1.0/eventhook/_event.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Any
+
+
+@dataclass(frozen=True)
+class Event:
+    event_id: str
+    event_type: str
+    payload: Any        # decoded from JSON bytes
+    timestamp: int      # unix ms
+    metadata: dict[str, str]
+
+    @classmethod
+    def _from_proto(cls, pb) -> "Event":
+        return cls(
+            event_id=pb.event_id,
+            event_type=pb.event_type,
+            payload=json.loads(pb.payload) if pb.payload else None,
+            timestamp=pb.timestamp,
+            metadata=dict(pb.metadata),
+        )
+
+
+class Ack(IntEnum):
+    SUCCESS = 0  # handler completed — event acknowledged
+    FAILED  = 1  # permanent failure — event dead-lettered, no retry
+    RETRY   = 2  # internal: emitted by the SDK daemon on exception/stall, not for handler authors

eventhook-0.1.0/eventhook/_proto/eventbridge/eventbridge_pb2.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: eventbridge/eventbridge.proto
+# Protobuf Python Version: 6.33.5
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    33,
+    5,
+    '',
+    'eventbridge/eventbridge.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1d\x65ventbridge/eventbridge.proto\x12\x0b\x65ventbridge\"l\n\rClientMessage\x12\x32\n\tsubscribe\x18\x01 \x01(\x0b\x32\x1d.eventbridge.SubscribeRequestH\x00\x12\x1f\n\x03\x61\x63k\x18\x02 \x01(\x0b\x32\x10.eventbridge.AckH\x00\x42\x06\n\x04\x62ody\"\'\n\x10SubscribeRequest\x12\x13\n\x0b\x65vent_types\x18\x01 \x03(\t\"\xb6\x01\n\x05\x45vent\x12\x10\n\x08\x65vent_id\x18\x01 \x01(\t\x12\x12\n\nevent_type\x18\x02 \x01(\t\x12\x0f\n\x07payload\x18\x03 \x01(\x0c\x12\x11\n\ttimestamp\x18\x04 \x01(\x03\x12\x32\n\x08metadata\x18\x05 \x03(\x0b\x32 .eventbridge.Event.MetadataEntry\x1a/\n\rMetadataEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\t:\x02\x38\x01\"z\n\x03\x41\x63k\x12\x10\n\x08\x65vent_id\x18\x01 \x01(\t\x12\'\n\x06status\x18\x02 \x01(\x0e\x32\x17.eventbridge.Ack.Status\"8\n\x06Status\x12\r\n\tDELIVERED\x10\x00\x12\x0c\n\x08RETRYING\x10\x01\x12\x11\n\rDEAD_LETTERED\x10\x02\x32N\n\x0b\x45ventBridge\x12?\n\tSubscribe\x12\x1a.eventbridge.ClientMessage\x1a\x12.eventbridge.Event(\x01\x30\x01\x42\x35Z3github.com/eventhook/stream-gateway/gen/eventbridgeb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'eventbridge.eventbridge_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'Z3github.com/eventhook/stream-gateway/gen/eventbridge'
+  _globals['_EVENT_METADATAENTRY']._loaded_options = None
+  _globals['_EVENT_METADATAENTRY']._serialized_options = b'8\001'
+  _globals['_CLIENTMESSAGE']._serialized_start=46
+  _globals['_CLIENTMESSAGE']._serialized_end=154
+  _globals['_SUBSCRIBEREQUEST']._serialized_start=156
+  _globals['_SUBSCRIBEREQUEST']._serialized_end=195
+  _globals['_EVENT']._serialized_start=198
+  _globals['_EVENT']._serialized_end=380
+  _globals['_EVENT_METADATAENTRY']._serialized_start=333
+  _globals['_EVENT_METADATAENTRY']._serialized_end=380
+  _globals['_ACK']._serialized_start=382
+  _globals['_ACK']._serialized_end=504
+  _globals['_ACK_STATUS']._serialized_start=448
+  _globals['_ACK_STATUS']._serialized_end=504
+  _globals['_EVENTBRIDGE']._serialized_start=506
+  _globals['_EVENTBRIDGE']._serialized_end=584
+# @@protoc_insertion_point(module_scope)

eventhook-0.1.0/eventhook/_proto/eventbridge/eventbridge_pb2_grpc.py

@@ -0,0 +1,97 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from . import eventbridge_pb2 as eventbridge_dot_eventbridge__pb2
+
+GRPC_GENERATED_VERSION = '1.81.0'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + ' but the generated code in eventbridge/eventbridge_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class EventBridgeStub:
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.Subscribe = channel.stream_stream(
+                '/eventbridge.EventBridge/Subscribe',
+                request_serializer=eventbridge_dot_eventbridge__pb2.ClientMessage.SerializeToString,
+                response_deserializer=eventbridge_dot_eventbridge__pb2.Event.FromString,
+                _registered_method=True)
+
+
+class EventBridgeServicer:
+    """Missing associated documentation comment in .proto file."""
+
+    def Subscribe(self, request_iterator, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_EventBridgeServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'Subscribe': grpc.stream_stream_rpc_method_handler(
+                    servicer.Subscribe,
+                    request_deserializer=eventbridge_dot_eventbridge__pb2.ClientMessage.FromString,
+                    response_serializer=eventbridge_dot_eventbridge__pb2.Event.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'eventbridge.EventBridge', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('eventbridge.EventBridge', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class EventBridge:
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def Subscribe(request_iterator,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.stream_stream(
+            request_iterator,
+            target,
+            '/eventbridge.EventBridge/Subscribe',
+            eventbridge_dot_eventbridge__pb2.ClientMessage.SerializeToString,
+            eventbridge_dot_eventbridge__pb2.Event.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

eventhook-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[project]
+name = "eventhook"
+version = "0.1.0"
+description = "Receive provider events in your app without exposing a public endpoint"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+keywords = ["webhooks", "events", "grpc", "real-time", "event-driven"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    "grpcio>=1.60.0,<3",
+    "protobuf>=6.33.5,<7",
+    "cachetools>=5.0,<6",
+]
+
+[project.urls]
+Homepage = "https://eventhook.dev"
+Repository = "https://github.com/iyifr/eventhook"
+Issues = "https://github.com/iyifr/eventhook/issues"
+
+[dependency-groups]
+dev = [
+    "grpcio-tools>=1.60.0,<3",
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+artifacts = ["eventhook/_proto/**"]
+
+[tool.hatch.build.targets.wheel]
+include = ["eventhook/**"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/eventhook",
+    "/pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"