kirimel-python 0.1.0__py3-none-any.whl

kirimel/__init__.py

@@ -0,0 +1,21 @@
+"""
+KiriMel Python SDK
+
+Official Python SDK for KiriMel Email Marketing API.
+"""
+from .client import KiriMel
+from .exceptions import (
+    ApiException,
+    AuthenticationException,
+    RateLimitException,
+    ValidationException,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "KiriMel",
+    "ApiException",
+    "AuthenticationException",
+    "RateLimitException",
+    "ValidationException",
+]

kirimel/client.py

@@ -0,0 +1,122 @@
+"""
+KiriMel Python SDK Client
+"""
+from typing import Optional
+from .http_client import HttpClient
+from .resources import (
+    Campaigns,
+    Subscribers,
+    Lists,
+    Segments,
+    Templates,
+    Forms,
+    Conversions,
+    LandingPages,
+    Workflows,
+)
+
+
+class KiriMel:
+    """
+    KiriMel API Client
+
+    Example:
+        >>> import kirimel
+        >>> client = kirimel.KiriMel(api_key="sk_test_xxx")
+        >>> campaigns = client.campaigns.list()
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://api.kirimel.com/v2",
+        timeout: int = 30,
+        retries: int = 3,
+    ):
+        """
+        Create a new API client
+
+        Args:
+            api_key: API key (or use KIRIMEL_API_KEY env variable)
+            base_url: Base URL (default: https://api.kirimel.com/v2)
+            timeout: Request timeout in seconds (default: 30)
+            retries: Number of retries (default: 3)
+        """
+        self._http_client = HttpClient(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            retries=retries,
+        )
+        self._campaigns: Optional[Campaigns] = None
+        self._subscribers: Optional[Subscribers] = None
+        self._lists: Optional[Lists] = None
+        self._segments: Optional[Segments] = None
+        self._templates: Optional[Templates] = None
+        self._forms: Optional[Forms] = None
+        self._conversions: Optional[Conversions] = None
+        self._landing_pages: Optional[LandingPages] = None
+        self._workflows: Optional[Workflows] = None
+
+    @property
+    def campaigns(self) -> Campaigns:
+        """Get campaigns resource client"""
+        if self._campaigns is None:
+            self._campaigns = Campaigns(self._http_client)
+        return self._campaigns
+
+    @property
+    def subscribers(self) -> Subscribers:
+        """Get subscribers resource client"""
+        if self._subscribers is None:
+            self._subscribers = Subscribers(self._http_client)
+        return self._subscribers
+
+    @property
+    def lists(self) -> Lists:
+        """Get lists resource client"""
+        if self._lists is None:
+            self._lists = Lists(self._http_client)
+        return self._lists
+
+    @property
+    def segments(self) -> Segments:
+        """Get segments resource client"""
+        if self._segments is None:
+            self._segments = Segments(self._http_client)
+        return self._segments
+
+    @property
+    def templates(self) -> Templates:
+        """Get templates resource client"""
+        if self._templates is None:
+            self._templates = Templates(self._http_client)
+        return self._templates
+
+    @property
+    def forms(self) -> Forms:
+        """Get forms resource client"""
+        if self._forms is None:
+            self._forms = Forms(self._http_client)
+        return self._forms
+
+    @property
+    def conversions(self) -> Conversions:
+        """Get conversions resource client"""
+        if self._conversions is None:
+            self._conversions = Conversions(self._http_client)
+        return self._conversions
+
+    @property
+    def landing_pages(self) -> LandingPages:
+        """Get landing pages resource client"""
+        if self._landing_pages is None:
+            self._landing_pages = LandingPages(self._http_client)
+        return self._landing_pages
+
+    @property
+    def workflows(self) -> Workflows:
+        """Get workflows resource client"""
+        if self._workflows is None:
+            self._workflows = Workflows(self._http_client)
+        return self._workflows

kirimel/exceptions.py

@@ -0,0 +1,38 @@
+"""
+KiriMel SDK Exception Classes
+"""
+
+
+class ApiException(Exception):
+    """Base API exception"""
+
+    def __init__(self, message: str, status_code: int = None, errors: dict = None):
+        self.message = message
+        self.status_code = status_code
+        self.errors = errors
+        super().__init__(self.message)
+
+    def __str__(self):
+        return self.message
+
+
+class AuthenticationException(ApiException):
+    """Authentication exception (401)"""
+
+    error_type = "authentication_error"
+
+
+class RateLimitException(ApiException):
+    """Rate limit exception (429)"""
+
+    error_type = "rate_limit_error"
+
+    def __init__(self, message: str, status_code: int = None, errors: dict = None, retry_after: int = None):
+        super().__init__(message, status_code, errors)
+        self.retry_after = retry_after
+
+
+class ValidationException(ApiException):
+    """Validation exception (422)"""
+
+    error_type = "validation_error"

kirimel/http_client.py

@@ -0,0 +1,128 @@
+"""
+HTTP Client for KiriMel API
+"""
+import os
+import time
+import logging
+from typing import Optional, Dict, Any, List
+import requests
+
+from .exceptions import ApiException, AuthenticationException, RateLimitException, ValidationException
+
+
+class HttpClient:
+    """HTTP client for making API requests"""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = "https://api.kirimel.com/v2",
+        timeout: int = 30,
+        retries: int = 3,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key or os.getenv("KIRIMEL_API_KEY")
+        self.timeout = timeout
+        self.retries = retries
+        self.session = requests.Session()
+        self.logger = logging.getLogger(__name__)
+
+    def set_logger(self, logger: logging.Logger) -> None:
+        """Set a custom logger"""
+        self.logger = logger
+
+    def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a GET request"""
+        url = self._build_url(path, params or {})
+        return self._request("GET", url)
+
+    def post(self, path: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a POST request"""
+        return self._request("POST", self._build_url(path), data)
+
+    def put(self, path: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a PUT request"""
+        return self._request("PUT", self._build_url(path), data)
+
+    def delete(self, path: str) -> Dict[str, Any]:
+        """Make a DELETE request"""
+        return self._request("DELETE", self._build_url(path))
+
+    def _build_url(self, path: str, params: Optional[Dict[str, Any]] = None) -> str:
+        """Build URL with query parameters"""
+        url = f"{self.base_url}/{path.lstrip('/')}"
+        if params:
+            import urllib.parse
+            query_string = urllib.parse.urlencode(params)
+            url = f"{url}?{query_string}"
+        return url
+
+    def _request(
+        self,
+        method: str,
+        url: str,
+        data: Optional[Dict[str, Any]] = None,
+        attempt: int = 0,
+    ) -> Dict[str, Any]:
+        """Make HTTP request with retry logic"""
+        self.logger.debug(f"Making {method} request to {url}", extra={"attempt": attempt + 1})
+
+        headers = self._build_headers()
+
+        try:
+            response = self.session.request(
+                method=method,
+                url=url,
+                json=data,
+                headers=headers,
+                timeout=self.timeout,
+            )
+        except requests.RequestException as e:
+            # Network error - retry if attempts remain
+            if attempt < self.retries - 1:
+                self.logger.warning(f"Network error, retrying...", extra={"error": str(e)})
+                time.sleep(0.1 * (attempt + 1))  # Exponential backoff
+                return self._request(method, url, data, attempt + 1)
+            raise ApiException(f"Network error: {str(e)}")
+
+        if response.status_code >= 400:
+            self._handle_error(response, url, attempt)
+
+        return response.json()
+
+    def _build_headers(self) -> Dict[str, str]:
+        """Build request headers"""
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "KiriMel-Python-SDK/0.1.0",
+        }
+
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+
+        return headers
+
+    def _handle_error(self, response: requests.Response, url: str, attempt: int) -> None:
+        """Handle API errors"""
+        try:
+            data = response.json()
+            message = data.get("message", "API request failed")
+            errors = data.get("errors")
+        except ValueError:
+            message = response.text or "API request failed"
+            errors = None
+
+        if response.status_code == 401:
+            raise AuthenticationException(message, response.status_code, errors)
+        elif response.status_code == 429:
+            retry_after = data.get("retry_after") if errors else None
+            if retry_after and attempt < self.retries - 1:
+                self.logger.info(f"Rate limited, waiting {retry_after}s...")
+                time.sleep(retry_after)
+                return  # Will retry
+            raise RateLimitException(message, response.status_code, errors, retry_after)
+        elif response.status_code == 422:
+            raise ValidationException(message, response.status_code, errors)
+        else:
+            raise ApiException(message, response.status_code, errors)

kirimel/resources/__init__.py

@@ -0,0 +1,437 @@
+"""
+Resource clients for KiriMel API
+"""
+from typing import Optional, Dict, Any, List
+from .http_client import HttpClient
+
+
+class ResourceClient:
+    """Base class for resource clients"""
+
+    def __init__(self, http_client: HttpClient):
+        self._http_client = http_client
+
+
+class Campaigns(ResourceClient):
+    """Campaigns resource client"""
+
+    def list(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """List campaigns"""
+        return self._http_client.get("campaigns", params or {})
+
+    def recent(self) -> Dict[str, Any]:
+        """Get recent campaigns"""
+        return self._http_client.get("campaigns/recent")
+
+    def get(self, campaign_id: int) -> Dict[str, Any]:
+        """Get single campaign"""
+        return self._http_client.get(f"campaigns/{campaign_id}")
+
+    def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create campaign"""
+        return self._http_client.post("campaigns", data)
+
+    def update(self, campaign_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update campaign"""
+        return self._http_client.post(f"campaigns/{campaign_id}", data)
+
+    def delete(self, campaign_id: int) -> Dict[str, Any]:
+        """Delete campaign"""
+        return self._http_client.post(f"campaigns/{campaign_id}/delete")
+
+    def duplicate(self, campaign_id: int) -> Dict[str, Any]:
+        """Duplicate campaign"""
+        return self._http_client.post(f"campaigns/{campaign_id}/duplicate")
+
+    def schedule(self, campaign_id: int, scheduled_at: str) -> Dict[str, Any]:
+        """Schedule campaign"""
+        return self._http_client.post(f"campaigns/{campaign_id}/schedule", {"scheduled_at": scheduled_at})
+
+    def pause(self, campaign_id: int) -> Dict[str, Any]:
+        """Pause campaign"""
+        return self._http_client.post(f"campaigns/{campaign_id}/pause")
+
+    def resume(self, campaign_id: int) -> Dict[str, Any]:
+        """Resume campaign"""
+        return self._http_client.post(f"campaigns/{campaign_id}/resume")
+
+    def stats(self, campaign_id: int) -> Dict[str, Any]:
+        """Get campaign statistics"""
+        return self._http_client.get(f"campaigns/{campaign_id}/stats")
+
+
+class Subscribers(ResourceClient):
+    """Subscribers resource client"""
+
+    def list(self, list_id: int, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """List subscribers for a list"""
+        return self._http_client.get(f"lists/{list_id}/subscribers", params or {})
+
+    def get(self, subscriber_id: int) -> Dict[str, Any]:
+        """Get single subscriber"""
+        return self._http_client.get(f"subscribers/{subscriber_id}")
+
+    def create(self, list_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Add subscriber to a list"""
+        return self._http_client.post(f"lists/{list_id}/subscribers", data)
+
+    def update(self, subscriber_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update subscriber"""
+        return self._http_client.post(f"subscribers/{subscriber_id}", data)
+
+    def delete(self, subscriber_id: int) -> Dict[str, Any]:
+        """Delete subscriber"""
+        return self._http_client.post(f"subscribers/{subscriber_id}/delete")
+
+    def unsubscribe(self, subscriber_id: int) -> Dict[str, Any]:
+        """Unsubscribe subscriber"""
+        return self._http_client.post(f"subscribers/{subscriber_id}/unsubscribe")
+
+    def bulk_unsubscribe(self, subscriber_ids: List[int]) -> Dict[str, Any]:
+        """Bulk unsubscribe"""
+        return self._http_client.post("subscribers/bulk-unsubscribe", {"subscriber_ids": subscriber_ids})
+
+    def bulk_delete(self, subscriber_ids: List[int]) -> Dict[str, Any]:
+        """Bulk delete"""
+        return self._http_client.post("subscribers/bulk-delete", {"subscriber_ids": subscriber_ids})
+
+    def activity(self, subscriber_id: int) -> Dict[str, Any]:
+        """Get subscriber activity"""
+        return self._http_client.get(f"subscribers/{subscriber_id}/activity")
+
+    def stats(self, subscriber_id: int) -> Dict[str, Any]:
+        """Get subscriber statistics"""
+        return self._http_client.get(f"subscribers/{subscriber_id}/stats")
+
+    def toggle_vip(self, subscriber_id: int) -> Dict[str, Any]:
+        """Toggle VIP status"""
+        return self._http_client.post(f"subscribers/{subscriber_id}/toggle-vip")
+
+    def search(self, query: str) -> Dict[str, Any]:
+        """Search subscribers"""
+        return self._http_client.get("subscribers/search", {"q": query})
+
+    def add_tag(self, subscriber_id: int, tag: str) -> Dict[str, Any]:
+        """Add tag to subscriber"""
+        return self._http_client.post(f"subscribers/{subscriber_id}/tags", {"tag": tag})
+
+    def remove_tag(self, subscriber_id: int, tag: str) -> Dict[str, Any]:
+        """Remove tag from subscriber"""
+        return self._http_client.post(f"subscribers/{subscriber_id}/tags/{tag}/remove")
+
+    def import_subscribers(self, list_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Import subscribers"""
+        return self._http_client.post(f"lists/{list_id}/subscribers/import", data)
+
+
+class Lists(ResourceClient):
+    """Lists resource client"""
+
+    def list(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """List all lists"""
+        return self._http_client.get("lists", params or {})
+
+    def get(self, list_id: int) -> Dict[str, Any]:
+        """Get single list"""
+        return self._http_client.get(f"lists/{list_id}")
+
+    def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create list"""
+        return self._http_client.post("lists", data)
+
+    def update(self, list_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update list"""
+        return self._http_client.post(f"lists/{list_id}", data)
+
+    def delete(self, list_id: int) -> Dict[str, Any]:
+        """Delete list"""
+        return self._http_client.post(f"lists/{list_id}/delete")
+
+    def stats(self, list_id: int) -> Dict[str, Any]:
+        """Get list statistics"""
+        return self._http_client.get(f"lists/{list_id}/stats")
+
+
+class Segments(ResourceClient):
+    """Segments resource client"""
+
+    def list(self, list_id: int) -> Dict[str, Any]:
+        """List segments for a list"""
+        return self._http_client.get(f"lists/{list_id}/segments")
+
+    def get(self, segment_id: int) -> Dict[str, Any]:
+        """Get single segment"""
+        return self._http_client.get(f"segments/{segment_id}")
+
+    def create(self, list_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create segment"""
+        return self._http_client.post(f"lists/{list_id}/segments", data)
+
+    def update(self, segment_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update segment"""
+        return self._http_client.post(f"segments/{segment_id}", data)
+
+    def delete(self, segment_id: int) -> Dict[str, Any]:
+        """Delete segment"""
+        return self._http_client.post(f"segments/{segment_id}/delete")
+
+    def preview(self, list_id: int, conditions: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """Preview segment (without saving)"""
+        return self._http_client.post(f"lists/{list_id}/segments/preview", {"conditions": conditions})
+
+    def subscribers(self, segment_id: int, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Get segment subscribers"""
+        return self._http_client.get(f"segments/{segment_id}/subscribers", params or {})
+
+    def refresh(self, segment_id: int) -> Dict[str, Any]:
+        """Refresh segment count"""
+        return self._http_client.post(f"segments/{segment_id}/refresh")
+
+    def logs(self, segment_id: int) -> Dict[str, Any]:
+        """Get segment build logs"""
+        return self._http_client.get(f"segments/{segment_id}/logs")
+
+    def templates(self) -> Dict[str, Any]:
+        """Get segment templates"""
+        return self._http_client.get("segments/templates")
+
+    def fields(self) -> Dict[str, Any]:
+        """Get available fields"""
+        return self._http_client.get("segments/fields")
+
+
+class Templates(ResourceClient):
+    """Templates resource client"""
+
+    def list(self, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """List all templates"""
+        return self._http_client.get("templates", params or {})
+
+    def get(self, template_id: int) -> Dict[str, Any]:
+        """Get single template"""
+        return self._http_client.get(f"templates/{template_id}")
+
+    def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create template"""
+        return self._http_client.post("templates", data)
+
+    def update(self, template_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update template"""
+        return self._http_client.post(f"templates/{template_id}", data)
+
+    def delete(self, template_id: int) -> Dict[str, Any]:
+        """Delete template"""
+        return self._http_client.post(f"templates/{template_id}/delete")
+
+    def duplicate(self, template_id: int) -> Dict[str, Any]:
+        """Duplicate template"""
+        return self._http_client.post(f"templates/{template_id}/duplicate")
+
+    def by_category(self, category: str) -> Dict[str, Any]:
+        """Get templates by category"""
+        return self._http_client.get(f"templates/category/{category}")
+
+    def search(self, query: str) -> Dict[str, Any]:
+        """Search templates"""
+        return self._http_client.get("templates/search", {"q": query})
+
+    def categories(self) -> Dict[str, Any]:
+        """Get categories"""
+        return self._http_client.get("templates/categories")
+
+
+class Forms(ResourceClient):
+    """Forms resource client"""
+
+    def list(self) -> Dict[str, Any]:
+        """List all forms"""
+        return self._http_client.get("forms")
+
+    def get(self, form_id: int) -> Dict[str, Any]:
+        """Get single form"""
+        return self._http_client.get(f"forms/{form_id}")
+
+    def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create form"""
+        return self._http_client.post("forms", data)
+
+    def update(self, form_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update form"""
+        return self._http_client.post(f"forms/{form_id}", data)
+
+    def delete(self, form_id: int) -> Dict[str, Any]:
+        """Delete form"""
+        return self._http_client.post(f"forms/{form_id}/delete")
+
+    def duplicate(self, form_id: int) -> Dict[str, Any]:
+        """Duplicate form"""
+        return self._http_client.post(f"forms/{form_id}/duplicate")
+
+    def analytics(self, form_id: int) -> Dict[str, Any]:
+        """Get form analytics"""
+        return self._http_client.get(f"forms/{form_id}/analytics")
+
+    def submissions(self, form_id: int, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Get form submissions"""
+        return self._http_client.get(f"forms/{form_id}/submissions", params or {})
+
+    def embed(self, form_id: int) -> Dict[str, Any]:
+        """Get embed code"""
+        return self._http_client.get(f"forms/{form_id}/embed")
+
+
+class Conversions(ResourceClient):
+    """Conversions resource client"""
+
+    def list(self) -> Dict[str, Any]:
+        """List all conversion goals"""
+        return self._http_client.get("conversions")
+
+    def get(self, goal_id: int) -> Dict[str, Any]:
+        """Get single conversion goal"""
+        return self._http_client.get(f"conversions/{goal_id}")
+
+    def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create conversion goal"""
+        return self._http_client.post("conversions", data)
+
+    def update(self, goal_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update conversion goal"""
+        return self._http_client.post(f"conversions/{goal_id}", data)
+
+    def delete(self, goal_id: int) -> Dict[str, Any]:
+        """Delete conversion goal"""
+        return self._http_client.post(f"conversions/{goal_id}/delete")
+
+    def track(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Track a conversion"""
+        return self._http_client.post("conversions/track", data)
+
+    def conversions(self, goal_id: int) -> Dict[str, Any]:
+        """Get conversions for a goal"""
+        return self._http_client.get(f"conversions/{goal_id}/conversions")
+
+    def roi(self) -> Dict[str, Any]:
+        """Get ROI report"""
+        return self._http_client.get("conversions/roi")
+
+    def funnel(self, goal_id: int) -> Dict[str, Any]:
+        """Get funnel analysis"""
+        return self._http_client.get(f"conversions/{goal_id}/funnel")
+
+
+class LandingPages(ResourceClient):
+    """Landing Pages resource client"""
+
+    def list(self) -> Dict[str, Any]:
+        """List all landing pages"""
+        return self._http_client.get("landing-pages")
+
+    def get(self, page_id: int) -> Dict[str, Any]:
+        """Get single landing page"""
+        return self._http_client.get(f"landing-pages/{page_id}")
+
+    def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create landing page"""
+        return self._http_client.post("landing-pages", data)
+
+    def update(self, page_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update landing page"""
+        return self._http_client.post(f"landing-pages/{page_id}", data)
+
+    def delete(self, page_id: int) -> Dict[str, Any]:
+        """Delete landing page"""
+        return self._http_client.post(f"landing-pages/{page_id}/delete")
+
+    def duplicate(self, page_id: int) -> Dict[str, Any]:
+        """Duplicate landing page"""
+        return self._http_client.post(f"landing-pages/{page_id}/duplicate")
+
+    def publish(self, page_id: int) -> Dict[str, Any]:
+        """Publish landing page"""
+        return self._http_client.post(f"landing-pages/{page_id}/publish")
+
+    def unpublish(self, page_id: int) -> Dict[str, Any]:
+        """Unpublish landing page"""
+        return self._http_client.post(f"landing-pages/{page_id}/unpublish")
+
+    def analytics(self, page_id: int) -> Dict[str, Any]:
+        """Get landing page analytics"""
+        return self._http_client.get(f"landing-pages/{page_id}/analytics")
+
+    def templates(self) -> Dict[str, Any]:
+        """Get templates"""
+        return self._http_client.get("landing-pages/templates")
+
+
+class Workflows(ResourceClient):
+    """Workflows resource client"""
+
+    def list(self) -> Dict[str, Any]:
+        """List all workflows"""
+        return self._http_client.get("workflows")
+
+    def get(self, workflow_id: int) -> Dict[str, Any]:
+        """Get single workflow"""
+        return self._http_client.get(f"workflows/{workflow_id}")
+
+    def create(self, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Create workflow"""
+        return self._http_client.post("workflows", data)
+
+    def update(self, workflow_id: int, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Update workflow"""
+        return self._http_client.post(f"workflows/{workflow_id}", data)
+
+    def delete(self, workflow_id: int) -> Dict[str, Any]:
+        """Delete workflow"""
+        return self._http_client.post(f"workflows/{workflow_id}/delete")
+
+    def duplicate(self, workflow_id: int) -> Dict[str, Any]:
+        """Duplicate workflow"""
+        return self._http_client.post(f"workflows/{workflow_id}/duplicate")
+
+    def activate(self, workflow_id: int) -> Dict[str, Any]:
+        """Activate workflow"""
+        return self._http_client.post(f"workflows/{workflow_id}/activate")
+
+    def pause(self, workflow_id: int) -> Dict[str, Any]:
+        """Pause workflow"""
+        return self._http_client.post(f"workflows/{workflow_id}/pause")
+
+    def validate(self, workflow_id: int) -> Dict[str, Any]:
+        """Validate workflow"""
+        return self._http_client.post(f"workflows/{workflow_id}/validate")
+
+    def executions(self, workflow_id: int) -> Dict[str, Any]:
+        """Get workflow executions"""
+        return self._http_client.get(f"workflows/{workflow_id}/executions")
+
+    def templates(self) -> Dict[str, Any]:
+        """Get workflow templates"""
+        return self._http_client.get("workflows/templates")
+
+    def from_template(self, template_id: int) -> Dict[str, Any]:
+        """Create workflow from template"""
+        return self._http_client.post("workflows/from-template", {"template_id": template_id})
+
+    def node_types(self) -> Dict[str, Any]:
+        """Get available node types"""
+        return self._http_client.get("workflows/node-types")
+
+    def get_data(self, workflow_id: int) -> Dict[str, Any]:
+        """Get workflow data"""
+        return self._http_client.get(f"workflows/{workflow_id}/data")
+
+
+__all__ = [
+    "Campaigns",
+    "Subscribers",
+    "Lists",
+    "Segments",
+    "Templates",
+    "Forms",
+    "Conversions",
+    "LandingPages",
+    "Workflows",
+]

kirimel_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,504 @@
+Metadata-Version: 2.4
+Name: kirimel-python
+Version: 0.1.0
+Summary: Official KiriMel Python SDK
+Author-email: KiriMel <support@kirimel.com>
+License: MIT
+Project-URL: Homepage, https://github.com/kirimel/kirimel-python-sdk
+Project-URL: Documentation, https://docs.kirimel.com
+Project-URL: Repository, https://github.com/kirimel/kirimel-python-sdk
+Project-URL: Issues, https://github.com/kirimel/kirimel-python-sdk/issues
+Keywords: kirimel,email,marketing,sdk,api
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Dynamic: license-file
+
+# KiriMel Python SDK
+
+Official Python SDK for KiriMel Email Marketing API.
+
+## Installation
+
+```bash
+pip install kirimel-python
+```
+
+## Quick Start
+
+```python
+import kirimel
+
+# Initialize the client
+client = kirimel.KiriMel(
+    api_key='sk_test_xxx',  # Or set KIRIMEL_API_KEY env variable
+    base_url='https://api.kirimel.com/v2',
+    timeout=30,
+    retries=3
+)
+
+# List campaigns
+campaigns = client.campaigns.list(status='sent', limit=20)
+
+# Create a campaign
+campaign = client.campaigns.create({
+    'name': 'Welcome Email',
+    'subject': 'Welcome to KiriMel!',
+    'list_id': 123,
+    'template_id': 456
+})
+
+# Get campaign statistics
+stats = client.campaigns.stats(campaign['id'])
+```
+
+## Authentication
+
+The SDK supports two authentication methods:
+
+```python
+# Method 1: API Key (recommended)
+client = kirimel.KiriMel(api_key='sk_test_xxx')
+
+# Method 2: Environment variable
+# Set KIRIMEL_API_KEY=sk_test_xxx in your environment
+client = kirimel.KiriMel()
+```
+
+## Resources
+
+### Campaigns
+
+```python
+# List campaigns
+campaigns = client.campaigns.list(limit=20, status='sent')
+
+# Get recent campaigns
+recent = client.campaigns.recent()
+
+# Get single campaign
+campaign = client.campaigns.get(id)
+
+# Create campaign
+campaign = client.campaigns.create({
+    'name': 'Summer Sale',
+    'subject': '50% Off Everything!',
+    'list_id': 123,
+    'template_id': 456
+})
+
+# Update campaign
+client.campaigns.update(id, {'subject': 'New Subject'})
+
+# Delete campaign
+client.campaigns.delete(id)
+
+# Duplicate campaign
+duplicate = client.campaigns.duplicate(id)
+
+# Schedule campaign
+client.campaigns.schedule(id, '2024-06-01 10:00:00')
+
+# Pause campaign
+client.campaigns.pause(id)
+
+# Resume campaign
+client.campaigns.resume(id)
+
+# Get campaign statistics
+stats = client.campaigns.stats(id)
+```
+
+### Subscribers
+
+```python
+# List subscribers for a list
+subscribers = client.subscribers.list(list_id, limit=50)
+
+# Get single subscriber
+subscriber = client.subscribers.get(id)
+
+# Add subscriber to a list
+subscriber = client.subscribers.create(list_id, {
+    'email': 'user@example.com',
+    'first_name': 'John',
+    'last_name': 'Doe'
+})
+
+# Update subscriber
+client.subscribers.update(id, {'first_name': 'Jane'})
+
+# Delete subscriber
+client.subscribers.delete(id)
+
+# Unsubscribe subscriber
+client.subscribers.unsubscribe(id)
+
+# Bulk unsubscribe
+client.subscribers.bulk_unsubscribe([id1, id2, id3])
+
+# Bulk delete
+client.subscribers.bulk_delete([id1, id2, id3])
+
+# Get subscriber activity
+activity = client.subscribers.activity(id)
+
+# Get subscriber statistics
+stats = client.subscribers.stats(id)
+
+# Toggle VIP status
+client.subscribers.toggle_vip(id)
+
+# Search subscribers
+results = client.subscribers.search('john@example.com')
+
+# Add tag
+client.subscribers.add_tag(id, 'premium-customer')
+
+# Remove tag
+client.subscribers.remove_tag(id, 'premium-customer')
+
+# Import subscribers
+result = client.subscribers.import_subscribers(list_id, {
+    'subscribers': [
+        {'email': 'user1@example.com', 'first_name': 'User 1'},
+        {'email': 'user2@example.com', 'first_name': 'User 2'}
+    ]
+})
+```
+
+### Lists
+
+```python
+# List all lists
+lists = client.lists.list()
+
+# Get single list
+lst = client.lists.get(id)
+
+# Create list
+lst = client.lists.create({
+    'name': 'Newsletter Subscribers',
+    'description': 'Monthly newsletter'
+})
+
+# Update list
+client.lists.update(id, {'name': 'Updated Name'})
+
+# Delete list
+client.lists.delete(id)
+
+# Get list statistics
+stats = client.lists.stats(id)
+```
+
+### Segments
+
+```python
+# List segments for a list
+segments = client.segments.list(list_id)
+
+# Get single segment
+segment = client.segments.get(id)
+
+# Create segment
+segment = client.segments.create(list_id, {
+    'name': 'Active Subscribers',
+    'conditions': [
+        {'field': 'status', 'operator': 'equals', 'value': 'active'}
+    ]
+})
+
+# Update segment
+client.segments.update(id, {'name': 'Updated Name'})
+
+# Delete segment
+client.segments.delete(id)
+
+# Preview segment (without saving)
+preview = client.segments.preview(list_id, [
+    {'field': 'status', 'operator': 'equals', 'value': 'active'}
+])
+
+# Get segment subscribers
+subscribers = client.segments.subscribers(id)
+
+# Refresh segment count
+client.segments.refresh(id)
+
+# Get segment build logs
+logs = client.segments.logs(id)
+
+# Get segment templates
+templates = client.segments.templates()
+
+# Get available fields
+fields = client.segments.fields()
+```
+
+### Templates
+
+```python
+# List all templates
+templates = client.templates.list(limit=20)
+
+# Get single template
+template = client.templates.get(id)
+
+# Create template
+template = client.templates.create({
+    'name': 'Welcome Email',
+    'subject': 'Welcome!',
+    'html_content': '<h1>Hello {{name}}</h1>',
+    'category': 'transactional'
+})
+
+# Update template
+client.templates.update(id, {'name': 'Updated Name'})
+
+# Delete template
+client.templates.delete(id)
+
+# Duplicate template
+duplicate = client.templates.duplicate(id)
+
+# Get templates by category
+templates = client.templates.by_category('newsletter')
+
+# Search templates
+results = client.templates.search('welcome')
+
+# Get categories
+categories = client.templates.categories()
+```
+
+### Forms
+
+```python
+# List all forms
+forms = client.forms.list()
+
+# Get single form
+form = client.forms.get(id)
+
+# Create form
+form = client.forms.create({
+    'name': 'Newsletter Signup',
+    'list_id': 123,
+    'fields': [
+        {'name': 'email', 'type': 'email', 'required': True},
+        {'name': 'first_name', 'type': 'text', 'required': False}
+    ]
+})
+
+# Update form
+client.forms.update(id, {'name': 'Updated Name'})
+
+# Delete form
+client.forms.delete(id)
+
+# Duplicate form
+duplicate = client.forms.duplicate(id)
+
+# Get form analytics
+analytics = client.forms.analytics(id)
+
+# Get form submissions
+submissions = client.forms.submissions(id)
+
+# Get embed code
+embed = client.forms.embed(id)
+```
+
+### Conversions
+
+```python
+# List all conversion goals
+conversions = client.conversions.list()
+
+# Get single conversion goal
+goal = client.conversions.get(id)
+
+# Create conversion goal
+goal = client.conversions.create({
+    'name': 'Purchase',
+    'event_type': 'purchase',
+    'value': 100
+})
+
+# Update conversion goal
+client.conversions.update(id, {'name': 'Updated Name'})
+
+# Delete conversion goal
+client.conversions.delete(id)
+
+# Track a conversion
+client.conversions.track({
+    'goal_id': id,
+    'subscriber_id': 123,
+    'value': 50
+})
+
+# Get conversions for a goal
+conversions = client.conversions.conversions(id)
+
+# Get ROI report
+roi = client.conversions.roi()
+
+# Get funnel analysis
+funnel = client.conversions.funnel(id)
+```
+
+### Landing Pages
+
+```python
+# List all landing pages
+pages = client.landing_pages.list()
+
+# Get single landing page
+page = client.landing_pages.get(id)
+
+# Create landing page
+page = client.landing_pages.create({
+    'name': 'Thank You Page',
+    'slug': 'thank-you',
+    'html_content': '<h1>Thank you!</h1>'
+})
+
+# Update landing page
+client.landing_pages.update(id, {'name': 'Updated Name'})
+
+# Delete landing page
+client.landing_pages.delete(id)
+
+# Duplicate landing page
+duplicate = client.landing_pages.duplicate(id)
+
+# Publish landing page
+client.landing_pages.publish(id)
+
+# Unpublish landing page
+client.landing_pages.unpublish(id)
+
+# Get landing page analytics
+analytics = client.landing_pages.analytics(id)
+
+# Get templates
+templates = client.landing_pages.templates()
+```
+
+### Workflows
+
+```python
+# List all workflows
+workflows = client.workflows.list()
+
+# Get single workflow
+workflow = client.workflows.get(id)
+
+# Create workflow
+workflow = client.workflows.create({
+    'name': 'Welcome Series',
+    'nodes': [...],
+    'edges': [...]
+})
+
+# Update workflow
+client.workflows.update(id, {'name': 'Updated Name'})
+
+# Delete workflow
+client.workflows.delete(id)
+
+# Duplicate workflow
+duplicate = client.workflows.duplicate(id)
+
+# Activate workflow
+client.workflows.activate(id)
+
+# Pause workflow
+client.workflows.pause(id)
+
+# Validate workflow
+validation = client.workflows.validate(id)
+
+# Get workflow executions
+executions = client.workflows.executions(id)
+
+# Get workflow templates
+templates = client.workflows.templates()
+
+# Create workflow from template
+workflow = client.workflows.from_template(template_id)
+
+# Get available node types
+node_types = client.workflows.node_types()
+
+# Get workflow data
+data = client.workflows.get_data(id)
+```
+
+## Error Handling
+
+```python
+from kirimel import (
+    ApiException,
+    AuthenticationException,
+    RateLimitException,
+    ValidationException
+)
+
+try:
+    campaign = client.campaigns.create(data)
+except AuthenticationException as e:
+    # Invalid API key
+    print(f"Authentication failed: {e.message}")
+except RateLimitException as e:
+    # Too many requests
+    print(f"Rate limited. Retry after: {e.retry_after} seconds")
+except ValidationException as e:
+    # Invalid data
+    print(f"Validation errors: {e.errors}")
+except ApiException as e:
+    # General API error
+    print(f"API error ({e.status_code}): {e.message}")
+```
+
+## Logging
+
+```python
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+
+# The SDK will use the root logger by default
+```
+
+## Requirements
+
+- Python 3.8 or higher
+- requests >= 2.28.0
+
+## License
+
+MIT License
+
+## Support
+
+- Documentation: https://docs.kirimel.com
+- GitHub: https://github.com/hualiglobal/kirimel-python-sdk
+- Issues: https://github.com/hualiglobal/kirimel-python-sdk/issues

kirimel_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+kirimel/__init__.py,sha256=wMYmn0-EMr1F_aOoSPslMueRfjVj8KhUzx8sv7LZp8Y,389
+kirimel/client.py,sha256=plRDNMnM5FTq7y_M8IkALNN-IqtuG95JemuCaTD-daQ,3601
+kirimel/exceptions.py,sha256=M-xnViNC3h7fdHA6EzsmZEWVFar165rKceR6YarIOdw,941
+kirimel/http_client.py,sha256=cMolOCvSAKbJv5Or4qiDOn4V36TEqZfdgeSofKZL8ok,4613
+kirimel/resources/__init__.py,sha256=ZMcaVwoDL6BSUKz3DXqHbQQOWuuAOgmqad71VqJuBVU,16687
+kirimel_python-0.1.0.dist-info/licenses/LICENSE,sha256=7Om6VWyG3CquT1oA7zTeIhMJMzzO1mAyHI2T_1RRxFE,1064
+kirimel_python-0.1.0.dist-info/METADATA,sha256=FlJ7m-fV0GMehMKoY55ZXacoE8mW87WFaAqmZEihVOE,10595
+kirimel_python-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+kirimel_python-0.1.0.dist-info/top_level.txt,sha256=8bso5h6_Im2tu-GdN4MRfXGDPR7qJ51o0-XusPi_ZI8,8
+kirimel_python-0.1.0.dist-info/RECORD,,

kirimel_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kirimel_python-0.1.0.dist-info/licenses/LICENSE

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

kirimel_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+kirimel