webscout 7.8__py3-none-any.whl → 8.0__py3-none-any.whl

webscout/Extra/tempmail/__init__.py

@@ -0,0 +1,26 @@
+"""
+TempMail Package - Temporary Email Generation Functionality
+Part of Webscout Extra tools
+"""
+
+from .base import (
+    TempMailProvider, 
+    AsyncTempMailProvider, 
+    get_random_email, 
+    get_disposable_email,
+    get_provider
+)
+from .mail_tm import MailTM, MailTMAsync
+from .temp_mail_io import TempMailIO, TempMailIOAsync
+
+__all__ = [
+    'TempMailProvider',
+    'AsyncTempMailProvider', 
+    'MailTM',
+    'MailTMAsync',
+    'TempMailIO',
+    'TempMailIOAsync',
+    'get_random_email',
+    'get_disposable_email',
+    'get_provider'
+]

webscout/Extra/tempmail/async_utils.py

@@ -0,0 +1,141 @@
+"""
+Async utilities for temporary email generation
+"""
+import asyncio
+import logging
+from typing import Dict, List, Optional, Tuple
+
+from .base import TempMailAPI, MessageResponseModel
+
+logger = logging.getLogger(__name__)
+
+class AsyncTempMailHelper:
+    """
+    Async helper class for TempMail.io API
+    Provides simplified methods for async usage of TempMail.io
+    """
+    
+    def __init__(self):
+        self.api = None
+        self.email = None
+        self.token = None
+        
+    async def create(self, alias: Optional[str] = None, domain: Optional[str] = None) -> Tuple[str, str]:
+        """
+        Create a new temporary email
+        
+        Args:
+            alias: Optional alias for the email
+            domain: Optional domain for the email
+            
+        Returns:
+            Tuple containing the email address and token
+        """
+        self.api = TempMailAPI()
+        await self.api.initialize()
+        
+        try:
+            result = await self.api.create_email(alias, domain)
+            self.email = result.email
+            self.token = result.token
+            return self.email, self.token
+        except Exception as e:
+            logger.error(f"Error creating email: {e}")
+            await self.close()
+            raise
+    
+    async def get_messages(self) -> List[Dict]:
+        """
+        Get messages for the current email
+        
+        Returns:
+            List of message dictionaries
+        """
+        if not self.api or not self.email:
+            raise ValueError("No email created yet")
+        
+        try:
+            messages = await self.api.get_messages(self.email)
+            if not messages:
+                return []
+                
+            return [
+                {
+                    "id": msg.id,
+                    "from": msg.email_from,
+                    "to": msg.email_to,
+                    "subject": msg.subject,
+                    "created_at": msg.created_at,
+                    "body": msg.body_text or msg.body_html,
+                    "has_attachments": bool(msg.attachments and len(msg.attachments) > 0)
+                }
+                for msg in messages
+            ]
+        except Exception as e:
+            logger.error(f"Error getting messages: {e}")
+            return []
+    
+    async def delete(self) -> bool:
+        """
+        Delete the current temporary email
+        
+        Returns:
+            True if deletion was successful, False otherwise
+        """
+        if not self.api or not self.email or not self.token:
+            logger.warning("No email to delete")
+            return False
+            
+        try:
+            result = await self.api.delete_email(self.email, self.token)
+            return result
+        except Exception as e:
+            logger.error(f"Error deleting email: {e}")
+            return False
+        finally:
+            await self.close()
+    
+    async def close(self) -> None:
+        """Close the API connection"""
+        if self.api:
+            await self.api.close()
+            self.api = None
+
+
+async def get_temp_email(alias: Optional[str] = None, domain: Optional[str] = None) -> Tuple[str, AsyncTempMailHelper]:
+    """
+    Get a temporary email address asynchronously
+    
+    Args:
+        alias: Optional alias for the email
+        domain: Optional domain for the email
+        
+    Returns:
+        Tuple containing the email address and the TempMail helper instance
+    """
+    helper = AsyncTempMailHelper()
+    email, _ = await helper.create(alias, domain)
+    return email, helper
+
+
+async def wait_for_message(helper: AsyncTempMailHelper, timeout: int = 60, check_interval: int = 5) -> Optional[Dict]:
+    """
+    Wait for a message to arrive in the inbox
+    
+    Args:
+        helper: The TempMail helper instance
+        timeout: Maximum time to wait in seconds
+        check_interval: Time between checks in seconds
+        
+    Returns:
+        The first message if one arrives, None otherwise
+    """
+    start_time = asyncio.get_event_loop().time()
+    
+    while asyncio.get_event_loop().time() - start_time < timeout:
+        messages = await helper.get_messages()
+        if messages:
+            return messages[0]
+        await asyncio.sleep(check_interval)
+    
+    return None

webscout/Extra/tempmail/base.py

