edgecron-python 1.0.0__py3-none-any.whl

edgecron/__init__.py

@@ -0,0 +1,69 @@
+"""EdgeCron Python SDK."""
+
+from .client import EdgeCron
+from .error import APIError, is_api_error
+from .types import (
+    CreateEndpointRequest,
+    CreateRetryPolicyRequest,
+    CreateScheduleRequest,
+    CreateTaskRequest,
+    Delivery,
+    DeliveryList,
+    EndpointList,
+    Event,
+    EventList,
+    PublishEventRequest,
+    PublishEventResult,
+    ResourceLimits,
+    RetryDeliveryResult,
+    RetryJob,
+    RetryJobList,
+    RetryPolicy,
+    RetryPolicyList,
+    Schedule,
+    ScheduleList,
+    SubscriptionQuota,
+    Task,
+    TaskList,
+    UpdateEndpointRequest,
+    UpdateRetryPolicyRequest,
+    UpdateScheduleRequest,
+    UsageRecords,
+    WebhookEndpoint,
+)
+
+__version__ = "1.2.0"
+
+__all__ = [
+    "APIError",
+    "CreateEndpointRequest",
+    "CreateRetryPolicyRequest",
+    "CreateScheduleRequest",
+    "CreateTaskRequest",
+    "Delivery",
+    "DeliveryList",
+    "EdgeCron",
+    "EndpointList",
+    "Event",
+    "EventList",
+    "PublishEventRequest",
+    "PublishEventResult",
+    "ResourceLimits",
+    "RetryDeliveryResult",
+    "RetryJob",
+    "RetryJobList",
+    "RetryPolicy",
+    "RetryPolicyList",
+    "Schedule",
+    "ScheduleList",
+    "SubscriptionQuota",
+    "Task",
+    "TaskList",
+    "UpdateEndpointRequest",
+    "UpdateRetryPolicyRequest",
+    "UpdateScheduleRequest",
+    "UsageRecords",
+    "WebhookEndpoint",
+    "__version__",
+    "is_api_error",
+]

edgecron/client.py

@@ -0,0 +1,57 @@
+"""Public client entrypoint for the EdgeCron SDK."""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+import requests
+
+from .deliveries import DeliveriesService
+from .endpoints import EndpointsService
+from .events import EventsService
+from .retries import RetriesService
+from .schedules import SchedulesService
+from .subscription import SubscriptionService
+from .tasks import TasksService
+from .transport import DEFAULT_BASE_URL, SDK_VERSION, Transport
+
+_KEY_ID_RE = re.compile(r"^ak_[0-9a-zA-Z_]+$")
+
+
+class EdgeCron:
+    """EdgeCron API client.
+
+    The client is safe to reuse across requests. Create once and reuse.
+    """
+
+    version = SDK_VERSION
+
+    def __init__(
+        self,
+        key_id: str,
+        secret: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        session: Optional[requests.Session] = None,
+    ) -> None:
+        if not _KEY_ID_RE.fullmatch(key_id):
+            raise ValueError(f"edgecron: key_id must match ak_<hex>, got: {key_id}")
+        if not secret:
+            raise ValueError("edgecron: secret must not be empty")
+
+        self._transport = Transport(
+            key_id=key_id,
+            secret=secret,
+            base_url=base_url,
+            timeout=timeout,
+            session=session,
+        )
+        self.schedules = SchedulesService(self._transport)
+        self.tasks = TasksService(self._transport)
+        self.events = EventsService(self._transport)
+        self.endpoints = EndpointsService(self._transport)
+        self.deliveries = DeliveriesService(self._transport)
+        self.retries = RetriesService(self._transport)
+        self.subscription = SubscriptionService(self._transport)

edgecron/deliveries.py

