mailkite-dev 0.4.0__tar.gz → 0.6.0__tar.gz

{mailkite_dev-0.4.0 → mailkite_dev-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mailkite-dev
-Version: 0.4.0
+Version: 0.6.0
 Summary: Official MailKite SDK for Python — send and manage email over your own authenticated domain.
 License: MIT
 Project-URL: Homepage, https://mailkite.dev/docs/libraries

{mailkite_dev-0.4.0 → mailkite_dev-0.6.0}/mailkite/__init__.py

@@ -22,7 +22,37 @@ DEFAULT_BASE_URL = "https://api.mailkite.dev"
 # Reject webhook events older than this (ms) to block replays. Pass 0 to disable.
 DEFAULT_TOLERANCE_MS = 5 * 60 * 1000
 
-__all__ = ["MailKite", "MailKiteError", "verify_webhook", "reply_ok", "encrypt", "decrypt"]
+# Best-effort extension -> MIME map for raw binary attachment uploads.
+_CONTENT_TYPES = {
+    "pdf": "application/pdf",
+    "png": "image/png",
+    "jpg": "image/jpeg",
+    "jpeg": "image/jpeg",
+    "gif": "image/gif",
+    "webp": "image/webp",
+    "svg": "image/svg+xml",
+    "csv": "text/csv",
+    "txt": "text/plain",
+    "html": "text/html",
+    "json": "application/json",
+    "zip": "application/zip",
+    "doc": "application/msword",
+    "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "xls": "application/vnd.ms-excel",
+    "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "ics": "text/calendar",
+    "ical": "text/calendar",
+}
+
+
+def _guess_content_type(name):
+    """Guess a MIME type from a filename's extension (default octet-stream)."""
+    ext = ""
+    if name and "." in name:
+        ext = name.rsplit(".", 1)[1].lower()
+    return _CONTENT_TYPES.get(ext, "application/octet-stream")
+
+__all__ = ["MailKite", "MailKiteError", "verify_webhook", "reply_ok", "reply_spam", "reply_drop", "reply_block_sender", "encrypt", "decrypt"]
 
 
 def verify_webhook(signature, payload, secret, toleranceMs=DEFAULT_TOLERANCE_MS):
@@ -61,6 +91,28 @@ def reply_ok():
     return '{"status":"ok"}'
 
 
+def reply_spam():
+    """Control-mode reply telling MailKite to mark the message as spam.
+
+    Returns the exact string ``{"status":"spam"}``. No network call."""
+    return '{"status":"spam"}'
+
+
+def reply_drop():
+    """Control-mode reply telling MailKite to drop (discard) the message.
+
+    Returns the exact string ``{"status":"drop"}``. No network call."""
+    return '{"status":"drop"}'
+
+
+def reply_block_sender():
+    """Control-mode reply telling MailKite to block the sender.
+
+    Returns the exact string ``{"status":"ok","actions":[{"type":"block-sender"}]}``.
+    No network call."""
+    return '{"status":"ok","actions":[{"type":"block-sender"}]}'
+
+
 def encrypt(plaintext, public_key):
     """Encrypt a UTF-8 string to a MailKite at-rest envelope (JSON string).
 
@@ -159,6 +211,28 @@ class MailKite:
             message = parsed.get("error") if isinstance(parsed, dict) else None
             raise MailKiteError(e.code, message or e.reason or "HTTP %d" % e.code, parsed)
 
+    # Raw-binary variant of request(): the body is the file bytes themselves
+    # (not JSON, not multipart) and filename/retentionDays ride in the query.
+    def requestBinary(self, method, path, data, filename, contentType=None, retentionDays=None):
+        query = {"filename": filename}
+        if retentionDays is not None:
+            query["retentionDays"] = retentionDays
+        url = self.baseUrl + path + "?" + urllib.parse.urlencode(query)
+        headers = {
+            "Authorization": "Bearer " + self.apiKey,
+            "Content-Type": contentType or "application/octet-stream",
+        }
+        req = urllib.request.Request(url, data=data, method=method, headers=headers)
+        try:
+            with urllib.request.urlopen(req) as resp:
+                text = resp.read().decode("utf-8")
+                return json.loads(text) if text else None
+        except urllib.error.HTTPError as e:
+            text = e.read().decode("utf-8")
+            parsed = json.loads(text) if text else None
+            message = parsed.get("error") if isinstance(parsed, dict) else None
+            raise MailKiteError(e.code, message or e.reason or "HTTP %d" % e.code, parsed)
+
     # --- Sending ----------------------------------------------------------
     def send(self, message):
         """Send an email. ``message`` is a dict with ``from``, ``to`` and a
@@ -167,6 +241,60 @@ class MailKite:
         and ``templateData`` (dict) to supply its variables."""
         return self.request("POST", "/v1/send", message)
 
+    def uploadAttachment(self, file):
+        """Upload a file and get back a secure, time-limited URL to reference as
+        a send() attachment (``{ filename, url }``) or link inline — instead of
+        base64-inlining large files on every send. ``file`` is a dict that
+        provides the file ONE of four ways (checked in this order):
+
+        - ``url`` (str): MailKite fetches and re-hosts the remote file.
+        - ``bytes`` (raw ``bytes``): uploaded directly as a raw binary body.
+        - ``path`` (str): a local file read off disk, then uploaded as raw bytes;
+          ``filename`` and ``contentType`` are derived from the path if omitted.
+        - ``content`` (str): a base64-encoded body (the original JSON form).
+
+        Optional in every mode: ``filename``, ``contentType`` and
+        ``retentionDays`` (7 | 30 | 90 | 365, default 7). Returns
+        ``{id, url, filename, contentType, size, expiresAt}``."""
+        file = file or {}
+        filename = file.get("filename")
+        content = file.get("content")
+        url = file.get("url")
+        path = file.get("path")
+        data = file.get("bytes")
+        contentType = file.get("contentType")
+        retentionDays = file.get("retentionDays")
+        if url is not None:
+            body = {"url": url}
+            if filename is not None:
+                body["filename"] = filename
+            if contentType is not None:
+                body["contentType"] = contentType
+            if retentionDays is not None:
+                body["retentionDays"] = retentionDays
+            return self.request("POST", "/v1/attachments", body)
+        if data is not None or path is not None:
+            name = filename
+            ctype = contentType
+            if data is None:
+                with open(path, "rb") as f:
+                    data = f.read()
+                if not name:
+                    name = os.path.basename(path)
+                if not ctype:
+                    ctype = _guess_content_type(name)
+            return self.requestBinary("POST", "/v1/attachments", data, name, ctype, retentionDays)
+        if content is not None:
+            body = {"content": content}
+            if filename is not None:
+                body["filename"] = filename
+            if contentType is not None:
+                body["contentType"] = contentType
+            if retentionDays is not None:
+                body["retentionDays"] = retentionDays
+            return self.request("POST", "/v1/attachments", body)
+        raise MailKiteError(0, "uploadAttachment needs one of: path, bytes, url, or base64 content")
+
     def agent(self, message):
         """Send a message to an AI agent inbox. ``message`` is a dict with
         ``text`` (required) and optional ``subject``, ``from``, ``html``,
@@ -251,6 +379,21 @@ class MailKite:
         :func:`reply_ok`."""
         return reply_ok()
 
+    def reply_spam(self):
+        """Control-mode reply marking the message as spam. See module-level
+        :func:`reply_spam`."""
+        return reply_spam()
+
+    def reply_drop(self):
+        """Control-mode reply dropping the message. See module-level
+        :func:`reply_drop`."""
+        return reply_drop()
+
+    def reply_block_sender(self):
+        """Control-mode reply blocking the sender. See module-level
+        :func:`reply_block_sender`."""
+        return reply_block_sender()
+
     def encrypt(self, plaintext, public_key):
         """Encrypt to a MailKite at-rest envelope. See module-level
         :func:`encrypt`."""

{mailkite_dev-0.4.0 → mailkite_dev-0.6.0}/mailkite_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mailkite-dev
-Version: 0.4.0
+Version: 0.6.0
 Summary: Official MailKite SDK for Python — send and manage email over your own authenticated domain.
 License: MIT
 Project-URL: Homepage, https://mailkite.dev/docs/libraries

{mailkite_dev-0.4.0 → mailkite_dev-0.6.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # old account. Installs as `pip install mailkite-dev`; still imports as `import mailkite`
 # (the package dir below is unchanged). Rename back to `mailkite` once reclaimed.
 name = "mailkite-dev"
-version = "0.4.0"
+version = "0.6.0"
 description = "Official MailKite SDK for Python — send and manage email over your own authenticated domain."
 readme = "README.md"
 requires-python = ">=3.7"