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

webscout/Extra/tempmail/mail_tm.py

@@ -1,361 +0,0 @@
-"""
-Mail.TM Provider Implementation
-Based on mail.tm and mail.gw APIs
-"""
-
-import string
-import requests
-import json
-import random
-import time
-import asyncio
-from typing import List, Dict, Any, Optional, Union, Tuple
-
-from ...scout import Scout
-from .base import TempMailProvider, AsyncTempMailProvider, EMAIL_LENGTH, PASSWORD_LENGTH, generate_random_string
-
-
-class MailTM(TempMailProvider):
-    """
-    Mail.TM API client for temporary email services
-    Implements the synchronous TempMailProvider interface
-    """
-    
-    def __init__(self, auto_create=False):
-        """
-        Initialize MailTM client
-        
-        Args:
-            auto_create (bool): Automatically create an email upon initialization
-        """
-        self.url_bases = ['https://api.mail.tm', 'https://api.mail.gw']
-        self.url_base = self.url_bases[random.randrange(2)]
-        self.url_accounts = f"{self.url_base}/accounts"
-        self.url_me = f"{self.url_base}/me"
-        self.url_domain = f"{self.url_base}/domains"
-        self.url_msg = f"{self.url_base}/messages"
-        self.url_token = f"{self.url_base}/token"
-        
-        self.email = None
-        self.password = None
-        self.token = None
-        self.account_id = None
-        self.header = None
-        self.messages_count = 0
-        
-        if auto_create:
-            self.create_account()
-    
-    def get_domain(self) -> str:
-        """Get available domain for email creation"""
-        try:
-            resp = requests.get(f"{self.url_domain}?page=1")
-            resp.raise_for_status()
-            ans = json.loads(str(resp.text))
-            return ans['hydra:member'][0]['domain']
-        except requests.exceptions.HTTPError:
-            return ""
-    
-    def create_account(self) -> bool:
-        """Create a new temporary email account"""
-        domain = self.get_domain()
-        if not domain:
-            return False
-            
-        # Generate random email and password
-        self.email = generate_random_string(EMAIL_LENGTH) + '@' + domain
-        self.password = generate_random_string(PASSWORD_LENGTH, include_digits=True)
-        
-        # Register the account
-        myobj = {'address': self.email, "password": self.password}
-        try:
-            resp = requests.post(self.url_accounts, json=myobj)
-            resp.raise_for_status()
-            ans = json.loads(str(resp.text))
-            self.account_id = ans['id']
-            
-            # Get token
-            self.get_token()
-            return True if self.token else False
-            
-        except requests.exceptions.HTTPError:
-            return False
-    
-    def get_token(self) -> str:
-        """Get authentication token"""
-        if not self.email or not self.password:
-            return ""
-            
-        myobj = {'address': self.email, "password": self.password}
-        try:
-            resp = requests.post(self.url_token, json=myobj)
-            resp.raise_for_status()
-            ans = json.loads(str(resp.text))
-            self.token = ans['token']
-            self.header = {'Authorization': 'Bearer ' + self.token}
-            return self.token
-        except requests.exceptions.HTTPError:
-            return ""
-    
-    def get_message_detail(self, msg_id: str) -> str:
-        """Get detailed content of a message"""
-        if not self.header:
-            return ""
-            
-        try:
-            resp = requests.get(f"{self.url_msg}/{msg_id}", headers=self.header)
-            resp.raise_for_status()
-            ans = json.loads(str(resp.text))
-            
-            # Use Scout instead of BeautifulSoup for HTML parsing
-            scout = Scout(ans['text'])
-            
-            # Extract text with Scout's get_text method
-            return scout.get_text(strip=True)
-            
-        except requests.exceptions.HTTPError:
-            return ""
-    
-    def get_messages(self) -> List[Dict]:
-        """Get messages from the inbox"""
-        if not self.header:
-            return []
-            
-        try:
-            resp = requests.get(f"{self.url_msg}?page=1", headers=self.header)
-            resp.raise_for_status()
-            ans = json.loads(str(resp.text))
-            
-            messages = []
-            if ans['hydra:totalItems'] > 0:
-                for x in ans['hydra:member']:
-                    msg_dict = {
-                        'msg_id': x['id'],
-                        'from': x['from']['address'],
-                        'subject': x['subject'],
-                        'intro': x['intro'],
-                        'hasAttachments': x['hasAttachments'],
-                        'createdAt': x['createdAt'],
-                        'body': self.get_message_detail(x['id'])
-                    }
-                    messages.append(msg_dict)
-            return messages
-        except requests.exceptions.HTTPError:
-            return []
-    
-    def check_new_messages(self) -> List[Dict]:
-        """Check for new messages and return only the new ones"""
-        messages = self.get_messages()
-        if not messages:
-            return []
-        
-        if len(messages) > self.messages_count:
-            new_msg_count = len(messages) - self.messages_count
-            new_messages = messages[:new_msg_count]
-            self.messages_count = len(messages)
-            return new_messages
-        
-        self.messages_count = len(messages)
-        return []
-    
-    def delete_account(self) -> bool:
-        """Delete the current temporary email account"""
-        if not self.header or not self.account_id:
-            return False
-            
-        try:
-            resp = requests.delete(f"{self.url_accounts}/{self.account_id}", headers=self.header)
-            resp.raise_for_status()
-            self.email = None
-            self.password = None
-            self.token = None
-            self.account_id = None
-            self.header = None
-            self.messages_count = 0
-            return True
-        except requests.exceptions.HTTPError:
-            return False
-    
-    def get_account_info(self) -> Dict:
-        """Get current account information"""
-        if not self.header:
-            return {}
-            
-        try:
-            resp = requests.get(self.url_me, headers=self.header)
-            resp.raise_for_status()
-            return json.loads(str(resp.text))
-        except requests.exceptions.HTTPError:
-            return {}
-
-
-class MailTMAsync(AsyncTempMailProvider):
-    """
-    Asynchronous Mail.TM API client for temporary email services
-    Implements the AsyncTempMailProvider interface
-    """
-    
-    def __init__(self):
-        """Initialize MailTM Async client"""
-        self.url_bases = ['https://api.mail.tm', 'https://api.mail.gw']
-        self.url_base = self.url_bases[random.randrange(2)]
-        self.url_accounts = f"{self.url_base}/accounts"
-        self.url_me = f"{self.url_base}/me"
-        self.url_domain = f"{self.url_base}/domains"
-        self.url_msg = f"{self.url_base}/messages"
-        self.url_token = f"{self.url_base}/token"
-        
-        self.session = None
-        self.email = None
-        self.password = None
-        self.token = None
-        self.account_id = None
-        self.header = None
-        
-    async def initialize(self):
-        """Initialize the session"""
-        import aiohttp
-        self.session = aiohttp.ClientSession()
-        return self
-    
-    async def close(self) -> None:
-        """Close the session"""
-        if self.session:
-            await self.session.close()
-            self.session = None
-    
-    async def __aenter__(self):
-        """Context manager entry"""
-        return await self.initialize()
-    
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit"""
-        await self.close()
-    
-    async def get_domain(self) -> str:
-        """Get available domain for email creation"""
-        if not self.session:
-            await self.initialize()
-            
-        try:
-            async with self.session.get(f"{self.url_domain}?page=1") as resp:
-                resp.raise_for_status()
-                ans = await resp.json()
-                return ans['hydra:member'][0]['domain']
-        except Exception:
-            return ""
-    
-    async def create_email(self, alias: Optional[str] = None, domain: Optional[str] = None) -> Tuple[str, str]:
-        """Create a new email account"""
-        if not self.session:
-            await self.initialize()
-            
-        if not domain:
-            domain = await self.get_domain()
-            if not domain:
-                return "", ""
-        
-        # Generate random email address or use alias
-        if alias:
-            self.email = f"{alias}@{domain}"
-        else:
-            self.email = f"{generate_random_string(EMAIL_LENGTH)}@{domain}"
-            
-        # Generate password
-        self.password = generate_random_string(PASSWORD_LENGTH, include_digits=True)
-        
-        # Register account
-        data = {'address': self.email, 'password': self.password}
-        try:
-            async with self.session.post(self.url_accounts, json=data) as resp:
-                resp.raise_for_status()
-                ans = await resp.json()
-                self.account_id = ans['id']
-                
-                # Get token
-                token = await self._get_token()
-                return self.email, token
-                
-        except Exception:
-            return "", ""
-    
-    async def _get_token(self) -> str:
-        """Get authentication token"""
-        if not self.email or not self.password:
-            return ""
-            
-        data = {'address': self.email, 'password': self.password}
-        try:
-            async with self.session.post(self.url_token, json=data) as resp:
-                resp.raise_for_status()
-                ans = await resp.json()
-                self.token = ans['token']
-                self.header = {'Authorization': f'Bearer {self.token}'}
-                return self.token
-        except Exception:
-            return ""
-    
-    async def get_message_detail(self, msg_id: str) -> str:
-        """Get detailed content of a message"""
-        if not self.header:
-            return ""
-            
-        try:
-            async with self.session.get(f"{self.url_msg}/{msg_id}", headers=self.header) as resp:
-                resp.raise_for_status()
-                ans = await resp.json()
-                
-                # Use Scout instead of BeautifulSoup for HTML parsing
-                scout = Scout(ans['text'])
-                
-                # Extract text with Scout's get_text method with improved options
-                # Strip whitespace for cleaner output
-                return scout.get_text(separator=' ', strip=True)
-                
-        except Exception:
-            return ""
-    
-    async def get_messages(self) -> List[Dict]:
-        """Get messages for a temporary email"""
-        if not self.header:
-            return []
-            
-        try:
-            async with self.session.get(f"{self.url_msg}?page=1", headers=self.header) as resp:
-                resp.raise_for_status()
-                ans = await resp.json()
-                
-                messages = []
-                if ans['hydra:totalItems'] > 0:
-                    for x in ans['hydra:member']:
-                        detail = await self.get_message_detail(x['id'])
-                        msg_dict = {
-                            'msg_id': x['id'],
-                            'from': x['from']['address'],
-                            'subject': x['subject'],
-                            'intro': x['intro'],
-                            'hasAttachments': x['hasAttachments'],
-                            'createdAt': x['createdAt'],
-                            'body': detail
-                        }
-                        messages.append(msg_dict)
-                return messages
-        except Exception:
-            return []
-    
-    async def delete_email(self) -> bool:
-        """Delete a temporary email"""
-        if not self.header or not self.account_id:
-            return False
-            
-        try:
-            async with self.session.delete(f"{self.url_accounts}/{self.account_id}", headers=self.header) as resp:
-                resp.raise_for_status()
-                self.email = None
-                self.password = None
-                self.token = None
-                self.account_id = None
-                self.header = None
-                return True
-        except Exception:
-            return False

webscout/Extra/tempmail/temp_mail_io.py

@@ -1,292 +0,0 @@
-"""
-TempMail.io Provider Implementation
-Based on temp-mail.io API
-"""
-
-import aiohttp
-import asyncio
-from dataclasses import dataclass
-from typing import List, Dict, Any, Optional, Union, Tuple, NoReturn
-
-from .base import AsyncTempMailProvider, TempMailProvider, generate_random_string
-
-
-@dataclass
-class DomainModel:
-    """Domain model for TempMail.io API"""
-    name: str
-    type: str
-    forward_available: str
-    forward_max_seconds: str
-
-
-@dataclass
-class CreateEmailResponseModel:
-    """Response model for email creation in TempMail.io API"""
-    email: str
-    token: str
-
-
-@dataclass
-class MessageResponseModel:
-    """Message model for TempMail.io API"""
-    attachments: Optional[List[Any]]
-    body_html: Optional[str]
-    body_text: Optional[str]
-    cc: Optional[str]
-    created_at: str
-    email_from: Optional[str]
-    id: str
-    subject: Optional[str]
-    email_to: Optional[str]
-
-
-class TempMailIOAsync(AsyncTempMailProvider):
-    """
-    TempMail.io API client for temporary email services
-    Implements the AsyncTempMailProvider interface
-    """
-
-    def __init__(self):
-        """Initialize TempMail.io Async client"""
-        self._session = None
-        self.email = None
-        self.token = None
-
-    async def initialize(self):
-        """Initialize the aiohttp session"""
-        self._session = aiohttp.ClientSession(
-            base_url="https://api.internal.temp-mail.io",
-            headers={
-                'Host': 'api.internal.temp-mail.io',
-                'User-Agent': 'okhttp/4.5.0',
-                'Connection': 'close'
-            }
-        )
-        return self
-
-    async def close(self) -> None:
-        """Close the aiohttp session"""
-        if self._session and not self._session.closed:
-            await self._session.close()
-            self._session = None
-
-    async def __aenter__(self):
-        """Context manager entry"""
-        return await self.initialize()
-
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit"""
-        await self.close()
-        return None
-
-    async def get_domains(self) -> List[DomainModel]:
-        """Get available domains"""
-        if not self._session:
-            await self.initialize()
-
-        try:
-            async with self._session.get("/api/v3/domains") as response:
-                response_json = await response.json()
-                return [DomainModel(
-                    domain['name'],
-                    domain['type'],
-                    domain['forward_available'],
-                    domain['forward_max_seconds']
-                ) for domain in response_json['domains']]
-        except Exception:
-            return []
-
-    async def create_email(self, alias: Optional[str] = None, domain: Optional[str] = None) -> Tuple[str, str]:
-        """Create a new temporary email"""
-        if not self._session:
-            await self.initialize()
-
-        try:
-            async with self._session.post(
-                "/api/v3/email/new",
-                data={'name': alias, 'domain': domain}
-            ) as response:
-                response_json = await response.json()
-                self.email = response_json['email']
-                self.token = response_json['token']
-                return self.email, self.token
-        except Exception:
-            return "", ""
-
-    async def delete_email(self) -> bool:
-        """Delete a temporary email"""
-        if not self._session or not self.email or not self.token:
-            return False
-
-        try:
-            async with self._session.delete(
-                f"/api/v3/email/{self.email}",
-                data={'token': self.token}
-            ) as response:
-                success = response.status == 200
-                if success:
-                    self.email = None
-                    self.token = None
-                return success
-        except Exception:
-            return False
-
-    async def get_messages(self) -> List[Dict]:
-        """Get messages for a temporary email"""
-        if not self._session or not self.email:
-            return []
-
-        try:
-            async with self._session.get(f"/api/v3/email/{self.email}/messages") as response:
-                response_json = await response.json()
-                if len(response_json) == 0:
-                    return []
-
-                messages = []
-                for message in response_json:
-                    msg_dict = {
-                        'msg_id': message['id'],
-                        'from': message['from'],
-                        'to': message['to'],
-                        'subject': message['subject'] if 'subject' in message else "",
-                        'body': message['body_text'] or message['body_html'],
-                        'hasAttachments': bool(message['attachments'] and len(message['attachments']) > 0),
-                        'createdAt': message['created_at']
-                    }
-                    messages.append(msg_dict)
-                return messages
-        except Exception:
-            return []
-
-
-class TempMailIO(TempMailProvider):
-    """
-    Synchronous implementation for TempMail.io API
-    Implements the TempMailProvider interface
-    """
-
-    def __init__(self, auto_create=False):
-        """
-        Initialize TempMail.io client
-
-        Args:
-            auto_create: Automatically create an email upon initialization
-        """
-        import requests
-        self.session = requests.Session()
-        self.session.headers.update({
-            'Host': 'api.internal.temp-mail.io',
-            'User-Agent': 'okhttp/4.5.0',
-            'Connection': 'close'
-        })
-        self.base_url = "https://api.internal.temp-mail.io"
-        self.email = None
-        self.token = None
-        self.messages_count = 0
-
-        if auto_create:
-            self.create_account()
-
-    def get_domains(self) -> List[DomainModel]:
-        """Get available domains"""
-        try:
-            response = self.session.get(f"{self.base_url}/api/v3/domains")
-            response.raise_for_status()
-            response_json = response.json()
-            return [DomainModel(
-                domain['name'],
-                domain['type'],
-                domain['forward_available'],
-                domain['forward_max_seconds']
-            ) for domain in response_json['domains']]
-        except Exception:
-            return []
-
-    def create_account(self) -> bool:
-        """Create a new temporary email account"""
-        try:
-            response = self.session.post(
-                f"{self.base_url}/api/v3/email/new",
-                data={}
-            )
-            response.raise_for_status()
-            response_json = response.json()
-            self.email = response_json['email']
-            self.token = response_json['token']
-            return True
-        except Exception:
-            return False
-
-    def get_messages(self) -> List[Dict]:
-        """Get all messages in the inbox"""
-        if not self.email:
-            return []
-
-        try:
-            response = self.session.get(f"{self.base_url}/api/v3/email/{self.email}/messages")
-            response.raise_for_status()
-            response_json = response.json()
-            if len(response_json) == 0:
-                return []
-
-            messages = []
-            for message in response_json:
-                msg_dict = {
-                    'msg_id': message['id'],
-                    'from': message['from'] if 'from' in message else "",
-                    'to': message['to'] if 'to' in message else "",
-                    'subject': message['subject'] if 'subject' in message else "",
-                    'body': message['body_text'] or message['body_html'] or "",
-                    'hasAttachments': bool(message.get('attachments') and len(message['attachments']) > 0),
-                    'createdAt': message['created_at']
-                }
-                messages.append(msg_dict)
-            return messages
-        except Exception:
-            return []
-
-    def check_new_messages(self) -> List[Dict]:
-        """Check for new messages and return only the new ones"""
-        messages = self.get_messages()
-        if not messages:
-            return []
-
-        if len(messages) > self.messages_count:
-            new_msg_count = len(messages) - self.messages_count
-            new_messages = messages[:new_msg_count]
-            self.messages_count = len(messages)
-            return new_messages
-
-        self.messages_count = len(messages)
-        return []
-
-    def delete_account(self) -> bool:
-        """Delete the current temporary email account"""
-        if not self.email or not self.token:
-            return False
-
-        try:
-            response = self.session.delete(
-                f"{self.base_url}/api/v3/email/{self.email}",
-                data={'token': self.token}
-            )
-            response.raise_for_status()
-            success = response.status_code == 200
-            if success:
-                self.email = None
-                self.token = None
-                self.messages_count = 0
-            return success
-        except Exception:
-            return False
-
-    def get_account_info(self) -> Dict:
-        """Get current account information"""
-        if not self.email or not self.token:
-            return {}
-
-        return {
-            'email': self.email,
-            'token': self.token
-        }