mail-swarms 1.3.2__py3-none-any.whl

mail/stdlib/fs/__init__.py

@@ -0,0 +1,15 @@
+from .actions import (
+    create_directory,
+    delete_file,
+    read_directory,
+    read_file,
+    write_file,
+)
+
+__all__ = [
+    "read_file",
+    "write_file",
+    "delete_file",
+    "create_directory",
+    "read_directory",
+]

mail/stdlib/fs/actions.py

@@ -0,0 +1,209 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2025 Addison Kline
+
+from pathlib import Path
+from typing import Any
+
+from mail.api import action
+
+FILE_READ_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "The path to the file to read",
+        },
+    },
+    "required": ["path"],
+}
+
+
+@action(
+    name="read_file",
+    description="Read a file from the filesystem",
+    parameters=FILE_READ_PARAMETERS,
+)
+async def read_file(args: dict[str, Any]) -> str:
+    """
+    Read a file from the filesystem.
+    """
+    path = args.get("path")
+
+    if not isinstance(path, str):
+        return "Error: `path` must be a string"
+
+    target = Path(path)
+    if not target.exists():
+        return f"Error: file not found at {path}"
+    if not target.is_file():
+        return f"Error: {path} is not a file"
+
+    try:
+        return target.read_text()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+FILE_WRITE_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "The path to the file to write to",
+        },
+        "content": {
+            "type": "string",
+            "description": "The content to write to the file",
+        },
+    },
+}
+
+
+@action(
+    name="write_file",
+    description="Write to a file on the filesystem",
+    parameters=FILE_WRITE_PARAMETERS,
+)
+async def write_file(args: dict[str, Any]) -> str:
+    """
+    Write to a file on the filesystem.
+    """
+    path = args.get("path")
+    content = args.get("content")
+
+    if not isinstance(path, str):
+        return "Error: `path` must be a string"
+    if not isinstance(content, str):
+        return "Error: `content` must be a string"
+
+    target = Path(path)
+    if not target.exists():
+        try:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(content)
+            return f"successfully wrote to {path}"
+        except Exception as e:
+            return f"Error: {e}"
+
+    if not target.is_file():
+        return f"Error: {path} is not a file"
+
+    try:
+        target.write_text(content)
+        return f"successfully wrote to {path}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+FILE_DELETE_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "The path to the file to delete",
+        },
+    },
+    "required": ["path"],
+}
+
+
+@action(
+    name="delete_file",
+    description="Delete a file from the filesystem",
+    parameters=FILE_DELETE_PARAMETERS,
+)
+async def delete_file(args: dict[str, Any]) -> str:
+    """
+    Delete a file from the filesystem.
+    """
+    path = args.get("path")
+    if not isinstance(path, str):
+        return "Error: `path` must be a string"
+
+    target = Path(path)
+    if not target.exists():
+        return f"Error: file not found at {path}"
+    if not target.is_file():
+        return f"Error: {path} is not a file"
+
+    try:
+        target.unlink()
+        return f"successfully deleted {path}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+DIR_CREATE_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "The path to the directory to create",
+        },
+    },
+    "required": ["path"],
+}
+
+
+@action(
+    name="create_directory",
+    description="Create a directory on the filesystem",
+    parameters=DIR_CREATE_PARAMETERS,
+)
+async def create_directory(args: dict[str, Any]) -> str:
+    """
+    Create a directory on the filesystem.
+    """
+    path = args["path"]
+    if not isinstance(path, str):
+        return "Error: `path` must be a string"
+
+    target = Path(path)
+    if target.exists() and target.is_dir():
+        return f"Error: directory already exists at {path}"
+    if target.exists() and target.is_file():
+        return f"Error: {path} is a file, not a directory"
+
+    try:
+        target.mkdir(parents=True, exist_ok=False)
+        return f"successfully created directory at {path}"
+    except Exception as e:
+        return f"Error: {e}"
+
+
+DIR_READ_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "The path to the directory to read",
+        },
+    },
+    "required": ["path"],
+}
+
+
+@action(
+    name="read_directory",
+    description="Read a directory on the filesystem",
+    parameters=DIR_READ_PARAMETERS,
+)
+async def read_directory(args: dict[str, Any]) -> str:
+    """
+    Read a directory on the filesystem.
+    """
+    path = args.get("path")
+    if not isinstance(path, str):
+        return "Error: `path` must be a string"
+
+    target = Path(path)
+    if not target.exists():
+        return f"Error: directory not found at {path}"
+    if not target.is_dir():
+        return f"Error: {path} is not a directory"
+
+    try:
+        entries = sorted(target.iterdir(), key=lambda p: p.name)
+        return "\n".join(entry.name for entry in entries)
+    except Exception as e:
+        return f"Error: {e}"

