hooksniff-python 0.4.1__py3-none-any.whl

hooksniff/__init__.py

@@ -0,0 +1,41 @@
+"""
+HookSniff Python SDK - Webhook infrastructure for developers.
+
+Usage:
+    from hooksniff import HookSniff
+
+    hs = HookSniff("hr_live_...")
+
+    # Create application
+    app = hs.application.create(name="My App")
+
+    # Create endpoint
+    ep = hs.endpoint.create(url="https://app.com/webhook", application_id=app["id"])
+
+    # Send webhook
+    delivery = hs.webhook.send(endpoint_id=ep["id"], event="order.created", data={"id": "123"})
+"""
+
+from .client import HookSniff
+from .webhook import Webhook, WebhookVerificationError
+from .exceptions import (
+    HookSniffError,
+    AuthenticationError,
+    NotFoundError,
+    RateLimitError,
+    ValidationError,
+    ServerError,
+)
+
+__version__ = "0.4.1"
+__all__ = [
+    "HookSniff",
+    "Webhook",
+    "WebhookVerificationError",
+    "HookSniffError",
+    "AuthenticationError",
+    "NotFoundError",
+    "RateLimitError",
+    "ValidationError",
+    "ServerError",
+]

hooksniff/client.py

@@ -0,0 +1,108 @@
+"""
+HookSniff Python SDK client.
+
+Usage:
+    from hooksniff import HookSniff
+
+    hs = HookSniff("hr_live_...")
+
+    # Create application
+    app = hs.application.create(name="My App")
+
+    # Create endpoint
+    ep = hs.endpoint.create(url="https://app.com/webhook", application_id=app["id"])
+
+    # Send webhook
+    delivery = hs.webhook.send(endpoint_id=ep["id"], event="order.created", data={"id": "123"})
+
+    # Auto-pagination
+    for ep in hs.endpoint.list():
+        print(ep["url"])
+"""
+
+from typing import Any, Dict
+from .http_client import HttpClient
+from .resources import (
+    ApplicationResource,
+    EndpointResource,
+    WebhookResource,
+    ApiKeyResource,
+    AnalyticsResource,
+    SearchResource,
+    HealthResource,
+    BillingResource,
+    NotificationResource,
+    CortexResource,
+    TeamResource,
+    AlertResource,
+    TemplateResource,
+    SchemaResource,
+    ConnectorResource,
+    StreamResource,
+    BackgroundTaskResource,
+    IntegrationResource,
+    ServiceTokenResource,
+    OperationalWebhookResource,
+    RateLimitResource,
+    AuditResource,
+    SsoResource,
+    CustomDomainResource,
+    EnvironmentResource,
+)
+
+
+class HookSniff:
+    """
+    HookSniff SDK client.
+
+    Args:
+        api_key: Your HookSniff API key (hr_live_* or hr_test_*)
+        base_url: Custom API URL (optional)
+        timeout: Request timeout in seconds (default: 30)
+        retries: Max retries on 5xx/429 (default: 3)
+
+    Example:
+        hs = HookSniff("hr_live_...")
+        app = hs.application.create(name="My App")
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = None,
+        timeout: int = None,
+        retries: int = None,
+        headers: Dict[str, str] = None,
+    ):
+        self.http = HttpClient(api_key, base_url, timeout, retries, headers)
+
+        # Resources
+        self.application = ApplicationResource(self.http)
+        self.endpoint = EndpointResource(self.http)
+        self.webhook = WebhookResource(self.http)
+        self.api_key = ApiKeyResource(self.http)
+        self.analytics = AnalyticsResource(self.http)
+        self.search = SearchResource(self.http)
+        self.health = HealthResource(self.http)
+        self.billing = BillingResource(self.http)
+        self.notification = NotificationResource(self.http)
+        self.cortex = CortexResource(self.http)
+        self.team = TeamResource(self.http)
+        self.alert = AlertResource(self.http)
+        self.template = TemplateResource(self.http)
+        self.schema = SchemaResource(self.http)
+        self.connector = ConnectorResource(self.http)
+        self.stream = StreamResource(self.http)
+        self.background_task = BackgroundTaskResource(self.http)
+        self.integration = IntegrationResource(self.http)
+        self.service_token = ServiceTokenResource(self.http)
+        self.operational_webhook = OperationalWebhookResource(self.http)
+        self.rate_limit = RateLimitResource(self.http)
+        self.audit = AuditResource(self.http)
+        self.sso = SsoResource(self.http)
+        self.custom_domain = CustomDomainResource(self.http)
+        self.environment = EnvironmentResource(self.http)
+
+    def me(self) -> Dict[str, Any]:
+        """Get current user profile."""
+        return self.http.request("GET", "/v1/auth/me")

hooksniff/exceptions.py

@@ -0,0 +1,50 @@
+class HookSniffError(Exception):
+    """Base exception for HookSniff SDK."""
+    def __init__(self, message: str, status_code: int = None, code: str = None):
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+
+class AuthenticationError(HookSniffError):
+    """Invalid API key."""
+    def __init__(self, message: str = "Invalid API key"):
+        super().__init__(message, 401, "UNAUTHORIZED")
+
+class NotFoundError(HookSniffError):
+    """Resource not found."""
+    def __init__(self, message: str = "Resource not found"):
+        super().__init__(message, 404, "NOT_FOUND")
+
+class RateLimitError(HookSniffError):
+    """Rate limited."""
+    def __init__(self, message: str = "Rate limited", retry_after: int = 60):
+        super().__init__(message, 429, "RATE_LIMITED")
+        self.retry_after = retry_after
+
+class ValidationError(HookSniffError):
+    """Validation failed."""
+    def __init__(self, message: str = "Validation failed"):
+        super().__init__(message, 400, "BAD_REQUEST")
+
+class ServerError(HookSniffError):
+    """Internal server error."""
+    def __init__(self, message: str = "Internal server error"):
+        super().__init__(message, 500, "INTERNAL_ERROR")
+
+def map_error(status_code: int, body: dict) -> HookSniffError:
+    error = body.get("error", {})
+    code = error.get("code", "UNKNOWN")
+    detail = error.get("detail") or error.get("message") or "Unknown error"
+    
+    if status_code == 401:
+        return AuthenticationError(detail)
+    elif status_code == 404:
+        return NotFoundError(detail)
+    elif status_code == 429:
+        return RateLimitError(detail)
+    elif status_code in (400, 422):
+        return ValidationError(detail)
+    elif status_code >= 500:
+        return ServerError(detail)
+    else:
+        return HookSniffError(detail, status_code, code)

hooksniff/http_client.py

@@ -0,0 +1,138 @@
+import json
+import time
+import urllib.request
+import urllib.error
+from typing import Any, Dict, Optional
+from .exceptions import map_error, RateLimitError, HookSniffError
+
+DEFAULT_BASE_URL = "https://hooksniff-api-e6ztf3x2ma-ew.a.run.app"
+DEFAULT_TIMEOUT = 30
+DEFAULT_RETRIES = 3
+SDK_VERSION = "0.4.0"
+
+
+class HttpClient:
+    def __init__(self, api_key: str, base_url: str = None, timeout: int = None, retries: int = None, headers: Dict[str, str] = None):
+        if not api_key:
+            raise ValueError("HookSniff API key is required")
+        self.api_key = api_key
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout or DEFAULT_TIMEOUT
+        self.retries = retries if retries is not None else DEFAULT_RETRIES
+        self.extra_headers = headers or {}
+
+    def request(self, method: str, path: str, body: Any = None, options: Dict[str, str] = None) -> Any:
+        url = f"{self.base_url}{path}"
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+            "User-Agent": f"hooksniff-sdk/python/{SDK_VERSION}",
+            **self.extra_headers,
+        }
+
+        if options and options.get("idempotency_key"):
+            headers["Idempotency-Key"] = options["idempotency_key"]
+
+        last_error = None
+
+        for attempt in range(self.retries + 1):
+            try:
+                data = json.dumps(body).encode("utf-8") if body else None
+                req = urllib.request.Request(url, data=data, headers=headers, method=method)
+                
+                with urllib.request.urlopen(req, timeout=self.timeout) as response:
+                    response_body = response.read().decode("utf-8")
+                    if not response_body:
+                        return None
+                    return json.loads(response_body)
+
+            except urllib.error.HTTPError as e:
+                try:
+                    error_body = json.loads(e.read().decode("utf-8"))
+                except Exception:
+                    error_body = {}
+
+                # Don't retry client errors except 429 and 408
+                if 400 <= e.code < 500 and e.code != 429 and e.code != 408:
+                    raise map_error(e.code, error_body)
+
+                # Handle rate limiting
+                if e.code == 429:
+                    retry_after = int(e.headers.get("Retry-After", "60"))
+                    if attempt < self.retries:
+                        time.sleep(retry_after)
+                        continue
+                    raise RateLimitError(error_body.get("error", {}).get("detail", "Rate limited"), retry_after)
+
+                # Server errors and timeouts - retry
+                last_error = map_error(e.code, error_body)
+                if attempt < self.retries:
+                    time.sleep(2 ** attempt + 0.5)
+                    continue
+
+                raise last_error
+
+            except Exception as e:
+                last_error = e
+                if attempt < self.retries:
+                    time.sleep(2 ** attempt + 0.5)
+                    continue
+
+        raise last_error or Exception("Request failed after retries")
+
+
+class PaginatedList:
+    """Auto-paginating list iterator."""
+
+    def __init__(self, http: HttpClient, path: str, params: Dict[str, Any] = None, per_page: int = 50):
+        self.http = http
+        self.path = path
+        self.params = params or {}
+        self.per_page = per_page
+        self.page = 1
+        self.items = []
+        self.exhausted = False
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        if not self.items and not self.exhausted:
+            self._fetch_page()
+        
+        if not self.items:
+            raise StopIteration
+        
+        return self.items.pop(0)
+
+    def _fetch_page(self):
+        params = {**self.params, "page": str(self.page), "per_page": str(self.per_page)}
+        query = "&".join(f"{k}={v}" for k, v in params.items() if v)
+        path = f"{self.path}?{query}" if query else self.path
+        
+        response = self.http.request("GET", path)
+        
+        if isinstance(response, list):
+            self.items = response
+            if len(self.items) < self.per_page:
+                self.exhausted = True
+        elif isinstance(response, dict):
+            # Handle different response formats
+            if "deliveries" in response:
+                self.items = response["deliveries"]
+            elif "data" in response:
+                self.items = response["data"]
+            elif "applications" in response:
+                self.items = response["applications"]
+            elif "endpoints" in response:
+                self.items = response["endpoints"]
+            else:
+                self.items = []
+            if not self.items or response.get("has_more") is False:
+                self.exhausted = True
+        
+        self.page += 1
+
+    def all(self) -> list:
+        """Collect all items into a list."""
+        return list(self)

hooksniff/resources.py

@@ -0,0 +1,410 @@
+from typing import Any, Dict, List, Optional
+from .http_client import HttpClient, PaginatedList
+
+
+class ApplicationResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def create(self, name: str, description: str = None) -> Dict[str, Any]:
+        body = {"name": name}
+        if description:
+            body["description"] = description
+        return self.http.request("POST", "/v1/applications", body)
+
+    def list(self, per_page: int = 50) -> PaginatedList:
+        return PaginatedList(self.http, "/v1/applications", per_page=per_page)
+
+    def get(self, application_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/applications/{application_id}")
+
+    def update(self, application_id: str, **kwargs) -> Dict[str, Any]:
+        return self.http.request("PUT", f"/v1/applications/{application_id}", kwargs)
+
+    def delete(self, application_id: str) -> None:
+        self.http.request("DELETE", f"/v1/applications/{application_id}")
+
+
+class EndpointResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def create(self, url: str, application_id: str, description: str = None, **kwargs) -> Dict[str, Any]:
+        body = {"url": url, "application_id": application_id}
+        if description:
+            body["description"] = description
+        body.update(kwargs)
+        return self.http.request("POST", "/v1/endpoints", body)
+
+    def list(self, per_page: int = 50) -> PaginatedList:
+        return PaginatedList(self.http, "/v1/endpoints", per_page=per_page)
+
+    def get(self, endpoint_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/endpoints/{endpoint_id}")
+
+    def update(self, endpoint_id: str, **kwargs) -> Dict[str, Any]:
+        return self.http.request("PUT", f"/v1/endpoints/{endpoint_id}", kwargs)
+
+    def delete(self, endpoint_id: str) -> None:
+        self.http.request("DELETE", f"/v1/endpoints/{endpoint_id}")
+
+    def rotate_secret(self, endpoint_id: str) -> Dict[str, Any]:
+        return self.http.request("POST", f"/v1/endpoints/{endpoint_id}/rotate-secret")
+
+
+class WebhookResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def send(self, endpoint_id: str, event: str, data: Dict[str, Any], idempotency_key: str = None) -> Dict[str, Any]:
+        body = {"endpoint_id": endpoint_id, "event": event, "data": data}
+        options = {"idempotency_key": idempotency_key} if idempotency_key else None
+        return self.http.request("POST", "/v1/webhooks", body, options)
+
+    def send_batch(self, webhooks: List[Dict[str, Any]]) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/webhooks/batch", {"webhooks": webhooks})
+
+    def list(self, per_page: int = 50, endpoint_id: str = None, status: str = None) -> PaginatedList:
+        params = {}
+        if endpoint_id:
+            params["endpoint_id"] = endpoint_id
+        if status:
+            params["status"] = status
+        return PaginatedList(self.http, "/v1/webhooks", params=params, per_page=per_page)
+
+    def get(self, webhook_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/webhooks/{webhook_id}")
+
+    def replay(self, webhook_id: str) -> Dict[str, Any]:
+        return self.http.request("POST", f"/v1/webhooks/{webhook_id}/replay")
+
+
+class ApiKeyResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/api-keys")
+
+    def create(self, name: str) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/api-keys", {"name": name})
+
+    def delete(self, api_key_id: str) -> None:
+        self.http.request("DELETE", f"/v1/api-keys/{api_key_id}")
+
+
+class AnalyticsResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def deliveries(self, range: str = "24h") -> Any:
+        return self.http.request("GET", f"/v1/analytics/deliveries?range={range}")
+
+    def success_rate(self, range: str = "24h") -> Any:
+        return self.http.request("GET", f"/v1/analytics/success-rate?range={range}")
+
+
+class SearchResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def deliveries(self, query: str, page: int = 1, per_page: int = 20) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/search?q={query}&page={page}&per_page={per_page}")
+
+
+class HealthResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def check(self) -> Dict[str, Any]:
+        return self.http.request("GET", "/health")
+
+    def outbound_ips(self) -> Dict[str, Any]:
+        return self.http.request("GET", "/v1/outbound-ips")
+
+
+class BillingResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def subscription(self) -> Dict[str, Any]:
+        return self.http.request("GET", "/v1/billing/subscription")
+
+    def upgrade(self, plan: str) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/billing/upgrade", {"plan": plan})
+
+    def portal(self) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/billing/portal")
+
+
+class NotificationResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self, per_page: int = 20) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/notifications?per_page={per_page}")
+
+    def get_unread_count(self) -> Dict[str, Any]:
+        response = self.http.request("GET", "/v1/notifications/unread-count")
+        return {"count": response.get("unread_count", 0)}
+
+    def mark_read(self, notification_id: str) -> None:
+        self.http.request("POST", f"/v1/notifications/{notification_id}/read")
+
+    def mark_all_read(self) -> None:
+        self.http.request("POST", "/v1/notifications/read-all")
+
+
+class CortexResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def insights(self) -> List[Dict[str, Any]]:
+        response = self.http.request("GET", "/v1/cortex/insights")
+        if isinstance(response, dict) and "insights" in response:
+            raw = response["insights"]
+            result = []
+            for row in raw:
+                if isinstance(row, list) and len(row) >= 10:
+                    result.append({
+                        "id": row[0],
+                        "customer_id": row[1],
+                        "type": row[2],
+                        "title": row[3],
+                        "description": row[4],
+                        "severity": row[5],
+                        "metadata": row[7] if len(row) > 7 else {},
+                        "created_at": row[9] if len(row) > 9 else None,
+                    })
+                else:
+                    result.append(row)
+            return result
+        return response if isinstance(response, list) else []
+
+    def anomalies(self, endpoint_id: str = None) -> List[Dict[str, Any]]:
+        path = "/v1/cortex/anomalies"
+        if endpoint_id:
+            path += f"?endpoint_id={endpoint_id}"
+        return self.http.request("GET", path)
+
+    def predict(self, endpoint_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/cortex/predict/{endpoint_id}")
+
+    def auto_heal(self, endpoint_id: str) -> Dict[str, Any]:
+        return self.http.request("POST", f"/v1/cortex/auto-heal/{endpoint_id}")
+
+
+class TeamResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/teams")
+
+    def create(self, name: str, description: str = None) -> Dict[str, Any]:
+        body = {"name": name}
+        if description:
+            body["description"] = description
+        return self.http.request("POST", "/v1/teams", body)
+
+    def get(self, team_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/teams/{team_id}")
+
+    def delete(self, team_id: str) -> None:
+        self.http.request("DELETE", f"/v1/teams/{team_id}")
+
+
+class AlertResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        response = self.http.request("GET", "/v1/alerts")
+        return response if isinstance(response, list) else response.get("alerts", [])
+
+    def create(self, name: str, condition: str, threshold: int, channels: List[str]) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/alerts", {
+            "name": name, "condition": condition, "threshold": threshold, "channels": channels
+        })
+
+    def get(self, alert_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/alerts/{alert_id}")
+
+    def delete(self, alert_id: str) -> None:
+        self.http.request("DELETE", f"/v1/alerts/{alert_id}")
+
+
+class TemplateResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        response = self.http.request("GET", "/v1/templates")
+        return response if isinstance(response, list) else response.get("templates", [])
+
+    def get(self, template_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/templates/{template_id}")
+
+
+class SchemaResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        response = self.http.request("GET", "/v1/schemas")
+        return response if isinstance(response, list) else response.get("schemas", [])
+
+    def create(self, name: str, schema: Dict[str, Any]) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/schemas", {"name": name, "schema": schema})
+
+    def get(self, schema_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/schemas/{schema_id}")
+
+    def delete(self, schema_id: str) -> None:
+        self.http.request("DELETE", f"/v1/schemas/{schema_id}")
+
+
+class ConnectorResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/connectors")
+
+    def get(self, connector_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/connectors/{connector_id}")
+
+    def list_configs(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/connectors/configs")
+
+    def create_config(self, connector_id: str, name: str, config: Dict[str, Any]) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/connectors/configs", {
+            "connector_id": connector_id, "name": name, "config": config
+        })
+
+
+class StreamResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list_channels(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/stream/channels")
+
+    def create_channel(self, name: str, description: str = None) -> Dict[str, Any]:
+        body = {"name": name}
+        if description:
+            body["description"] = description
+        return self.http.request("POST", "/v1/stream/channels", body)
+
+    def get_channel(self, channel_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/stream/channels/{channel_id}")
+
+    def delete_channel(self, channel_id: str) -> None:
+        self.http.request("DELETE", f"/v1/stream/channels/{channel_id}")
+
+    def publish(self, channel_id: str, event: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/stream/publish", {
+            "channel_id": channel_id, "event": event, "data": data
+        })
+
+    def list_subscriptions(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/stream/subscriptions")
+
+
+class BackgroundTaskResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/background-tasks")
+
+    def get(self, task_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/background-tasks/{task_id}")
+
+    def cancel(self, task_id: str) -> None:
+        self.http.request("POST", f"/v1/background-tasks/{task_id}/cancel")
+
+
+class IntegrationResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/integrations")
+
+    def get(self, integration_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/integrations/{integration_id}")
+
+    def delete(self, integration_id: str) -> None:
+        self.http.request("DELETE", f"/v1/integrations/{integration_id}")
+
+
+class ServiceTokenResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/service-tokens")
+
+    def create(self, name: str) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/service-tokens", {"name": name})
+
+    def delete(self, token_id: str) -> None:
+        self.http.request("DELETE", f"/v1/service-tokens/{token_id}")
+
+
+class OperationalWebhookResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/operational-webhooks")
+
+    def create(self, url: str, events: List[str]) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/operational-webhooks", {"url": url, "events": events})
+
+    def get(self, webhook_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/operational-webhooks/{webhook_id}")
+
+    def delete(self, webhook_id: str) -> None:
+        self.http.request("DELETE", f"/v1/operational-webhooks/{webhook_id}")
+
+
+class RateLimitResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/rate-limits")
+
+
+class AuditResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> Dict[str, Any]:
+        return self.http.request("GET", "/v1/audit-log")
+
+
+class SsoResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def get_config(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/sso/config")
+
+
+class CustomDomainResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/custom-domains")
+
+
+class EnvironmentResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/environments")

hooksniff/webhook.py

@@ -0,0 +1,85 @@
+import json
+import time
+import hmac
+import hashlib
+import base64
+from typing import Any, Dict, Union
+
+
+class WebhookVerificationError(Exception):
+    """Webhook verification failed."""
+    pass
+
+
+class Webhook:
+    """
+    Verify and parse incoming webhook payloads.
+    Compliant with the Standard Webhooks specification.
+
+    Usage:
+        wh = Webhook("whsec_...")
+        event = wh.verify(request.body, request.headers)
+    """
+
+    def __init__(self, secret: str):
+        if not secret:
+            raise ValueError("Webhook secret is required")
+        self.secret = secret
+
+    def verify(self, payload: Union[str, bytes], headers: Dict[str, str]) -> Any:
+        normalized_headers = {k.lower(): v for k, v in headers.items()}
+
+        msg_id = normalized_headers.get("webhook-id")
+        msg_signature = normalized_headers.get("webhook-signature")
+        msg_timestamp = normalized_headers.get("webhook-timestamp")
+
+        if not msg_id or not msg_signature or not msg_timestamp:
+            raise WebhookVerificationError(
+                "Missing required webhook headers (webhook-id, webhook-signature, webhook-timestamp)"
+            )
+
+        try:
+            timestamp = int(msg_timestamp)
+        except ValueError:
+            raise WebhookVerificationError("Invalid webhook timestamp")
+
+        now = int(time.time())
+        if abs(now - timestamp) > 300:
+            raise WebhookVerificationError("Webhook timestamp is too old")
+
+        content = payload if isinstance(payload, str) else payload.decode("utf-8")
+        to_sign = f"{msg_id}.{msg_timestamp}.{content}"
+        expected_signature = self._sign(to_sign)
+
+        signatures = msg_signature.split(" ")
+        is_valid = False
+        for sig in signatures:
+            parts = sig.split(",", 1)
+            if len(parts) != 2:
+                continue
+            version, signature = parts
+            if version != "v1":
+                continue
+
+            try:
+                if hmac.compare_digest(signature, expected_signature):
+                    is_valid = True
+                    break
+            except Exception:
+                continue
+
+        if not is_valid:
+            raise WebhookVerificationError("Invalid webhook signature")
+
+        return json.loads(content)
+
+    def _sign(self, content: str) -> str:
+        secret_bytes = self.secret.replace("whsec_", "").encode("utf-8")
+        try:
+            secret_key = base64.b64decode(secret_bytes)
+        except Exception:
+            secret_key = secret_bytes
+        
+        return base64.b64encode(
+            hmac.new(secret_key, content.encode("utf-8"), hashlib.sha256).digest()
+        ).decode("utf-8")

hooksniff_python-0.4.1.dist-info/METADATA

@@ -0,0 +1,284 @@
+Metadata-Version: 2.4
+Name: hooksniff-python
+Version: 0.4.1
+Summary: Official HookSniff SDK for Python - Webhook infrastructure for developers
+Project-URL: Homepage, https://hooksniff.vercel.app
+Project-URL: Repository, https://github.com/servetarslan02/hooksniff-python
+Author-email: HookSniff <support@hooksniff.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: api,hooksniff,sdk,webhook,webhooks
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# HookSniff Python SDK
+
+Official Python SDK for [HookSniff](https://hooksniff.vercel.app) — the webhook infrastructure for developers.
+
+## Installation
+
+```bash
+pip install hooksniff
+```
+
+## Quick Start
+
+```python
+from hooksniff import HookSniff
+
+hs = HookSniff("hr_live_...")
+
+# Create an application
+app = hs.application.create(name="My App")
+
+# Create an endpoint
+ep = hs.endpoint.create(
+    url="https://app.com/webhook",
+    application_id=app["id"],
+    description="Order notifications",
+)
+
+# Send a webhook
+delivery = hs.webhook.send(
+    endpoint_id=ep["id"],
+    event="order.created",
+    data={"order_id": "12345", "amount": 99.99},
+)
+
+print(delivery["id"])  # "msg_..."
+```
+
+## Features
+
+- **Simple API** — 2 lines to send a webhook
+- **Auto-pagination** — Iterate through all resources automatically
+- **Auto-retry** — Exponential backoff on 429/5xx errors
+- **Idempotency** — Built-in idempotency key support
+- **Webhook verification** — Verify incoming webhooks (Standard Webhooks compliant)
+- **Error handling** — Typed exceptions
+- **27+ Resources** — Application, Endpoint, Webhook, Billing, Cortex, Teams, and more
+
+## Usage
+
+### Applications
+
+```python
+# Create
+app = hs.application.create(name="My App", description="My application")
+
+# List with auto-pagination
+for app in hs.application.list():
+    print(app["name"])
+
+# Get
+app = hs.application.get("app_123")
+
+# Update
+app = hs.application.update("app_123", name="New Name")
+
+# Delete
+hs.application.delete("app_123")
+```
+
+### Endpoints
+
+```python
+# Create
+ep = hs.endpoint.create(
+    url="https://app.com/webhook",
+    application_id="app_123",
+    description="Order notifications",
+)
+
+# List with auto-pagination
+for ep in hs.endpoint.list():
+    print(ep["url"])
+
+# Get
+ep = hs.endpoint.get("ep_123")
+
+# Update
+ep = hs.endpoint.update("ep_123", url="https://new-url.com/webhook")
+
+# Delete
+hs.endpoint.delete("ep_123")
+
+# Rotate signing secret
+secret = hs.endpoint.rotate_secret("ep_123")
+print(secret["signing_secret"])  # "whsec_..."
+```
+
+### Webhooks
+
+```python
+# Send a webhook
+delivery = hs.webhook.send(
+    endpoint_id="ep_123",
+    event="order.created",
+    data={"order_id": "12345", "amount": 99.99},
+)
+
+# Send with idempotency key
+delivery = hs.webhook.send(
+    endpoint_id="ep_123",
+    event="order.created",
+    data={},
+    idempotency_key="unique-key-123",
+)
+
+# Send batch
+result = hs.webhook.send_batch([
+    {"endpoint_id": "ep_123", "event": "order.created", "data": {"id": "1"}},
+    {"endpoint_id": "ep_123", "event": "order.created", "data": {"id": "2"}},
+])
+
+# List deliveries with auto-pagination
+for d in hs.webhook.list(per_page=10):
+    print(d["status"])
+
+# Get delivery
+delivery = hs.webhook.get("msg_123")
+
+# Replay delivery
+delivery = hs.webhook.replay("msg_123")
+```
+
+### Webhook Verification
+
+```python
+from hooksniff import Webhook, WebhookVerificationError
+
+wh = Webhook("whsec_...")
+
+# In your Flask/FastAPI handler:
+def handle_webhook(request):
+    try:
+        event = wh.verify(request.body, request.headers)
+        print(event)
+        return "OK", 200
+    except WebhookVerificationError:
+        return "Invalid signature", 401
+```
+
+### Error Handling
+
+```python
+from hooksniff import AuthenticationError, NotFoundError, RateLimitError
+
+try:
+    hs.endpoint.get("invalid_id")
+except NotFoundError:
+    print("Endpoint not found")
+except AuthenticationError:
+    print("Invalid API key")
+except RateLimitError as e:
+    print(f"Rate limited, retry after {e.retry_after}s")
+```
+
+### All Resources
+
+```python
+# API Keys
+hs.api_key.list()
+hs.api_key.create(name="Production Key")
+hs.api_key.delete("key_123")
+
+# Analytics
+hs.analytics.deliveries(range="24h")
+hs.analytics.success_rate(range="7d")
+
+# Billing
+hs.billing.subscription()
+hs.billing.upgrade(plan="pro")
+hs.billing.portal()
+
+# Teams
+hs.team.list()
+hs.team.create(name="Engineering")
+
+# Cortex AI
+hs.cortex.insights()
+hs.cortex.anomalies(endpoint_id="ep_123")
+hs.cortex.predict("ep_123")
+hs.cortex.auto_heal("ep_123")
+
+# Notifications
+hs.notification.list()
+hs.notification.get_unread_count()
+hs.notification.mark_read("notif_123")
+hs.notification.mark_all_read()
+
+# Templates
+hs.template.list()
+hs.template.get("tmpl_123")
+
+# Schemas
+hs.schema.list()
+hs.schema.create(name="Order Schema", schema={...})
+hs.schema.validate("schema_123", {"order_id": "123"})
+
+# Alerts
+hs.alert.list()
+hs.alert.create(name="...", condition="failure_rate", threshold=10, channels=["email"])
+
+# Connectors
+hs.connector.list()
+hs.connector.list_configs()
+
+# Stream
+hs.stream.list_channels()
+hs.stream.publish(channel_id="ch_123", event="test", data={...})
+
+# Background Tasks
+hs.background_task.list()
+hs.background_task.get("task_123")
+
+# Integrations
+hs.integration.list()
+
+# Service Tokens
+hs.service_token.list()
+
+# Operational Webhooks
+hs.operational_webhook.list()
+
+# Search
+hs.search.deliveries("order.created")
+
+# Health
+hs.health.check()
+hs.health.outbound_ips()
+
+# User
+hs.me()
+```
+
+## Configuration
+
+```python
+hs = HookSniff(
+    "hr_live_...",
+    base_url="https://your-instance.com",  # Custom API URL
+    timeout=30,                             # Request timeout (seconds)
+    retries=3,                              # Max retries on 5xx/429
+    headers={"X-Custom": "value"},          # Custom headers
+)
+```
+
+## Requirements
+
+- Python 3.8+
+
+## License
+
+MIT — see [LICENSE](LICENSE) for details.

hooksniff_python-0.4.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+hooksniff/__init__.py,sha256=-umMsNLbD7dXy5F0lwRSdCGszw9DrsJUN9moD1puGug,917
+hooksniff/client.py,sha256=2fej_BEzzsMChLvpKZgu-yhuMXO_CfHEr6eUS1rATe8,3292
+hooksniff/exceptions.py,sha256=6gMV_z99GPo50eoQvTgJ4TMdKrijJsGdI6o6c2ZshdE,1857
+hooksniff/http_client.py,sha256=PJjtnmbTLhP37dXmayn2notznqUr3J9LEMmJUa3akUc,5038
+hooksniff/resources.py,sha256=s72ROxldkvhqKvX8s7kiKkBymP_UXmAc1-HB1mEjGLU,14648
+hooksniff/webhook.py,sha256=fRiCwe7iO3VJCs5LMPuJqVg90ahiwP9x4Rfl8hX5uP4,2680
+hooksniff_python-0.4.1.dist-info/METADATA,sha256=1zSa9rZ6OgfcsvFCY8i3M_nyyPWBE82IGsVcd3-lojE,6355
+hooksniff_python-0.4.1.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+hooksniff_python-0.4.1.dist-info/licenses/LICENSE,sha256=vUMb56ZR5dltGS5hpFwKXc8P5mMh4E8S1zwf3MIVAZE,1066
+hooksniff_python-0.4.1.dist-info/RECORD,,

hooksniff_python-0.4.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

hooksniff_python-0.4.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HookSniff
+
+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.