beepgrid 0.1.0__py3-none-any.whl

beepgrid/__init__.py

@@ -0,0 +1,356 @@
+"""Beep Grid's dependency-free synchronous application and worker client."""
+from __future__ import annotations
+import json
+import http.client
+import time
+import uuid
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Callable
+
+
+class NotifError(Exception):
+    def __init__(self, code: str, message: str, status: int):
+        super().__init__(f"{code}: {message}")
+        self.code, self.message, self.status = code, message, status
+
+
+class _NoRedirect(urllib.request.HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None
+
+
+def _open(request, *, timeout):
+    # A bearer credential must never follow a redirect to another origin.
+    return urllib.request.build_opener(_NoRedirect()).open(request, timeout=timeout)
+
+
+class Client:
+    def __init__(self, base_url: str, token: str, timeout: float = 20):
+        parsed = urllib.parse.urlsplit(base_url)
+        if parsed.scheme not in ("http", "https") or not parsed.netloc or parsed.username:
+            raise ValueError("Invalid Beep Grid server URL")
+        self.base_url, self._token, self.timeout = base_url.rstrip("/"), token, timeout
+
+    def credentials(self) -> list[dict[str, Any]]:
+        """List permitted metadata without retrieving secrets."""
+        return self.call("GET", "/api/v1/credentials")
+
+    def create_credential(self, principal_id: str, *, kind: str = "api", name: str = "", **options) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/credentials", dict(principal_id=principal_id, kind=kind, name=name, **options))
+
+    def edit_credential(self, credential_id: str, *, version: int, **changes) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/credentials/" + urllib.parse.quote(credential_id, safe="") + "/edit", dict(version=version, **changes))
+
+    def rotate_credential(self, credential_id: str, *, version: int, overlap_seconds: int = 3600) -> dict[str, Any]:
+        """Returns a secret once; does not automatically retry an uncertain write."""
+        return self.call("POST", "/api/v1/credentials/" + urllib.parse.quote(credential_id, safe="") + "/rotate", dict(version=version, overlap_seconds=overlap_seconds))
+
+    def revoke_credential(self, credential_id: str, *, revoke_workers: bool = False) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/credentials/" + urllib.parse.quote(credential_id, safe="") + "/revoke", dict(revoke_workers=revoke_workers))
+
+    def renew_credential(self) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/credentials/self/renew", {})
+
+    def delivery_preferences(self, person_id: str) -> dict[str, Any]:
+        """Read your channel defaults and ordered Agent/Agent-role overrides."""
+        return self.call("GET", "/api/v1/people/" + urllib.parse.quote(person_id, safe="") + "/delivery-preferences")
+
+    def save_delivery_preferences(self, person_id: str, preferences: dict[str, Any]) -> dict[str, Any]:
+        """Save the observed version. This never grants communication access."""
+        return self.call("POST", "/api/v1/people/" + urllib.parse.quote(person_id, safe="") + "/delivery-preferences", preferences)
+
+    def call(self, method: str, path: str, data: Any = None, *, key: str | None = None, minimal: bool = False, timeout: float | None = None) -> Any:
+        if not path.startswith("/api/v1/"):
+            raise ValueError("Invalid API path")
+        raw = json.dumps(data).encode() if data is not None else None
+        headers = {"Content-Type": "application/json", "Authorization": "Bearer " + self._token,
+                   "User-Agent": "BeepgridPython/0.1.0"}
+        if minimal:
+            headers["Prefer"] = "return=minimal"
+        if key:
+            headers["Idempotency-Key"] = key
+        for attempt in range(3):
+            req = urllib.request.Request(self.base_url + path, raw, headers, method=method)
+            try:
+                with _open(req, timeout=self.timeout if timeout is None else timeout) as response:
+                    return json.load(response)
+            except urllib.error.HTTPError as error:
+                try:
+                    with error:
+                        detail = json.load(error).get("error", {})
+                except (ValueError, AttributeError):
+                    detail = {}
+                raise NotifError(detail.get("code", "HTTP_ERROR"), detail.get("message", "Request failed"), error.code) from error
+            except (urllib.error.URLError, TimeoutError, ConnectionError, http.client.IncompleteRead):
+                if attempt == 2 or (method != "GET" and not key):
+                    raise
+                time.sleep(.2 * (attempt + 1))
+        raise RuntimeError("Request attempts exhausted")
+
+    def events(self, **options: Any):
+        """Yield canonical events. Save sequence only after applying each event."""
+        from .events import read_events
+        return read_events(self, **options)
+
+    def start_chat(self, *, targets: list[dict[str, str]], body: str, title: str = "", approval: bool = False,
+                   choices: list[str] | None = None, mentions: list[dict[str, Any]] | None = None,
+                   attachment_ids: list[str] | None = None,
+                   key: str | None = None) -> dict[str, Any]:
+        """Start shared history. Mention offsets are code points; all members receive it."""
+        data: dict[str, Any] = {"targets": targets, "body": body}
+        if title: data["title"] = title
+        if approval: data["approval"] = True
+        if choices is not None: data["choices"] = choices
+        if mentions is not None: data["mentions"] = mentions
+        if attachment_ids is not None: data["attachment_ids"] = attachment_ids
+        return self.call("POST", "/api/v1/conversations", data, key=key or str(uuid.uuid4()))
+
+    def change_chat_membership(self, conversation_id: str, *, operation: str, version: int, title: str = "",
+                               members: list[str] | None = None, share_history: bool = False,
+                               next_manager: str = "", key: str | None = None) -> dict[str, Any]:
+        """Change shared disclosure, never IAM. Earlier history is shared only by explicit opt-in."""
+        data: dict[str, Any] = {"operation": operation, "version": version}
+        if title: data["title"] = title
+        if members is not None: data["members"] = members
+        if share_history: data["share_history"] = True
+        if next_manager: data["next_manager"] = next_manager
+        return self.call("POST", "/api/v1/conversations/" + urllib.parse.quote(conversation_id, safe="") + "/membership", data, key=key or str(uuid.uuid4()))
+
+    def attachments(self, conversation_id: str) -> list[dict[str, Any]]:
+        return self.call("GET", "/api/v1/conversations/" + urllib.parse.quote(conversation_id, safe="") + "/attachments")
+
+    def upload_attachment(self, conversation_id: str, name: str, media: str, data: bytes) -> dict[str, Any]:
+        """No automatic retry: list attachments after an unknown upload outcome."""
+        return self._upload_attachment("/api/v1/conversations/" + urllib.parse.quote(conversation_id, safe="") + "/attachments", name, media, data)
+
+    def stage_attachment(self, name: str, media: str, data: bytes) -> dict[str, Any]:
+        """Private draft for attachment_ids. No automatic retry; unused drafts expire after 24 hours."""
+        return self._upload_attachment("/api/v1/attachments", name, media, data)
+
+    def _upload_attachment(self, path: str, name: str, media: str, data: bytes) -> dict[str, Any]:
+        if not data or len(data) > 5 * 1024 * 1024 or any(ch in name + media for ch in "\r\n"):
+            raise ValueError("Invalid attachment or size exceeds 5 MiB")
+        boundary = "beepgrid-" + uuid.uuid4().hex
+        escaped = name.replace("\\", "\\\\").replace('"', '\\"')
+        header = ('--' + boundary + '\r\nContent-Disposition: form-data; name="file"; filename="' + escaped + '"\r\nContent-Type: ' + media + '\r\n\r\n').encode()
+        raw = header + data + ("\r\n--" + boundary + "--\r\n").encode()
+        return json.loads(self._file_request("POST", path, raw, "multipart/form-data; boundary=" + boundary))
+
+    def download_attachment(self, attachment_id: str) -> bytes:
+        return self._file_request("GET", "/api/v1/attachments/" + urllib.parse.quote(attachment_id, safe=""))
+
+    def _file_request(self, method: str, path: str, data=None, content_type="") -> bytes:
+        headers = {"Authorization": "Bearer " + self._token, "User-Agent": "BeepgridPython/0.1.0"}
+        if content_type: headers["Content-Type"] = content_type
+        req = urllib.request.Request(self.base_url + path, data=data, headers=headers, method=method)
+        try:
+            with _open(req, timeout=self.timeout) as response:
+                raw = response.read(5 * 1024 * 1024 + 1)
+                if len(raw) > 5 * 1024 * 1024: raise ValueError("Attachment response exceeds 5 MiB")
+                return raw
+        except urllib.error.HTTPError as error:
+            with error:
+                try: detail = json.loads(error.read(65536)).get("error", {})
+                except (ValueError, AttributeError): detail = {}
+            raise NotifError(detail.get("code", "HTTP_ERROR"), detail.get("message", "Attachment request rejected"), error.code) from error
+
+    def directory(self, kind: str, search: str = "") -> dict[str, Any]:
+        if kind not in ("agent", "person", "service"): raise ValueError("Invalid identity kind")
+        return self.query("people" if kind == "person" else kind + "s", search=search)
+
+    def conversation(self, conversation_id: str) -> dict[str, Any]:
+        return self.call("GET", "/api/v1/conversations/" + urllib.parse.quote(conversation_id, safe=""))
+
+    def provider_catalog(self) -> list[dict[str, Any]]:
+        return self.call("GET", "/api/v1/integrations/catalog")
+
+    def connection_setup(self, connection_id: str) -> dict[str, Any]:
+        return self.call("GET", "/api/v1/connections/" + urllib.parse.quote(connection_id, safe="") + "/setup")
+
+    def replace_request(self, request_id: str, version: int, body: str, *, key: str | None = None, mentions: list[dict[str, Any]] | None = None) -> dict[str, Any]:
+        """Replace an own pending request. Retain key when retrying an unknown result."""
+        payload = {"version": version, "body": body}
+        if mentions is not None:
+            payload["mentions"] = mentions
+        return self.call("POST", "/api/v1/requests/" + urllib.parse.quote(request_id, safe="") + "/replace", payload, key=key or str(uuid.uuid4()))
+
+    def cancel(self, request_id: str, version: int) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/requests/" + urllib.parse.quote(request_id, safe="") + "/cancel", {"version": version})
+
+    def query(self, collection: str, **options: Any) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/query", {"collection": collection, **options})
+
+    def capabilities(self, **options: Any) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/capabilities", options)
+
+    def preview_contact_permissions(self, subject: dict[str, str], *, rules: list[dict[str, str]] | None = None,
+                                    version: int = 0, targets: list[dict[str, str]] | None = None) -> dict[str, Any]:
+        data: dict[str, Any] = {"subject": subject, "version": version, "targets": targets or []}
+        if rules is not None:
+            data["rules"] = rules
+        return self.call("POST", "/api/v1/contact-permissions/preview", data)
+
+    def save_contact_permissions(self, subject: dict[str, str], rules: list[dict[str, str]], *, version: int) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/contact-permissions", {"subject": subject, "rules": rules, "version": version})
+
+    def access(self, subject_id: str = "") -> dict[str, Any]:
+        return self.call("GET", "/api/v1/access?subject_id=" + urllib.parse.quote(subject_id, safe=""))
+
+    def dispatch_preview(self, targets: list[dict[str, str]], operation: str, **options: Any) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/dispatch-preview", {"targets": targets, "operation": operation, **options})
+
+    def send_batch(self, targets: list[dict[str, str]], body: str, *, key: str | None = None, **options: Any) -> list[dict[str, Any]]:
+        return self.call("POST", "/api/v1/message-batches", {"targets": targets, "body": body, **options}, key=key or str(uuid.uuid4()))
+
+    def ask_batch(self, targets: list[dict[str, str]], request: dict[str, Any], *, key: str | None = None, **options: Any) -> list[dict[str, Any]]:
+        return self.call("POST", "/api/v1/request-batches", {"targets": targets, "request": request, **options}, key=key or str(uuid.uuid4()))
+
+    def request_trace(self, request_id: str, cursor: str = "") -> dict[str, Any]:
+        return self.call("GET", "/api/v1/requests/" + urllib.parse.quote(request_id, safe="") + "/trace?delivery_cursor=" + urllib.parse.quote(cursor, safe=""))
+
+    def workspace(self) -> dict[str, Any]:
+        return self.call("GET", "/api/v1/workspace")
+
+    def account(self) -> dict[str, Any]:
+        return self.call("GET", "/api/v1/workspace/account")
+
+    def connect(self, agent: str, name: str, capabilities: list[str] | None = None,
+                metadata: dict[str, Any] | None = None, *, renewable: bool = False,
+                expires_at: str | None = None, connection_name: str = "", never_expires: bool = False) -> tuple[Client, dict[str, Any]]:
+        data = {"agent": agent, "name": name, "capabilities": capabilities or [], "metadata": metadata or {}, "renewable": renewable, "connection_name": connection_name, "never_expires": never_expires}
+        if expires_at is not None:
+            data["expires_at"] = expires_at
+        session = self.call("POST", "/api/v1/sessions", data)
+        return Client(self.base_url, session["token"], self.timeout), session
+
+    def send(self, *, body: str, target: dict[str, str] | None = None, conversation_id: str = "",
+             title: str = "", key: str | None = None, minimal: bool = False, preview_token: str = "", mentions: list[dict[str, Any]] | None = None, reuse_direct: bool = False, attachment_ids: list[str] | None = None) -> dict[str, Any]:
+        data: dict[str, Any] = {"body": body, "conversation_id": conversation_id, "title": title}
+        if mentions:
+            data["mentions"] = mentions
+        if reuse_direct:
+            data["reuse_direct"] = True
+        if attachment_ids is not None:
+            data["attachment_ids"] = attachment_ids
+        if target:
+            data["target"] = target
+        if preview_token:
+            data["preview_token"] = preview_token
+        return self.call("POST", "/api/v1/messages", data, key=key or str(uuid.uuid4()), minimal=minimal)
+
+    def notify(self, **options: Any) -> dict[str, Any]:
+        """Durable acceptance only. send with the same input/key recovers the full receipt."""
+        return self.send(**{**options, "minimal": True})
+
+    def ask(self, *, target: dict[str, str] | None = None, title: str = "", key: str | None = None, **options: Any) -> dict[str, Any]:
+        """Use target for a new dispatch or conversation_id for an existing chat."""
+        data = {"title": title, **options}
+        if target is not None:
+            data["target"] = target
+        return self.call("POST", "/api/v1/requests", data, key=key or str(uuid.uuid4()))
+
+    def set_request_blocking(self, request_id: str, blocking: bool) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/requests/" + urllib.parse.quote(request_id, safe="") + "/blocking", {"blocking": blocking})
+
+    def coordinate(self, prompt: str, *, key: str | None = None, **options: Any) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/fleet/coordinate", {"prompt": prompt, **options}, key=key or str(uuid.uuid4()), timeout=max(40, self.timeout))
+
+    def get_request(self, request_id: str) -> dict[str, Any]:
+        return self.call("GET", "/api/v1/requests/" + urllib.parse.quote(request_id, safe=""))
+
+    def respond(self, request_id: str, outcome: str, *, version: int, answer: Any = None) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/requests/" + urllib.parse.quote(request_id, safe="") + "/responses",
+                         {"outcome": outcome, "version": version, "answer": answer})
+
+    def assistance(self) -> dict[str, Any]:
+        return self.call("GET", "/api/v1/assistance/settings")
+
+    def update_assistance(self, *, overseer: bool | None = None, version: int | None = None) -> dict[str, Any]:
+        settings = {key: value for key, value in {"overseer": overseer, "version": version}.items() if value is not None}
+        return self.call("POST", "/api/v1/assistance/settings", settings)
+
+    def plan_overseer(self, prompt: str, target: dict[str, str] | None = None, *, previous_plan_id: str | None = None, key: str | None = None) -> dict[str, Any]:
+        data: dict[str, Any] = {"prompt": prompt}
+        if target is not None:
+            data["target"] = target
+        if previous_plan_id is not None:
+            data["previous_plan_id"] = previous_plan_id
+        options = {"key": key} if key is not None else {}
+        return self.call("POST", "/api/v1/fleet/plan", data, timeout=max(40, self.timeout), **options)
+
+    def overseer_plans(self) -> list[dict[str, Any]]:
+        return self.call("GET", "/api/v1/fleet/plans")
+
+    def overseer_plan(self, plan_id: str) -> dict[str, Any]:
+        return self.call("GET", "/api/v1/fleet/plans/" + urllib.parse.quote(plan_id, safe=""))
+
+    def confirm_overseer(self, plan_id: str) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/fleet/command", {"plan_id": plan_id})
+
+    def summarize_overseer(self, plan_id: str) -> dict[str, Any]:
+        return self.call("POST", "/api/v1/fleet/plans/" + urllib.parse.quote(plan_id, safe="") + "/summary",
+                         {}, timeout=max(40, self.timeout))
+
+    def redeem(self, request_id: str, action: dict[str, Any]) -> dict[str, Any]:
+        """Recheck authorization; the business tool must enforce operation/version fences."""
+        return self.call("POST", "/api/v1/requests/" + urllib.parse.quote(request_id, safe="") + "/redeem",
+                         action, key=str(uuid.uuid4()))
+
+    def report_execution(self, execution_id: str, state: str, result: Any = None) -> dict[str, Any]:
+        """Report observed state without equating delivery or approval with execution."""
+        return self.call("POST", "/api/v1/executions/" + urllib.parse.quote(execution_id, safe=""),
+                         {"state": state, "result": result}, key=str(uuid.uuid4()))
+
+    def wait(self, request_id: str, timeout: float | None = None, interval: float = 1) -> dict[str, Any]:
+        deadline = None if timeout is None else time.monotonic() + timeout
+        while True:
+            if deadline is not None and time.monotonic() >= deadline:
+                raise TimeoutError("Stopped waiting; the durable request remains active")
+            request = self.get_request(request_id)
+            if request["state"] != "open":
+                return request
+            remaining = interval if deadline is None else min(interval, max(0, deadline - time.monotonic()))
+            time.sleep(remaining)
+
+    def inbox(self) -> list[dict[str, Any]]:
+        return self.call("GET", "/api/v1/worker/inbox")
+
+    def ack(self, delivery: dict[str, Any]) -> None:
+        self.call("POST", "/api/v1/worker/inbox/" + urllib.parse.quote(delivery["id"], safe="") + "/ack",
+                  {"generation": delivery["generation"]})
+
+    def heartbeat(self, **progress: Any) -> None:
+        self.call("POST", "/api/v1/worker/heartbeat", progress)
+
+    def run(self, handler: Callable[[dict[str, Any]], None], stop: Callable[[], bool] = lambda: False) -> None:
+        while not stop():
+            try:
+                deliveries = self.call("GET", "/api/v1/worker/inbox?wait_ms=15000")
+            except NotifError as error:
+                if error.status < 500 and error.status != 429:
+                    raise
+                time.sleep(2)
+                continue
+            except (urllib.error.URLError, TimeoutError, ConnectionError, http.client.IncompleteRead):
+                time.sleep(2)
+                continue
+            for delivery in deliveries:
+                handler(delivery)
+                self.ack(delivery)
+            if not deliveries:
+                time.sleep(.1)
+
+
+__all__ = ["Client", "NotifError"]
+
+
+def mention_context(message: dict[str, Any], recipient: str) -> str:
+    """An addressing hint. Other room participants may still contribute."""
+    mentions = message.get("mentions", [])
+    if not mentions:
+        return ""
+    if any(m.get("principal_id") == recipient for m in mentions):
+        return "You are explicitly addressed. Other participants may contribute relevant context."
+    return "Other participants are explicitly addressed. You may contribute relevant context."