@@ -0,0 +1,37 @@
+"""Delivery APIs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .transport import Transport
+from .types import Delivery, DeliveryList, RetryDeliveryResult
+from .schedules import _page_query
+
+
+class DeliveriesService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def list(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        status: str = "",
+        task_id: int = 0,
+        endpoint_id: int = 0,
+    ) -> DeliveryList:
+        q = _page_query(page, page_size)
+        if status:
+            q["status"] = status
+        if task_id > 0:
+            q["task_id"] = task_id
+        if endpoint_id > 0:
+            q["endpoint_id"] = endpoint_id
+        data = self._transport.request_json("GET", "/v1/deliveries", query=q)
+        items = [Delivery(**d) for d in (data.get("list") or [])]
+        return DeliveryList(total=data.get("total", 0), list=items)
+
+    def retry(self, id: int) -> RetryDeliveryResult:
+        data = self._transport.request_json("POST", f"/v1/deliveries/{id}/retry")
+        return RetryDeliveryResult(**data)

edgecron/endpoints.py

@@ -0,0 +1,43 @@
+"""Webhook endpoint APIs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .transport import Transport
+from .types import CreateEndpointRequest, EndpointList, UpdateEndpointRequest, WebhookEndpoint
+from .schedules import _compact, _page_query, _asdict
+
+
+class EndpointsService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def create(self, req: CreateEndpointRequest) -> WebhookEndpoint:
+        data = self._transport.request_json("POST", "/v1/endpoints", body=_asdict(req))
+        return WebhookEndpoint(**data)
+
+    def get(self, id: int) -> WebhookEndpoint:
+        data = self._transport.request_json("GET", f"/v1/endpoints/{id}")
+        return WebhookEndpoint(**data)
+
+    def update(self, id: int, req: UpdateEndpointRequest) -> WebhookEndpoint:
+        data = self._transport.request_json("PATCH", f"/v1/endpoints/{id}", body=_compact(_asdict(req)))
+        return WebhookEndpoint(**data)
+
+    def list(self, page: int = 1, page_size: int = 20, status: str = "") -> EndpointList:
+        q = _page_query(page, page_size)
+        if status:
+            q["status"] = status
+        data = self._transport.request_json("GET", "/v1/endpoints", query=q)
+        items = [WebhookEndpoint(**ep) for ep in (data.get("list") or [])]
+        return EndpointList(total=data.get("total", 0), list=items)
+
+    def delete(self, id: int) -> None:
+        self._transport.request_json("DELETE", f"/v1/endpoints/{id}")
+
+    def enable(self, id: int) -> None:
+        self._transport.request_json("POST", f"/v1/endpoints/{id}/enable")
+
+    def disable(self, id: int) -> None:
+        self._transport.request_json("POST", f"/v1/endpoints/{id}/disable")

edgecron/error.py

@@ -0,0 +1,18 @@
+"""Error types for the EdgeCron SDK."""
+
+from __future__ import annotations
+
+
+class APIError(Exception):
+    """Business error returned by the EdgeCron API."""
+
+    def __init__(self, code: int, message: str, request_id: str) -> None:
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+        super().__init__(f"edgecron: code={code} message={message} request_id={request_id}")
+
+
+def is_api_error(exc: BaseException) -> bool:
+    """Return True when *exc* is an :class:`APIError`."""
+    return isinstance(exc, APIError)

edgecron/events.py

