hooksniff-python 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

hooksniff/__init__.py

@@ -27,7 +27,7 @@ from .exceptions import (
     ServerError,
 )
 
-__version__ = "0.4.1"
+__version__ = "0.4.3"
 __all__ = [
     "HookSniff",
     "Webhook",

hooksniff/client.py

@@ -23,6 +23,8 @@ Usage:
 from typing import Any, Dict
 from .http_client import HttpClient
 from .resources import (
+    BroadcastResource,
+    TransformResource,
     ApplicationResource,
     EndpointResource,
     WebhookResource,
@@ -102,6 +104,8 @@ class HookSniff:
         self.sso = SsoResource(self.http)
         self.custom_domain = CustomDomainResource(self.http)
         self.environment = EnvironmentResource(self.http)
+        self.broadcast = BroadcastResource(self.http)
+        self.transform = TransformResource(self.http)
 
     def me(self) -> Dict[str, Any]:
         """Get current user profile."""

hooksniff/resources/__init__.py

@@ -0,0 +1,58 @@
+"""HookSniff SDK resources."""
+
+from .application import ApplicationResource
+from .endpoint import EndpointResource
+from .webhook import WebhookResource
+from .api_key import ApiKeyResource
+from .analytics import AnalyticsResource
+from .search import SearchResource
+from .health import HealthResource
+from .billing import BillingResource
+from .notification import NotificationResource
+from .cortex import CortexResource
+from .team import TeamResource
+from .alert import AlertResource
+from .template import TemplateResource
+from .schema import SchemaResource
+from .connector import ConnectorResource
+from .stream import StreamResource
+from .advanced import (
+    BackgroundTaskResource,
+    IntegrationResource,
+    ServiceTokenResource,
+    OperationalWebhookResource,
+)
+from .routing import RateLimitResource, AuditResource
+from .platform import SsoResource, CustomDomainResource, EnvironmentResource
+from .broadcast import BroadcastResource
+from .transform import TransformResource
+
+__all__ = [
+    "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",
+    "BroadcastResource",
+    "TransformResource",
+]

hooksniff/resources/advanced.py

@@ -0,0 +1,66 @@
+"""Advanced resources: Background tasks, Integrations, Service tokens, Operational webhooks."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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}")
+
+    def rotate_key(self, integration_id: str) -> Dict[str, Any]:
+        return self.http.request("POST", f"/v1/integrations/{integration_id}/rotate-key")
+
+
+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}")

hooksniff/resources/alert.py

@@ -0,0 +1,30 @@
+"""Alert resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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 update(self, alert_id: str, **kwargs) -> Dict[str, Any]:
+        return self.http.request("PUT", f"/v1/alerts/{alert_id}", kwargs)
+
+    def delete(self, alert_id: str) -> None:
+        self.http.request("DELETE", f"/v1/alerts/{alert_id}")
+
+    def list_events(self, alert_id: str) -> List[Dict[str, Any]]:
+        return self.http.request("GET", f"/v1/alerts/{alert_id}/events")

hooksniff/resources/analytics.py

@@ -0,0 +1,18 @@
+"""Analytics resource."""
+
+from typing import Any
+from ..http_client import HttpClient
+
+
+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}")
+
+    def latency(self, range: str = "24h") -> Any:
+        return self.http.request("GET", f"/v1/analytics/latency?range={range}")

hooksniff/resources/api_key.py

@@ -0,0 +1,21 @@
+"""API Key resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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}")
+
+    def rotate(self, api_key_id: str) -> Dict[str, Any]:
+        return self.http.request("POST", f"/v1/api-keys/{api_key_id}/rotate")

hooksniff/resources/application.py

@@ -0,0 +1,27 @@
+"""Application resource."""
+
+from typing import Any, Dict
+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: Dict[str, Any] = {"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}")

hooksniff/resources/billing.py

@@ -0,0 +1,24 @@
+"""Billing resource."""
+
+from typing import Any, Dict
+from ..http_client import HttpClient
+
+
+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")
+
+    def usage(self) -> Dict[str, Any]:
+        return self.http.request("GET", "/v1/billing/usage")
+
+    def invoices(self) -> Dict[str, Any]:
+        return self.http.request("GET", "/v1/billing/invoices")

hooksniff/resources/broadcast.py

@@ -0,0 +1,27 @@
+"""Broadcast resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+class BroadcastResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self) -> List[Dict[str, Any]]:
+        return self.http.request("GET", "/v1/broadcasts")
+
+    def create(self, title: str, message: str, scheduled_at: str = None) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"title": title, "message": message}
+        if scheduled_at:
+            body["scheduled_at"] = scheduled_at
+        return self.http.request("POST", "/v1/broadcasts", body)
+
+    def get(self, broadcast_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/broadcasts/{broadcast_id}")
+
+    def delete(self, broadcast_id: str) -> None:
+        self.http.request("DELETE", f"/v1/broadcasts/{broadcast_id}")
+
+    def send(self, broadcast_id: str) -> None:
+        self.http.request("POST", f"/v1/broadcasts/{broadcast_id}/send")

hooksniff/resources/connector.py

@@ -0,0 +1,32 @@
+"""Connector resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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
+        })
+
+    def get_config(self, config_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/connectors/configs/{config_id}")
+
+    def update_config(self, config_id: str, **kwargs) -> Dict[str, Any]:
+        return self.http.request("PUT", f"/v1/connectors/configs/{config_id}", kwargs)
+
+    def delete_config(self, config_id: str) -> None:
+        self.http.request("DELETE", f"/v1/connectors/configs/{config_id}")

hooksniff/resources/cortex.py

@@ -0,0 +1,43 @@
+"""Cortex AI resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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}")

