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

webscout/Extra/tempmail/async_utils.py

@@ -1,141 +1,143 @@
-"""
-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
+"""
+Async utilities for temporary email generation
+"""
+import asyncio
+from typing import Dict, List, Optional, Tuple
+
+from litprinter import ic
+
+from .temp_mail_io import TempMailIOAsync as TempMailAPI
+
+
+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:
+            self.email, self.token = await self.api.create_email(alias, domain)
+            return self.email, self.token
+        except Exception as e:
+            ic.configureOutput(prefix='ERROR| ')
+            ic(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()
+            if not messages:
+                return []
+
+            return [
+                {
+                    "id": msg.get("id") or msg.get("msg_id"),
+                    "from": msg.get("from") or msg.get("email_from"),
+                    "to": msg.get("to") or msg.get("email_to"),
+                    "subject": msg.get("subject"),
+                    "created_at": msg.get("created_at") or msg.get("createdAt"),
+                    "body": msg.get("body_text") or msg.get("body_html") or msg.get("body"),
+                    "has_attachments": bool(msg.get("attachments") or msg.get("has_attachments") or msg.get("hasAttachments"))
+                }
+                for msg in messages
+            ]
+        except Exception as e:
+            ic.configureOutput(prefix='ERROR| ')
+            ic(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:
+            ic.configureOutput(prefix='WARNING| ')
+            ic("No email to delete")
+            return False
+
+        try:
+            result = await self.api.delete_email()
+            return result
+        except Exception as e:
+            ic.configureOutput(prefix='ERROR| ')
+            ic(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 +1,172 @@
-"""
-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()
+"""
+Temporary Email Generation Base Module
+Abstract base classes for tempmail providers
+"""
+
+import random
+import string
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Tuple, Union
+
+# Constants for email generation
+EMAIL_LENGTH = 16
+PASSWORD_LENGTH = 10
+
+
+class TempMailProvider(ABC):
+    """
+    Abstract base class for synchronous temporary email providers
+    """
+    email: Optional[str] = None
+    account_id: Optional[str] = None
+
+    @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")
+
+    def get_token(self) -> str:
+        """Get authentication token (optional for some providers)"""
+        return ""
+
+
+class AsyncTempMailProvider(ABC):
+    """
+    Abstract base class for asynchronous temporary email providers
+    """
+    email: Optional[str] = None
+    account_id: Optional[str] = None
+
+    @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)
+
+    if isinstance(provider, AsyncTempMailProvider):
+        raise TypeError("get_random_email only supports synchronous providers")
+
+    # For providers that require explicit initialization
+    if getattr(provider, '_initialized', True) is False:
+        try:
+            # If there's an initialization method that needs to be called
+            if hasattr(provider, 'initialize'):
+                provider.initialize() # type: ignore
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize provider: {e}")
+
+    # Create the account (auto-generates a random email)
+    success = provider.create_account()
+    if not success:
+        raise RuntimeError(f"Failed to create account with provider {provider_name}")
+
+    return getattr(provider, 'email', ""), provider
+
+
+def get_disposable_email() -> Tuple[str, TempMailProvider]:
+    """Alias for get_random_email"""
+    return get_random_email()