mailifica 1.0.0__tar.gz

mailifica-1.0.0/LICENSE

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

mailifica-1.0.0/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: mailifica
+Version: 1.0.0
+Summary: Official Python SDK for Mailifica Email Infrastructure
+Home-page: https://github.com/mailifica/mailifica-python
+Author: Mailifica
+Author-email: Mailifica <team@mailifica.com>
+License: MIT
+Project-URL: Homepage, https://mailifica.com
+Project-URL: Documentation, https://mailifica.com/docs
+Project-URL: Repository, https://github.com/mailifica/mailifica-python
+Project-URL: Bug Tracker, https://github.com/mailifica/mailifica-python/issues
+Keywords: email,transactional-email,mailifica,sdk,api
+Classifier: Development Status :: 5 - Production/Stable
+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
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: typing-extensions>=4.0.0; python_version < "3.10"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Mailifica Python SDK (`mailifica`)
+
+> SDK oficial em Python para a infraestrutura de e-mails transacionais **Mailifica**, com interface drop-in replacement compatível com o Resend.
+
+---
+
+## 📦 Instalação
+
+```bash
+pip install mailifica
+# ou com Poetry
+poetry add mailifica
+```
+
+---
+
+## 🚀 Como Usar
+
+### 1. Envio Estático (Estilo Resend)
+
+```python
+import mailifica
+
+# Configurar API Key
+mailifica.api_key = "ma_live_123456789"
+
+params: mailifica.Emails.SendParams = {
+    "from": "onboarding@suaempresa.ao",
+    "to": ["cliente@gmail.com"],
+    "subject": "Boas-vindas!",
+    "html": "<h1>Olá!</h1><p>Seu e-mail transacional foi entregue.</p>",
+}
+
+email = mailifica.Emails.send(params)
+print("E-mail ID:", email["id"])
+```
+
+### 2. Envio Orientado a Objetos / Instância
+
+```python
+from mailifica import Mailifica
+
+client = Mailifica("ma_live_123456789")
+
+response = client.emails.send({
+    "from": "suporte@suaempresa.ao",
+    "to": "usuario@empresa.com",
+    "subject": "Notificação",
+    "text": "Seu chamado foi atualizado.",
+})
+```
+
+### 3. Envio em Lote (Batch)
+
+```python
+import mailifica
+
+mailifica.api_key = "ma_live_123456789"
+
+batch_response = mailifica.Batch.send([
+    {
+        "from": "novidades@suaempresa.ao",
+        "to": "cliente1@gmail.com",
+        "subject": "Atualização Mensal",
+        "html": "<p>Novidades do mês</p>",
+    },
+    {
+        "from": "novidades@suaempresa.ao",
+        "to": "cliente2@gmail.com",
+        "subject": "Atualização Mensal",
+        "html": "<p>Novidades do mês</p>",
+    }
+])
+```
+
+### 4. Gestão de Domínios & API Keys
+
+```python
+import mailifica
+
+# Criar domínio
+domain = mailifica.Domains.create({"name": "meudominio.ao"})
+
+# Verificar registros DNS
+verified = mailifica.Domains.verify(domain["id"])
+
+# Listar API Keys
+keys = mailifica.ApiKeys.list()
+```
+
+### 5. Validação de Webhooks HMAC
+
+```python
+from mailifica import Webhooks
+
+is_valid = Webhooks.verify_signature(
+    payload=raw_body,
+    signature=headers.get("mailifica-signature"),
+    secret="seu_webhook_secret"
+)
+```
+
+---
+
+## 📄 Licença
+
+MIT © [Mailifica](https://mailifica.com)

mailifica-1.0.0/README.md

@@ -0,0 +1,107 @@
+# Mailifica Python SDK (`mailifica`)
+
+> SDK oficial em Python para a infraestrutura de e-mails transacionais **Mailifica**, com interface drop-in replacement compatível com o Resend.
+
+---
+
+## 📦 Instalação
+
+```bash
+pip install mailifica
+# ou com Poetry
+poetry add mailifica
+```
+
+---
+
+## 🚀 Como Usar
+
+### 1. Envio Estático (Estilo Resend)
+
+```python
+import mailifica
+
+# Configurar API Key
+mailifica.api_key = "ma_live_123456789"
+
+params: mailifica.Emails.SendParams = {
+    "from": "onboarding@suaempresa.ao",
+    "to": ["cliente@gmail.com"],
+    "subject": "Boas-vindas!",
+    "html": "<h1>Olá!</h1><p>Seu e-mail transacional foi entregue.</p>",
+}
+
+email = mailifica.Emails.send(params)
+print("E-mail ID:", email["id"])
+```
+
+### 2. Envio Orientado a Objetos / Instância
+
+```python
+from mailifica import Mailifica
+
+client = Mailifica("ma_live_123456789")
+
+response = client.emails.send({
+    "from": "suporte@suaempresa.ao",
+    "to": "usuario@empresa.com",
+    "subject": "Notificação",
+    "text": "Seu chamado foi atualizado.",
+})
+```
+
+### 3. Envio em Lote (Batch)
+
+```python
+import mailifica
+
+mailifica.api_key = "ma_live_123456789"
+
+batch_response = mailifica.Batch.send([
+    {
+        "from": "novidades@suaempresa.ao",
+        "to": "cliente1@gmail.com",
+        "subject": "Atualização Mensal",
+        "html": "<p>Novidades do mês</p>",
+    },
+    {
+        "from": "novidades@suaempresa.ao",
+        "to": "cliente2@gmail.com",
+        "subject": "Atualização Mensal",
+        "html": "<p>Novidades do mês</p>",
+    }
+])
+```
+
+### 4. Gestão de Domínios & API Keys
+
+```python
+import mailifica
+
+# Criar domínio
+domain = mailifica.Domains.create({"name": "meudominio.ao"})
+
+# Verificar registros DNS
+verified = mailifica.Domains.verify(domain["id"])
+
+# Listar API Keys
+keys = mailifica.ApiKeys.list()
+```
+
+### 5. Validação de Webhooks HMAC
+
+```python
+from mailifica import Webhooks
+
+is_valid = Webhooks.verify_signature(
+    payload=raw_body,
+    signature=headers.get("mailifica-signature"),
+    secret="seu_webhook_secret"
+)
+```
+
+---
+
+## 📄 Licença
+
+MIT © [Mailifica](https://mailifica.com)

mailifica-1.0.0/mailifica/__init__.py

@@ -0,0 +1,44 @@
+import os
+from typing import Optional
+from mailifica.emails import Emails
+from mailifica.batch import Batch
+from mailifica.domains import Domains
+from mailifica.api_keys import ApiKeys
+from mailifica.webhooks import Webhooks
+from mailifica.errors import (
+    MailificaError,
+    AuthenticationError,
+    InvalidRequestError,
+    RateLimitError,
+    InternalServerError,
+)
+from mailifica._version import __version__
+
+api_key: Optional[str] = os.environ.get("MAILIFICA_API_KEY")
+api_url: Optional[str] = os.environ.get("MAILIFICA_BASE_URL")
+
+class Mailifica:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or os.environ.get("MAILIFICA_API_KEY")
+        self.emails = Emails(api_key=self.api_key)
+        self.batch = Batch(api_key=self.api_key)
+        self.domains = Domains(api_key=self.api_key)
+        self.api_keys = ApiKeys(api_key=self.api_key)
+        self.webhooks = Webhooks()
+
+__all__ = [
+    "Mailifica",
+    "Emails",
+    "Batch",
+    "Domains",
+    "ApiKeys",
+    "Webhooks",
+    "MailificaError",
+    "AuthenticationError",
+    "InvalidRequestError",
+    "RateLimitError",
+    "InternalServerError",
+    "api_key",
+    "api_url",
+    "__version__",
+]

mailifica-1.0.0/mailifica/_client.py

@@ -0,0 +1,89 @@
+import os
+import requests
+from typing import Any, Dict, Optional
+from mailifica.errors import (
+    MailificaError,
+    AuthenticationError,
+    InvalidRequestError,
+    RateLimitError,
+    InternalServerError,
+)
+
+DEFAULT_BASE_URL = "https://api.mailifica.com/v1"
+
+class HttpClient:
+    @staticmethod
+    def get_api_key(api_key: Optional[str] = None) -> str:
+        from mailifica import api_key as global_key
+        key = api_key or global_key or os.environ.get("MAILIFICA_API_KEY")
+        if not key:
+            raise AuthenticationError("No API key provided. Set mailifica.api_key or pass api_key parameter.")
+        return key
+
+    @staticmethod
+    def get_base_url(base_url: Optional[str] = None) -> str:
+        from mailifica import api_url as global_url
+        return (base_url or global_url or os.environ.get("MAILIFICA_BASE_URL", DEFAULT_BASE_URL)).rstrip("/")
+
+    @classmethod
+    def request(
+        cls,
+        method: str,
+        path: str,
+        params: Optional[Any] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        key = cls.get_api_key(api_key)
+        url = f"{cls.get_base_url(base_url)}/{path.lstrip('/')}"
+
+        headers = {
+            "Authorization": f"Bearer {key}",
+            "Content-Type": "application/json",
+            "User-Agent": "mailifica-python/1.0.0",
+        }
+
+        try:
+            response = requests.request(
+                method=method,
+                url=url,
+                json=params if method in ["POST", "PUT", "PATCH", "DELETE"] and params is not None else None,
+                params=params if method == "GET" and isinstance(params, dict) else None,
+                headers=headers,
+                timeout=30,
+            )
+
+            if not response.ok:
+                try:
+                    err_json = response.json()
+                    message = (
+                        err_json.get("error", {}).get("message")
+                        if isinstance(err_json.get("error"), dict)
+                        else err_json.get("message") or response.text
+                    )
+                    err_type = (
+                        err_json.get("error", {}).get("code")
+                        if isinstance(err_json.get("error"), dict)
+                        else err_json.get("error")
+                    )
+                except Exception:
+                    message = response.text
+                    err_type = "unknown_error"
+
+                if response.status_code == 401 or response.status_code == 403:
+                    raise AuthenticationError(message, status_code=response.status_code, error_type=err_type)
+                elif response.status_code == 400 or response.status_code == 422:
+                    raise InvalidRequestError(message, status_code=response.status_code, error_type=err_type)
+                elif response.status_code == 429:
+                    raise RateLimitError(message, status_code=429, error_type=err_type)
+                elif response.status_code >= 500:
+                    raise InternalServerError(message, status_code=response.status_code, error_type=err_type)
+                else:
+                    raise MailificaError(message, status_code=response.status_code, error_type=err_type)
+
+            if response.status_code == 204 or not response.content:
+                return {"success": True}
+
+            return response.json()
+        except requests.RequestException as e:
+            raise MailificaError(f"Network error: {str(e)}")

mailifica-1.0.0/mailifica/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

mailifica-1.0.0/mailifica/api_keys.py

@@ -0,0 +1,40 @@
+from typing import Any, Dict, Optional
+from mailifica._client import HttpClient
+
+class ApiKeys:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+
+    def create(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        return ApiKeys.create_api_key(params, api_key=self.api_key)
+
+    def list(self) -> Dict[str, Any]:
+        return ApiKeys.list_api_keys(api_key=self.api_key)
+
+    def remove(self, api_key_id: str) -> Dict[str, Any]:
+        return ApiKeys.remove_api_key(api_key_id, api_key=self.api_key)
+
+    @classmethod
+    def create_api_key(cls, params: Dict[str, Any], api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("POST", "/api-keys", params=params, api_key=api_key)
+
+    @classmethod
+    def list_api_keys(cls, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("GET", "/api-keys", api_key=api_key)
+
+    @classmethod
+    def remove_api_key(cls, api_key_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("DELETE", f"/api-keys/{api_key_id}", api_key=api_key)
+
+    # Static aliases
+    @classmethod
+    def create(cls, params: Dict[str, Any], api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.create_api_key(params, api_key=api_key)
+
+    @classmethod
+    def list(cls, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.list_api_keys(api_key=api_key)
+
+    @classmethod
+    def remove(cls, api_key_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.remove_api_key(api_key_id, api_key=api_key)

mailifica-1.0.0/mailifica/batch.py

@@ -0,0 +1,32 @@
+from typing import Any, Dict, List, Optional
+from mailifica._client import HttpClient
+
+class Batch:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+
+    def send(self, params: List[Dict[str, Any]]) -> Dict[str, Any]:
+        return Batch.send_batch(params, api_key=self.api_key)
+
+    @classmethod
+    def send_batch(cls, params: List[Dict[str, Any]], api_key: Optional[str] = None) -> Dict[str, Any]:
+        normalized = []
+        for item in params:
+            d = dict(item)
+            if "from_email" in d:
+                d["from"] = d.pop("from_email")
+            if "from_" in d:
+                d["from"] = d.pop("from_")
+            if isinstance(d.get("to"), str):
+                d["to"] = [d["to"]]
+            if isinstance(d.get("cc"), str):
+                d["cc"] = [d["cc"]]
+            if isinstance(d.get("bcc"), str):
+                d["bcc"] = [d["bcc"]]
+            normalized.append(d)
+        return HttpClient.request("POST", "/emails/batch", params=normalized, api_key=api_key)
+
+    # Class-level static alias
+    @classmethod
+    def send(cls, params: List[Dict[str, Any]], api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.send_batch(params, api_key=api_key)

mailifica-1.0.0/mailifica/domains.py

@@ -0,0 +1,62 @@
+from typing import Any, Dict, Optional
+from mailifica._client import HttpClient
+
+class Domains:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+
+    def create(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        return Domains.create_domain(params, api_key=self.api_key)
+
+    def list(self) -> Dict[str, Any]:
+        return Domains.list_domains(api_key=self.api_key)
+
+    def get(self, domain_id: str) -> Dict[str, Any]:
+        return Domains.get_domain(domain_id, api_key=self.api_key)
+
+    def verify(self, domain_id: str) -> Dict[str, Any]:
+        return Domains.verify_domain(domain_id, api_key=self.api_key)
+
+    def remove(self, domain_id: str) -> Dict[str, Any]:
+        return Domains.remove_domain(domain_id, api_key=self.api_key)
+
+    @classmethod
+    def create_domain(cls, params: Dict[str, Any], api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("POST", "/domains", params=params, api_key=api_key)
+
+    @classmethod
+    def list_domains(cls, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("GET", "/domains", api_key=api_key)
+
+    @classmethod
+    def get_domain(cls, domain_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("GET", f"/domains/{domain_id}", api_key=api_key)
+
+    @classmethod
+    def verify_domain(cls, domain_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("POST", f"/domains/{domain_id}/verify", api_key=api_key)
+
+    @classmethod
+    def remove_domain(cls, domain_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("DELETE", f"/domains/{domain_id}", api_key=api_key)
+
+    # Static aliases
+    @classmethod
+    def create(cls, params: Dict[str, Any], api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.create_domain(params, api_key=api_key)
+
+    @classmethod
+    def list(cls, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.list_domains(api_key=api_key)
+
+    @classmethod
+    def get(cls, domain_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.get_domain(domain_id, api_key=api_key)
+
+    @classmethod
+    def verify(cls, domain_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.verify_domain(domain_id, api_key=api_key)
+
+    @classmethod
+    def remove(cls, domain_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.remove_domain(domain_id, api_key=api_key)

mailifica-1.0.0/mailifica/emails.py

@@ -0,0 +1,68 @@
+from typing import Any, Dict, List, Optional, Union
+from typing_extensions import TypedDict
+from mailifica._client import HttpClient
+
+class Tag(TypedDict, total=False):
+    name: str
+    value: str
+
+class Attachment(TypedDict, total=False):
+    content: Union[str, bytes]
+    filename: str
+    content_type: str
+    path: str
+
+class SendParams(TypedDict, total=False):
+    from_email: str
+    from_: str
+    to: Union[str, List[str]]
+    subject: str
+    html: Optional[str]
+    text: Optional[str]
+    cc: Optional[Union[str, List[str]]]
+    bcc: Optional[Union[str, List[str]]]
+    reply_to: Optional[Union[str, List[str]]]
+    headers: Optional[Dict[str, str]]
+    attachments: Optional[List[Attachment]]
+    tags: Optional[List[Tag]]
+    scheduled_at: Optional[str]
+
+class Emails:
+    SendParams = SendParams
+
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key
+
+    def send(self, params: Union[SendParams, Dict[str, Any]]) -> Dict[str, Any]:
+        return Emails.send_email(params, api_key=self.api_key)
+
+    def get(self, email_id: str) -> Dict[str, Any]:
+        return Emails.get_email(email_id, api_key=self.api_key)
+
+    @classmethod
+    def send_email(cls, params: Union[SendParams, Dict[str, Any]], api_key: Optional[str] = None) -> Dict[str, Any]:
+        payload = dict(params)
+        if "from" in payload:
+            payload["from"] = payload.pop("from")
+        elif "from_email" in payload:
+            payload["from"] = payload.pop("from_email")
+        elif "from_" in payload:
+            payload["from"] = payload.pop("from_")
+
+        if isinstance(payload.get("to"), str):
+            payload["to"] = [payload["to"]]
+        if isinstance(payload.get("cc"), str):
+            payload["cc"] = [payload["cc"]]
+        if isinstance(payload.get("bcc"), str):
+            payload["bcc"] = [payload["bcc"]]
+
+        return HttpClient.request("POST", "/emails", params=payload, api_key=api_key)
+
+    # Class-level static aliases (Resend syntax: resend.Emails.send(...))
+    @classmethod
+    def send(cls, params: Union[SendParams, Dict[str, Any]], api_key: Optional[str] = None) -> Dict[str, Any]:
+        return cls.send_email(params, api_key=api_key)
+
+    @classmethod
+    def get(cls, email_id: str, api_key: Optional[str] = None) -> Dict[str, Any]:
+        return HttpClient.request("GET", f"/emails/{email_id}", api_key=api_key)

mailifica-1.0.0/mailifica/errors.py

@@ -0,0 +1,20 @@
+from typing import Optional
+
+class MailificaError(Exception):
+    def __init__(self, message: str, status_code: Optional[int] = None, error_type: Optional[str] = None):
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+        self.error_type = error_type
+
+class AuthenticationError(MailificaError):
+    pass
+
+class InvalidRequestError(MailificaError):
+    pass
+
+class RateLimitError(MailificaError):
+    pass
+
+class InternalServerError(MailificaError):
+    pass

mailifica-1.0.0/mailifica/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561

mailifica-1.0.0/mailifica/webhooks.py

@@ -0,0 +1,34 @@
+import hmac
+import hashlib
+import json
+from typing import Any, Dict, Union
+from mailifica.errors import InvalidRequestError
+
+class Webhooks:
+    @staticmethod
+    def verify_signature(payload: Union[str, bytes], signature: str, secret: str) -> bool:
+        if not signature or not secret:
+            return False
+
+        if isinstance(payload, str):
+            body_bytes = payload.encode("utf-8")
+        else:
+            body_bytes = payload
+
+        expected_sig = hmac.new(
+            secret.encode("utf-8"),
+            body_bytes,
+            hashlib.sha256
+        ).hexdigest()
+
+        return hmac.compare_digest(signature, expected_sig)
+
+    @classmethod
+    def construct_event(cls, payload: Union[str, bytes], signature: str, secret: str) -> Dict[str, Any]:
+        if not cls.verify_signature(payload, signature, secret):
+            raise InvalidRequestError("Invalid webhook HMAC signature.")
+
+        if isinstance(payload, bytes):
+            payload = payload.decode("utf-8")
+
+        return json.loads(payload)

mailifica-1.0.0/mailifica.egg-info/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: mailifica
+Version: 1.0.0
+Summary: Official Python SDK for Mailifica Email Infrastructure
+Home-page: https://github.com/mailifica/mailifica-python
+Author: Mailifica
+Author-email: Mailifica <team@mailifica.com>
+License: MIT
+Project-URL: Homepage, https://mailifica.com
+Project-URL: Documentation, https://mailifica.com/docs
+Project-URL: Repository, https://github.com/mailifica/mailifica-python
+Project-URL: Bug Tracker, https://github.com/mailifica/mailifica-python/issues
+Keywords: email,transactional-email,mailifica,sdk,api
+Classifier: Development Status :: 5 - Production/Stable
+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
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: typing-extensions>=4.0.0; python_version < "3.10"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Mailifica Python SDK (`mailifica`)
+
+> SDK oficial em Python para a infraestrutura de e-mails transacionais **Mailifica**, com interface drop-in replacement compatível com o Resend.
+
+---
+
+## 📦 Instalação
+
+```bash
+pip install mailifica
+# ou com Poetry
+poetry add mailifica
+```
+
+---
+
+## 🚀 Como Usar
+
+### 1. Envio Estático (Estilo Resend)
+
+```python
+import mailifica
+
+# Configurar API Key
+mailifica.api_key = "ma_live_123456789"
+
+params: mailifica.Emails.SendParams = {
+    "from": "onboarding@suaempresa.ao",
+    "to": ["cliente@gmail.com"],
+    "subject": "Boas-vindas!",
+    "html": "<h1>Olá!</h1><p>Seu e-mail transacional foi entregue.</p>",
+}
+
+email = mailifica.Emails.send(params)
+print("E-mail ID:", email["id"])
+```
+
+### 2. Envio Orientado a Objetos / Instância
+
+```python
+from mailifica import Mailifica
+
+client = Mailifica("ma_live_123456789")
+
+response = client.emails.send({
+    "from": "suporte@suaempresa.ao",
+    "to": "usuario@empresa.com",
+    "subject": "Notificação",
+    "text": "Seu chamado foi atualizado.",
+})
+```
+
+### 3. Envio em Lote (Batch)
+
+```python
+import mailifica
+
+mailifica.api_key = "ma_live_123456789"
+
+batch_response = mailifica.Batch.send([
+    {
+        "from": "novidades@suaempresa.ao",
+        "to": "cliente1@gmail.com",
+        "subject": "Atualização Mensal",
+        "html": "<p>Novidades do mês</p>",
+    },
+    {
+        "from": "novidades@suaempresa.ao",
+        "to": "cliente2@gmail.com",
+        "subject": "Atualização Mensal",
+        "html": "<p>Novidades do mês</p>",
+    }
+])
+```
+
+### 4. Gestão de Domínios & API Keys
+
+```python
+import mailifica
+
+# Criar domínio
+domain = mailifica.Domains.create({"name": "meudominio.ao"})
+
+# Verificar registros DNS
+verified = mailifica.Domains.verify(domain["id"])
+
+# Listar API Keys
+keys = mailifica.ApiKeys.list()
+```
+
+### 5. Validação de Webhooks HMAC
+
+```python
+from mailifica import Webhooks
+
+is_valid = Webhooks.verify_signature(
+    payload=raw_body,
+    signature=headers.get("mailifica-signature"),
+    secret="seu_webhook_secret"
+)
+```
+
+---
+
+## 📄 Licença
+
+MIT © [Mailifica](https://mailifica.com)

mailifica-1.0.0/mailifica.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+mailifica/__init__.py
+mailifica/_client.py
+mailifica/_version.py
+mailifica/api_keys.py
+mailifica/batch.py
+mailifica/domains.py
+mailifica/emails.py
+mailifica/errors.py
+mailifica/py.typed
+mailifica/webhooks.py
+mailifica.egg-info/PKG-INFO
+mailifica.egg-info/SOURCES.txt
+mailifica.egg-info/dependency_links.txt
+mailifica.egg-info/requires.txt
+mailifica.egg-info/top_level.txt
+tests/test_mailifica.py

mailifica-1.0.0/mailifica.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mailifica-1.0.0/mailifica.egg-info/requires.txt

@@ -0,0 +1,4 @@
+requests>=2.28.0
+
+[:python_version < "3.10"]
+typing-extensions>=4.0.0

mailifica-1.0.0/mailifica.egg-info/top_level.txt

@@ -0,0 +1 @@
+mailifica

mailifica-1.0.0/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mailifica"
+version = "1.0.0"
+description = "Official Python SDK for Mailifica Email Infrastructure"
+readme = "README.md"
+authors = [
+  { name = "Mailifica", email = "team@mailifica.com" }
+]
+license = { text = "MIT" }
+requires-python = ">=3.8"
+dependencies = [
+  "requests>=2.28.0",
+  "typing-extensions>=4.0.0;python_version<'3.10'",
+]
+keywords = ["email", "transactional-email", "mailifica", "sdk", "api"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://mailifica.com"
+Documentation = "https://mailifica.com/docs"
+Repository = "https://github.com/mailifica/mailifica-python"
+"Bug Tracker" = "https://github.com/mailifica/mailifica-python/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["mailifica*"]
+
+[tool.setuptools.package-data]
+mailifica = ["py.typed"]

mailifica-1.0.0/setup.cfg

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

mailifica-1.0.0/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="mailifica",
+    version="1.0.0",
+    description="Official Python SDK for Mailifica Email Infrastructure",
+    long_description=open("README.md", "r", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="Mailifica",
+    author_email="team@mailifica.com",
+    url="https://github.com/mailifica/mailifica-python",
+    packages=find_packages(),
+    package_data={"mailifica": ["py.typed"]},
+    install_requires=[
+        "requests>=2.28.0",
+        "typing-extensions>=4.0.0;python_version<'3.10'",
+    ],
+    python_requires=">=3.8",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+)

mailifica-1.0.0/tests/test_mailifica.py

@@ -0,0 +1,93 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import hmac
+import hashlib
+import json
+import mailifica
+from mailifica import Mailifica, Webhooks, AuthenticationError, InvalidRequestError
+
+class TestMailificaPython(unittest.TestCase):
+    def setUp(self):
+        mailifica.api_key = "ma_test_123456789"
+        self.client = Mailifica("ma_test_123456789")
+
+    @patch("requests.request")
+    def test_send_email_static(self, mock_request):
+        mock_response = MagicMock()
+        mock_response.ok = True
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"id": "email_123", "status": "queued"}
+        mock_request.return_value = mock_response
+
+        response = mailifica.Emails.send({
+            "from": "onboarding@empresa.ao",
+            "to": "cliente@gmail.com",
+            "subject": "Boas-vindas",
+            "html": "<p>Olá!</p>"
+        })
+
+        self.assertEqual(response["id"], "email_123")
+        mock_request.assert_called_once()
+        args, kwargs = mock_request.call_args
+        self.assertEqual(kwargs["json"]["from"], "onboarding@empresa.ao")
+        self.assertEqual(kwargs["headers"]["Authorization"], "Bearer ma_test_123456789")
+
+    @patch("requests.request")
+    def test_send_email_instance(self, mock_request):
+        mock_response = MagicMock()
+        mock_response.ok = True
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"id": "email_456", "status": "sent"}
+        mock_request.return_value = mock_response
+
+        response = self.client.emails.send({
+            "from": "onboarding@empresa.ao",
+            "to": ["cliente@gmail.com"],
+            "subject": "Teste",
+            "html": "<p>Teste</p>"
+        })
+
+        self.assertEqual(response["id"], "email_456")
+
+    @patch("requests.request")
+    def test_batch_send(self, mock_request):
+        mock_response = MagicMock()
+        mock_response.ok = True
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"data": [{"id": "1"}, {"id": "2"}]}
+        mock_request.return_value = mock_response
+
+        response = mailifica.Batch.send([
+            {"from": "a@a.ao", "to": "b@b.com", "subject": "1", "html": "1"},
+            {"from": "a@a.ao", "to": "c@c.com", "subject": "2", "html": "2"}
+        ])
+
+        self.assertEqual(len(response["data"]), 2)
+
+    def test_webhook_verification(self):
+        secret = "whsec_test_123"
+        payload = json.dumps({"id": "evt_1", "type": "email.delivered"})
+        signature = hmac.new(secret.encode("utf-8"), payload.encode("utf-8"), hashlib.sha256).hexdigest()
+
+        is_valid = Webhooks.verify_signature(payload, signature, secret)
+        self.assertTrue(is_valid)
+
+        event = Webhooks.construct_event(payload, signature, secret)
+        self.assertEqual(event["id"], "evt_1")
+
+        is_invalid = Webhooks.verify_signature(payload, "bad_signature", secret)
+        self.assertFalse(is_invalid)
+
+    @patch("requests.request")
+    def test_error_handling(self, mock_request):
+        mock_response = MagicMock()
+        mock_response.ok = False
+        mock_response.status_code = 401
+        mock_response.json.return_value = {"error": {"message": "Invalid API Key", "code": "unauthorized"}}
+        mock_request.return_value = mock_response
+
+        with self.assertRaises(AuthenticationError):
+            mailifica.Emails.send({"from": "a@a.ao", "to": "b@b.ao", "subject": "a", "html": "a"})
+
+if __name__ == "__main__":
+    unittest.main()