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

webscout/Extra/tempmail/mail_tm.py

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

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