mezi 0.1.0__tar.gz

mezi-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pentarosa Co.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mezi-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: mezi
+Version: 0.1.0
+Summary: The mezi API client and webhook verifier. Standard library only.
+Author: Pentarosa Co.
+License: MIT
+Project-URL: Homepage, https://developer.mezi.app
+Project-URL: Documentation, https://developer.mezi.app/guides/client
+Keywords: mezi,api,webhooks,payments
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mezi
+
+The mezi API client and webhook verifier for Python 3.9 or newer. Standard library only.
+
+mezi holds a buyer's payment until they approve the work, then releases it. The API reads your account, deals and events. Nothing in it moves money.
+
+```sh
+pip install mezi
+```
+
+Keep the key in `MEZI_API_KEY`, on a server.
+
+## Read your deals
+
+```python
+from mezi import MeziClient
+
+mezi = MeziClient()  # reads MEZI_API_KEY
+for deal in mezi.all_deals(role="owner"):
+    print(deal["id"], deal["state"], deal["amountCents"])
+```
+
+## Follow events as they happen
+
+```python
+from mezi import MeziClient
+
+mezi = MeziClient()
+for event in mezi.stream_events(types=["deal.funded", "payout.released"]):
+    print(event["id"], event["type"], event["data"]["id"])  # dedupe on event["id"]
+```
+
+Where a proxy cuts long connections, `mezi.watch_events()` does the same job by polling. Both take `cursor` and `on_cursor` so a restart resumes where it stopped.
+
+## Check a webhook
+
+```python
+import os
+from flask import Flask, request
+from mezi import verify_webhook, WebhookVerificationError
+
+app = Flask(__name__)
+
+@app.post("/mezi/webhooks")
+def mezi_webhook():
+    try:
+        event = verify_webhook(
+            request.get_data(), request.headers.get("Mezi-Signature"), os.environ["MEZI_WEBHOOK_SECRET"]
+        )
+    except WebhookVerificationError:
+        return "", 400
+    print(event["type"], event["data"]["id"])
+    return "", 204
+```
+
+Errors from the API raise `MeziApiError`; branch on `err.code` (for example `DEAL_NOT_FOUND`).
+
+Full guide: https://developer.mezi.app/guides/client

mezi-0.1.0/README.md

@@ -0,0 +1,58 @@
+# mezi
+
+The mezi API client and webhook verifier for Python 3.9 or newer. Standard library only.
+
+mezi holds a buyer's payment until they approve the work, then releases it. The API reads your account, deals and events. Nothing in it moves money.
+
+```sh
+pip install mezi
+```
+
+Keep the key in `MEZI_API_KEY`, on a server.
+
+## Read your deals
+
+```python
+from mezi import MeziClient
+
+mezi = MeziClient()  # reads MEZI_API_KEY
+for deal in mezi.all_deals(role="owner"):
+    print(deal["id"], deal["state"], deal["amountCents"])
+```
+
+## Follow events as they happen
+
+```python
+from mezi import MeziClient
+
+mezi = MeziClient()
+for event in mezi.stream_events(types=["deal.funded", "payout.released"]):
+    print(event["id"], event["type"], event["data"]["id"])  # dedupe on event["id"]
+```
+
+Where a proxy cuts long connections, `mezi.watch_events()` does the same job by polling. Both take `cursor` and `on_cursor` so a restart resumes where it stopped.
+
+## Check a webhook
+
+```python
+import os
+from flask import Flask, request
+from mezi import verify_webhook, WebhookVerificationError
+
+app = Flask(__name__)
+
+@app.post("/mezi/webhooks")
+def mezi_webhook():
+    try:
+        event = verify_webhook(
+            request.get_data(), request.headers.get("Mezi-Signature"), os.environ["MEZI_WEBHOOK_SECRET"]
+        )
+    except WebhookVerificationError:
+        return "", 400
+    print(event["type"], event["data"]["id"])
+    return "", 204
+```
+
+Errors from the API raise `MeziApiError`; branch on `err.code` (for example `DEAL_NOT_FOUND`).
+
+Full guide: https://developer.mezi.app/guides/client

mezi-0.1.0/mezi/__init__.py

