postwing 0.3.0__py3-none-any.whl

postwing/__init__.py

@@ -0,0 +1,7 @@
+"""PostwingSDK - Python SDK for Postwing email service API."""
+
+from .sdk import PostwingSdk
+from .exceptions import PostwingSdkException
+
+__version__ = "1.0.0"
+__all__ = ["PostwingSdk", "PostwingSdkException"]

postwing/exceptions.py

@@ -0,0 +1,9 @@
+class PostwingSdkException(Exception):
+    msg = "Unhandled exception"
+
+    def __init__(self, msg: str, *args):
+        super().__init__(*args)
+        self.msg = msg
+
+    def __str__(self):
+        return f"PostwingSdkException: {self.msg}"

postwing/sdk.py

@@ -0,0 +1,314 @@
+import logging
+from concurrent.futures import ThreadPoolExecutor, Future
+from typing import Callable
+
+import requests
+from requests import exceptions
+import json
+
+from .exceptions import PostwingSdkException
+
+
+logger = logging.getLogger(__name__)
+
+
+class PostwingSdk:
+    SERVER_URL = "https://api.postwing.app"
+    auth = {}
+    fail_silently = False
+    debug = False
+    _executor = None
+    _max_workers = 5
+    _logger = None
+
+    @property
+    def api_url(self):
+        return f"{self.SERVER_URL}/external/"
+
+    @property
+    def executor(self) -> ThreadPoolExecutor:
+        """Lazy initialization of thread pool executor"""
+        if self._executor is None:
+            self._logger.info(f"Initializing ThreadPoolExecutor with {self._max_workers} workers")
+            self._executor = ThreadPoolExecutor(max_workers=self._max_workers)
+        return self._executor
+
+    def __init__(self, username: str, password: str, fail_silently=False, max_workers=5, log_level=logging.INFO):
+        """
+        Initialize PostwingSdk.
+
+        Args:
+            username: API username
+            password: API password
+            fail_silently: If True, suppress exceptions and return False on errors
+            max_workers: Number of worker threads for async operations
+            log_level: Logging level (e.g., logging.DEBUG, logging.INFO, logging.WARNING)
+                      Use logging.DEBUG to see detailed request/response logs
+        """
+        self.auth = {"username": username, "password": password}
+        self.fail_silently = fail_silently
+        self._max_workers = max_workers
+
+        # Configure logger for this instance
+        self._logger = logging.getLogger(f"{__name__}.{id(self)}")
+        self._logger.setLevel(log_level)
+
+        # Add handler if none exists (avoid duplicate handlers)
+        if not self._logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setLevel(log_level)
+            formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+            handler.setFormatter(formatter)
+            self._logger.addHandler(handler)
+
+        self._logger.info(f"PostwingSdk initialized with username={username}, max_workers={max_workers}, log_level={logging.getLevelName(log_level)}")
+
+    def send_simple(
+        self,
+        recipient: str,
+        sender: str,
+        subject: str,
+        body: str,
+        idempotency_key: str = None,
+    ) -> bool:
+        payload = {
+            "auth": self.auth,
+            "recipient": recipient,
+            "sender": sender,
+            "subject": subject,
+            "body": body,
+            "idempotency_key": idempotency_key,
+        }
+        try:
+            path = f"{self.api_url}send_email_simple/"
+
+            # Debug log for request
+            self._logger.debug(
+                f"Sending simple email - URL: {path}, "
+                f"recipient: {recipient}, sender: {sender}, subject: {subject}, "
+                f"idempotency_key: {idempotency_key}"
+            )
+            self._logger.debug(f"Request payload: {json.dumps({**payload, 'auth': '***'})}")
+
+            res = requests.post(path, json=payload)
+
+            # Debug log for response
+            try:
+                response_text = res.text[:200] + "..." if len(res.text) > 200 else res.text
+            except (TypeError, AttributeError):
+                response_text = str(res.text)
+            self._logger.debug(f"Response received - status_code: {res.status_code}, response: {response_text}")
+
+            if not res.ok:
+                self._logger.error(f"API error - status: {res.status_code}, response: {res.text}")
+                raise PostwingSdkException(res.text)
+
+            self._logger.info(f"Simple email sent successfully to {recipient}")
+        except exceptions.RequestException as exc:
+            self._logger.error(f"Request exception while sending email: {exc}")
+            if not self.fail_silently:
+                raise PostwingSdkException("Postwing API error") from exc
+        return True
+
+    def send(
+        self,
+        tpl: str,
+        recipient: str,
+        sender: str,
+        lang: str | None = None,
+        params: dict | None = None,
+        idempotency_key: str | None = None,
+    ):
+        payload = {
+            "auth": self.auth,
+            "tpl": tpl,
+            "recipient": recipient,
+            "sender": sender,
+            "lang": lang,
+            "params": params,
+            "idempotency_key": idempotency_key,
+        }
+        try:
+            path = f"{self.api_url}send_email_tpl/"
+
+            # Debug log for request
+            self._logger.debug(
+                f"Sending templated email - URL: {path}, "
+                f"template: {tpl}, recipient: {recipient}, sender: {sender}, "
+                f"lang: {lang}, idempotency_key: {idempotency_key}"
+            )
+            self._logger.debug(f"Request payload: {json.dumps({**payload, 'auth': '***'})}")
+
+            res = requests.post(path, json=payload)
+
+            # Debug log for response
+            try:
+                response_text = res.text[:200] + "..." if len(res.text) > 200 else res.text
+            except (TypeError, AttributeError):
+                response_text = str(res.text)
+            self._logger.debug(f"Response received - status_code: {res.status_code}, response: {response_text}")
+
+            if not res.ok:
+                self._logger.error(f"API error - status: {res.status_code}, response: {res.text}")
+                raise PostwingSdkException(str(res.text))
+
+            self._logger.info(f"Templated email sent successfully to {recipient} using template '{tpl}'")
+        except exceptions.RequestException as exc:
+            self._logger.error(f"Request exception while sending email: {exc}")
+            if not self.fail_silently:
+                raise PostwingSdkException("Postwing API error") from exc
+        return True
+
+    def send_simple_async(
+        self,
+        recipient: str,
+        sender: str,
+        subject: str,
+        body: str,
+        idempotency_key: str = None,
+        callback: Callable[[bool, Exception | None], None] | None = None,
+    ) -> Future:
+        """
+        Send a simple email asynchronously in a background thread.
+
+        Args:
+            recipient: Email recipient
+            sender: Email sender
+            subject: Email subject
+            body: Email body (HTML)
+            idempotency_key: Optional unique key to prevent duplicate sends
+            callback: Optional callback function called with (result, exception)
+
+        Returns:
+            Future object that can be used to wait for the result or check status
+
+        Example:
+            # Fire and forget
+            sdk.send_simple_async(recipient="user@example.com", ...)
+
+            # With callback
+            def on_complete(success, error):
+                if error:
+                    print(f"Error: {error}")
+                else:
+                    print("Email sent successfully")
+
+            sdk.send_simple_async(recipient="user@example.com", ..., callback=on_complete)
+
+            # Wait for result
+            future = sdk.send_simple_async(recipient="user@example.com", ...)
+            result = future.result()  # Blocks until complete
+        """
+        self._logger.debug(f"Submitting async simple email task for {recipient}")
+
+        def task():
+            try:
+                self._logger.debug(f"Async task started for simple email to {recipient}")
+                result = self.send_simple(
+                    recipient=recipient,
+                    sender=sender,
+                    subject=subject,
+                    body=body,
+                    idempotency_key=idempotency_key,
+                )
+                if callback:
+                    self._logger.debug(f"Calling callback for successful async email to {recipient}")
+                    callback(result, None)
+                self._logger.debug(f"Async task completed successfully for {recipient}")
+                return result
+            except Exception as e:
+                self._logger.error(f"Async task failed for {recipient}: {e}")
+                if callback:
+                    self._logger.debug(f"Calling callback with error for {recipient}")
+                    callback(False, e)
+                raise
+
+        return self.executor.submit(task)
+
+    def send_async(
+        self,
+        tpl: str,
+        recipient: str,
+        sender: str,
+        lang: str | None = None,
+        params: dict | None = None,
+        idempotency_key: str | None = None,
+        callback: Callable[[bool, Exception | None], None] | None = None,
+    ) -> Future:
+        """
+        Send a templated email asynchronously in a background thread.
+
+        Args:
+            tpl: Template name
+            recipient: Email recipient
+            sender: Email sender
+            lang: Language code (e.g., 'en', 'ru')
+            params: Template parameters
+            idempotency_key: Optional unique key to prevent duplicate sends
+            callback: Optional callback function called with (result, exception)
+
+        Returns:
+            Future object that can be used to wait for the result or check status
+
+        Example:
+            # Fire and forget
+            sdk.send_async(tpl="welcome", recipient="user@example.com", ...)
+
+            # With callback
+            def on_complete(success, error):
+                if error:
+                    print(f"Error: {error}")
+                else:
+                    print("Email sent successfully")
+
+            sdk.send_async(tpl="welcome", ..., callback=on_complete)
+
+            # Wait for result
+            future = sdk.send_async(tpl="welcome", ...)
+            result = future.result()  # Blocks until complete
+        """
+        self._logger.debug(f"Submitting async templated email task for {recipient} with template '{tpl}'")
+
+        def task():
+            try:
+                self._logger.debug(f"Async task started for templated email to {recipient} (template: {tpl})")
+                result = self.send(
+                    tpl=tpl,
+                    recipient=recipient,
+                    sender=sender,
+                    lang=lang,
+                    params=params,
+                    idempotency_key=idempotency_key,
+                )
+                if callback:
+                    self._logger.debug(f"Calling callback for successful async email to {recipient}")
+                    callback(result, None)
+                self._logger.debug(f"Async task completed successfully for {recipient}")
+                return result
+            except Exception as e:
+                self._logger.error(f"Async task failed for {recipient}: {e}")
+                if callback:
+                    self._logger.debug(f"Calling callback with error for {recipient}")
+                    callback(False, e)
+                raise
+
+        return self.executor.submit(task)
+
+    def shutdown(self, wait=True):
+        """
+        Shutdown the thread pool executor.
+
+        Args:
+            wait: If True, wait for all pending tasks to complete
+        """
+        if self._executor is not None:
+            self._logger.info(f"Shutting down ThreadPoolExecutor (wait={wait})")
+            self._executor.shutdown(wait=wait)
+            self._executor = None
+            self._logger.debug("ThreadPoolExecutor shutdown complete")
+
+    def __del__(self):
+        """Cleanup executor on garbage collection"""
+        if self._logger:
+            self._logger.debug("PostwingSdk instance being destroyed, cleaning up executor")
+        self.shutdown(wait=False)

