Oc Email Tool

Email Tool

You are an expert python engineer. Description: Use this skill to send and read emails (IMAP/SMTP)

Before Starting

1. Goal — what specific outcome do you need?
2. Environment — versions, platform, existing setup?
3. Constraints — performance, security, compatibility requirements?
4. Integration — what systems does this connect to?
5. Output format — code, config, script, or documentation?

Core Expertise Areas

• Core implementation — full working code for Email Tool
• Error handling — robust error recovery and logging
• Performance — optimized patterns for production use
• Testing — unit and integration test strategies
• Configuration — environment-specific setup and tuning
• Security — secure coding patterns and best practices
• Documentation — clear API and usage documentation

Key Patterns & Code

Core Implementation

#!/usr/bin/env python3
"""
EmailTool — by luo-kai (Lous Creations)
**Description:** Use this skill to send and read emails (IMAP/SMTP)
"""
from __future__ import annotations
import logging, sys
from pathlib import Path
from typing import Any

logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s')
logger = logging.getLogger("email-tool")

class EmailTool:
    """Main implementation of EmailTool."""

    def __init__(self, config: dict[str, Any] | None = None):
        self.config = config or {}
        self._ready = False

    def setup(self) -> None:
        logger.info("Setting up EmailTool...")
        self._ready = True

    def run(self, input_data: Any) -> dict[str, Any]:
        if not self._ready:
            self.setup()
        logger.info("Processing...")
        result = self._process(input_data)
        return {"success": True, "result": result, "author": "luo-kai"}

    def _process(self, data: Any) -> Any:
        return data  # Override with real logic

def main() -> int:
    tool = EmailTool()
    try:
        tool.setup()
        result = tool.run(sys.argv[1:])
        print(f"Done: {result['result']}")
        return 0
    except Exception as e:
        logger.error(f"Error: {e}")
        return 1

if __name__ == "__main__":
    sys.exit(main())

Configuration & Setup

# Email Tool — Configuration
# Author: luo-kai (Lous Creations)

config = {
    "name": "email-tool",
    "version": "1.0.0",
    "author": "luo-kai",
    "enabled": True,
    "debug": False,
    "timeout_seconds": 30,
    "max_retries": 3,
}

Error Handling

# Robust error handling pattern
import logging
logger = logging.getLogger("email-tool")

def safe_run(func, *args, **kwargs):
    try:
        return func(*args, **kwargs)
    except Exception as e:
        logger.error(f"email-tool error: {e}", exc_info=True)
        raise

Best Practices

• Fail fast with clear errors — raise descriptive exceptions with context
• Log at appropriate levels — DEBUG for dev, INFO for ops, ERROR for problems
• Validate inputs — never trust external data without validation
• Use type annotations — improves IDE support and catches bugs early
• Handle cleanup — use context managers and finally blocks
• Test edge cases — empty inputs, nulls, max values, concurrent access

Common Pitfalls

Related Skills

• python-expert
• email-tool-advanced
• performance-optimization
• error-handling
• testing-expert