@@ -0,0 +1,20 @@
+"""The mezi API client and webhook verifier.
+
+mezi holds a buyer's payment until they approve the work, then releases it.
+The API reads your account, deals and events; nothing in it moves money.
+https://developer.mezi.app/guides/client
+"""
+from .client import DEFAULT_API_BASE, DEFAULT_STATUS_BASE, MeziApiError, MeziClient
+from .webhooks import WebhookVerificationError, verify_webhook
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DEFAULT_API_BASE",
+    "DEFAULT_STATUS_BASE",
+    "MeziApiError",
+    "MeziClient",
+    "WebhookVerificationError",
+    "verify_webhook",
+    "__version__",
+]

mezi-0.1.0/mezi/client.py

@@ -0,0 +1,322 @@
+"""A small mezi API client on the standard library (urllib).
+
+Reads your account and deals, follows your events (a live stream, or a polled
+feed), sends sample events with a sandbox key, and reads mezi's public status.
+
+    from mezi import MeziClient
+    mezi = MeziClient()  # reads MEZI_API_KEY
+    for event in mezi.stream_events():
+        print(event["type"], event["data"]["id"])
+
+https://developer.mezi.app/guides/client
+"""
+import http.client
+import json
+import os
+import time
+import uuid
+from typing import Any, Callable, Dict, Iterator, List, Optional, Union
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode
+from urllib.request import HTTPRedirectHandler, Request, build_opener
+
+from .types import Deal, Event, EventsPage, Status, User
+
+DEFAULT_API_BASE = "https://api.mezi.app/api/v1"
+DEFAULT_STATUS_BASE = "https://status.mezi.app"
+USER_AGENT = "mezi-python/0.1.0"
+
+Stop = Union[None, Callable[[], bool], Any]
+"""Something that says when to stop: a callable answering True, or a threading.Event."""
+
+
+class MeziApiError(Exception):
+    """A coded API error: branch on `code` (and `status`), never on the message."""
+
+    def __init__(self, status: int, body: Any = None) -> None:
+        self.status = status
+        self.body = body
+        self.code = body.get("error") if isinstance(body, dict) and body.get("error") else "UNKNOWN"
+        super().__init__(f"mezi API {status}: {self.code}")
+
+
+class _NoRedirects(HTTPRedirectHandler):
+    # A redirect would carry the API key somewhere else: refuse it instead.
+    def redirect_request(self, req, fp, code, msg, headers, newurl):  # type: ignore[override]
+        return None
+
+
+def _stopped(stop: Stop) -> bool:
+    if stop is None:
+        return False
+    if hasattr(stop, "is_set"):
+        return bool(stop.is_set())
+    return bool(stop())
+
+
+def _wait(seconds: float, stop: Stop) -> bool:
+    """Sleep, waking early when `stop` is a threading.Event. True when told to stop."""
+    if stop is not None and hasattr(stop, "wait"):
+        return bool(stop.wait(seconds))
+    time.sleep(seconds)
+    return _stopped(stop)
+
+
+def _read_body(fp: Any) -> Any:
+    try:
+        return json.loads(fp.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def _retry_after(headers: Any, attempt: int) -> float:
+    try:
+        after = float(headers.get("Retry-After") or 0)
+    except (TypeError, ValueError):
+        after = 0
+    return after if after > 0 else 0.5 * 2**attempt
+
+
+class MeziClient:
+    """The mezi API.
+
+    api_key     mz_live_... or mz_test_...; defaults to MEZI_API_KEY
+    base_url    defaults to MEZI_API_BASE, else https://api.mezi.app/api/v1
+    status_url  defaults to MEZI_STATUS_BASE, else https://status.mezi.app
+    retries     retries for 429, 5xx and network errors (honors Retry-After)
+    timeout     seconds per request
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        status_url: Optional[str] = None,
+        retries: int = 3,
+        timeout: float = 30,
+    ) -> None:
+        self.api_key = api_key or os.environ.get("MEZI_API_KEY")
+        if not self.api_key:
+            raise ValueError("MeziClient: api_key is required (MEZI_API_KEY)")
+        self.base_url = (base_url or os.environ.get("MEZI_API_BASE") or DEFAULT_API_BASE).rstrip("/")
+        self.status_url = (
+            status_url or os.environ.get("MEZI_STATUS_BASE") or DEFAULT_STATUS_BASE
+        ).rstrip("/")
+        self.retries = retries
+        self.timeout = timeout
+        self._opener = build_opener(_NoRedirects)
+
+    # ── Plumbing ──
+
+    def _url(self, path: str, query: Optional[Dict[str, Any]] = None) -> str:
+        params = {}
+        for key, value in (query or {}).items():
+            if value is None or value == "":
+                continue
+            if isinstance(value, bool):
+                value = "true" if value else "false"
+            elif isinstance(value, (list, tuple)):
+                value = ",".join(str(v) for v in value)
+            params[key] = str(value)
+        return self.base_url + path + (f"?{urlencode(params)}" if params else "")
+
+    def _headers(self, accept: str = "application/json") -> Dict[str, str]:
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": accept,
+            "User-Agent": USER_AGENT,
+        }
+
+    def _send(self, url: str, method: str = "GET", headers: Optional[Dict[str, str]] = None,
+              data: Optional[bytes] = None) -> Any:
+        for attempt in range(self.retries + 1):
+            req = Request(url, data=data, method=method, headers=headers or {})
+            try:
+                with self._opener.open(req, timeout=self.timeout) as res:
+                    return _read_body(res)
+            except HTTPError as err:
+                retryable = err.code == 429 or err.code >= 500
+                if retryable and attempt < self.retries:
+                    time.sleep(_retry_after(err.headers, attempt))
+                    continue
+                raise MeziApiError(err.code, _read_body(err)) from None
+            except (URLError, OSError, http.client.HTTPException):
+                if attempt >= self.retries:
+                    raise
+                time.sleep(0.5 * 2**attempt)
+        raise AssertionError("unreachable")
+
+    def request(self, method: str, path: str, query: Optional[Dict[str, Any]] = None,
+                body: Any = None, idempotency_key: Optional[str] = None) -> Any:
+        """One API call. A write carries an Idempotency-Key, the same on every retry."""
+        headers = self._headers()
+        data = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+        if method != "GET":
+            headers["Idempotency-Key"] = idempotency_key or str(uuid.uuid4())
+        return self._send(self._url(path, query), method, headers, data)
+
+    # ── Reads ──
+
+    def me(self) -> Dict[str, User]:
+        """The account and the key making the call: {"user": {...}}."""
+        return self.request("GET", "/me")
+
+    def deals(self, **filters: Any) -> Dict[str, Any]:
+        """One page of deals: state, kind, role (owner|seller), page, limit."""
+        return self.request("GET", "/deals", filters)
+
+    def all_deals(self, **filters: Any) -> Iterator[Deal]:
+        """Every deal matching the filters, page by page."""
+        page = 1
+        while True:
+            answer = self.request("GET", "/deals", {**filters, "page": page, "limit": 100})
+            yield from answer["items"]
+            if not (answer.get("pagination") or {}).get("hasNext"):
+                return
+            page += 1
+
+    def deal(self, deal_id: str) -> Dict[str, Deal]:
+        """One deal by id (its slug): {"deal": {...}}. Raises DEAL_NOT_FOUND."""
+        return self.request("GET", f"/deals/{quote(str(deal_id), safe='')}")
+
+    def submissions(self, deal_id: str, page: Optional[int] = None,
+                    limit: Optional[int] = None) -> Dict[str, Any]:
+        """One page of a deal's submissions: {"items": [Submission], "pagination": {...}}."""
+        return self.request("GET", f"/deals/{quote(str(deal_id), safe='')}/submissions",
+                            {"page": page, "limit": limit})
+
+    def webhook_endpoints(self, page: Optional[int] = None,
+                          limit: Optional[int] = None) -> Dict[str, Any]:
+        """One page of your webhook endpoints."""
+        return self.request("GET", "/webhook_endpoints", {"page": page, "limit": limit})
+
+    def status(self) -> Status:
+        """mezi's public status: {status, components, notices, updatedAt}. No key is sent."""
+        return self._send(f"{self.status_url}/v1/summary",
+                          headers={"Accept": "application/json", "User-Agent": USER_AGENT})
+
+    # ── Events ──
+
+    def events(self, after: Optional[str] = None, limit: Optional[int] = None,
+               types: Optional[Union[List[str], str]] = None) -> EventsPage:
+        """One page of the events feed: {"items", "nextCursor", "hasMore"}."""
+        return self.request("GET", "/events", {"after": after, "limit": limit, "type": types})
+
+    def watch_events(self, cursor: Optional[str] = None, types: Optional[List[str]] = None,
+                     interval_seconds: float = 15,
+                     on_cursor: Optional[Callable[[str], None]] = None,
+                     stop: Stop = None) -> Iterator[Event]:
+        """Every new event, oldest first, by polling the feed until `stop` says so.
+
+        Pass `cursor` (and save what `on_cursor` gets somewhere durable) so a
+        restart picks up where it stopped instead of at "now".
+        """
+        save = on_cursor or (lambda c: None)
+        after = cursor
+        if not after:
+            after = self.events(types=types, limit=1)["nextCursor"]
+            save(after)
+        while not _stopped(stop):
+            try:
+                page = self.events(after=after, types=types, limit=100)
+            except MeziApiError as err:
+                # A cursor the feed no longer knows: start again from now.
+                if err.code == "EVENTS_CURSOR_INVALID":
+                    after = self.events(types=types, limit=1)["nextCursor"]
+                    save(after)
+                    continue
+                raise
+            for event in page["items"]:
+                yield event
+            if page["nextCursor"] != after:
+                after = page["nextCursor"]
+                save(after)
+            if not page["hasMore"] and _wait(interval_seconds, stop):
+                return
+
+    def stream_events(self, cursor: Optional[str] = None, types: Optional[List[str]] = None,
+                      on_cursor: Optional[Callable[[str], None]] = None, stop: Stop = None,
+                      read_timeout: float = 60) -> Iterator[Event]:
+        """Every new event as it happens, over server-sent events, oldest first.
+
+        Same cursor as the feed. Reconnects on its own when the server ends
+        the stream. Where a proxy cuts streams, watch_events does the same job.
+        """
+        save = on_cursor or (lambda c: None)
+        after = cursor
+        failures = 0
+        while not _stopped(stop):
+            url = self._url("/events/stream", {"after": after, "type": types})
+            req = Request(url, headers=self._headers("text/event-stream"))
+            try:
+                res = self._opener.open(req, timeout=read_timeout)
+            except HTTPError as err:
+                retryable = err.code == 429 or err.code >= 500
+                failures += 1
+                if not retryable or failures > 8:
+                    raise MeziApiError(err.code, _read_body(err)) from None
+                if _wait(_retry_after(err.headers, failures), stop):
+                    return
+                continue
+            except (URLError, OSError, http.client.HTTPException):
+                failures += 1
+                if failures > 8:
+                    raise
+                if _wait(min(30.0, 0.5 * 2**failures), stop):
+                    return
+                continue
+            failures = 0
+            try:
+                with res:
+                    for message in _server_sent_events(res, stop):
+                        if message["id"] and message["id"] != after:
+                            after = message["id"]
+                            save(after)
+                        if message["event"] == "message" and message["data"]:
+                            yield json.loads(message["data"])
+            except (OSError, http.client.HTTPException):
+                failures += 1
+                if failures > 8:
+                    raise
+            # The server ends a stream after a while; pick up from the cursor.
+            if _wait(0.25, stop):
+                return
+
+    # ── Sandbox ──
+
+    def trigger_sandbox_event(self, type: str, idempotency_key: Optional[str] = None) -> Dict[str, Event]:
+        """Sandbox keys only: send a sample event of `type`, marked sandbox: true. Answers {"event"}."""
+        return self.request("POST", "/sandbox/events", body={"type": type},
+                            idempotency_key=idempotency_key)
+
+
+def _server_sent_events(res: Any, stop: Stop = None) -> Iterator[Dict[str, str]]:
+    """Parse a text/event-stream response into {id, event, data} messages."""
+    message: Dict[str, Any] = {"id": "", "event": "message", "data": []}
+    while not _stopped(stop):
+        raw = res.readline()
+        if not raw:
+            return
+        line = raw.decode("utf-8").rstrip("\r\n")
+        if line == "":
+            if message["data"] or message["id"]:
+                yield {"id": message["id"], "event": message["event"], "data": "\n".join(message["data"])}
+            message = {"id": "", "event": "message", "data": []}
+            continue
+        if line.startswith(":"):
+            continue
+        field, colon, value = line.partition(":")
+        if colon and value.startswith(" "):
+            value = value[1:]
+        if field == "data":
+            message["data"].append(value)
+        elif field == "event":
+            message["event"] = value
+        elif field == "id":
+            message["id"] = value
+
+
+__all__ = ["DEFAULT_API_BASE", "DEFAULT_STATUS_BASE", "MeziApiError", "MeziClient"]

mezi-0.1.0/mezi/types.py

@@ -0,0 +1,151 @@
+"""The shapes the mezi API answers with, as TypedDicts for type checkers."""
+from typing import Any, Dict, List, Literal, Optional, TypedDict
+
+EventType = Literal[
+    "deal.created",
+    "deal.funded",
+    "deal.accepted",
+    "submission.created",
+    "submission.approved",
+    "submission.revision_requested",
+    "payout.released",
+    "deal.completed",
+    "deal.canceled",
+    "dispute.opened",
+    "deal.deadline_soon",
+    "message.received",
+    "status.changed",
+]
+
+
+class Pagination(TypedDict):
+    page: int
+    limit: int
+    total: int
+    totalPages: int
+    hasNext: bool
+    hasPrev: bool
+
+
+class ApiKeyInfo(TypedDict):
+    id: str
+    mode: Literal["live", "test"]
+    scopes: List[str]
+    sandbox: bool
+
+
+class User(TypedDict):
+    id: str
+    object: Literal["user"]
+    handle: str
+    displayName: Optional[str]
+    email: Optional[str]
+    createdAt: str
+    apiKey: ApiKeyInfo
+
+
+class DealViewer(TypedDict):
+    isOwner: bool
+    side: Optional[str]
+    role: Optional[str]
+
+
+class Deal(TypedDict):
+    object: Literal["deal"]
+    id: str
+    """The deal's slug."""
+    kind: str
+    """PRIVATE or BOUNTY."""
+    state: str
+    """INVITED, ACTIVE, INACTIVE or DECLINED."""
+    amountCents: int
+    currency: str
+    paymentState: Optional[str]
+    """HELD while mezi holds the money, RELEASED once paid, DISPUTED while frozen."""
+    createdAt: str
+    fundedAt: Optional[str]
+    deadlineAt: Optional[str]
+    completedAt: Optional[str]
+    title: Optional[str]
+    description: Optional[str]
+    viewer: "DealViewer"
+    """Your side: {"isOwner": bool, "side": "BUYER"|"SELLER"|None, "role": ...}."""
+
+
+class Submission(TypedDict):
+    object: Literal["submission"]
+    id: str
+    deal: str
+    """The deal's slug."""
+    state: str
+    revisionRound: int
+    isWinner: bool
+    createdAt: str
+    submittedAt: Optional[str]
+    decidedAt: Optional[str]
+
+
+class _EventFields(TypedDict):
+    id: str
+    """evt_...: dedupe on this."""
+    type: EventType
+    created_at: str
+    api_version: str
+    data: Dict[str, Any]
+    """{ object, id, ... }: thin, ids, states and amounts only."""
+
+
+class Event(_EventFields, total=False):
+    sandbox: bool
+    """Present and true on sample events sent with a sandbox key."""
+
+
+class EventsPage(TypedDict):
+    items: List[Event]
+    nextCursor: str
+    hasMore: bool
+
+
+class StatusComponent(TypedDict):
+    id: str
+    name: str
+    status: str
+
+
+class StatusNotice(TypedDict, total=False):
+    id: str
+    title: str
+
+
+class Status(TypedDict):
+    status: str
+    """operational, or how it is not."""
+    updatedAt: str
+    components: List[StatusComponent]
+    notices: List[StatusNotice]
+
+
+class WebhookEndpoint(TypedDict, total=False):
+    id: str
+    url: str
+    description: Optional[str]
+    eventTypes: List[str]
+    enabled: bool
+    format: Literal["event", "slack", "discord"]
+    status: str
+
+
+__all__ = [
+    "ApiKeyInfo",
+    "Deal",
+    "Event",
+    "EventType",
+    "EventsPage",
+    "Pagination",
+    "Status",
+    "StatusComponent",
+    "StatusNotice",
+    "Submission",
+    "User",
+    "WebhookEndpoint",
+]

mezi-0.1.0/mezi/webhooks.py

@@ -0,0 +1,59 @@
+"""Check a mezi webhook before you trust it.
+
+https://developer.mezi.app/webhooks/signatures
+
+    event = verify_webhook(request.get_data(), request.headers["Mezi-Signature"], secret)
+"""
+import hashlib
+import hmac
+import json
+import re
+import time
+from typing import Any, Dict, List, Optional, Union
+
+_HEX64 = re.compile(r"^[0-9a-f]{64}$")
+
+
+class WebhookVerificationError(ValueError):
+    """The signature does not hold: refuse the request."""
+
+
+def verify_webhook(
+    raw_body: Union[bytes, str],
+    header: Optional[str],
+    secret: Union[str, List[str]],
+    tolerance: int = 300,
+    now: Optional[float] = None,
+) -> Dict[str, Any]:
+    """Return the parsed event when `header` signs `raw_body` with `secret`.
+
+    `raw_body` is the request body exactly as received, before any JSON
+    parsing. `secret` is the endpoint's signing secret (whsec_...), or a list
+    of them while you rotate. Raises WebhookVerificationError otherwise.
+    """
+    body = raw_body.encode("utf-8") if isinstance(raw_body, str) else bytes(raw_body)
+    timestamp = None
+    signatures = []
+    for part in (header or "").split(","):
+        key, _, value = part.strip().partition("=")
+        if key == "t" and value.isdigit():
+            timestamp = int(value)
+        elif key == "v1" and _HEX64.match(value):
+            signatures.append(value)
+    if timestamp is None or not signatures:
+        raise WebhookVerificationError("malformed Mezi-Signature header")
+    current = time.time() if now is None else now
+    if abs(int(current) - timestamp) > tolerance:
+        raise WebhookVerificationError("signature timestamp is outside the tolerance")
+    secrets = [secret] if isinstance(secret, str) else list(secret)
+    signed = str(timestamp).encode() + b"." + body
+    matched = False
+    for s in secrets:
+        expected = hmac.new(s.encode(), signed, hashlib.sha256).hexdigest()
+        for sig in signatures:
+            # Check every pair so the time taken does not depend on which matched.
+            if hmac.compare_digest(expected, sig):
+                matched = True
+    if not matched:
+        raise WebhookVerificationError("no signature matches")
+    return json.loads(body)

mezi-0.1.0/mezi.egg-info/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: mezi
+Version: 0.1.0
+Summary: The mezi API client and webhook verifier. Standard library only.
+Author: Pentarosa Co.
+License: MIT
+Project-URL: Homepage, https://developer.mezi.app
+Project-URL: Documentation, https://developer.mezi.app/guides/client
+Keywords: mezi,api,webhooks,payments
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mezi
+
+The mezi API client and webhook verifier for Python 3.9 or newer. Standard library only.
+
+mezi holds a buyer's payment until they approve the work, then releases it. The API reads your account, deals and events. Nothing in it moves money.
+
+```sh
+pip install mezi
+```
+
+Keep the key in `MEZI_API_KEY`, on a server.
+
+## Read your deals
+
+```python
+from mezi import MeziClient
+
+mezi = MeziClient()  # reads MEZI_API_KEY
+for deal in mezi.all_deals(role="owner"):
+    print(deal["id"], deal["state"], deal["amountCents"])
+```
+
+## Follow events as they happen
+
+```python
+from mezi import MeziClient
+
+mezi = MeziClient()
+for event in mezi.stream_events(types=["deal.funded", "payout.released"]):
+    print(event["id"], event["type"], event["data"]["id"])  # dedupe on event["id"]
+```
+
+Where a proxy cuts long connections, `mezi.watch_events()` does the same job by polling. Both take `cursor` and `on_cursor` so a restart resumes where it stopped.
+
+## Check a webhook
+
+```python
+import os
+from flask import Flask, request
+from mezi import verify_webhook, WebhookVerificationError
+
+app = Flask(__name__)
+
+@app.post("/mezi/webhooks")
+def mezi_webhook():
+    try:
+        event = verify_webhook(
+            request.get_data(), request.headers.get("Mezi-Signature"), os.environ["MEZI_WEBHOOK_SECRET"]
+        )
+    except WebhookVerificationError:
+        return "", 400
+    print(event["type"], event["data"]["id"])
+    return "", 204
+```
+
+Errors from the API raise `MeziApiError`; branch on `err.code` (for example `DEAL_NOT_FOUND`).
+
+Full guide: https://developer.mezi.app/guides/client

mezi-0.1.0/mezi.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+mezi/__init__.py
+mezi/client.py
+mezi/py.typed
+mezi/types.py
+mezi/webhooks.py
+mezi.egg-info/PKG-INFO
+mezi.egg-info/SOURCES.txt
+mezi.egg-info/dependency_links.txt
+mezi.egg-info/top_level.txt

mezi-0.1.0/mezi.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mezi-0.1.0/mezi.egg-info/top_level.txt

@@ -0,0 +1 @@
+mezi

mezi-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mezi"
+version = "0.1.0"
+description = "The mezi API client and webhook verifier. Standard library only."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Pentarosa Co." }]
+dependencies = []
+keywords = ["mezi", "api", "webhooks", "payments"]
+classifiers = [
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Typing :: Typed",
+]
+
+[project.urls]
+Homepage = "https://developer.mezi.app"
+Documentation = "https://developer.mezi.app/guides/client"
+
+[tool.setuptools]
+packages = ["mezi"]
+
+[tool.setuptools.package-data]
+mezi = ["py.typed"]

mezi-0.1.0/setup.cfg

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