postwing-0.3.0.dist-info/METADATA

@@ -0,0 +1,528 @@
+Metadata-Version: 2.4
+Name: postwing
+Version: 0.3.0
+Summary: Python SDK for Postwing email service API (api.postwing.app)
+Author-email: Andrey Fanyagin <skymanrm@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/skymanrm/postwing-python-sdk
+Project-URL: Repository, https://github.com/skymanrm/postwing-python-sdk
+Project-URL: Issues, https://github.com/skymanrm/postwing-python-sdk/issues
+Keywords: email,postwing,sdk,api,email-service
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+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
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: faker>=8.0.0; extra == "dev"
+
+# PostwingSDK
+
+A Python SDK for the [Postwing](https://postwing.ru) email service API. Provides both synchronous and asynchronous methods for sending emails via templates or simple HTML content.
+
+## Features
+
+- **Synchronous and Asynchronous API** - Choose between blocking and non-blocking email sending
+- **Template Support** - Send emails using pre-configured templates with parameters
+- **Simple HTML Emails** - Send plain HTML emails directly
+- **Idempotency Keys** - Prevent duplicate email sends with unique keys
+- **Multi-language Support** - Send templated emails in different languages
+- **Thread Pool Execution** - Efficient concurrent email sending with configurable worker threads
+- **Callback Support** - Handle async results with callbacks for fire-and-forget patterns
+- **Fail Silently Mode** - Option to suppress exceptions for graceful degradation
+- **Comprehensive Logging** - Configurable logging levels with detailed request/response information for debugging
+
+## Installation
+
+Install the required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+### Dependencies
+
+- `requests` - For making HTTP API calls
+- `faker` - For running tests (development only)
+
+## Quick Start
+
+```python
+from postwing.sdk import PostwingSdk
+
+# Initialize the SDK
+sdk = PostwingSdk(
+    username="your-domain@example.com",
+    password="your-api-token"
+)
+
+# Send a simple HTML email
+sdk.send_simple(
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    subject="Welcome!",
+    body="<h1>Hello World</h1>"
+)
+
+# Send a templated email
+sdk.send(
+    tpl="welcome-template",
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    lang="en",
+    params={"name": "John", "code": "123456"}
+)
+```
+
+## Usage
+
+### Synchronous Methods
+
+#### Send Simple HTML Email
+
+```python
+sdk.send_simple(
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    subject="Important Notice",
+    body="<p>This is an important message.</p>",
+    idempotency_key="unique-key-123"  # Optional: prevent duplicates
+)
+```
+
+#### Send Templated Email
+
+```python
+sdk.send(
+    tpl="password-reset",
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    lang="en",  # Optional: language code
+    params={"reset_link": "https://example.com/reset/token"},  # Template variables
+    idempotency_key="reset-user-123"  # Optional: prevent duplicates
+)
+```
+
+### Asynchronous Methods
+
+Async methods use a thread pool executor for non-blocking operation. They return `Future` objects that can be used in various ways:
+
+#### Fire and Forget
+
+Send emails without waiting for responses:
+
+```python
+sdk.send_simple_async(
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    subject="Newsletter",
+    body="<h1>Latest Updates</h1>"
+)
+# Continues immediately without blocking
+```
+
+#### Using Callbacks
+
+Handle results with callback functions:
+
+```python
+def on_complete(success, error):
+    if error:
+        print(f"Failed to send email: {error}")
+    else:
+        print("Email sent successfully!")
+
+sdk.send_async(
+    tpl="notification",
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    params={"message": "You have a new notification"},
+    callback=on_complete
+)
+```
+
+#### Wait for Results
+
+Send async but wait for completion when needed:
+
+```python
+future = sdk.send_simple_async(
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    subject="Confirmation",
+    body="<p>Please confirm your action</p>"
+)
+
+# Do other work...
+
+# Wait for result (with timeout)
+try:
+    result = future.result(timeout=10)  # Wait up to 10 seconds
+    print(f"Email sent: {result}")
+except Exception as e:
+    print(f"Email failed: {e}")
+```
+
+#### Batch Sending
+
+Send multiple emails concurrently:
+
+```python
+recipients = ["user1@example.com", "user2@example.com", "user3@example.com"]
+futures = []
+
+for recipient in recipients:
+    future = sdk.send_simple_async(
+        recipient=recipient,
+        sender="noreply@example.com",
+        subject="Batch Email",
+        body="<p>Hello!</p>",
+        idempotency_key=f"batch-{recipient}"
+    )
+    futures.append(future)
+
+# Wait for all to complete
+for future in futures:
+    try:
+        future.result(timeout=30)
+    except Exception as e:
+        print(f"Failed: {e}")
+```
+
+#### Check Status Without Blocking
+
+```python
+future = sdk.send_simple_async(
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    subject="Status Check",
+    body="<p>Testing</p>"
+)
+
+if future.done():
+    result = future.result()
+    print(f"Already completed: {result}")
+else:
+    print("Still processing...")
+```
+
+## Configuration
+
+### SDK Options
+
+```python
+import logging
+
+sdk = PostwingSdk(
+    username="your-domain@example.com",
+    password="your-api-token",
+    fail_silently=False,  # If True, suppresses exceptions
+    max_workers=5,  # Number of concurrent threads for async operations
+    log_level=logging.INFO  # Logging level (default: INFO)
+)
+```
+
+### Logging
+
+The SDK includes comprehensive logging capabilities to help with debugging and monitoring email operations.
+
+#### Log Levels
+
+The SDK supports standard Python logging levels:
+
+- `logging.DEBUG` - Detailed information including request/response data (recommended for development)
+- `logging.INFO` - General operational messages about SDK lifecycle and email sends (default)
+- `logging.WARNING` - Warning messages
+- `logging.ERROR` - Error messages only
+
+#### Basic Logging Configuration
+
+```python
+import logging
+from postwing.sdk import PostwingSdk
+
+# Enable DEBUG logging to see detailed request/response information
+sdk = PostwingSdk(
+    username="your-domain@example.com",
+    password="your-api-token",
+    log_level=logging.DEBUG
+)
+
+# Send an email - you'll see detailed logs
+sdk.send_simple(
+    recipient="user@example.com",
+    sender="noreply@example.com",
+    subject="Test Email",
+    body="<p>Testing with debug logs</p>"
+)
+```
+
+#### What Gets Logged
+
+**INFO Level:**
+- SDK initialization with configuration
+- ThreadPoolExecutor creation and shutdown
+- Successful email sends
+
+**DEBUG Level:**
+- All INFO level messages
+- Full request details (URL, parameters, sanitized payload)
+- Full response details (status codes, response body)
+- Async task lifecycle (submission, start, completion)
+- Callback execution
+
+**ERROR Level:**
+- API errors (non-2xx responses)
+- Network/connection errors
+- Async task failures
+
+#### Example Output
+
+```
+2025-11-21 17:36:05,170 - postwing.sdk.4472389120 - INFO - PostwingSdk initialized with username=test, max_workers=5, log_level=INFO
+2025-11-21 17:36:05,171 - postwing.sdk.4472389120 - INFO - Initializing ThreadPoolExecutor with 5 workers
+2025-11-21 17:36:05,171 - postwing.sdk.4472389120 - DEBUG - Sending simple email - URL: https://api.postwing.app/external/send_email_simple/, recipient: user@example.com, sender: noreply@example.com, subject: Test, idempotency_key: None
+2025-11-21 17:36:05,171 - postwing.sdk.4472389120 - DEBUG - Request payload: {"recipient": "user@example.com", "sender": "noreply@example.com", "subject": "Test", "body": "<p>Test</p>", "auth": "***"}
+2025-11-21 17:36:05,171 - postwing.sdk.4472389120 - DEBUG - Response received - status_code: 200, response: {"success": true}
+2025-11-21 17:36:05,171 - postwing.sdk.4472389120 - INFO - Simple email sent successfully to user@example.com
+```
+
+#### Disable Logging
+
+To disable all logging output:
+
+```python
+sdk = PostwingSdk(
+    username="your-domain@example.com",
+    password="your-api-token",
+    log_level=logging.CRITICAL  # Only critical errors
+)
+```
+
+#### Production Recommendations
+
+For production environments, we recommend:
+
+1. Use `logging.INFO` or `logging.WARNING` to avoid logging sensitive data
+2. Configure external log aggregation (e.g., CloudWatch, Datadog)
+3. Monitor ERROR level logs for operational issues
+4. Use DEBUG level only for troubleshooting specific issues
+
+#### Custom Logging Configuration
+
+If you need more control over logging format or handlers, you can configure Python's logging system before initializing the SDK:
+
+```python
+import logging
+
+# Configure global logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('postwing.log'),
+        logging.StreamHandler()
+    ]
+)
+
+# SDK will use the configured logging system
+sdk = PostwingSdk(
+    username="your-domain@example.com",
+    password="your-api-token",
+    log_level=logging.DEBUG
+)
+```
+
+### Cleanup
+
+Properly shutdown the thread pool when done:
+
+```python
+# Wait for all pending emails to complete before shutdown
+sdk.shutdown(wait=True)
+```
+
+Or use a try-finally pattern:
+
+```python
+try:
+    sdk.send_simple_async(...)
+    # ... more operations
+finally:
+    sdk.shutdown(wait=True)
+```
+
+## API Reference
+
+### `PostwingSdk`
+
+#### Constructor
+
+```python
+PostwingSdk(username: str, password: str, fail_silently=False, max_workers=5, log_level=logging.INFO)
+```
+
+- `username` - Your Postwing account username (typically your domain)
+- `password` - Your Postwing API token
+- `fail_silently` - If True, suppresses exceptions on errors
+- `max_workers` - Number of threads for async operations (default: 5)
+- `log_level` - Logging level using Python's logging constants (default: logging.INFO). Use logging.DEBUG for detailed request/response logs
+
+#### Methods
+
+##### `send_simple(recipient, sender, subject, body, idempotency_key=None) -> bool`
+
+Send a simple HTML email synchronously.
+
+##### `send(tpl, recipient, sender, lang=None, params=None, idempotency_key=None) -> bool`
+
+Send a templated email synchronously.
+
+##### `send_simple_async(recipient, sender, subject, body, idempotency_key=None, callback=None) -> Future`
+
+Send a simple HTML email asynchronously.
+
+##### `send_async(tpl, recipient, sender, lang=None, params=None, idempotency_key=None, callback=None) -> Future`
+
+Send a templated email asynchronously.
+
+##### `shutdown(wait=True)`
+
+Shutdown the thread pool executor.
+
+### Exceptions
+
+#### `PostwingSdkException`
+
+Raised when API requests fail or network errors occur. Can be suppressed with `fail_silently=True`.
+
+## Development
+
+### Using the Makefile
+
+The project includes a Makefile for common development tasks:
+
+```bash
+# View all available commands
+make help
+
+# Install dependencies
+make install
+
+# Run all tests
+make test
+
+# Run synchronous tests only
+make test-sync
+
+# Run asynchronous tests only
+make test-async
+
+# Run a specific test
+make test-specific TEST=tests.PostwingAsyncTestUtils.test_send_simple_async_success
+
+# Build the package
+make build
+
+# Clean build artifacts
+make clean
+```
+
+### Testing
+
+The SDK includes a comprehensive test suite covering both synchronous and asynchronous operations.
+
+#### Quick Test Commands (Using Makefile)
+
+```bash
+# Run all tests
+make test
+
+# Run specific test classes
+make test-sync    # Synchronous tests only
+make test-async   # Asynchronous tests only
+
+# Run a specific test
+make test-specific TEST=tests.PostwingAsyncTestUtils.test_send_simple_async_success
+```
+
+#### Manual Test Commands (Without Makefile)
+
+```bash
+# Run all tests
+source .venv/bin/activate
+PYTHONPATH=/Users/skyman/Documents/My/Python:$PYTHONPATH python -m unittest tests
+
+# Run specific test class
+PYTHONPATH=/Users/skyman/Documents/My/Python:$PYTHONPATH python -m unittest tests.PostwingTestUtils
+
+# Run specific test
+PYTHONPATH=/Users/skyman/Documents/My/Python:$PYTHONPATH python -m unittest tests.PostwingAsyncTestUtils.test_send_simple_async_success
+```
+
+### Building and Publishing
+
+Build the package for distribution:
+
+```bash
+# Build the package
+make build
+
+# Publish to TestPyPI (for testing)
+make publish-test
+
+# Publish to PyPI (production)
+make publish
+```
+
+Or manually:
+
+```bash
+# Build
+python -m build
+
+# Check the distribution
+twine check dist/*
+
+# Upload to PyPI
+twine upload dist/*
+```
+
+## Examples
+
+See `async_example.py` for comprehensive examples of all async patterns including:
+- Fire and forget
+- Callback handling
+- Waiting for results
+- Batch sending
+- Status checking
+- Proper cleanup
+
+## API Endpoints
+
+The SDK communicates with the following Postwing API endpoints:
+
+- **Base URL**: `https://api.postwing.app/external/`
+- **Simple Send**: `POST /external/send_email_simple/`
+- **Template Send**: `POST /external/send_email_tpl/`
+
+## Contributing
+
+Contributions are welcome! Please ensure all tests pass before submitting a pull request.
+
+## License
+
+[Add your license information here]
+
+## Support
+
+For issues, questions, or feature requests, please contact Postwing support or open an issue in this repository.

postwing-0.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+postwing/__init__.py,sha256=x3d3lOraxp9KAZar8zG2wuANkwzFXoZmaP28tGFhBsY,211
+postwing/exceptions.py,sha256=MYu58rUJ_WeXPiMNzDzD0zn1UgYSPdSeLAajUVA5Vpc,243
+postwing/sdk.py,sha256=WLsEG-3dLG6Z32Ow68W9lTtuVk9-k-l7NztbOtzf-xE,11664
+postwing-0.3.0.dist-info/METADATA,sha256=_KNkhG6zQ1QfBadIPZKj8Bi2Pwx-uVNjx2_TzE87VFw,13792
+postwing-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+postwing-0.3.0.dist-info/top_level.txt,sha256=At-KaZlOibwogX4nh-ucNoXgYDTUjIOW3jVOYy_aAq8,9
+postwing-0.3.0.dist-info/RECORD,,

postwing-0.3.0.dist-info/WHEEL

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

postwing-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+postwing