webscout 8.2.2__py3-none-any.whl → 8.2.7__py3-none-any.whl

webscout/Extra/tempmail/__init__.py

@@ -1,28 +0,0 @@
-"""
-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
-from .emailnator import EmailnatorProvider
-
-__all__ = [
-    'TempMailProvider',
-    'AsyncTempMailProvider', 
-    'MailTM',
-    'MailTMAsync',
-    'TempMailIO',
-    'TempMailIOAsync',
-    'EmailnatorProvider',
-    'get_random_email',
-    'get_disposable_email',
-    'get_provider'
-]

webscout/Extra/tempmail/async_utils.py

@@ -1,141 +0,0 @@
-"""
-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

@@ -1,161 +0,0 @@
-"""
-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", "tempmailio", or "emailnator")
-        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()
-        elif provider_name.lower() == "emailnator":
-            raise NotImplementedError("Emailnator async provider not implemented.")
-        else:
-            from .mail_tm import MailTMAsync
-            return MailTMAsync()
-    else:
-        if provider_name.lower() == "tempmailio":
-            from .temp_mail_io import TempMailIO
-            return TempMailIO()
-        elif provider_name.lower() == "emailnator":
-            from .emailnator import EmailnatorProvider
-            return EmailnatorProvider()
-        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

@@ -1,187 +0,0 @@
-"""
-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()

webscout/Extra/tempmail/emailnator.py

@@ -1,84 +0,0 @@
-"""
-Emailnator Provider Implementation
-Synchronous provider for Emailnator.com
-"""
-
-from typing import List, Dict
-from time import sleep
-from requests import Session
-from webscout.litagent import LitAgent
-from .base import TempMailProvider
-from json import loads
-from re import findall
-
-class EmailnatorProvider(TempMailProvider):
-    def __init__(self):
-        self.client = Session()
-        self.client.get("https://www.emailnator.com/", timeout=6)
-        self.cookies = self.client.cookies.get_dict()
-        self.user_agent = LitAgent()
-        self.client.headers = {
-            "authority": "www.emailnator.com",
-            "origin": "https://www.emailnator.com",
-            "referer": "https://www.emailnator.com/",
-            "user-agent": self.user_agent.random(),
-            "x-xsrf-token": self.client.cookies.get("XSRF-TOKEN")[:-3] + "=",
-        }
-        self.email = None
-        self._messages = []
-        self._account_deleted = False
-
-    def create_account(self) -> bool:
-        response = self.client.post(
-            "https://www.emailnator.com/generate-email",
-            json={"email": ["plusGmail", "dotGmail"]},
-        )
-        self.email = loads(response.text)["email"][0]
-        return bool(self.email)
-
-    def get_messages(self) -> List[Dict]:
-        # Wait for at least one message
-        for _ in range(30):  # Wait up to 60 seconds
-            sleep(2)
-            mail_token = self.client.post(
-                "https://www.emailnator.com/message-list", json={"email": self.email}
-            )
-            mail_token = loads(mail_token.text)["messageData"]
-            if len(mail_token) > 1:
-                break
-        else:
-            return []
-        # Get message details
-        messages = []
-        for msg in mail_token[1:]:
-            msg_id = msg["messageID"]
-            mail_context = self.client.post(
-                "https://www.emailnator.com/message-list",
-                json={"email": self.email, "messageID": msg_id},
-            )
-            # The response is HTML, so we just store it as body
-            messages.append({
-                "msg_id": msg_id,
-                "from": msg.get("from", ""),
-                "subject": msg.get("subject", ""),
-                "body": mail_context.text,
-            })
-        self._messages = messages
-        return messages
-
-    def check_new_messages(self) -> List[Dict]:
-        current = self.get_messages()
-        if not self._messages:
-            return current
-        # Return only new messages
-        old_ids = {m["msg_id"] for m in self._messages}
-        new_msgs = [m for m in current if m["msg_id"] not in old_ids]
-        return new_msgs
-
-    def delete_account(self) -> bool:
-        # Emailnator does not support explicit account deletion, so just mark as deleted
-        self._account_deleted = True
-        return True
-
-    def get_account_info(self) -> Dict:
-        return {"email": self.email, "deleted": self._account_deleted}