@@ -0,0 +1,41 @@
+"""Event APIs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .transport import Transport
+from .types import Event, EventList, PublishEventRequest, PublishEventResult
+from .schedules import _page_query, _asdict
+
+
+class EventsService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def publish(self, req: PublishEventRequest) -> PublishEventResult:
+        data = self._transport.request_json("POST", "/v1/events", body=_asdict(req))
+        return PublishEventResult(**data)
+
+    def get(self, id: int) -> Event:
+        data = self._transport.request_json("GET", f"/v1/events/{id}")
+        return Event(**data)
+
+    def list(self, page: int = 1, page_size: int = 20, event_name: str = "", status: str = "") -> EventList:
+        q = _page_query(page, page_size)
+        if event_name:
+            q["event_name"] = event_name
+        if status:
+            q["status"] = status
+        data = self._transport.request_json("GET", "/v1/events", query=q)
+        items = [Event(**e) for e in (data.get("list") or [])]
+        return EventList(total=data.get("total", 0), list=items)
+
+    def enable(self, id: int) -> None:
+        self._transport.request_json("POST", f"/v1/events/{id}/enable")
+
+    def disable(self, id: int) -> None:
+        self._transport.request_json("POST", f"/v1/events/{id}/disable")
+
+    def delete(self, id: int) -> None:
+        self._transport.request_json("DELETE", f"/v1/events/{id}")

edgecron/retries.py

@@ -0,0 +1,60 @@
+"""Retry APIs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .transport import Transport
+from .types import (
+    CreateRetryPolicyRequest,
+    RetryJob,
+    RetryJobList,
+    RetryPolicy,
+    RetryPolicyList,
+    UpdateRetryPolicyRequest,
+)
+from .schedules import _compact, _page_query, _asdict
+
+
+class RetriesService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def create_policy(self, req: CreateRetryPolicyRequest) -> RetryPolicy:
+        data = self._transport.request_json("POST", "/v1/retries/policies", body=_asdict(req))
+        return RetryPolicy(**data)
+
+    def get_policy(self, id: int) -> RetryPolicy:
+        data = self._transport.request_json("GET", f"/v1/retries/policies/{id}")
+        return RetryPolicy(**data)
+
+    def list_policies(self) -> RetryPolicyList:
+        data = self._transport.request_json("GET", "/v1/retries/policies")
+        items = [RetryPolicy(**p) for p in (data.get("list") or [])]
+        return RetryPolicyList(total=data.get("total", 0), list=items)
+
+    def update_policy(self, id: int, req: UpdateRetryPolicyRequest) -> RetryPolicy:
+        data = self._transport.request_json("PATCH", f"/v1/retries/policies/{id}", body=_compact(_asdict(req)))
+        return RetryPolicy(**data)
+
+    def delete_policy(self, id: int) -> None:
+        self._transport.request_json("DELETE", f"/v1/retries/policies/{id}")
+
+    def list_jobs(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        status: str = "",
+        delivery_id: int = 0,
+    ) -> RetryJobList:
+        q = _page_query(page, page_size)
+        if status:
+            q["status"] = status
+        if delivery_id > 0:
+            q["delivery_id"] = delivery_id
+        data = self._transport.request_json("GET", "/v1/retries/jobs", query=q)
+        items = [RetryJob(**j) for j in (data.get("list") or [])]
+        return RetryJobList(total=data.get("total", 0), list=items)
+
+    def cancel_job(self, id: int) -> None:
+        self._transport.request_json("POST", f"/v1/retries/jobs/{id}/cancel")

edgecron/schedules.py

@@ -0,0 +1,61 @@
+"""Schedule APIs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .transport import Transport
+from .types import CreateScheduleRequest, Schedule, ScheduleList, UpdateScheduleRequest
+
+
+class SchedulesService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def create(self, req: CreateScheduleRequest) -> Schedule:
+        data = self._transport.request_json("POST", "/v1/schedules", body=_asdict(req))
+        return Schedule(**data)
+
+    def get(self, id: int) -> Schedule:
+        data = self._transport.request_json("GET", f"/v1/schedules/{id}")
+        return Schedule(**data)
+
+    def update(self, id: int, req: UpdateScheduleRequest) -> Schedule:
+        data = self._transport.request_json("PATCH", f"/v1/schedules/{id}", body=_compact(_asdict(req)))
+        return Schedule(**data)
+
+    def list(self, page: int = 1, page_size: int = 20, status: str = "") -> ScheduleList:
+        q = _page_query(page, page_size)
+        if status:
+            q["status"] = status
+        data = self._transport.request_json("GET", "/v1/schedules", query=q)
+        items = [Schedule(**s) for s in (data.get("list") or [])]
+        return ScheduleList(total=data.get("total", 0), list=items)
+
+    def delete(self, id: int) -> None:
+        self._transport.request_json("DELETE", f"/v1/schedules/{id}")
+
+    def pause(self, id: int) -> None:
+        self._transport.request_json("POST", f"/v1/schedules/{id}/pause")
+
+    def resume(self, id: int) -> None:
+        self._transport.request_json("POST", f"/v1/schedules/{id}/resume")
+
+
+def _compact(d: dict) -> dict:
+    return {k: v for k, v in d.items() if v is not None}
+
+
+def _page_query(page: int, page_size: int) -> dict:
+    if page <= 0:
+        page = 1
+    if page_size <= 0:
+        page_size = 20
+    page_size = min(page_size, 100)
+    return {"page": page, "page_size": page_size}
+
+
+def _asdict(obj) -> dict:
+    if hasattr(obj, "__dataclass_fields__"):
+        return {f.name: getattr(obj, f.name) for f in obj.__dataclass_fields__.values()}
+    return dict(obj)

edgecron/signer.py

@@ -0,0 +1,31 @@
+"""HMAC-SHA256 signing for the EdgeCron SDK."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+from typing import Mapping, Optional
+
+
+def sign(secret: str, timestamp: str, query: Optional[Mapping[str, str]], body: bytes) -> str:
+    """Return the lowercase hex HMAC-SHA256 signature for a request.
+
+    Algorithm (matches Go reference implementation):
+      1. Sort URL query parameters by key alphabetically.
+      2. Join as: key1=value1&key2=value2
+      3. If non-empty request body exists, append "&" + raw_body
+      4. If no query params and no body, payload is empty string ""
+      5. to_sign = unix_timestamp_string + "\\n" + payload
+      6. signature = hex(HMAC-SHA256(secret_bytes, to_sign_bytes))
+    """
+    parts = []
+    if query:
+        for key in sorted(query):
+            parts.append(f"{key}={query[key]}")
+    payload = "&".join(parts)
+    if body:
+        body_text = body.decode("utf-8")
+        payload = f"{payload}&{body_text}" if payload else body_text
+    to_sign = f"{timestamp}\n{payload}"
+    digest = hmac.new(secret.encode("utf-8"), to_sign.encode("utf-8"), hashlib.sha256)
+    return digest.hexdigest()

