wip: refactor

src/services/himalaya/__init__.py

@@ -0,0 +1,21 @@
+"""
+Himalaya API module for interacting with the Himalaya email client.
+"""
+
+from .client import (
+    list_envelopes,
+    list_accounts,
+    list_folders,
+    delete_message,
+    archive_message,
+    get_message_content,
+)
+
+__all__ = [
+    "list_envelopes",
+    "list_accounts",
+    "list_folders",
+    "delete_message",
+    "archive_message",
+    "get_message_content",
+]

src/services/himalaya/client.py

@@ -0,0 +1,184 @@
+from typing import Tuple, List, Dict, Any, Optional
+import asyncio
+import json
+import logging
+import subprocess
+
+
+async def list_envelopes(limit: int = 9999) -> Tuple[List[Dict[str, Any]], bool]:
+    """
+    Retrieve a list of email envelopes using the Himalaya CLI.
+
+    Args:
+        limit: Maximum number of envelopes to retrieve
+
+    Returns:
+        Tuple containing:
+        - List of envelope dictionaries
+        - Success status (True if operation was successful)
+    """
+    try:
+        process = await asyncio.create_subprocess_shell(
+            f"himalaya envelope list -o json -s {limit}",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+
+        if process.returncode == 0:
+            envelopes = json.loads(stdout.decode())
+            return envelopes, True
+        else:
+            logging.error(f"Error listing envelopes: {stderr.decode()}")
+            return [], False
+    except Exception as e:
+        logging.error(f"Exception during envelope listing: {e}")
+        return [], False
+
+
+async def list_accounts() -> Tuple[List[Dict[str, Any]], bool]:
+    """
+    Retrieve a list of accounts configured in Himalaya.
+
+    Returns:
+        Tuple containing:
+        - List of account dictionaries
+        - Success status (True if operation was successful)
+    """
+    try:
+        process = await asyncio.create_subprocess_shell(
+            "himalaya account list -o json",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+
+        if process.returncode == 0:
+            accounts = json.loads(stdout.decode())
+            return accounts, True
+        else:
+            logging.error(f"Error listing accounts: {stderr.decode()}")
+            return [], False
+    except Exception as e:
+        logging.error(f"Exception during account listing: {e}")
+        return [], False
+
+
+async def list_folders() -> Tuple[List[Dict[str, Any]], bool]:
+    """
+    Retrieve a list of folders available in Himalaya.
+
+    Returns:
+        Tuple containing:
+        - List of folder dictionaries
+        - Success status (True if operation was successful)
+    """
+    try:
+        process = await asyncio.create_subprocess_shell(
+            "himalaya folder list -o json",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+
+        if process.returncode == 0:
+            folders = json.loads(stdout.decode())
+            return folders, True
+        else:
+            logging.error(f"Error listing folders: {stderr.decode()}")
+            return [], False
+    except Exception as e:
+        logging.error(f"Exception during folder listing: {e}")
+        return [], False
+
+
+async def delete_message(message_id: int) -> bool:
+    """
+    Delete a message by its ID.
+
+    Args:
+        message_id: The ID of the message to delete
+
+    Returns:
+        True if deletion was successful, False otherwise
+    """
+    try:
+        process = await asyncio.create_subprocess_shell(
+            f"himalaya message delete {message_id}",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+
+        return process.returncode == 0
+    except Exception as e:
+        logging.error(f"Exception during message deletion: {e}")
+        return False
+
+
+async def archive_message(message_id: int) -> bool:
+    """
+    Archive a message by its ID.
+
+    Args:
+        message_id: The ID of the message to archive
+
+    Returns:
+        True if archiving was successful, False otherwise
+    """
+    try:
+        process = await asyncio.create_subprocess_shell(
+            f"himalaya message archive {message_id}",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+
+        return process.returncode == 0
+    except Exception as e:
+        logging.error(f"Exception during message archiving: {e}")
+        return False
+
+
+async def get_message_content(message_id: int) -> Tuple[Optional[str], bool]:
+    """
+    Retrieve the content of a message by its ID.
+
+    Args:
+        message_id: The ID of the message to retrieve
+        format: The desired format of the message content ("html" or "text")
+
+    Returns:
+        Tuple containing:
+        - Message content (or None if retrieval failed)
+        - Success status (True if operation was successful)
+    """
+    try:
+        cmd = f"himalaya message read {message_id}"
+
+        process = await asyncio.create_subprocess_shell(
+            cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, stderr = await process.communicate()
+
+        if process.returncode == 0:
+            content = stdout.decode()
+            return content, True
+        else:
+            logging.error(f"Error retrieving message content: {
+                          stderr.decode()}")
+            return None, False
+    except Exception as e:
+        logging.error(f"Exception during message content retrieval: {e}")
+        return None, False
+
+
+def sync_himalaya():
+    """Synchronize data using Himalaya."""
+    try:
+        # subprocess.run(["himalaya", "sync"], check=True)
+        print("Himalaya sync completed successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"Error during Himalaya sync: {e}")