mail/stdlib/http/__init__.py

@@ -0,0 +1,19 @@
+from .actions import (
+    http_delete,
+    http_get,
+    http_head,
+    http_options,
+    http_patch,
+    http_post,
+    http_put,
+)
+
+__all__ = [
+    "http_get",
+    "http_post",
+    "http_put",
+    "http_delete",
+    "http_patch",
+    "http_head",
+    "http_options",
+]

mail/stdlib/http/actions.py

@@ -0,0 +1,333 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright (c) 2025 Addison Kline
+
+from typing import Any
+
+import aiohttp
+
+from mail import action
+
+HTTP_GET_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "url": {
+            "type": "string",
+            "description": "The URL to GET.",
+        },
+        "headers": {
+            "type": "object",
+            "description": "The headers to send with the request.",
+            "optional": True,
+        },
+    },
+    "required": ["url"],
+}
+
+
+@action(
+    name="http_get",
+    description="Get a URL via HTTP.",
+    parameters=HTTP_GET_PARAMETERS,
+)
+async def http_get(args: dict[str, Any]) -> str:
+    """
+    Get a URL via HTTP.
+    """
+    url = args.get("url")
+    if url is None:
+        return "Error: `url` is required"
+    if not isinstance(url, str):
+        return "Error: `url` must be a string"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url) as response:
+                return await response.text()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+HTTP_POST_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "url": {
+            "type": "string",
+            "description": "The URL to POST to.",
+        },
+        "headers": {
+            "type": "object",
+            "description": "The headers to send with the request.",
+        },
+        "body": {
+            "type": "object",
+            "description": "The body to send with the request.",
+        },
+    },
+    "required": ["url", "headers", "body"],
+}
+
+
+@action(
+    name="http_post",
+    description="Post to a URL via HTTP.",
+    parameters=HTTP_POST_PARAMETERS,
+)
+async def http_post(args: dict[str, Any]) -> str:
+    """
+    Post to a URL via HTTP.
+    """
+    url = args.get("url")
+    headers = args.get("headers")
+    body = args.get("body")
+
+    if url is None:
+        return "Error: `url` is required"
+    if headers is None:
+        return "Error: `headers` is required"
+    if body is None:
+        return "Error: `body` is required"
+
+    if not isinstance(url, str):
+        return "Error: `url` must be a string"
+    if not isinstance(headers, dict):
+        return "Error: `headers` must be a dictionary"
+    if not isinstance(body, dict):
+        return "Error: `body` must be a dictionary"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(url, headers=headers, json=body) as response:
+                return await response.text()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+HTTP_PUT_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "url": {
+            "type": "string",
+            "description": "The URL to PUT to.",
+        },
+        "headers": {
+            "type": "object",
+            "description": "The headers to send with the request.",
+        },
+        "body": {
+            "type": "object",
+            "description": "The body to send with the request.",
+        },
+    },
+    "required": ["url", "headers", "body"],
+}
+
+
+@action(
+    name="http_put",
+    description="Put to a URL via HTTP.",
+    parameters=HTTP_PUT_PARAMETERS,
+)
+async def http_put(args: dict[str, Any]) -> str:
+    """
+    Put to a URL via HTTP.
+    """
+    url = args.get("url")
+    headers = args.get("headers")
+    body = args.get("body")
+
+    if url is None:
+        return "Error: `url` is required"
+    if headers is None:
+        return "Error: `headers` is required"
+    if body is None:
+        return "Error: `body` is required"
+
+    if not isinstance(url, str):
+        return "Error: `url` must be a string"
+    if not isinstance(headers, dict):
+        return "Error: `headers` must be a dictionary"
+    if not isinstance(body, dict):
+        return "Error: `body` must be a dictionary"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.put(url, headers=headers, json=body) as response:
+                return await response.text()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+HTTP_DELETE_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "url": {
+            "type": "string",
+            "description": "The URL to DELETE.",
+        },
+        "headers": {
+            "type": "object",
+            "description": "The headers to send with the request.",
+            "optional": True,
+        },
+    },
+    "required": ["url"],
+}
+
+
+@action(
+    name="http_delete",
+    description="Delete a URL via HTTP.",
+    parameters=HTTP_DELETE_PARAMETERS,
+)
+async def http_delete(args: dict[str, Any]) -> str:
+    """
+    Delete a URL via HTTP.
+    """
+    url = args.get("url")
+    if url is None:
+        return "Error: `url` is required"
+    if not isinstance(url, str):
+        return "Error: `url` must be a string"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.delete(url) as response:
+                return await response.text()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+HTTP_PATCH_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "url": {
+            "type": "string",
+            "description": "The URL to PATCH.",
+        },
+        "headers": {
+            "type": "object",
+            "description": "The headers to send with the request.",
+            "optional": True,
+        },
+        "body": {
+            "type": "object",
+            "description": "The body to send with the request.",
+        },
+    },
+    "required": ["url", "body"],
+}
+
+
+@action(
+    name="http_patch",
+    description="Patch a URL via HTTP.",
+    parameters=HTTP_PATCH_PARAMETERS,
+)
+async def http_patch(args: dict[str, Any]) -> str:
+    """
+    Patch a URL via HTTP.
+    """
+    url = args.get("url")
+    headers = args.get("headers")
+    body = args.get("body")
+
+    if url is None:
+        return "Error: `url` is required"
+    if body is None:
+        return "Error: `body` is required"
+
+    if not isinstance(url, str):
+        return "Error: `url` must be a string"
+    if not isinstance(body, dict):
+        return "Error: `body` must be a dictionary"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.patch(url, headers=headers, json=body) as response:
+                return await response.text()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+HTTP_HEAD_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "url": {
+            "type": "string",
+            "description": "The URL to HEAD.",
+        },
+        "headers": {
+            "type": "object",
+            "description": "The headers to send with the request.",
+            "optional": True,
+        },
+    },
+    "required": ["url"],
+}
+
+
+@action(
+    name="http_head",
+    description="Head a URL via HTTP.",
+    parameters=HTTP_HEAD_PARAMETERS,
+)
+async def http_head(args: dict[str, Any]) -> str:
+    """
+    Head a URL via HTTP.
+    """
+    url = args.get("url")
+    headers = args.get("headers")
+
+    if url is None:
+        return "Error: `url` is required"
+    if not isinstance(url, str):
+        return "Error: `url` must be a string"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.head(url, headers=headers) as response:
+                return await response.text()
+    except Exception as e:
+        return f"Error: {e}"
+
+
+HTTP_OPTIONS_PARAMETERS = {
+    "type": "object",
+    "properties": {
+        "url": {
+            "type": "string",
+            "description": "The URL to OPTIONS.",
+        },
+        "headers": {
+            "type": "object",
+            "description": "The headers to send with the request.",
+            "optional": True,
+        },
+    },
+    "required": ["url"],
+}
+
+
+@action(
+    name="http_options",
+    description="Options a URL via HTTP.",
+    parameters=HTTP_OPTIONS_PARAMETERS,
+)
+async def http_options(args: dict[str, Any]) -> str:
+    """
+    Options a URL via HTTP.
+    """
+    url = args.get("url")
+    headers = args.get("headers")
+
+    if url is None:
+        return "Error: `url` is required"
+    if not isinstance(url, str):
+        return "Error: `url` must be a string"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.options(url, headers=headers) as response:
+                return await response.text()
+    except Exception as e:
+        return f"Error: {e}"

mail/stdlib/interswarm/__init__.py

@@ -0,0 +1,11 @@
+from .actions import (
+    get_swarm_health,
+    get_swarm_registry,
+    ping_swarm,
+)
+
+__all__ = [
+    "ping_swarm",
+    "get_swarm_health",
+    "get_swarm_registry",
+]