beepgrid/events.py

@@ -0,0 +1,72 @@
+"""Bounded full-event SSE consumption with explicit application checkpoints."""
+import http.client
+import json
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+
+_MAX_FRAME = 8 * 1024 * 1024
+
+
+def read_frames(response):
+    data, event_id, kind, size = [], "", "", 0
+    while True:
+        line = response.readline(_MAX_FRAME + 1)
+        if not line:
+            return  # Discard incomplete frames after connection loss.
+        size += len(line)
+        if size > _MAX_FRAME:
+            raise ValueError("Event frame exceeds limit")
+        line = line.decode("utf-8").rstrip("\r\n")
+        if not line:
+            if event_id and data:
+                if not event_id.isdecimal():
+                    raise ValueError("Invalid event ID")
+                sequence = int(event_id)
+                if kind == "cursor":
+                    yield sequence, None
+                else:
+                    event = json.loads("\n".join(data))
+                    if not isinstance(event, dict) or event.get("sequence") != sequence or not isinstance(event.get("kind"), str):
+                        raise ValueError("Event identity mismatch")
+                    yield sequence, event
+            data, event_id, kind, size = [], "", "", 0
+        elif not line.startswith(":"):
+            name, _, value = line.partition(":")
+            value = value.removeprefix(" ")
+            if name == "data": data.append(value)
+            elif name == "id": event_id = value
+            elif name == "event": kind = value
+
+
+def read_events(client, *, after=0, summary=False, conversation_id="", stop=lambda: False):
+    from . import NotifError, _open
+    if isinstance(after, bool) or not isinstance(after, int) or after < 0:
+        raise ValueError("Invalid event cursor")
+    cursor = after
+    while not stop():
+        query = {"stream": "1", "after": str(cursor)}
+        if summary: query["summary"] = "1"
+        if conversation_id: query["conversation_id"] = conversation_id
+        request = urllib.request.Request(client.base_url + "/api/v1/events?" + urllib.parse.urlencode(query),
+            headers={"Authorization": "Bearer " + client._token, "Last-Event-ID": str(cursor), "User-Agent": "BeepgridPython/0.1.0"})
+        try:
+            with _open(request, timeout=max(35, client.timeout)) as response:
+                if not response.headers.get("Content-Type", "").startswith("text/event-stream"):
+                    raise NotifError("INVALID_EVENT_STREAM", "Expected an event stream", 502)
+                for sequence, event in read_frames(response):
+                    if stop(): return
+                    if sequence > cursor:
+                        if event is not None:
+                            yield event
+                        cursor = sequence
+        except urllib.error.HTTPError as error:
+            error.close()
+            if error.code < 500 and error.code != 429:
+                raise NotifError("EVENT_STREAM_REJECTED", "Event stream rejected", error.code) from error
+        except (ValueError, UnicodeError) as error:
+            raise NotifError("INVALID_EVENT_STREAM", "Invalid event frame", 502) from error
+        except (urllib.error.URLError, TimeoutError, ConnectionError, http.client.IncompleteRead):
+            pass
+        if not stop(): time.sleep(.1)