@@ -0,0 +1,156 @@
+"""
+Temporary Email Generation Base Module
+Abstract base classes for tempmail providers
+"""
+
+from abc import ABC, abstractmethod
+import string
+import random
+from typing import Dict, List, Any, Optional, Union, Tuple, AsyncGenerator, Generator
+
+# Constants for email generation
+EMAIL_LENGTH = 16
+PASSWORD_LENGTH = 10
+
+
+class TempMailProvider(ABC):
+    """
+    Abstract base class for synchronous temporary email providers
+    """
+
+    @abstractmethod
+    def create_account(self) -> bool:
+        """Create a new temporary email account"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def get_messages(self) -> List[Dict]:
+        """Get all messages in the inbox"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def check_new_messages(self) -> List[Dict]:
+        """Check for new messages and return only the new ones"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def delete_account(self) -> bool:
+        """Delete the current temporary email account"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    def get_account_info(self) -> Dict:
+        """Get current account information"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+
+class AsyncTempMailProvider(ABC):
+    """
+    Abstract base class for asynchronous temporary email providers
+    """
+
+    @abstractmethod
+    async def initialize(self):
+        """Initialize the provider session"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close the provider session"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def create_email(self, alias: Optional[str] = None, domain: Optional[str] = None) -> Tuple[str, str]:
+        """Create a new temporary email address"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def get_messages(self) -> List[Dict]:
+        """Get messages for a temporary email"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+    @abstractmethod
+    async def delete_email(self) -> bool:
+        """Delete a temporary email"""
+        raise NotImplementedError("Method needs to be implemented in subclass")
+
+
+# Utility functions
+def generate_random_string(length: int, include_digits: bool = True) -> str:
+    """
+    Generate a random string of specified length
+
+    Args:
+        length: Length of the string to generate
+        include_digits: Whether to include digits in the string
+
+    Returns:
+        Random string of specified length
+    """
+    chars = string.ascii_lowercase
+    if include_digits:
+        chars += string.digits
+    return ''.join(random.sample(chars, length))
+
+
+# Factory function for getting a temporary email provider
+def get_provider(provider_name: str = "mailtm", async_provider: bool = False) -> Union[TempMailProvider, AsyncTempMailProvider]:
+    """
+    Get a temporary email provider instance
+
+    Args:
+        provider_name: Name of the provider to use ("mailtm" or "tempmailio")
+        async_provider: Whether to return an async provider
+
+    Returns:
+        A temporary email provider instance
+    """
+    if async_provider:
+        if provider_name.lower() == "tempmailio":
+            from .temp_mail_io import TempMailIOAsync
+            return TempMailIOAsync()
+        else:
+            from .mail_tm import MailTMAsync
+            return MailTMAsync()
+    else:
+        if provider_name.lower() == "tempmailio":
+            from .temp_mail_io import TempMailIO
+            return TempMailIO()
+        else:
+            from .mail_tm import MailTM
+            return MailTM()
+
+
+# Simplified helpers for common operations
+def get_random_email(provider_name: str = "mailtm") -> Tuple[str, TempMailProvider]:
+    """
+    Get a random temporary email address
+
+    Args:
+        provider_name: Name of the provider to use
+
+    Returns:
+        Tuple containing the email address and the provider instance
+    """
+    provider = get_provider(provider_name)
+
+    # For providers that require explicit initialization
+    if hasattr(provider, '_initialized') and not provider._initialized:
+        try:
+            # If there's an initialization method that needs to be called
+            if hasattr(provider, 'initialize'):
+                provider.initialize()
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize provider: {e}")
+
+    # Create the account
+    success = provider.create_account()
+    if not success:
+        raise RuntimeError(f"Failed to create account with provider {provider_name}")
+
+    return provider.email, provider
+
+
+def get_disposable_email() -> Tuple[str, TempMailProvider]:
+    """Alias for get_random_email"""
+    return get_random_email()

webscout/Extra/tempmail/cli.py