edgecron/subscription.py

@@ -0,0 +1,28 @@
+"""Subscription APIs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .transport import Transport
+from .types import ResourceLimits, SubscriptionQuota, UsageRecords
+
+
+class SubscriptionService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def quota(self) -> SubscriptionQuota:
+        data = self._transport.request_json("GET", "/v1/subscription/quota")
+        return SubscriptionQuota(**data)
+
+    def usage(self, period: str = "") -> UsageRecords:
+        q = {}
+        if period:
+            q["period"] = period
+        data = self._transport.request_json("GET", "/v1/subscription/usage", query=q)
+        return UsageRecords(**data)
+
+    def resource_limits(self) -> ResourceLimits:
+        data = self._transport.request_json("GET", "/v1/subscription/resource-limits")
+        return ResourceLimits(**data)

edgecron/tasks.py

@@ -0,0 +1,44 @@
+"""Task APIs."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from .transport import Transport
+from .types import CreateTaskRequest, Task, TaskList
+from .schedules import _page_query, _asdict
+
+
+class TasksService:
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    def create(self, req: CreateTaskRequest) -> Task:
+        data = self._transport.request_json("POST", "/v1/tasks", body=_asdict(req))
+        return Task(**data)
+
+    def get(self, id: int) -> Task:
+        data = self._transport.request_json("GET", f"/v1/tasks/{id}")
+        return Task(**data)
+
+    def list(
+        self,
+        page: int = 1,
+        page_size: int = 20,
+        status: str = "",
+        schedule_id: int = 0,
+        event_id: int = 0,
+    ) -> TaskList:
+        q = _page_query(page, page_size)
+        if status:
+            q["status"] = status
+        if schedule_id > 0:
+            q["schedule_id"] = schedule_id
+        if event_id > 0:
+            q["event_id"] = event_id
+        data = self._transport.request_json("GET", "/v1/tasks", query=q)
+        items = [Task(**t) for t in (data.get("list") or [])]
+        return TaskList(total=data.get("total", 0), list=items)
+
+    def cancel(self, id: int) -> None:
+        self._transport.request_json("POST", f"/v1/tasks/{id}/cancel")

edgecron/transport.py