beepgrid/runtime.py

@@ -0,0 +1,359 @@
+"""Durable, independent input for existing async Agent loops. No model dependency.
+
+Use one connection exclusively. Tool-only MCP should use --live-input so it
+cannot compete for this inbox. Local custody is not model/business completion.
+"""
+
+from __future__ import annotations
+import asyncio
+import json
+import os
+from pathlib import Path
+import sqlite3
+import time
+import uuid
+import contextvars
+import urllib.error
+from typing import Any, Callable, Awaitable
+
+
+class LiveInbox:
+    def __init__(
+        self,
+        client,
+        path: str,
+        identity: str,
+        *,
+        mode: str = "steer",
+        max_pending: int = 1000,
+    ):
+        if (
+            mode not in ("steer", "queue")
+            or not identity
+            or path == ":memory:"
+            or max_pending < 1
+        ):
+            raise ValueError(
+                "Use steer or queue, an exact connection identity and a persistent path"
+            )
+        self.client, self.mode, self.max_pending = client, mode, max_pending
+        Path(path).parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        self.db = sqlite3.connect(path)
+        os.chmod(path, 0o600)
+        self.db.execute("PRAGMA journal_mode=WAL")
+        self.db.execute("PRAGMA synchronous=FULL")
+        self.db.executescript("""
+          CREATE TABLE IF NOT EXISTS identity(id INTEGER PRIMARY KEY CHECK(id=1),value TEXT NOT NULL);
+          CREATE TABLE IF NOT EXISTS lease(id INTEGER PRIMARY KEY CHECK(id=1),owner TEXT NOT NULL,expires INTEGER NOT NULL);
+          CREATE TABLE IF NOT EXISTS inputs(id TEXT PRIMARY KEY,payload TEXT NOT NULL,state TEXT NOT NULL,created INTEGER NOT NULL);
+        """)
+        self.owner = str(uuid.uuid4())
+        try:
+            with self.db:
+                self.db.execute("BEGIN IMMEDIATE")
+                row = self.db.execute(
+                    "SELECT value FROM identity WHERE id=1"
+                ).fetchone()
+                if row and row[0] != identity:
+                    raise ValueError("Inbox belongs to another connection")
+                self.db.execute(
+                    "INSERT OR IGNORE INTO identity VALUES(1,?)", (identity,)
+                )
+                row = self.db.execute("SELECT expires FROM lease WHERE id=1").fetchone()
+                if row and row[0] > self.now():
+                    raise ValueError("This inbox already has a receiver")
+                self.db.execute(
+                    "INSERT OR REPLACE INTO lease VALUES(1,?,?)",
+                    (self.owner, self.now() + 30000),
+                )
+        except BaseException:
+            self.db.close()
+            raise
+        self.changed = asyncio.Event()
+        self.tasks: set[asyncio.Task] = set()
+        self.receiving = None
+        self.renewing = None
+        self.ready = False
+
+    @staticmethod
+    def now():
+        return int(time.time() * 1000)
+
+    def guard(self):
+        row = self.db.execute("SELECT owner,expires FROM lease WHERE id=1").fetchone()
+        if not row or row[0] != self.owner or row[1] <= self.now():
+            raise RuntimeError("Receiver lease lost; restart before receiving")
+
+    def pending(self, conversation: str | None = None):
+        self.guard()
+        rows = self.db.execute(
+            "SELECT payload FROM inputs WHERE state!='accepted' ORDER BY created,rowid"
+        ).fetchall()
+        values = [json.loads(row[0]) for row in rows]
+        return [
+            v
+            for v in values
+            if conversation is None or v["conversationId"] == conversation
+        ]
+
+    def put(self, delivery):
+        self.guard()
+        payload = delivery["payload"]
+        conversation = (
+            payload.get("conversation_id")
+            or payload.get("message", {}).get("conversation_id")
+            or payload.get("request", {}).get("conversation_id")
+        )
+        if not conversation or not delivery.get("id"):
+            raise ValueError("Missing delivery identity")
+        with self.db:
+            if self.db.execute(
+                "SELECT 1 FROM inputs WHERE id=?", (delivery["id"],)
+            ).fetchone():
+                return
+            if (
+                self.db.execute(
+                    "SELECT count(*) FROM inputs WHERE state!='accepted'"
+                ).fetchone()[0]
+                >= self.max_pending
+            ):
+                raise RuntimeError("Local inbox full; receiving paused")
+            value = dict(
+                id=delivery["id"],
+                conversationId=conversation,
+                kind=payload["type"],
+                delivery=delivery,
+            )
+            self.db.execute(
+                "INSERT INTO inputs VALUES(?,?,'pending',?)",
+                (delivery["id"], json.dumps(value), self.now()),
+            )
+            self.db.execute(
+                "DELETE FROM inputs WHERE state='accepted' AND created<?",
+                (self.now() - 31 * 86400000,),
+            )
+        self.changed.set()
+
+    def checkpoint(self, ids):
+        """Only after host state containing these IDs is durably checkpointed."""
+        self.guard()
+        with self.db:
+            self.db.executemany(
+                "UPDATE inputs SET state='accepted',payload=json_remove(payload,'$.delivery.payload.message','$.delivery.payload.request') WHERE id=?",
+                [(i,) for i in ids],
+            )
+
+    async def receive(self):
+        while True:
+            self.guard()
+            with self.db:
+                self.db.execute(
+                    "UPDATE lease SET expires=? WHERE owner=?",
+                    (self.now() + 30000, self.owner),
+                )
+            try:
+                jobs = await asyncio.to_thread(
+                    self.client.call, "GET", "/api/v1/worker/inbox?wait_ms=15000"
+                )
+                self.ready = True
+                for job in jobs:
+                    self.put(job)
+                    await asyncio.to_thread(self.client.ack, job)
+                if not jobs:
+                    await asyncio.sleep(0.05)
+            except asyncio.CancelledError:
+                raise
+            except (urllib.error.URLError, TimeoutError, ConnectionError):
+                await asyncio.sleep(0.5)
+            except Exception as error:
+                status = getattr(error, "status", None)
+                if status in (409, 429) or status and status >= 500:
+                    await asyncio.sleep(0.5)
+                elif str(error).startswith("Local inbox full"):
+                    await asyncio.sleep(0.5)
+                else:
+                    raise
+
+    async def renew(self):
+        while True:
+            await asyncio.sleep(5)
+            self.guard()
+            with self.db:
+                self.db.execute(
+                    "UPDATE lease SET expires=? WHERE owner=?",
+                    (self.now() + 30000, self.owner),
+                )
+
+    def start(self):
+        if self.receiving:
+            raise RuntimeError("Already started")
+        self.receiving = asyncio.create_task(self.receive())
+        self.renewing = asyncio.create_task(self.renew())
+        return self
+
+    async def close(self):
+        if self.receiving:
+            self.receiving.cancel()
+            await asyncio.gather(self.receiving, return_exceptions=True)
+        if self.renewing:
+            self.renewing.cancel()
+            await asyncio.gather(self.renewing, return_exceptions=True)
+        for task in self.tasks:
+            task.cancel()
+        await asyncio.gather(*self.tasks, return_exceptions=True)
+        with self.db:
+            self.db.execute("DELETE FROM lease WHERE owner=?", (self.owner,))
+        self.db.close()
+
+
+def input_text(value):
+    """Keep external input, sender, mentions, attachments and correlation as data."""
+    return json.dumps(
+        {
+            "beepgrid": {
+                **value["delivery"]["payload"],
+                "delivery_id": value["id"],
+                "conversation_id": value["conversationId"],
+            }
+        }
+    )
+
+
+class LangGraphBridge:
+    """LangChain Agent middleware and LangGraph checkpoint-compatible receiving.
+
+    Configure the graph with a durable checkpointer and before_model(). Existing
+    tools/model/session state remain owned by the application. serve() owns one
+    invocation per conversation, checks the final checkpoint and catches the
+    input-arrived-at-completion race. It never updates a running graph externally.
+    """
+
+    def __init__(self, inbox: LiveInbox, *, thread_id: Callable[[str], str] | None = None):
+        self.inbox = inbox
+        self.thread_id = thread_id or (lambda conversation: conversation)
+        self.active: dict[str, asyncio.Task] = {}
+        self.initial: dict[str, set[str]] = {}
+        self.conversation = contextvars.ContextVar("beepgrid_conversation")
+
+    def before_model(self):
+        from langchain.agents.middleware import before_model
+        from langchain_core.messages import HumanMessage
+
+        @before_model
+        async def receive_input(state, runtime):
+            conversation = self.conversation.get()
+            existing = {getattr(m, "id", None) for m in state.get("messages", [])}
+            inputs = self.inbox.pending(conversation)
+            if self.inbox.mode == "queue":
+                inputs = [
+                    i
+                    for i in inputs
+                    if i["id"] in self.initial.get(conversation, set())
+                    or i["kind"] == "request.resolved"
+                ]
+            messages = [
+                HumanMessage(content=input_text(i), id="beepgrid/" + i["id"])
+                for i in inputs
+                if "beepgrid/" + i["id"] not in existing
+            ]
+            return {"messages": messages} if messages else None
+
+        return receive_input
+
+    async def serve(
+        self, graph, *, on_result: Callable[[str, Any, str], Awaitable[None]]
+    ):
+        if not graph.checkpointer:
+            raise ValueError("Configure the existing graph with a durable checkpointer")
+        if not self.inbox.receiving:
+            self.inbox.start()
+
+        async def publish(conversation, values, persisted):
+            ids = sorted(
+                i["id"]
+                for i in self.inbox.pending(conversation)
+                if "beepgrid/" + i["id"] in persisted
+            )
+            if ids:
+                import hashlib
+
+                key = (
+                    "beepgrid-result/"
+                    + hashlib.sha256(json.dumps(ids).encode()).hexdigest()
+                )
+                await on_result(conversation, values, key)
+                self.inbox.checkpoint(ids)
+
+        async def run(conversation):
+            self.conversation.set(conversation)
+            config = {"configurable": {"thread_id": self.thread_id(conversation)}}
+            try:
+                while self.inbox.pending(conversation):
+                    snapshot = await graph.aget_state(config)
+                    if snapshot.next:
+                        raise RuntimeError(
+                            "Graph is paused; resume its native interrupt/approval instead of starting another run"
+                        )
+                    existing = {
+                        getattr(m, "id", None)
+                        for m in snapshot.values.get("messages", [])
+                    }
+                    await publish(conversation, snapshot.values, existing)
+                    values = self.inbox.pending(conversation)
+                    if not values:
+                        break
+                    self.initial[conversation] = {i["id"] for i in values}
+                    # Queue includes only the batch at invocation start. Steer also
+                    # receives subsequent arrivals through the local middleware.
+                    from langchain_core.messages import HumanMessage
+
+                    result = await graph.ainvoke(
+                        {
+                            "messages": [
+                                HumanMessage(
+                                    content=input_text(i), id="beepgrid/" + i["id"]
+                                )
+                                for i in values
+                            ]
+                        },
+                        config,
+                    )
+                    snapshot = await graph.aget_state(config)
+                    if snapshot.next:
+                        raise RuntimeError(
+                            "Graph paused; leave custody pending until native resume"
+                        )
+                    persisted = {
+                        getattr(m, "id", None)
+                        for m in snapshot.values.get("messages", [])
+                    }
+                    if not any("beepgrid/" + i["id"] in persisted for i in values):
+                        raise RuntimeError("Host checkpoint did not retain input IDs")
+                    await publish(conversation, result, persisted)
+            finally:
+                self.active.pop(conversation, None)
+                self.initial.pop(conversation, None)
+                self.inbox.changed.set()
+
+        while True:
+            if self.inbox.receiving.done():
+                await self.inbox.receiving
+            if self.inbox.renewing.done():
+                await self.inbox.renewing
+            if self.inbox.ready:
+                for conversation in dict.fromkeys(
+                    i["conversationId"] for i in self.inbox.pending()
+                ):
+                    if conversation not in self.active and len(self.active) < 8:
+                        task = asyncio.create_task(run(conversation))
+                        self.active[conversation] = task
+                        self.inbox.tasks.add(task)
+            self.inbox.changed.clear()
+            completed = [t for t in self.inbox.tasks if t.done()]
+            for task in completed:
+                self.inbox.tasks.remove(task)
+                await task  # Do not silently retry failed business jobs.
+            try:
+                await asyncio.wait_for(self.inbox.changed.wait(), 0.25)
+            except asyncio.TimeoutError:
+                pass