@@ -0,0 +1,187 @@
+"""
+Command-line interface for temporary email generation using SwiftCLI
+"""
+
+import sys
+import time
+from rich.console import Console
+from webscout.swiftcli import CLI, option
+from .base import get_provider
+
+# Initialize console for rich output
+console = Console()
+
+# Create CLI app
+app = CLI(
+    name="tempmail",
+    help="Temporary Email CLI Tool",
+    version="1.0.0"
+)
+
+@app.command()
+@option("--wait", "-w", type=int, default=10, help="Wait time in seconds between checking for new messages")
+@option("--output", "-o", type=str, choices=["simple", "detailed"], default="simple", help="Output format")
+@option("--provider", "-p", type=str, choices=["mailtm", "tempmailio"], default="mailtm", help="Email provider to use")
+def monitor(wait: int = 10, output: str = "simple", provider: str = "mailtm"):
+    """
+    Create and monitor a temporary email account
+
+    Continuously checks for new messages and displays them in the terminal.
+    Press Ctrl+C to exit and delete the account.
+    """
+    # Create a new email
+    mail = get_provider(provider_name=provider)
+
+    if hasattr(mail, 'auto_create'):
+        mail = get_provider(provider_name=provider, async_provider=False)
+        mail.create_account()
+    else:
+        success = mail.create_account()
+        if not success:
+            console.print("[red]Failed to create temporary email account.[/red]")
+            sys.exit(1)
+
+    console.print("[yellow]Temporary email address CLI[/yellow]")
+    console.print(f"[cyan]EMAIL: {mail.email}[/cyan]")
+    console.print(f"Account ID: {mail.account_id}")
+    console.print("Press Ctrl+C to exit and delete the account")
+
+    try:
+        while True:
+            console.print(f"Checking for new messages... ({time.strftime('%H:%M:%S')})")
+            new_messages = mail.check_new_messages()
+
+            if new_messages:
+                console.print(f"New messages: {len(new_messages)}")
+                console.print("-" * 40)
+
+                for msg in new_messages:
+                    console.print(f"From: {msg['from']}")
+                    console.print(f"Subject: {msg['subject']}")
+
+                    if output == "detailed":
+                        console.print(f"Body: {msg['body']}")
+                        console.print(f"Has attachments: {msg['hasAttachments']}")
+                        console.print(f"Created at: {msg['createdAt']}")
+
+                    console.print("[magenta]" + "-" * 40 + "[/magenta]")
+
+            time.sleep(wait)
+
+    except KeyboardInterrupt:
+        console.print("\nCtrl+C pressed. Exiting program and deleting account...")
+        if mail.delete_account():
+            console.print("[red]--Account deleted--[/red]")
+        else:
+            console.print("[red]--Failed to delete account--[/red]")
+
+@app.command()
+@option("--provider", "-p", type=str, choices=["mailtm", "tempmailio"], default="mailtm", help="Email provider to use")
+def create(provider: str = "mailtm"):
+    """
+    Create a temporary email account and display its details
+
+    Creates a new temporary email account and displays the email address.
+    The account will remain active until manually deleted.
+    """
+    mail = get_provider(provider_name=provider)
+
+    if hasattr(mail, 'auto_create'):
+        mail = get_provider(provider_name=provider, async_provider=False)
+        mail.create_account()
+    else:
+        success = mail.create_account()
+        if not success:
+            console.print("[red]Failed to create temporary email account.[/red]")
+            sys.exit(1)
+
+    console.print("[yellow]Temporary Email Created[/yellow]")
+    console.print(f"[cyan]EMAIL: {mail.email}[/cyan]")
+    console.print(f"Account ID: {mail.account_id}")
+    console.print("Use 'tempmail monitor' to check for messages")
+
+@app.command()
+@option("--email", "-e", type=str, required=True, help="Email address to check")
+@option("--account-id", "-a", type=str, required=True, help="Account ID for the email")
+@option("--provider", "-p", type=str, choices=["mailtm", "tempmailio"], default="mailtm", help="Email provider to use")
+@option("--output", "-o", type=str, choices=["simple", "detailed"], default="simple", help="Output format")
+def check(email: str, account_id: str, provider: str = "mailtm", output: str = "simple"):
+    """
+    Check messages for an existing temporary email account
+
+    Retrieves and displays messages for an existing temporary email account.
+    Requires the email address and account ID.
+    """
+    mail = get_provider(provider_name=provider)
+    mail.email = email
+    mail.account_id = account_id
+
+    # Try to get token if needed
+    if hasattr(mail, 'get_token'):
+        mail.get_token()
+
+    console.print(f"[cyan]Checking messages for: {email}[/cyan]")
+
+    try:
+        messages = mail.get_messages()
+
+        if not messages:
+            console.print("[yellow]No messages found[/yellow]")
+            return
+
+        console.print(f"Found {len(messages)} messages:")
+        console.print("-" * 40)
+
+        for msg in messages:
+            console.print(f"From: {msg['from']}")
+            console.print(f"Subject: {msg['subject']}")
+
+            if output == "detailed":
+                console.print(f"Body: {msg['body']}")
+                console.print(f"Has attachments: {msg['hasAttachments']}")
+                console.print(f"Created at: {msg['createdAt']}")
+
+            console.print("[magenta]" + "-" * 40 + "[/magenta]")
+
+    except Exception as e:
+        console.print(f"[red]Error checking messages: {str(e)}[/red]")
+
+@app.command()
+@option("--email", "-e", type=str, required=True, help="Email address to delete")
+@option("--account-id", "-a", type=str, required=True, help="Account ID for the email")
+@option("--provider", "-p", type=str, choices=["mailtm", "tempmailio"], default="mailtm", help="Email provider to use")
+def delete(email: str, account_id: str, provider: str = "mailtm"):
+    """
+    Delete an existing temporary email account
+
+    Deletes a temporary email account using the provided email address and account ID.
+    """
+    mail = get_provider(provider_name=provider)
+    mail.email = email
+    mail.account_id = account_id
+
+    # Try to get token if needed
+    if hasattr(mail, 'get_token'):
+        mail.get_token()
+
+    console.print(f"[yellow]Deleting account: {email}[/yellow]")
+
+    try:
+        success = mail.delete_account()
+        if success:
+            console.print("[green]Account successfully deleted[/green]")
+        else:
+            console.print("[red]Failed to delete account[/red]")
+    except Exception as e:
+        console.print(f"[red]Error deleting account: {str(e)}[/red]")
+
+def main():
+    """Main CLI function for tempmail"""
+    try:
+        app.run()
+    except Exception as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()