@@ -0,0 +1,146 @@
+"""HTTP transport for the EdgeCron SDK."""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Dict, Mapping, Optional
+from urllib.parse import urlencode
+
+import requests
+
+from .error import APIError
+from .signer import sign
+
+DEFAULT_BASE_URL = "https://api.edgecron.com"
+SDK_VERSION = "1.0.0"
+MAX_RESPONSE_BYTES = 10 << 20
+
+
+class Transport:
+    """Low-level HTTP transport shared by all services."""
+
+    def __init__(
+        self,
+        *,
+        key_id: str,
+        secret: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        session: Optional[requests.Session] = None,
+        user_agent: Optional[str] = None,
+    ) -> None:
+        self.key_id = key_id
+        self.secret = secret
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        if session is None:
+            self.session = requests.Session()
+            self.session.trust_env = False
+        else:
+            self.session = session
+        self.user_agent = user_agent or f"edgecron-python/{SDK_VERSION}"
+
+    def request_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Mapping[str, Any]] = None,
+        body: Optional[Mapping[str, Any]] = None,
+    ) -> Any:
+        body_bytes = b""
+        if body is not None:
+            body_bytes = json.dumps(body, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+        return self._send(
+            method=method,
+            path=path,
+            query=self._normalize_query(query),
+            body_bytes=body_bytes,
+            content_type="application/json",
+        )
+
+    def _send(
+        self,
+        *,
+        method: str,
+        path: str,
+        query: Optional[Dict[str, str]],
+        body_bytes: bytes,
+        content_type: str,
+    ) -> Any:
+        timestamp = str(int(time.time()))
+        signature = sign(self.secret, timestamp, query, body_bytes)
+
+        url = self.base_url + path
+        if query:
+            url = f"{url}?{urlencode(sorted(query.items()))}"
+
+        req = requests.Request(method=method, url=url, data=body_bytes)
+        prepared = self.session.prepare_request(req)
+        prepared.headers["Content-Type"] = content_type
+        prepared.headers["X-Key-ID"] = self.key_id
+        prepared.headers["X-Timestamp"] = timestamp
+        prepared.headers["X-Signature"] = signature
+        prepared.headers["User-Agent"] = self.user_agent
+
+        response = self.session.send(prepared, timeout=self.timeout, stream=True)
+        raw = self._read_response(response)
+
+        if response.status_code < 200 or response.status_code >= 300:
+            api_error = self._maybe_api_error(raw)
+            if api_error is not None:
+                raise api_error
+            raise requests.HTTPError(
+                f"edgecron: http status {response.status_code}",
+                response=response,
+            )
+
+        try:
+            envelope = json.loads(raw.decode("utf-8"))
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"edgecron: decode response (status={response.status_code}): {exc}") from exc
+
+        code = int(envelope.get("code", 0))
+        if code != 0:
+            raise APIError(
+                code,
+                str(envelope.get("message", "")),
+                str(envelope.get("request_id", "")),
+            )
+        return envelope.get("data")
+
+    def _read_response(self, response: requests.Response) -> bytes:
+        chunks = []
+        total = 0
+        try:
+            for chunk in response.iter_content(chunk_size=8192):
+                if not chunk:
+                    continue
+                total += len(chunk)
+                if total > MAX_RESPONSE_BYTES:
+                    raise ValueError("edgecron: response exceeds 10 MB limit")
+                chunks.append(chunk)
+        finally:
+            response.close()
+        return b"".join(chunks)
+
+    @staticmethod
+    def _maybe_api_error(raw: bytes) -> Optional[APIError]:
+        try:
+            envelope = json.loads(raw.decode("utf-8"))
+        except (UnicodeDecodeError, json.JSONDecodeError):
+            return None
+        code_value = envelope.get("code", 0)
+        if code_value in (None, ""):
+            return None
+        code = int(code_value)
+        if code == 0:
+            return None
+        return APIError(code, str(envelope.get("message", "")), str(envelope.get("request_id", "")))
+
+    @staticmethod
+    def _normalize_query(query: Optional[Mapping[str, Any]]) -> Optional[Dict[str, str]]:
+        if not query:
+            return None
+        return {str(key): str(value) for key, value in query.items()}

edgecron/types.py