beepgrid-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: beepgrid
+Version: 0.1.0
+Summary: Reliable communication between AI agents, people and services
+Author-email: Beepgrid <sasi@beepgrid.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://beepgrid.com/
+Project-URL: Documentation, https://beepgrid.com/docs/sdks/python/
+Project-URL: Repository, https://github.com/beepgrid/beepgrid
+Project-URL: Issues, https://github.com/beepgrid/beepgrid/issues
+Keywords: beepgrid,agents,communication
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Beepgrid for Python
+
+For an Agent that is already running in a framework or custom loop, see
+[live input](https://beepgrid.com/docs/live-input/). `beepgrid.runtime.LiveInbox` receives
+independently of ongoing work, and `LangGraphBridge` adds Steer/Queue behavior
+to an existing LangChain Agent with its own durable checkpointer. Framework
+packages remain optional. Keep the existing model, tools and runtime authority.
+
+[Website](https://beepgrid.com) · [Documentation](https://beepgrid.com/docs/sdks/python/) · [Source](https://github.com/beepgrid/beepgrid/tree/main/sdk/python)
+
+```sh
+pip install beepgrid
+# or: uv add beepgrid
+```
+
+Python 3.10 or later. No runtime dependencies.
+
+```python
+import os
+from beepgrid import Client
+client = Client(os.environ["NOTIF_URL"], os.environ["NOTIF_TOKEN"])
+```
+
+Use an individually issued credential from your secret manager or a protected file. The legacy `notif` import remains available.
+
+Start with a dashboard-issued worker credential. Save it in a protected file, then run from the source checkout:
+
+```sh
+export NOTIF_URL="https://your-workspace.example"
+export NOTIF_TOKEN_FILE="/absolute/path/beepgrid-worker-token"
+chmod 600 "$NOTIF_TOKEN_FILE"
+unset NOTIF_AGENT_ID
+python3 examples/python-worker/main.py
+```
+
+The complete starter validates its agent identity, receives ordinary messages and replies in the original conversation. Replace its deterministic handler with your existing agent. For explicit launcher enrollment, see [runtime examples](https://github.com/beepgrid/beepgrid/tree/main/examples).
+
+`Client(url, token)` constructs a synchronous client. `send` sends ordinary content; `ask` creates a saved request and `wait(request_id, timeout=300)` optionally waits for its decision. `respond(request_id, outcome, version=current_version, answer=value)` supplies a current-version answer. Use a stable `key` for writes you may retry. A local `TimeoutError` does not cancel the saved request. `run` acknowledges after the handler returns, so persist long work first.
+
+`Notify` (Go) / `notify` (TypeScript and Python) requests `Prefer: return=minimal` and returns only `conversation_id` and `message_count`. It confirms durable canonical storage and queueing, not provider acceptance, human receipt or execution. `Send` / `send` keeps its full response by default. Replay identical input with the same stable operation key through `Send` / `send` to retrieve every canonical message without sending twice.
+
+`directory("agent", search="Reviewer")` returns a bounded authorized page. Use `query` and `next_cursor` to continue larger results. `conversation`, `cancel`, `provider_catalog` and `connection_setup` expose the corresponding existing API journeys.
+
+`upload_attachment(conversation_id, name, media, bytes)`, `attachments` and `download_attachment` use current history access, with a 5 MiB bound. Upload is not idempotent and is never automatically retried; list files after an unknown response before another upload. Files inherit conversation access and are untrusted content.
+
+`for event in client.events(after=saved_cursor): ...` consumes full SSE, reconnects from complete frames and terminates on authorization denial. Apply the event before persisting its `sequence`. Closing the iterator closes its local response; `stop` is checked between received frames and reconnects, with a bounded socket timeout. Clear private caches when access changes. This is a synchronous consumer, not a background model wake-up mechanism.
+
+Run `examples/file-exchange/main.py` only against a selected disposable workspace to qualify two numbered agents exchanging a file and a canonical reply. It uses the owner only to create explicit test grants; both agents communicate with their own worker credentials.
+
+`start_chat` starts explicit shared history with recipients and content plus optional title, choices, approval and `mentions`. Mention offsets count Unicode code points. An emoji counts as one code point; UTF-16 code units are not used. All members receive the original communication. The optional initial mention field requires the integrated engine contract published on 30 October 2026. `stage_attachment` creates a private 24-hour draft. Pass its ID through `attachment_ids` on send, ask, shared creation or message batches (maximum five). `change_chat_membership` implements rename/add/remove/leave with the current version and a stable operation key. New members see history from joining by default; explicit `share_history=True` reveals earlier history. Membership does not grant contact or decision rights. Removal revokes current history/file access. These helpers require the committed schema 32 engine contract.
+
+For the maintained runtime starter, a dashboard-created worker token already identifies one connection. Supply `NOTIF_URL` and a protected `NOTIF_TOKEN_FILE` and omit `NOTIF_AGENT_ID` to use it directly. Set `NOTIF_AGENT_ID` only with a namespace-restricted enrollment credential. The starter checks `/me` in existing-worker mode and does not call enrollment or create another instance.

beepgrid-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+beepgrid/__init__.py,sha256=7Edd7N-y1AkfuMC8qEO30tclGfbtpc3SiPtCjjNjkeE,21110
+beepgrid/events.py,sha256=fwOXUs4RfpKBr8wFPBsEdldHrgOnQBIMOkDeGrD-SEo,3332
+beepgrid/runtime.py,sha256=58gV_uoRdp-IypzW0N7JDZTxNeTHSv3jUGHOoy4ipo4,14182
+beepgrid-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+notif/__init__.py,sha256=QL9ZHnJTKTDygxiqdxBdwLHL7VVzmoNlFdkyLV_cHCc,92
+notif/events.py,sha256=N4sTArG8FVRVqgNpFlbnUGnhmqA8_842bdtPDLVIFpc,78
+notif/runtime.py,sha256=d5SJh_oEnzobJ2HVYpHKim0DCCIHKCNFo_AqpxHtpVA,80
+beepgrid-0.1.0.dist-info/METADATA,sha256=Ycq_BU8mKrlvY8wFKokBl70837dZHlK9paGgqSAisXY,5662
+beepgrid-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+beepgrid-0.1.0.dist-info/top_level.txt,sha256=c8YlLI1zLnQ9ZL6KW1rji-lK0VrW0ZGOOtC9aZuBQM4,15
+beepgrid-0.1.0.dist-info/RECORD,,

beepgrid-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

beepgrid-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

beepgrid-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+beepgrid
+notif

notif/__init__.py

@@ -0,0 +1,2 @@
+"""Compatibility import. New applications should import beepgrid."""
+from beepgrid import *

notif/events.py

@@ -0,0 +1,2 @@
+"""Compatibility import for beepgrid.events."""
+from beepgrid.events import *

notif/runtime.py

@@ -0,0 +1,2 @@
+"""Compatibility import for beepgrid.runtime."""
+from beepgrid.runtime import *