hooksniff/resources/endpoint.py

@@ -0,0 +1,31 @@
+"""Endpoint resource."""
+
+from typing import Any, Dict
+from ..http_client import HttpClient, PaginatedList
+
+
+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: Dict[str, Any] = {"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")

hooksniff/resources/health.py

@@ -0,0 +1,15 @@
+"""Health resource."""
+
+from typing import Any, Dict
+from ..http_client import HttpClient
+
+
+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")

hooksniff/resources/notification.py

@@ -0,0 +1,22 @@
+"""Notification resource."""
+
+from typing import Any, Dict
+from ..http_client import HttpClient
+
+
+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")

hooksniff/resources/platform.py

@@ -0,0 +1,28 @@
+"""Platform resources: SSO, Custom domains, Environments."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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/resources/routing.py

@@ -0,0 +1,20 @@
+"""Routing resources: Rate limits, Audit log."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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")

hooksniff/resources/schema.py

@@ -0,0 +1,25 @@
+"""Schema resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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}")
+
+    def validate(self, schema_id: str, data: Any) -> Dict[str, Any]:
+        return self.http.request("POST", f"/v1/schemas/{schema_id}/validate", {"data": data})

hooksniff/resources/search.py

@@ -0,0 +1,12 @@
+"""Search resource."""
+
+from typing import Any, Dict
+from ..http_client import HttpClient
+
+
+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}")

hooksniff/resources/stream.py

@@ -0,0 +1,41 @@
+"""Stream resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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: Dict[str, Any] = {"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 list_messages(self, channel_id: str) -> List[Dict[str, Any]]:
+        return self.http.request("GET", f"/v1/stream/channels/{channel_id}/messages")
+
+    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")
+
+    def get_subscription(self, subscription_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/stream/subscriptions/{subscription_id}")
+
+    def disconnect_subscription(self, subscription_id: str) -> None:
+        self.http.request("DELETE", f"/v1/stream/subscriptions/{subscription_id}")

hooksniff/resources/team.py

@@ -0,0 +1,33 @@
+"""Team resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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: Dict[str, Any] = {"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}")
+
+    def list_members(self, team_id: str) -> List[Dict[str, Any]]:
+        return self.http.request("GET", f"/v1/teams/{team_id}/members")
+
+    def invite_member(self, team_id: str, email: str, role: str = "viewer") -> Dict[str, Any]:
+        return self.http.request("POST", f"/v1/teams/{team_id}/members", {"email": email, "role": role})
+
+    def remove_member(self, team_id: str, member_id: str) -> None:
+        self.http.request("DELETE", f"/v1/teams/{team_id}/members/{member_id}")

hooksniff/resources/template.py

@@ -0,0 +1,28 @@
+"""Template resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+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 create(self, name: str, content: str, description: str = None) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"name": name, "content": content}
+        if description:
+            body["description"] = description
+        return self.http.request("POST", "/v1/templates", body)
+
+    def get(self, template_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/templates/{template_id}")
+
+    def update(self, template_id: str, **kwargs) -> Dict[str, Any]:
+        return self.http.request("PUT", f"/v1/templates/{template_id}", kwargs)
+
+    def delete(self, template_id: str) -> None:
+        self.http.request("DELETE", f"/v1/templates/{template_id}")

hooksniff/resources/transform.py

@@ -0,0 +1,24 @@
+"""Transform resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient
+
+
+class TransformResource:
+    def __init__(self, http: HttpClient):
+        self.http = http
+
+    def list(self, endpoint_id: str) -> List[Dict[str, Any]]:
+        return self.http.request("GET", f"/v1/endpoints/{endpoint_id}/transforms")
+
+    def create(self, endpoint_id: str, name: str, code: str) -> Dict[str, Any]:
+        return self.http.request("POST", f"/v1/endpoints/{endpoint_id}/transforms", {"name": name, "code": code})
+
+    def get(self, endpoint_id: str, transform_id: str) -> Dict[str, Any]:
+        return self.http.request("GET", f"/v1/endpoints/{endpoint_id}/transforms/{transform_id}")
+
+    def update(self, endpoint_id: str, transform_id: str, **kwargs) -> Dict[str, Any]:
+        return self.http.request("PUT", f"/v1/endpoints/{endpoint_id}/transforms/{transform_id}", kwargs)
+
+    def delete(self, endpoint_id: str, transform_id: str) -> None:
+        self.http.request("DELETE", f"/v1/endpoints/{endpoint_id}/transforms/{transform_id}")

hooksniff/resources/webhook.py

@@ -0,0 +1,34 @@
+"""Webhook resource."""
+
+from typing import Any, Dict, List
+from ..http_client import HttpClient, PaginatedList
+
+
+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: Dict[str, str] = {}
+        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")
+
+    def batch_replay(self, webhook_ids: List[str]) -> Dict[str, Any]:
+        return self.http.request("POST", "/v1/webhooks/batch-replay", {"webhook_ids": webhook_ids})

hooksniff/webhook.py

@@ -81,5 +81,5 @@ class Webhook:
             secret_key = secret_bytes
         
         return base64.b64encode(
-            hmac.new(secret_key, content.encode("utf-8"), hashlib.sha256).digest()
+            hmac.HMAC(secret_key, content.encode("utf-8"), hashlib.sha256).digest()
         ).decode("utf-8")

{hooksniff_python-0.4.1.dist-info → hooksniff_python-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hooksniff-python
-Version: 0.4.1
+Version: 0.4.3
 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
@@ -28,7 +28,7 @@ Official Python SDK for [HookSniff](https://hooksniff.vercel.app) — the webhoo
 ## Installation
 
 ```bash
-pip install hooksniff
+pip install hooksniff-python
 ```
 
 ## Quick Start

hooksniff_python-0.4.3.dist-info/RECORD

@@ -0,0 +1,31 @@
+hooksniff/__init__.py,sha256=8TC7LGxK8m-xzyjvX1mVUxWATtn7vy5tbdaTcNd3fJ4,917
+hooksniff/client.py,sha256=D_h7IL68Zo24mpqwJ4G50wbDeknpgO7R15G1VnLfk9E,3446
+hooksniff/exceptions.py,sha256=6gMV_z99GPo50eoQvTgJ4TMdKrijJsGdI6o6c2ZshdE,1857
+hooksniff/http_client.py,sha256=PJjtnmbTLhP37dXmayn2notznqUr3J9LEMmJUa3akUc,5038
+hooksniff/webhook.py,sha256=kkjfzdoWgkbT-jh3HT1gnU7MpuJdXqjxmJf9jU_JuZQ,2681
+hooksniff/resources/__init__.py,sha256=EAvjWMudGdOacS_ddH9V7MFibuTACz5dbjZ9QAfS_3E,1659
+hooksniff/resources/advanced.py,sha256=dUVm2NhbN_U2P-iVMtVd9zvepP1KVB7jdwO_h5yqjcY,2346
+hooksniff/resources/alert.py,sha256=HBnra6jVSkuPbwZr7P_Muum4FRxV3RcGlI6acyI1KS0,1149
+hooksniff/resources/analytics.py,sha256=jcBfAueVc9NG2nld-k5IQHlA_gQ_17mQXVvucwN4hlw,590
+hooksniff/resources/api_key.py,sha256=jz7iaXp6ouIyoxtPf0o5I2TM9jHKbzjU2ahmxUodkwQ,664
+hooksniff/resources/application.py,sha256=JH66TwcGeMUzNwEXC2IUIYAWQIDCxU_iboHYIX32q2I,1024
+hooksniff/resources/billing.py,sha256=o2dyAtsOB92BWTYS_xdR0_N3tF_uDftZDw7agz3b4Kg,743
+hooksniff/resources/broadcast.py,sha256=ihtHHtkfbSueQajHeuv7CuHiZP6g5v_GqmlQ86OJYNM,967
+hooksniff/resources/connector.py,sha256=u1VbQZTyJxM-NEGQDdkft6Kx3Yr2GwphO1Q4Gz6l9aU,1231
+hooksniff/resources/cortex.py,sha256=tciczFtHCugOKPwpUFAmt99ONaa3bzBR9P5bZpwWO5I,1641
+hooksniff/resources/endpoint.py,sha256=3BCc1GSG47NOCM8e8WhxbwHSy4Mq8oIbpinkt-Xffuw,1228
+hooksniff/resources/health.py,sha256=sSUQ6AmPXDFNk4ufUB0KFzuyh4ORh0hYcd8Qnn56k44,379
+hooksniff/resources/notification.py,sha256=TNr55JZ6ovrqaZM1gBu8SMxt7hM5yiwOPvPt2804HcY,758
+hooksniff/resources/platform.py,sha256=17Evon7C2xnQBlxFCrNwCHzHCQUuievSGtFXXzFpMlE,736
+hooksniff/resources/routing.py,sha256=ZnUQBV-t1VE-I9kcP51YqSzBWnqCvlxDwjzB0bMY1og,506
+hooksniff/resources/schema.py,sha256=TuVkq50SXrTTNCcq1vobi1yjd_VbU0FeB5myikeSs3A,941
+hooksniff/resources/search.py,sha256=qBdiP7FimOvry_tnMJDWum6u67kphee_xxuYWKeo0EM,370
+hooksniff/resources/stream.py,sha256=Ry04VRh46cRozv1UuYKgP6Y-kLDx9xfpt4EjPmmtRNo,1677
+hooksniff/resources/team.py,sha256=nZgQOjDu6mt5qjTHFMCRQUQLLHIdH1vJ7jYLslx-ezU,1243
+hooksniff/resources/template.py,sha256=ueQG25GiUXrYoNpY9WT1UiODeP8tnrg51Vlphww5Dog,1071
+hooksniff/resources/transform.py,sha256=5ekOm6Cfsm3G0ILdXwdFMR2CfxDt9wpsYkqA3OBzyUs,1063
+hooksniff/resources/webhook.py,sha256=UCh2sbwx74sL8SrbzTVEw7ktwF7MTt9xN21A4cj8MQA,1508
+hooksniff_python-0.4.3.dist-info/METADATA,sha256=D2EEtXwPxzoV92-H9nNxaI3mZR6Q0lu80gk-bFcBnRU,6362
+hooksniff_python-0.4.3.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+hooksniff_python-0.4.3.dist-info/licenses/LICENSE,sha256=vUMb56ZR5dltGS5hpFwKXc8P5mMh4E8S1zwf3MIVAZE,1066
+hooksniff_python-0.4.3.dist-info/RECORD,,

hooksniff/resources.py

@@ -1,410 +0,0 @@
-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_python-0.4.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-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,,