@@ -0,0 +1,303 @@
+"""All DTO (data transfer object) types for the EdgeCron SDK."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+
+# --- Schedules ---
+
+
+@dataclass
+class Schedule:
+    id: int
+    app_id: str = ""
+    name: str = ""
+    cron_expr: str = ""
+    timezone: str = ""
+    payload: Optional[str] = None
+    status: str = ""
+    next_run_at: Optional[int] = None
+    endpoint_ids: List[int] = field(default_factory=list)
+    endpoint_names: Dict[int, str] = field(default_factory=dict)
+    created_at: int = 0
+    updated_at: int = 0
+
+
+@dataclass
+class CreateScheduleRequest:
+    name: str
+    cron_expr: str
+    timezone: str = "UTC"
+    payload: Optional[str] = None
+    endpoint_ids: Optional[List[int]] = None
+
+
+@dataclass
+class UpdateScheduleRequest:
+    name: Optional[str] = None
+    cron_expr: Optional[str] = None
+    timezone: Optional[str] = None
+    payload: Optional[str] = None
+    endpoint_ids: Optional[List[int]] = None
+
+
+@dataclass
+class ScheduleList:
+    total: int = 0
+    list: List[Schedule] = field(default_factory=list)
+
+
+# --- Tasks ---
+
+
+@dataclass
+class Task:
+    id: int = 0
+    app_id: str = ""
+    schedule_id: Optional[int] = None
+    event_id: Optional[int] = None
+    endpoint_id: int = 0
+    task_type: str = ""
+    payload: Optional[str] = None
+    status: str = ""
+    run_at: Optional[int] = None
+    created_at: int = 0
+    updated_at: int = 0
+
+
+@dataclass
+class CreateTaskRequest:
+    endpoint_id: int
+    payload: Optional[str] = None
+    run_at: Optional[int] = None
+
+
+@dataclass
+class TaskList:
+    total: int = 0
+    list: List[Task] = field(default_factory=list)
+
+
+# --- Events ---
+
+
+@dataclass
+class Event:
+    id: int = 0
+    app_id: str = ""
+    event_name: str = ""
+    event_key: str = ""
+    payload: Optional[str] = None
+    status: str = ""
+    created_at: int = 0
+
+
+@dataclass
+class PublishEventRequest:
+    event_name: str
+    event_key: str = ""
+    payload: Optional[str] = None
+
+
+@dataclass
+class PublishEventResult:
+    id: int = 0
+    app_id: str = ""
+    event_name: str = ""
+    event_key: str = ""
+    payload: Optional[str] = None
+    status: str = ""
+    fanout_count: int = 0
+    created_at: int = 0
+
+
+@dataclass
+class EventList:
+    total: int = 0
+    list: List[Event] = field(default_factory=list)
+
+
+# --- Endpoints ---
+
+
+@dataclass
+class WebhookEndpoint:
+    id: int = 0
+    app_id: str = ""
+    name: str = ""
+    url: str = ""
+    method: str = ""
+    headers: Optional[str] = None
+    secret: Optional[str] = None
+    timeout_ms: int = 0
+    retry_policy_id: Optional[int] = None
+    filter_events: Optional[str] = None
+    status: str = ""
+    created_at: int = 0
+    updated_at: int = 0
+
+
+@dataclass
+class CreateEndpointRequest:
+    name: str
+    url: str
+    method: str = "POST"
+    headers: Optional[str] = None
+    secret: Optional[str] = None
+    timeout_ms: Optional[int] = None
+    retry_policy_id: Optional[int] = None
+    filter_events: Optional[str] = None
+
+
+@dataclass
+class UpdateEndpointRequest:
+    name: Optional[str] = None
+    url: Optional[str] = None
+    method: Optional[str] = None
+    headers: Optional[str] = None
+    secret: Optional[str] = None
+    timeout_ms: Optional[int] = None
+    retry_policy_id: Optional[int] = None
+    filter_events: Optional[str] = None
+
+
+@dataclass
+class EndpointList:
+    total: int = 0
+    list: List[WebhookEndpoint] = field(default_factory=list)
+
+
+# --- Deliveries ---
+
+
+@dataclass
+class Delivery:
+    id: int = 0
+    app_id: str = ""
+    task_id: int = 0
+    endpoint_id: int = 0
+    attempt: int = 0
+    status: str = ""
+    http_status: Optional[int] = None
+    latency_ms: int = 0
+    request_body_hash: str = ""
+    error_message: Optional[str] = None
+    next_retry_at: Optional[int] = None
+    created_at: int = 0
+    updated_at: int = 0
+
+
+@dataclass
+class DeliveryList:
+    total: int = 0
+    list: List[Delivery] = field(default_factory=list)
+
+
+@dataclass
+class RetryDeliveryResult:
+    delivery_id: int = 0
+    retry_job_id: int = 0
+    status: str = ""
+
+
+# --- Retries ---
+
+
+@dataclass
+class RetryPolicy:
+    id: int = 0
+    app_id: str = ""
+    name: str = ""
+    max_attempts: int = 0
+    backoff_type: str = ""
+    initial_delay_sec: int = 0
+    max_delay_sec: int = 0
+    status: str = ""
+    created_at: int = 0
+    updated_at: int = 0
+
+
+@dataclass
+class CreateRetryPolicyRequest:
+    name: str
+    max_attempts: int = 3
+    backoff_type: str = "exponential"
+    initial_delay_sec: int = 60
+    max_delay_sec: int = 3600
+
+
+@dataclass
+class UpdateRetryPolicyRequest:
+    name: Optional[str] = None
+    max_attempts: Optional[int] = None
+    backoff_type: Optional[str] = None
+    initial_delay_sec: Optional[int] = None
+    max_delay_sec: Optional[int] = None
+    status: Optional[str] = None
+
+
+@dataclass
+class RetryPolicyList:
+    total: int = 0
+    list: List[RetryPolicy] = field(default_factory=list)
+
+
+@dataclass
+class RetryJob:
+    id: int = 0
+    app_id: str = ""
+    delivery_id: int = 0
+    attempt: int = 0
+    status: str = ""
+    run_at: Optional[int] = None
+    locked_until: Optional[int] = None
+    last_error: Optional[str] = None
+    created_at: int = 0
+    updated_at: int = 0
+
+
+@dataclass
+class RetryJobList:
+    total: int = 0
+    list: List[RetryJob] = field(default_factory=list)
+
+
+# --- Subscription ---
+
+
+@dataclass
+class SubscriptionQuota:
+    plan_code: str = ""
+    billing_cycle: str = ""
+    quota: int = 0
+    used: int = 0
+    remaining: int = 0
+    exceeded: bool = False
+    current_period_start: int = 0
+    current_period_end: int = 0
+    usage_percent: float = 0.0
+
+
+@dataclass
+class UsageRecordItem:
+    event_type: str = ""
+    period: str = ""
+    count: int = 0
+
+
+@dataclass
+class UsageRecords:
+    period: str = ""
+    total_events: int = 0
+    items: List[UsageRecordItem] = field(default_factory=list)
+
+
+@dataclass
+class ResourceLimits:
+    max_cron_jobs: int = 0
+    current_cron_jobs: int = 0
+    max_endpoints: int = 0
+    current_endpoints: int = 0
+    log_retention_days: int = 0

edgecron_python-1.0.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.4
+Name: edgecron-python
+Version: 1.0.0
+Summary: Official Python SDK for the EdgeCron webhook scheduling and callback delivery platform.
+Project-URL: Homepage, https://github.com/edgecron/edgecron-python
+Project-URL: Repository, https://github.com/edgecron/edgecron-python
+Project-URL: Documentation, https://www.edgecron.com
+Author: EdgeCron Team
+License: MIT
+License-File: LICENSE
+Keywords: callback,delivery,edgecron,scheduling,webhook
+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 :: Only
+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
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: requests<3,>=2.31.0
+Provides-Extra: test
+Requires-Dist: pytest<9,>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# EdgeCron Python SDK
+
+Official Python SDK for the EdgeCron webhook scheduling and callback delivery platform.
+
+Schedule delayed HTTP requests, deliver webhooks reliably, and automatically retry failed calls — with full execution history so nothing gets lost.
+
+中文文档：[README.zh-CN.md](README.zh-CN.md)
+
+## Install
+
+```bash
+pip install edgecron-python
+```
+
+## Quick Start
+
+```python
+from edgecron import EdgeCron, APIError
+from edgecron.types import CreateScheduleRequest
+
+client = EdgeCron("ak_xxx", "sk_xxx")
+
+try:
+    schedule = client.schedules.create(
+        CreateScheduleRequest(
+            name="my-schedule",
+            cron_expr="*/5 * * * *",
+        )
+    )
+    print(schedule.id)
+except APIError as exc:
+    print(exc.code, exc.message, exc.request_id)
+```
+
+## Modules
+
+| Client method              | Description                      |
+|----------------------------|----------------------------------|
+| `client.schedules.*`       | Cron schedule CRUD, pause, resume |
+| `client.tasks.*`           | Task execution instances, cancel  |
+| `client.events.*`          | Event publishing and management   |
+| `client.endpoints.*`       | Webhook endpoint configuration    |
+| `client.deliveries.*`      | Delivery attempt records and retry |
+| `client.retries.*`         | Retry policies and jobs           |
+| `client.subscription.*`    | Quota, usage, and resource limits |
+
+## Configuration
+
+- `base_url` — override API base URL
+- `timeout` — HTTP client timeout in seconds
+- `session` — custom `requests.Session`
+
+## Error Handling
+
+Service-side business errors raise `APIError`.
+
+```python
+from edgecron import APIError
+
+try:
+    client.schedules.get(123)
+except APIError as exc:
+    print(exc.code, exc.message, exc.request_id)
+```
+
+## Security Notice
+
+This is a server-side SDK. Never expose `secret` in browsers, mobile apps, or other untrusted clients.

edgecron_python-1.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+edgecron/__init__.py,sha256=EpgWHS-kTSBTC93-ur8vGrQMi2iOOkdATKl-n-aWQeQ,1383
+edgecron/client.py,sha256=ay9dOdDdahm8Bx4bekyjRAUcaaUbIc_nj4HIk7q19UA,1722
+edgecron/deliveries.py,sha256=ePJMlupRisSMzA8JNBehst6ASVfoQB6bvtQExe7nq7M,1135
+edgecron/endpoints.py,sha256=4JARU8NWhldGQH9GUn_nmfhi12NEqPs5gh7KknABnFw,1720
+edgecron/error.py,sha256=dEqXWIJpqA0ViEfGjQyVvJdRQo-ODZ6qii_wsghCa2M,564
+edgecron/events.py,sha256=VvAn-24Zbb7TFteU-y7HtkjfDikV2KeZBkjdLOpEZFo,1490
+edgecron/retries.py,sha256=CgEByGc4IV1SXe3c4awTVrfD8HyoDq01AxJ7G7yoyu4,2096
+edgecron/schedules.py,sha256=JQFW-OAqiBrHt0X3vOHjDUpqrQkTjWGp8dEfNgYpNF4,2090
+edgecron/signer.py,sha256=S2k--UHcbIdxiU5wYPfkTU7_ot1uqmDBMQfSRX5n0t4,1157
+edgecron/subscription.py,sha256=4iIX2XEajqIakw2O8roP-sJpFLfQ0r_BzWJhRjIXCqw,891
+edgecron/tasks.py,sha256=22QxyK4UD_cdwlx0RSexhVb9qb3zabT6OGbRheIAmcY,1346
+edgecron/transport.py,sha256=EEZ5WX7V_mR-UW2iiduRgs4EUS8WWpiNdA5amixfnr0,4680
+edgecron/types.py,sha256=KM9htPSWSBbAHIa94fJwt4anqYe3zf5PiJJUfm9qTCc,6038
+edgecron_python-1.0.0.dist-info/METADATA,sha256=Y5tQb2U1zmCwKBQLwIXifpQTWmK-qNgx79_5BOM3rg0,3082
+edgecron_python-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+edgecron_python-1.0.0.dist-info/licenses/LICENSE,sha256=y3l8dQw2DbEPg-_RGDxGoA0Xa2SZaLTJNvxhfXMA0Kk,1070
+edgecron_python-1.0.0.dist-info/RECORD,,

edgecron_python-1.0.0.dist-info/WHEEL

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

edgecron_python-1.0.0.dist-info/licenses/LICENSE

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