contackd-sync 0.1.0__tar.gz

contackd_sync-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: contackd-sync
+Version: 0.1.0
+Summary: Python SDK for Contackd Sync
+Project-URL: Homepage, https://example.com/contackd-sync
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: urllib3>=2.0.0
+
+# contackd-sync
+
+Python SDK for the Contackd Sync API.
+
+## Installation
+
+```bash
+pip install requests urllib3
+```
+
+Or install the package from this repository once published as a build artifact.
+
+## Quick Start
+
+```python
+from contackd_sync import ContackdClient, Contact
+
+client = ContackdClient(
+    api_key="sk-your-key",
+    base_url="https://api.yourapp.com/v1",
+)
+
+contact = client.contacts.upsert(Contact(email="alice@example.com", first_name="Alice"))
+print(contact)
+```
+
+## Public API
+
+The package exports the main client, typed resource wrappers, models, sync helpers, and exceptions from `contackd_sync`.
+
+- `ContackdClient`
+- `ContactsResource`, `LeadsResource`, `ProspectsResource`
+- `Contact`, `Lead`, `Prospect`
+- `LeadStatus`, `PipelineStage`
+- `SyncEngine`, `SyncResult`, `BulkResult`
+- `ContackdError` and specialized exceptions
+
+## API Key Provisioning
+
+Create and revoke SDK keys from backend auth endpoints:
+
+1. Create key (JWT required):
+```bash
+curl -X POST http://localhost:8000/api/v1/auth/api-keys \
+  -H "Authorization: Bearer <ACCESS_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"name":"py-sdk"}'
+```
+
+2. Delete/revoke key:
+```bash
+curl -X DELETE http://localhost:8000/api/v1/auth/api-keys/<API_KEY_ID> \
+  -H "Authorization: Bearer <ACCESS_TOKEN>"
+```
+
+Use returned `api_key` as `api_key` when creating `ContackdClient`.

contackd_sync-0.1.0/README.md

@@ -0,0 +1,56 @@
+# contackd-sync
+
+Python SDK for the Contackd Sync API.
+
+## Installation
+
+```bash
+pip install requests urllib3
+```
+
+Or install the package from this repository once published as a build artifact.
+
+## Quick Start
+
+```python
+from contackd_sync import ContackdClient, Contact
+
+client = ContackdClient(
+    api_key="sk-your-key",
+    base_url="https://api.yourapp.com/v1",
+)
+
+contact = client.contacts.upsert(Contact(email="alice@example.com", first_name="Alice"))
+print(contact)
+```
+
+## Public API
+
+The package exports the main client, typed resource wrappers, models, sync helpers, and exceptions from `contackd_sync`.
+
+- `ContackdClient`
+- `ContactsResource`, `LeadsResource`, `ProspectsResource`
+- `Contact`, `Lead`, `Prospect`
+- `LeadStatus`, `PipelineStage`
+- `SyncEngine`, `SyncResult`, `BulkResult`
+- `ContackdError` and specialized exceptions
+
+## API Key Provisioning
+
+Create and revoke SDK keys from backend auth endpoints:
+
+1. Create key (JWT required):
+```bash
+curl -X POST http://localhost:8000/api/v1/auth/api-keys \
+  -H "Authorization: Bearer <ACCESS_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"name":"py-sdk"}'
+```
+
+2. Delete/revoke key:
+```bash
+curl -X DELETE http://localhost:8000/api/v1/auth/api-keys/<API_KEY_ID> \
+  -H "Authorization: Bearer <ACCESS_TOKEN>"
+```
+
+Use returned `api_key` as `api_key` when creating `ContackdClient`.

contackd_sync-0.1.0/contackd_sync/__init__.py

