posthubify 0.1.0__py3-none-any.whl

posthubify/__init__.py

@@ -0,0 +1,13 @@
+"""PostHubify resmî Python SDK'sı.
+
+    from posthubify import Posthubify, PosthubifyError
+
+    ph = Posthubify(api_key="sk_...", base_url="https://api.posthubify.com/v1")
+    print(ph.ping())
+"""
+
+from .client import Posthubify
+from .errors import PosthubifyError
+
+__version__ = "0.1.0"
+__all__ = ["Posthubify", "PosthubifyError", "__version__"]

posthubify/_http.py

@@ -0,0 +1,154 @@
+"""HTTP taşıma katmanı — stdlib urllib tabanlı (sıfır runtime bağımlılık).
+
+Node @posthubify/node transport deseninin Python aynası: Bearer auth, JSON gövde,
+multipart yükleme, ``{ data }`` zarfı açma, 2xx-dışı → PosthubifyError.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+import uuid
+from typing import Any, Dict, Mapping, Optional, Tuple
+
+from .errors import PosthubifyError
+
+Query = Optional[Mapping[str, Any]]
+
+_DEFAULT_BASE = "http://localhost:8787/v1"
+_USER_AGENT = "posthubify-python/0.1.0"
+
+
+def _qval(v: object) -> str:
+    # bool → JSON-küçük harf ('true'/'false'); Python str(True)='True' backend `=== 'true'` ile eşleşmez.
+    if isinstance(v, bool):
+        return "true" if v else "false"
+    return str(v)
+
+
+def _encode_query(query: Query) -> str:
+    if not query:
+        return ""
+    pairs = [
+        (str(k), _qval(v))
+        for k, v in query.items()
+        if v is not None
+    ]
+    return urllib.parse.urlencode(pairs) if pairs else ""
+
+
+class Transport:
+    """Düşük seviye istek motoru. ``req`` ham gövdeyi, ``data`` ``{data}`` zarfını açar."""
+
+    def __init__(self, api_key: str, base_url: str = _DEFAULT_BASE, timeout: float = 30.0) -> None:
+        if not api_key:
+            raise ValueError("api_key gerekli (sk_…)")
+        self._key = api_key
+        self._base = base_url.rstrip("/")
+        self._timeout = timeout
+
+    # -- genel istek --
+    def req(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Query = None,
+        body: Any = None,
+        files: Optional[Tuple[str, bytes, str]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        """İsteği gönderir; 2xx → ayrıştırılmış gövde, değilse PosthubifyError.
+
+        files: (alan_adı, bytes, dosya_adı) — çok parçalı yükleme (media.upload).
+        """
+        qs = _encode_query(query)
+        url = f"{self._base}{path}" + (f"?{qs}" if qs else "")
+        headers: Dict[str, str] = {
+            "Authorization": f"Bearer {self._key}",
+            "User-Agent": _USER_AGENT,
+            "Accept": "application/json",
+        }
+        if idempotency_key:
+            headers["Idempotency-Key"] = idempotency_key
+
+        data_bytes: Optional[bytes] = None
+        if files is not None:
+            field, content, filename = files
+            boundary = uuid.uuid4().hex
+            data_bytes, content_type = _build_multipart(field, content, filename, boundary)
+            headers["Content-Type"] = content_type
+        elif body is not None:
+            data_bytes = json.dumps(body).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+
+        request = urllib.request.Request(url, data=data_bytes, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(request, timeout=self._timeout) as resp:
+                raw = resp.read()
+                return _parse(raw)
+        except urllib.error.HTTPError as exc:  # 4xx/5xx
+            raw = exc.read()
+            parsed = _parse(raw)
+            message = None
+            code = None
+            if isinstance(parsed, dict):
+                message = parsed.get("error")
+                code = parsed.get("code")
+            raise PosthubifyError(
+                exc.code,
+                message or f"HTTP {exc.code}",
+                code,
+                parsed,
+            ) from None
+        except urllib.error.URLError as exc:  # ağ/bağlantı
+            raise PosthubifyError(0, f"Ağ hatası: {exc.reason}") from None
+
+    def data(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Query = None,
+        body: Any = None,
+        files: Optional[Tuple[str, bytes, str]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> Any:
+        """``{ data: ... }`` zarfını açar."""
+        result = self.req(
+            method, path, query=query, body=body, files=files, idempotency_key=idempotency_key
+        )
+        if isinstance(result, dict) and "data" in result:
+            return result["data"]
+        return result
+
+
+def _parse(raw: bytes) -> Any:
+    if not raw:
+        return None
+    try:
+        return json.loads(raw.decode("utf-8"))
+    except (ValueError, UnicodeDecodeError):
+        return None
+
+
+_MIME_BY_EXT = {"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg", "mp4": "video/mp4"}
+
+
+def _mime_for(filename: str) -> str:
+    # Sistem-bağımsız sabit eşleme (diğer SDK'larla parite + backend image/*|video/* kontrolü garantisi).
+    ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
+    return _MIME_BY_EXT.get(ext, "application/octet-stream")
+
+
+def _build_multipart(field: str, content: bytes, filename: str, boundary: str) -> Tuple[bytes, str]:
+    mime = _mime_for(filename)
+    pre = (
+        f"--{boundary}\r\n"
+        f'Content-Disposition: form-data; name="{field}"; filename="{filename}"\r\n'
+        f"Content-Type: {mime}\r\n\r\n"
+    ).encode("utf-8")
+    post = f"\r\n--{boundary}--\r\n".encode("utf-8")
+    return pre + content + post, f"multipart/form-data; boundary={boundary}"

posthubify/client.py

@@ -0,0 +1,258 @@
+"""Posthubify istemcisi — Node @posthubify/node ``Posthubify`` sınıfının Python aynası.
+
+Tüm resource grupları snake_case nitelik olarak bağlanır (Node camelCase → Python):
+profiles, accounts, posts, media, tools, ads, insights, platform_analytics,
+inbox_analytics, inbox, comments, reviews, contacts, automations, broadcasts,
+sequences, webhooks, api_keys, queue, account_groups, engagement, users,
+invite_tokens, numbers, senders, sms, otp.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from ._http import Transport, _DEFAULT_BASE
+from .resources.accounts import AccountsResource, ProfilesResource
+from .resources.ads import AdsResource
+from .resources.analytics import (
+    InboxAnalyticsResource,
+    InsightsResource,
+    PlatformAnalyticsResource,
+)
+from .resources.messaging import (
+    AutomationsResource,
+    CommentAutomationsResource,
+    WorkflowsResource,
+    BroadcastsResource,
+    CommentsResource,
+    ContactsResource,
+    InboxResource,
+    ReviewsResource,
+    SequencesResource,
+    CustomFieldsResource,
+    WhatsAppResource,
+    GmbResource,
+    DiscordResource,
+    DiscoveryResource,
+)
+from .resources.platform import (
+    AccountGroupsResource,
+    ApiKeysResource,
+    EngagementResource,
+    InviteTokensResource,
+    QueueResource,
+    UsersResource,
+    WebhooksResource,
+)
+from .resources.posts import MediaResource, PostsResource, ToolsResource
+from .resources.telecom import (
+    NumbersResource,
+    OtpResource,
+    SendersResource,
+    SmsResource,
+)
+
+
+class Posthubify:
+    """PostHubify /v1 API istemcisi.
+
+    Örnek:
+        >>> from posthubify import Posthubify
+        >>> ph = Posthubify(api_key="sk_...", base_url="https://api.posthubify.com/v1")
+        >>> ph.ping()
+        {"pong": True, "version": "v1", ...}
+        >>> ph.posts.list(platform="x", limit=10)
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = _DEFAULT_BASE,
+        timeout: float = 30.0,
+        transport: Optional[Transport] = None,
+    ) -> None:
+        # transport enjeksiyonu testler içindir (Node'daki opts.fetch karşılığı).
+        self._http = transport or Transport(api_key, base_url=base_url, timeout=timeout)
+
+        # --- resource grupları (Node attribute adlarının snake_case aynası) ---
+        self.profiles = ProfilesResource(self._http)
+        self.accounts = AccountsResource(self._http)
+        self.posts = PostsResource(self._http)
+        self.media = MediaResource(self._http)
+        self.tools = ToolsResource(self._http)
+        self.ads = AdsResource(self._http)
+        self.insights = InsightsResource(self._http)
+        self.platform_analytics = PlatformAnalyticsResource(self._http)
+        self.inbox_analytics = InboxAnalyticsResource(self._http)
+        self.inbox = InboxResource(self._http)
+        self.comments = CommentsResource(self._http)
+        self.reviews = ReviewsResource(self._http)
+        self.contacts = ContactsResource(self._http)
+        self.automations = AutomationsResource(self._http)
+        self.comment_automations = CommentAutomationsResource(self._http)
+        self.workflows = WorkflowsResource(self._http)
+        self.broadcasts = BroadcastsResource(self._http)
+        self.sequences = SequencesResource(self._http)
+        self.custom_fields = CustomFieldsResource(self._http)
+        self.whatsapp = WhatsAppResource(self._http)
+        self.gmb = GmbResource(self._http)
+        self.discord = DiscordResource(self._http)
+        self.discovery = DiscoveryResource(self._http)
+        self.webhooks = WebhooksResource(self._http)
+        self.api_keys = ApiKeysResource(self._http)
+        self.queue = QueueResource(self._http)
+        self.account_groups = AccountGroupsResource(self._http)
+        self.engagement = EngagementResource(self._http)
+        self.users = UsersResource(self._http)
+        self.invite_tokens = InviteTokensResource(self._http)
+        self.numbers = NumbersResource(self._http)
+        self.senders = SendersResource(self._http)
+        self.sms = SmsResource(self._http)
+        self.otp = OtpResource(self._http)
+
+    # --- üst seviye uçlar (Node sınıf metodları) ---
+    def openapi(self) -> Dict[str, Any]:
+        """OpenAPI 3.1 spec dokümanı (auth gerekmez ama anahtarla da çalışır)."""
+        return self._http.req("GET", "/openapi.json")
+
+    def ping(self) -> Dict[str, Any]:
+        """Entegrasyon sağlık testi: bağlantı + anahtar doğrulaması (geçersiz anahtar → 401)."""
+        return self._http.data("GET", "/ping")
+
+    def me(self) -> Dict[str, Any]:
+        """API anahtarı kimliği."""
+        return self._http.data("GET", "/me")
+
+    def generate(
+        self,
+        command: str,
+        platforms: List[str],
+        *,
+        variants: Optional[int] = None,
+        context: Optional[str] = None,
+        max_chars: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """AI içerik üretimi (F1) — komut → platform-başına taslak + varyant (çok-dil)."""
+        return self._http.data("POST", "/generate", body={
+            "command": command, "platforms": platforms, "variants": variants,
+            "context": context, "maxChars": max_chars,
+        })
+
+    def subtitles(
+        self,
+        text: str,
+        *,
+        format: str = "srt",
+        duration_sec: Optional[float] = None,
+        max_chars_per_line: Optional[int] = None,
+        max_lines_per_cue: Optional[int] = None,
+        chars_per_sec: Optional[float] = None,
+        gap_ms: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """Altyazı üretimi (F4) — metin → zamanlanmış SRT/VTT (saf dönüşüm, AI/ücret yok).
+
+        duration_sec verilirse küeler bu süreye orantılı dağıtılır (sesle/videoyla senkron; ≤86400).
+        chars_per_sec okuma hızıdır (kesirli olabilir, örn. 15.5)."""
+        return self._http.data("POST", "/subtitles", body={
+            "text": text, "format": format, "durationSec": duration_sec,
+            "maxCharsPerLine": max_chars_per_line, "maxLinesPerCue": max_lines_per_cue,
+            "charsPerSec": chars_per_sec, "gapMs": gap_ms,
+        })
+
+    def videos(
+        self,
+        image_url: str,
+        format: str,
+        *,
+        audio_url: Optional[str] = None,
+        subtitle_text: Optional[str] = None,
+        subtitle_rtl: Optional[bool] = None,
+        bumper_duration_sec: Optional[float] = None,
+        main_duration_sec: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Promo video render (F4) — uzak görsel (+ops. ses/altyazı) → markalı video (ffmpeg) → R2 URL.
+
+        format: '9:16' | '1:1' | '16:9'. AĞIR işlem (yazma izni + düşük hız sınırı).
+        Medya SSRF-korumalı indirilir (https + içerik-tipi + ≤25MB)."""
+        return self._http.data("POST", "/videos", body={
+            "imageUrl": image_url, "format": format, "audioUrl": audio_url,
+            "subtitleText": subtitle_text, "subtitleRtl": subtitle_rtl,
+            "bumperDurationSec": bumper_duration_sec, "mainDurationSec": main_duration_sec,
+        })
+
+    def analytics(self) -> Dict[str, Any]:
+        """Bağlı hesap + gönderi analitiği (platform API'lerinden canlı)."""
+        return self._http.data("GET", "/analytics")
+
+    def analytics_posts(
+        self,
+        *,
+        platform: Optional[str] = None,
+        account_id: Optional[str] = None,
+        source: Optional[str] = None,
+        limit: Optional[int] = None,
+        cursor: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Gönderi analitiği listesi — source='external': platformdan senkronlanan, PostHubify-dışı gönderiler (B5)."""
+        return self._http.req(
+            "GET",
+            "/analytics/posts",
+            query={
+                "platform": platform,
+                "accountId": account_id,
+                "source": source,
+                "limit": limit,
+                "cursor": cursor,
+            },
+        )
+
+    def analytics_timeseries(
+        self,
+        *,
+        days: Optional[int] = None,
+        platform: Optional[str] = None,
+        account_id: Optional[str] = None,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        source: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Depolanan günlük metrik zaman serisi (hesap/post/inbox toplamları)."""
+        return self._http.data(
+            "GET",
+            "/analytics/timeseries",
+            query={
+                "days": days,
+                "platform": platform,
+                "accountId": account_id,
+                "fromDate": from_date,
+                "toDate": to_date,
+                "source": source,
+            },
+        )
+
+    def logs(
+        self,
+        *,
+        limit: Optional[int] = None,
+        category: Optional[str] = None,
+        status: Optional[str] = None,
+        platform: Optional[str] = None,
+        days: Optional[int] = None,
+    ) -> Any:
+        """Etkinlik/denetim günlüğü kayıtları."""
+        return self._http.data(
+            "GET",
+            "/logs",
+            query={
+                "limit": limit,
+                "category": category,
+                "status": status,
+                "platform": platform,
+                "days": days,
+            },
+        )
+
+    def usage(self) -> Dict[str, Any]:
+        """Plan + cüzdan + 30 günlük kullanım sayaçları."""
+        return self._http.data("GET", "/usage")

posthubify/errors.py

@@ -0,0 +1,32 @@
+"""PostHubify API hata türü (Node @posthubify/node PosthubifyError aynası)."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+
+class PosthubifyError(Exception):
+    """Bir API isteği 2xx olmayan durum döndürdüğünde fırlatılır.
+
+    Attributes:
+        status: HTTP durum kodu (ör. 400, 401, 404, 429, 502).
+        message: Sunucunun ``error`` alanı ya da ``HTTP <status>``.
+        code: Sunucunun makine-okunur ``code`` alanı (varsa).
+        body: Ayrıştırılmış yanıt gövdesi (varsa).
+    """
+
+    def __init__(
+        self,
+        status: int,
+        message: str,
+        code: Optional[str] = None,
+        body: Any = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.message = message
+        self.code = code
+        self.body = body
+
+    def __repr__(self) -> str:  # pragma: no cover - sadece hata ayıklama
+        return f"PosthubifyError(status={self.status!r}, message={self.message!r}, code={self.code!r})"

posthubify/resources/__init__.py

@@ -0,0 +1 @@
+"""Resource sınıfları — Posthubify istemcisi bunları bağlar."""