@@ -0,0 +1,45 @@
+"""Contackd Sync Python SDK."""
+
+from .client import (
+    AuthError,
+    BulkResult,
+    ConflictStrategy,
+    Contact,
+    ContactsResource,
+    ContackdClient,
+    ContackdError,
+    Lead,
+    LeadStatus,
+    LeadsResource,
+    NotFoundError,
+    PipelineStage,
+    Prospect,
+    ProspectsResource,
+    RateLimitError,
+    RecordType,
+    SyncConflictError,
+    SyncEngine,
+    SyncResult,
+)
+
+__all__ = [
+    "AuthError",
+    "BulkResult",
+    "ConflictStrategy",
+    "Contact",
+    "ContactsResource",
+    "ContackdClient",
+    "ContackdError",
+    "Lead",
+    "LeadStatus",
+    "LeadsResource",
+    "NotFoundError",
+    "PipelineStage",
+    "Prospect",
+    "ProspectsResource",
+    "RateLimitError",
+    "RecordType",
+    "SyncConflictError",
+    "SyncEngine",
+    "SyncResult",
+]

contackd_sync-0.1.0/contackd_sync/client.py

@@ -0,0 +1,545 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from typing import Any, Callable, Dict, Generic, List, Optional, Protocol, TypeVar, Literal
+from urllib.parse import urljoin
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+
+class ContackdError(Exception):
+    """Base exception raised by the Contackd Sync SDK."""
+
+
+class AuthError(ContackdError):
+    """Raised when the API key is invalid or missing."""
+
+
+class NotFoundError(ContackdError):
+    """Raised when a requested record does not exist on the remote API."""
+
+
+class RateLimitError(ContackdError):
+    """Raised when the remote API returns HTTP 429."""
+
+
+class SyncConflictError(ContackdError):
+    """Raised when a bidirectional sync conflict cannot be auto-resolved."""
+
+    def __init__(self, record_type: str, record_id: str, local: dict, remote: dict):
+        self.record_type = record_type
+        self.record_id = record_id
+        self.local = local
+        self.remote = remote
+        super().__init__(
+            f"Conflict on {record_type} id={record_id}. "
+            "Resolve manually or pass conflict_strategy='local'|'remote'."
+        )
+
+
+class LeadStatus(str, Enum):
+    """Supported lead lifecycle states."""
+
+    NEW = "new"
+    CONTACTED = "contacted"
+    QUALIFIED = "qualified"
+    UNQUALIFIED = "unqualified"
+    CONVERTED = "converted"
+
+
+class PipelineStage(str, Enum):
+    """Supported prospect pipeline stages."""
+
+    AWARENESS = "awareness"
+    INTEREST = "interest"
+    CONSIDERATION = "consideration"
+    INTENT = "intent"
+    EVALUATION = "evaluation"
+    PURCHASE = "purchase"
+
+
+@dataclass
+class Contact:
+    """Contact record model used by the Contacts API."""
+
+    email: str
+    first_name: str = ""
+    last_name: str = ""
+    phone: Optional[str] = None
+    tags: List[str] = field(default_factory=list)
+    custom: Dict[str, Any] = field(default_factory=dict)
+    id: Optional[str] = None
+    updated_at: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Serialize the record to a JSON-friendly dictionary."""
+        data = asdict(self)
+        return {key: value for key, value in data.items() if value is not None}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Contact":
+        """Build a contact from API response data."""
+        return cls(**{key: value for key, value in data.items() if key in cls.__dataclass_fields__})
+
+    def fingerprint(self) -> str:
+        """Return a stable SHA-256 digest for change detection."""
+        payload = json.dumps(
+            {key: value for key, value in self.to_dict().items() if key not in ("id", "updated_at")},
+            sort_keys=True,
+        )
+        return hashlib.sha256(payload.encode()).hexdigest()
+
+
+@dataclass
+class Lead:
+    """Lead record model used by the Leads API."""
+
+    email: str
+    first_name: str = ""
+    last_name: str = ""
+    source: Optional[str] = None
+    score: int = 0
+    status: LeadStatus = LeadStatus.NEW
+    tags: List[str] = field(default_factory=list)
+    custom: Dict[str, Any] = field(default_factory=dict)
+    id: Optional[str] = None
+    updated_at: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Serialize the record to a JSON-friendly dictionary."""
+        data = asdict(self)
+        data["status"] = self.status.value
+        return {key: value for key, value in data.items() if value is not None}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Lead":
+        """Build a lead from API response data."""
+        payload = dict(data)
+        if "status" in payload:
+            payload["status"] = LeadStatus(payload["status"])
+        return cls(**{key: value for key, value in payload.items() if key in cls.__dataclass_fields__})
+
+    def fingerprint(self) -> str:
+        """Return a stable SHA-256 digest for change detection."""
+        payload = json.dumps(
+            {key: value for key, value in self.to_dict().items() if key not in ("id", "updated_at")},
+            sort_keys=True,
+        )
+        return hashlib.sha256(payload.encode()).hexdigest()
+
+
+@dataclass
+class Prospect:
+    """Prospect record model used by the Prospects API."""
+
+    email: str
+    first_name: str = ""
+    last_name: str = ""
+    stage: PipelineStage = PipelineStage.AWARENESS
+    notes: str = ""
+    estimated_value: Optional[float] = None
+    close_date: Optional[str] = None
+    tags: List[str] = field(default_factory=list)
+    custom: Dict[str, Any] = field(default_factory=dict)
+    id: Optional[str] = None
+    updated_at: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        """Serialize the record to a JSON-friendly dictionary."""
+        data = asdict(self)
+        data["stage"] = self.stage.value
+        return {key: value for key, value in data.items() if value is not None}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Prospect":
+        """Build a prospect from API response data."""
+        payload = dict(data)
+        if "stage" in payload:
+            payload["stage"] = PipelineStage(payload["stage"])
+        return cls(**{key: value for key, value in payload.items() if key in cls.__dataclass_fields__})
+
+    def fingerprint(self) -> str:
+        """Return a stable SHA-256 digest for change detection."""
+        payload = json.dumps(
+            {key: value for key, value in self.to_dict().items() if key not in ("id", "updated_at")},
+            sort_keys=True,
+        )
+        return hashlib.sha256(payload.encode()).hexdigest()
+
+
+RecordType = Contact | Lead | Prospect
+ConflictStrategy = Literal["local", "remote", "raise"]
+RecordT = TypeVar("RecordT", Contact, Lead, Prospect)
+
+
+class _RecordModel(Protocol):
+    email: str
+    id: Optional[str]
+
+    def to_dict(self) -> dict: ...
+
+    def fingerprint(self) -> str: ...
+
+
+class _RecordFactory(Protocol[RecordT]):
+    @classmethod
+    def from_dict(cls, data: dict) -> RecordT: ...
+
+
+class _HttpClient:
+    """Thin wrapper around requests with retry and auth headers."""
+
+    def __init__(self, base_url: str, api_key: str, timeout: int = 30):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+        retry = Retry(
+            total=3,
+            backoff_factor=0.5,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["GET", "POST", "PUT", "PATCH", "DELETE"],
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        self.session = requests.Session()
+        self.session.mount("https://", adapter)
+        self.session.mount("http://", adapter)
+        self.session.headers.update(
+            {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+                "Accept": "application/json",
+                "X-SDK-Version": "1.0.0",
+            }
+        )
+
+    def _url(self, path: str) -> str:
+        return urljoin(self.base_url + "/", path.lstrip("/"))
+
+    def _raise(self, response: requests.Response) -> None:
+        if response.status_code == 401:
+            raise AuthError("Invalid API key.")
+        if response.status_code == 404:
+            raise NotFoundError(response.text)
+        if response.status_code == 429:
+            raise RateLimitError("Rate limit hit. Retry after a moment.")
+        response.raise_for_status()
+
+    def get(self, path: str, **params: Any) -> dict:
+        response = self.session.get(self._url(path), params=params, timeout=self.timeout)
+        self._raise(response)
+        return response.json()
+
+    def post(self, path: str, body: dict) -> dict:
+        response = self.session.post(self._url(path), json=body, timeout=self.timeout)
+        self._raise(response)
+        return response.json()
+
+    def put(self, path: str, body: dict) -> dict:
+        response = self.session.put(self._url(path), json=body, timeout=self.timeout)
+        self._raise(response)
+        return response.json()
+
+    def delete(self, path: str) -> None:
+        response = self.session.delete(self._url(path), timeout=self.timeout)
+        self._raise(response)
+
+
+class _Resource(Generic[RecordT]):
+    """Base CRUD and bulk helpers for a typed API resource."""
+
+    _path: str
+    _model: _RecordFactory[RecordT]
+
+    def __init__(self, http: _HttpClient):
+        self._http = http
+
+    def create(self, record: RecordT) -> RecordT:
+        """Create a record on the remote API."""
+        data = self._http.post(self._path, record.to_dict())
+        return self._model.from_dict(data)
+
+    def get(self, record_id: str) -> RecordT:
+        """Fetch a record by ID."""
+        data = self._http.get(f"{self._path}/{record_id}")
+        return self._model.from_dict(data)
+
+    def update(self, record: RecordT) -> RecordT:
+        """Update a record by ID."""
+        if not record.id:
+            raise ContackdError("Record has no id — cannot update.")
+        data = self._http.put(f"{self._path}/{record.id}", record.to_dict())
+        return self._model.from_dict(data)
+
+    def delete(self, record_id: str) -> None:
+        """Delete a record by ID."""
+        self._http.delete(f"{self._path}/{record_id}")
+
+    def list(self, page: int = 1, per_page: int = 100, **filters: Any) -> List[RecordT]:
+        """List records, returning typed model instances."""
+        data = self._http.get(self._path, page=page, per_page=per_page, **filters)
+        items = data.get("results", data) if isinstance(data, dict) else data
+        return [self._model.from_dict(item) for item in items]
+
+    def upsert(self, record: RecordT) -> RecordT:
+        """Create or update a record using the natural key (email)."""
+        return self._model.from_dict(self._http.post(f"{self._path}/upsert", record.to_dict()))
+
+    def bulk_create(self, records: List[RecordT]) -> List[RecordT]:
+        """Create multiple records in a single request."""
+        payload = {"records": [record.to_dict() for record in records]}
+        data = self._http.post(f"{self._path}/bulk", payload)
+        return [self._model.from_dict(item) for item in data.get("created", [])]
+
+    def bulk_upsert(self, records: List[RecordT], chunk_size: int = 100) -> "BulkResult":
+        """Upsert records in chunks to stay within API limits."""
+        result = BulkResult()
+        for index in range(0, len(records), chunk_size):
+            chunk = records[index : index + chunk_size]
+            payload = {"records": [record.to_dict() for record in chunk]}
+            response = self._http.post(f"{self._path}/bulk/upsert", payload)
+            result.created.extend(self._model.from_dict(item) for item in response.get("created", []))
+            result.updated.extend(self._model.from_dict(item) for item in response.get("updated", []))
+            result.errors.extend(response.get("errors", []))
+        return result
+
+    def bulk_delete(self, record_ids: List[str]) -> None:
+        """Delete multiple records in a single request."""
+        self._http.post(f"{self._path}/bulk/delete", {"ids": record_ids})
+
+
+@dataclass
+class BulkResult:
+    """Container for bulk operation outcomes."""
+
+    created: List[Any] = field(default_factory=list)
+    updated: List[Any] = field(default_factory=list)
+    errors: List[Any] = field(default_factory=list)
+
+    @property
+    def total(self) -> int:
+        """Return the number of successfully processed records."""
+        return len(self.created) + len(self.updated)
+
+    def __repr__(self) -> str:
+        return (
+            f"BulkResult(created={len(self.created)}, "
+            f"updated={len(self.updated)}, errors={len(self.errors)})"
+        )
+
+
+class ContactsResource(_Resource[Contact]):
+    """Typed resource wrapper for contacts."""
+
+    _path = "contacts"
+    _model = Contact
+
+
+class LeadsResource(_Resource[Lead]):
+    """Typed resource wrapper for leads."""
+
+    _path = "leads"
+    _model = Lead
+
+
+class ProspectsResource(_Resource[Prospect]):
+    """Typed resource wrapper for prospects."""
+
+    _path = "prospects"
+    _model = Prospect
+
+
+@dataclass
+class SyncResult:
+    """Outcome summary for a bidirectional sync operation."""
+
+    pushed: List[Any] = field(default_factory=list)
+    skipped: List[Any] = field(default_factory=list)
+    resolved: List[Any] = field(default_factory=list)
+    remote_only: List[Any] = field(default_factory=list)
+    errors: List[Any] = field(default_factory=list)
+    bulk_result: Optional[BulkResult] = None
+
+    def __repr__(self) -> str:
+        return (
+            f"SyncResult(pushed={len(self.pushed)}, skipped={len(self.skipped)}, "
+            f"resolved={len(self.resolved)}, remote_only={len(self.remote_only)}, "
+            f"errors={len(self.errors)})"
+        )
+
+
+class SyncEngine(Generic[RecordT]):
+    """Bidirectional sync engine for local records and the remote API."""
+
+    def __init__(
+        self,
+        resource: _Resource[RecordT],
+        conflict_strategy: ConflictStrategy = "remote",
+        on_conflict: Optional[Callable[[SyncConflictError], RecordT]] = None,
+    ):
+        self.resource = resource
+        self.conflict_strategy = conflict_strategy
+        self.on_conflict = on_conflict
+
+    def push(self, records: List[RecordT], chunk_size: int = 100) -> BulkResult:
+        """Push local records to the remote API using bulk upsert."""
+        return self.resource.bulk_upsert(records, chunk_size=chunk_size)
+
+    def pull(self, **filters: Any) -> List[RecordT]:
+        """Fetch all remote records with auto-pagination."""
+        all_records: List[RecordT] = []
+        page = 1
+        while True:
+            page_data = self.resource.list(page=page, per_page=100, **filters)
+            if not page_data:
+                break
+            all_records.extend(page_data)
+            if len(page_data) < 100:
+                break
+            page += 1
+        return all_records
+
+    def sync(self, local_records: List[RecordT], **filters: Any) -> SyncResult:
+        """Run a full bidirectional sync against the remote API."""
+        result = SyncResult()
+        remote_records = self.pull(**filters)
+        remote_by_email: Dict[str, RecordT] = {record.email: record for record in remote_records}
+        local_emails = {record.email for record in local_records}
+
+        to_push: List[RecordT] = []
+
+        for local in local_records:
+            remote = remote_by_email.get(local.email)
+
+            if remote is None:
+                to_push.append(local)
+                result.pushed.append(local)
+                continue
+
+            if local.fingerprint() == remote.fingerprint():
+                result.skipped.append(local)
+                continue
+
+            winner = self._resolve(local, remote)
+            if winner is not None:
+                to_push.append(winner)
+                result.resolved.append((local, remote, winner))
+
+        if to_push:
+            bulk = self.resource.bulk_upsert(to_push)
+            result.bulk_result = bulk
+            result.errors.extend(bulk.errors)
+
+        result.remote_only = [record for record in remote_records if record.email not in local_emails]
+        return result
+
+    def _resolve(self, local: RecordT, remote: RecordT) -> Optional[RecordT]:
+        """Resolve a record conflict according to the configured strategy."""
+        error = SyncConflictError(
+            type(local).__name__, local.id or local.email, local.to_dict(), remote.to_dict()
+        )
+        if self.on_conflict:
+            return self.on_conflict(error)
+        if self.conflict_strategy == "local":
+            return local
+        if self.conflict_strategy == "remote":
+            return None
+        raise error
+
+
+class ContackdClient:
+    """Primary entry point for the Contackd Sync SDK."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str,
+        timeout: int = 30,
+        conflict_strategy: ConflictStrategy = "remote",
+    ):
+        self._http = _HttpClient(base_url=base_url, api_key=api_key, timeout=timeout)
+        self.conflict_strategy = conflict_strategy
+
+        self.contacts = ContactsResource(self._http)
+        self.leads = LeadsResource(self._http)
+        self.prospects = ProspectsResource(self._http)
+
+    def sync_contacts(
+        self,
+        local_records: List[Contact],
+        conflict_strategy: Optional[ConflictStrategy] = None,
+        on_conflict: Optional[Callable[[SyncConflictError], Contact]] = None,
+        **filters: Any,
+    ) -> SyncResult:
+        """Synchronize contacts between local state and the remote API."""
+        engine = SyncEngine(
+            self.contacts,
+            conflict_strategy=conflict_strategy or self.conflict_strategy,
+            on_conflict=on_conflict,
+        )
+        return engine.sync(local_records, **filters)
+
+    def sync_leads(
+        self,
+        local_records: List[Lead],
+        conflict_strategy: Optional[ConflictStrategy] = None,
+        on_conflict: Optional[Callable[[SyncConflictError], Lead]] = None,
+        **filters: Any,
+    ) -> SyncResult:
+        """Synchronize leads between local state and the remote API."""
+        engine = SyncEngine(
+            self.leads,
+            conflict_strategy=conflict_strategy or self.conflict_strategy,
+            on_conflict=on_conflict,
+        )
+        return engine.sync(local_records, **filters)
+
+    def sync_prospects(
+        self,
+        local_records: List[Prospect],
+        conflict_strategy: Optional[ConflictStrategy] = None,
+        on_conflict: Optional[Callable[[SyncConflictError], Prospect]] = None,
+        **filters: Any,
+    ) -> SyncResult:
+        """Synchronize prospects between local state and the remote API."""
+        engine = SyncEngine(
+            self.prospects,
+            conflict_strategy=conflict_strategy or self.conflict_strategy,
+            on_conflict=on_conflict,
+        )
+        return engine.sync(local_records, **filters)
+
+    def ping(self) -> bool:
+        """Return ``True`` when the health endpoint responds successfully."""
+        try:
+            self._http.get("health")
+            return True
+        except ContackdError:
+            return False
+
+
+__all__ = [
+    "AuthError",
+    "BulkResult",
+    "ConflictStrategy",
+    "Contact",
+    "ContactsResource",
+    "ContackdClient",
+    "ContackdError",
+    "Lead",
+    "LeadStatus",
+    "LeadsResource",
+    "NotFoundError",
+    "PipelineStage",
+    "Prospect",
+    "ProspectsResource",
+    "RateLimitError",
+    "RecordType",
+    "SyncConflictError",
+    "SyncEngine",
+    "SyncResult",
+]

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

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: contackd-sync
+Version: 0.1.0
+Summary: Python SDK for Contackd Sync
+Project-URL: Homepage, https://example.com/contackd-sync
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: urllib3>=2.0.0
+
+# contackd-sync
+
+Python SDK for the Contackd Sync API.
+
+## Installation
+
+```bash
+pip install requests urllib3
+```
+
+Or install the package from this repository once published as a build artifact.
+
+## Quick Start
+
+```python
+from contackd_sync import ContackdClient, Contact
+
+client = ContackdClient(
+    api_key="sk-your-key",
+    base_url="https://api.yourapp.com/v1",
+)
+
+contact = client.contacts.upsert(Contact(email="alice@example.com", first_name="Alice"))
+print(contact)
+```
+
+## Public API
+
+The package exports the main client, typed resource wrappers, models, sync helpers, and exceptions from `contackd_sync`.
+
+- `ContackdClient`
+- `ContactsResource`, `LeadsResource`, `ProspectsResource`
+- `Contact`, `Lead`, `Prospect`
+- `LeadStatus`, `PipelineStage`
+- `SyncEngine`, `SyncResult`, `BulkResult`
+- `ContackdError` and specialized exceptions
+
+## API Key Provisioning
+
+Create and revoke SDK keys from backend auth endpoints:
+
+1. Create key (JWT required):
+```bash
+curl -X POST http://localhost:8000/api/v1/auth/api-keys \
+  -H "Authorization: Bearer <ACCESS_TOKEN>" \
+  -H "Content-Type: application/json" \
+  -d '{"name":"py-sdk"}'
+```
+
+2. Delete/revoke key:
+```bash
+curl -X DELETE http://localhost:8000/api/v1/auth/api-keys/<API_KEY_ID> \
+  -H "Authorization: Bearer <ACCESS_TOKEN>"
+```
+
+Use returned `api_key` as `api_key` when creating `ContackdClient`.

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

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+contackd_sync/__init__.py
+contackd_sync/client.py
+contackd_sync.egg-info/PKG-INFO
+contackd_sync.egg-info/SOURCES.txt
+contackd_sync.egg-info/dependency_links.txt
+contackd_sync.egg-info/requires.txt
+contackd_sync.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

contackd_sync-0.1.0/contackd_sync.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.31.0
+urllib3>=2.0.0

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

@@ -0,0 +1 @@
+contackd_sync

contackd_sync-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "contackd-sync"
+version = "0.1.0"
+description = "Python SDK for Contackd Sync"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "requests>=2.31.0",
+  "urllib3>=2.0.0",
+]
+
+[project.urls]
+Homepage = "https://example.com/contackd-sync"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["contackd_sync*"]

contackd_sync-0.1.0/setup.cfg

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