user-scanner 1.0.10.3__py3-none-any.whl → 1.1.0.1__py3-none-any.whl

user_scanner/core/helpers.py

@@ -1,3 +1,15 @@
+import importlib
+import importlib.util
+from itertools import permutations
+from types import ModuleType
+from pathlib import Path
+from typing import Dict, List, Optional
+import random
+import threading
+import httpx
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
 def get_site_name(module) -> str:
     name = module.__name__.split('.')[-1].capitalize().replace("_", ".")
     if name == "X":
@@ -5,5 +17,185 @@ def get_site_name(module) -> str:
     return name
 
 
-def is_last_value(values, i: int) -> bool:
-    return i == len(values) - 1
+def load_modules(category_path: Path) -> List[ModuleType]:
+    modules = []
+    for file in category_path.glob("*.py"):
+        if file.name == "__init__.py":
+            continue
+        spec = importlib.util.spec_from_file_location(file.stem, str(file))
+        if spec is None or spec.loader is None:
+            continue
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        modules.append(module)
+    return modules
+
+
+def load_categories(is_email: bool = False) -> Dict[str, Path]:
+    folder_name = "email_scan" if is_email else "user_scan"
+    root = Path(__file__).resolve().parent.parent / folder_name
+    categories = {}
+
+    for subfolder in root.iterdir():
+        if subfolder.is_dir() and \
+                subfolder.name.lower() not in ["cli", "utils", "core"] and \
+                "__" not in subfolder.name:  # Removes __pycache__
+            categories[subfolder.name] = subfolder.resolve()
+
+    return categories
+
+
+def find_module(name: str, is_email: bool = False) -> List[ModuleType]:
+    name = name.lower()
+
+    return [
+        module
+        for category_path in load_categories(is_email).values()
+        for module in load_modules(category_path)
+        if module.__name__.split(".")[-1].lower() == name
+    ]
+
+
+def find_category(module: ModuleType) -> str | None:
+
+    module_file = getattr(module, '__file__', None)
+    if not module_file:
+        return None
+
+    category = Path(module_file).parent.name.lower()
+    if category in load_categories(False) or category in load_categories(True):
+        return category.capitalize()
+
+    return None
+
+
+def generate_permutations(username: str, pattern: str, limit: int | None = None, is_email: bool = False) -> List[str]:
+    """
+    Generate all order-based permutations of characters in `pattern`
+    appended after `username`.
+    """
+
+    if limit and limit <= 0:
+        return []
+
+    permutations_set = {username}
+    chars = list(pattern)
+
+    domain = ""
+    if is_email:
+        username, domain = username.strip().split("@")
+
+    # generate permutations of length 1 → len(chars)
+    for r in range(len(chars)):
+        for combo in permutations(chars, r):
+            new = username + ''.join(combo)
+            if is_email:
+                new += "@" + domain
+            permutations_set.add(new)
+            if limit and len(permutations_set) >= limit:
+                return sorted(permutations_set)
+
+    return sorted(permutations_set)
+
+
+def validate_proxies(proxy_list: List[str], timeout: int = 5, max_workers: int = 50) -> List[str]:
+    """Validate proxies by testing them against google.com. Returns list of working proxies."""
+    working_proxies = []
+    
+    def test_proxy(proxy: str) -> Optional[str]:
+        try:
+            with httpx.Client(proxy=proxy, timeout=timeout) as client:
+                response = client.get("https://www.google.com")
+                if response.status_code == 200:
+                    return proxy
+        except Exception:
+            pass
+        return None
+    
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {executor.submit(test_proxy, proxy): proxy for proxy in proxy_list}
+        for future in as_completed(futures):
+            result = future.result()
+            if result:
+                working_proxies.append(result)
+    
+    return working_proxies
+
+
+class ProxyManager:
+    """Thread-safe proxy manager that loads and rotates proxies from a file."""
+    
+    def __init__(self, proxy_file: str):
+        self.proxies: list[str] = []
+        self.current_index = 0
+        self.lock = threading.Lock()
+        self._load_proxies(proxy_file)
+    
+    def _load_proxies(self, proxy_file: str) -> None:
+        """Load proxies from a text file. Supports http://, https://, and socks5:// proxies."""
+        try:
+            with open(proxy_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        # Add protocol if not present
+                        if not line.startswith(('http://', 'https://', 'socks5://')):
+                            line = 'http://' + line
+                        self.proxies.append(line)
+            
+            if not self.proxies:
+                raise ValueError("No valid proxies found in file")
+                
+        except FileNotFoundError:
+            raise FileNotFoundError(f"Proxy file not found: {proxy_file}")
+        except Exception as e:
+            raise Exception(f"Error loading proxies: {e}")
+    
+    def get_next_proxy(self) -> Optional[str]:
+        """Get the next proxy in rotation (round-robin)."""
+        if not self.proxies:
+            return None
+        
+        with self.lock:
+            proxy = self.proxies[self.current_index]
+            self.current_index = (self.current_index + 1) % len(self.proxies)
+            return proxy
+    
+    def get_random_proxy(self) -> Optional[str]:
+        """Get a random proxy from the list."""
+        if not self.proxies:
+            return None
+        return random.choice(self.proxies)
+    
+    def count(self) -> int:
+        """Return the number of loaded proxies."""
+        return len(self.proxies)
+
+
+# Global proxy manager instance
+_proxy_manager: Optional[ProxyManager] = None
+
+
+def set_proxy_manager(proxy_file: Optional[str]) -> None:
+    """Initialize the global proxy manager with a proxy file."""
+    global _proxy_manager
+    if proxy_file:
+        _proxy_manager = ProxyManager(proxy_file)
+    else:
+        _proxy_manager = None
+
+
+def get_proxy() -> Optional[str]:
+    """Get the next proxy from the global proxy manager."""
+    if _proxy_manager:
+        return _proxy_manager.get_next_proxy()
+    return None
+
+
+def get_proxy_count() -> int:
+    """Get the count of loaded proxies."""
+    if _proxy_manager:
+        return _proxy_manager.count()
+    return 0
+

user_scanner/core/orchestrator.py

@@ -1,72 +1,14 @@
-import importlib
-import importlib.util
 from colorama import Fore, Style
 from concurrent.futures import ThreadPoolExecutor
-from itertools import permutations
 import httpx
 from pathlib import Path
-from user_scanner.cli.printer import Printer
 from user_scanner.core.result import Result
-from typing import Callable, Dict, List
-from user_scanner.core.helpers import get_site_name, is_last_value
+from typing import Callable, List
+from types import ModuleType
+from user_scanner.core.helpers import find_category,  get_site_name, load_categories, load_modules, get_proxy
 
 
-def load_modules(category_path: Path):
-    modules = []
-    for file in category_path.glob("*.py"):
-        if file.name == "__init__.py":
-            continue
-        spec = importlib.util.spec_from_file_location(file.stem, str(file))
-        if spec is None or spec.loader is None:
-            continue
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-
-        modules.append(module)
-    return modules
-
-
-def load_categories() -> Dict[str, Path]:
-    root = Path(__file__).resolve().parent.parent  # Should be user_scanner
-    categories = {}
-
-    for subfolder in root.iterdir():
-        if subfolder.is_dir() and \
-                subfolder.name.lower() not in ["cli", "utils", "core"] and \
-                "__" not in subfolder.name:  # Removes __pycache__
-            categories[subfolder.name] = subfolder.resolve()
-
-    return categories
-
-
-def find_module(name: str):
-    name = name.lower()
-
-    matches = [
-        module
-        for category_path in load_categories().values()
-        for module in load_modules(category_path)
-        if module.__name__.split(".")[-1].lower() == name
-    ]
-
-    return matches
-
-def find_category(module) -> str | None:
-
-    module_file = getattr(module, '__file__', None)
-    if not module_file:
-        return None
-
-    category = Path(module_file).parent.name.lower()
-    categories = load_categories()
-    if category in categories:
-        return category.capitalize()
-
-    return None
-
-
-
-def worker_single(module, username: str) -> Result:
+def _worker_single(module: ModuleType, username: str) -> Result:
     func = next((getattr(module, f) for f in dir(module)
                  if f.startswith("validate_") and callable(getattr(module, f))), None)
 
@@ -81,60 +23,43 @@ def worker_single(module, username: str) -> Result:
         return result
     except Exception as e:
         return Result.error(e, site_name=site_name, username=username)
-
-
-def run_module_single(module, username: str, printer: Printer, last: bool = True) -> List[Result]:
-    result = worker_single(module, username)
+    
+def run_user_module(module: ModuleType, username: str) -> List[Result]:
+    result = _worker_single(module, username)
 
     category = find_category(module)
     if category:
         result.update(category=category)
 
-    get_site_name(module)
-    msg = printer.get_result_output(result)
-    if not last and printer.is_json:
-        msg += ","
-    print(msg)
+    print(result.get_console_output())
 
     return [result]
 
 
-
-def run_checks_category(category_path: Path, username: str, printer: Printer, last: bool = True) -> List[Result]:
-    modules = load_modules(category_path)
-
+def run_user_category(category_path: Path, username: str) -> List[Result]:
     category_name = category_path.stem.capitalize()
-    if printer.is_console:
-        print(f"\n{Fore.MAGENTA}== {category_name} SITES =={Style.RESET_ALL}")
+    print(f"\n{Fore.MAGENTA}== {category_name} SITES =={Style.RESET_ALL}")
 
     results = []
+    modules = load_modules(category_path)
 
     with ThreadPoolExecutor(max_workers=10) as executor:
-        exec_map = executor.map(lambda m: worker_single(m, username), modules)
-        for i, result in enumerate(exec_map):
-            result.update(category = category_name)
+        exec_map = executor.map(lambda m: _worker_single(m, username), modules)
+        for result in exec_map:
+            result.update(category=category_name)
             results.append(result)
 
-            is_last = last and is_last_value(modules, i)
-            get_site_name(modules[i])
-            msg = printer.get_result_output(result)
-            if not is_last and printer.is_json:
-                msg += ","
-            print(msg)
+            print(result.get_console_output())
 
     return results
 
 
-def run_checks(username: str, printer: Printer, last: bool = True) -> List[Result]:
-    if printer.is_console:
-        print(f"\n{Fore.CYAN} Checking username: {username}{Style.RESET_ALL}")
-
+def run_user_full(username: str) -> List[Result]:
     results = []
 
     categories = list(load_categories().values())
-    for i, category_path in enumerate(categories):
-        last_cat = last and (i == len(categories) - 1)
-        temp = run_checks_category(category_path, username, printer, last_cat)
+    for category_path in categories:
+        temp = run_user_category(category_path, username)
         results.extend(temp)
 
     return results
@@ -154,6 +79,12 @@ def make_request(url: str, **kwargs) -> httpx.Response:
     if "timeout" not in kwargs:
         kwargs["timeout"] = 5.0
 
+    # Add proxy if available and not already set
+    if "proxy" not in kwargs:
+        proxy = get_proxy()
+        if proxy:
+            kwargs["proxy"] = proxy
+
     method = kwargs.pop("method", "GET")
 
     return httpx.request(method.upper(), url, **kwargs)
@@ -194,22 +125,3 @@ def status_validate(url: str, available: int | List[int], taken: int | List[int]
         return Result.error("Status didn't match. Report this on Github.")
 
     return generic_validate(url, inner, **kwargs)
-
-
-def generate_permutations(username, pattern, limit=None):
-    """
-    Generate all order-based permutations of characters in `pattern`
-    appended after `username`.
-    """
-    permutations_set = {username}
-
-    chars = list(pattern)
-
-    # generate permutations of length 1 → len(chars)
-    for r in range(1, len(chars) + 1):
-        for combo in permutations(chars, r):
-            permutations_set.add(username + ''.join(combo))
-            if limit and len(permutations_set) >= limit:
-                return list(permutations_set)[:limit]
-
-    return sorted(permutations_set)

user_scanner/core/result.py

@@ -1,11 +1,14 @@
 from enum import Enum
 
+from colorama import Fore, Style
+
 DEBUG_MSG = """Result {{
   status: {status},
   reason: "{reason}",
   username: "{username}",
   site_name: "{site_name}",
   category: "{category}",
+  is_email: "{is_email}"
 }}"""
 
 JSON_TEMPLATE = """{{
@@ -21,12 +24,10 @@ CSV_TEMPLATE = "{username},{category},{site_name},{status},{reason}"
 
 def humanize_exception(e: Exception) -> str:
     msg = str(e).lower()
-
     if "10054" in msg:
         return "Connection closed by remote server"
     if "11001" in msg:
         return "Could not resolve hostname"
-
     return str(e)
 
 
@@ -35,32 +36,39 @@ class Status(Enum):
     AVAILABLE = 1
     ERROR = 2
 
+    def to_label(self, is_email=False):
+        if self == Status.ERROR:
+            return "Error"
+        if is_email:
+            return "Registered" if self == Status.TAKEN else "Not Registered"
+        return "Taken" if self == Status.TAKEN else "Available"
+
     def __str__(self):
-        return super().__str__().split(".")[1].capitalize()
+        return self.to_label(is_email=False)
 
 
 class Result:
     def __init__(self, status: Status, reason: str | Exception | None = None, **kwargs):
         self.status = status
         self.reason = reason
-
         self.username = None
         self.site_name = None
         self.category = None
+        self.is_email = False
         self.update(**kwargs)
 
     def update(self, **kwargs):
-        for field in ("username", "site_name", "category"):
+        for field in ("username", "site_name", "category", "is_email"):
             if field in kwargs and kwargs[field] is not None:
                 setattr(self, field, kwargs[field])
 
     @classmethod
-    def taken(cls, **kwargs):
-        return cls(Status.TAKEN, **kwargs)
+    def taken(cls, reason: str | Exception | None = None, **kwargs):
+        return cls(Status.TAKEN, reason, **kwargs)
 
     @classmethod
-    def available(cls, **kwargs):
-        return cls(Status.AVAILABLE, **kwargs)
+    def available(cls, reason: str | Exception | None = None, **kwargs):
+        return cls(Status.AVAILABLE, reason, **kwargs)
 
     @classmethod
     def error(cls, reason: str | Exception | None = None, **kwargs):
@@ -72,8 +80,7 @@ class Result:
             status = Status(i)
         except ValueError:
             return cls(Status.ERROR, "Invalid status. Please contact maintainers.")
-
-        return cls(status,  reason if status == Status.ERROR else None)
+        return cls(status, reason)
 
     def to_number(self) -> int:
         return self.status.value
@@ -86,24 +93,27 @@ class Result:
             return ""
         if isinstance(self.reason, str):
             return self.reason
-        # Format the exception
         msg = humanize_exception(self.reason)
         return f"{type(self.reason).__name__}: {msg.capitalize()}"
 
     def as_dict(self) -> dict:
         return {
-            "status": self.status,
+            "status": self.status.to_label(self.is_email),
             "reason": self.get_reason(),
             "username": self.username,
             "site_name": self.site_name,
-            "category": self.category
+            "category": self.category,
+            "is_email": self.is_email,
         }
 
     def debug(self) -> str:
         return DEBUG_MSG.format(**self.as_dict())
 
     def to_json(self) -> str:
-        return JSON_TEMPLATE.format(**self.as_dict())
+        msg = JSON_TEMPLATE.format(**self.as_dict())
+        if self.is_email:
+            msg = msg.replace('\t"username":', '\t"email":')
+        return msg
 
     def to_csv(self) -> str:
         return CSV_TEMPLATE.format(**self.as_dict())
@@ -114,12 +124,35 @@ class Result:
     def __eq__(self, other):
         if isinstance(other, Status):
             return self.status == other
-
         if isinstance(other, Result):
             return self.status == other.status
-
         if isinstance(other, int):
             return self.to_number() == other
-
         return NotImplemented
 
+    def get_output_color(self) -> str:
+        if self == Status.ERROR:
+            return Fore.YELLOW
+        elif self.is_email:
+            return Fore.GREEN if self == Status.TAKEN else Fore.RED
+        else:
+            return Fore.GREEN if self == Status.AVAILABLE else Fore.RED
+
+    def get_output_icon(self) -> str:
+        if self == Status.ERROR:
+            return "[!]"
+        elif self.is_email:
+            return "[✔]" if self == Status.TAKEN else "[✘]"
+        else:
+            return "[✔]" if self == Status.AVAILABLE else "[✘]"
+
+    def get_console_output(self) -> str:
+        site_name = self.site_name
+        username = self.username
+        status_text = self.status.to_label(self.is_email)
+
+        color = self.get_output_color()
+        icon = self.get_output_icon()
+
+        reason = f" ({self.get_reason()})" if self.has_reason() else ""
+        return f"  {color}{icon} {site_name} ({username}): {status_text}{reason}{Style.RESET_ALL}"

user_scanner/email_scan/adult/pornhub.py

@@ -0,0 +1,62 @@
+import httpx
+import re
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    base_url = "https://www.pornhub.com"
+    check_api = f"{base_url}/api/v1/user/create_account_check"
+
+    headers = {
+        "user-agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36",
+        "x-requested-with": "XMLHttpRequest",
+        "origin": base_url,
+        "referer": base_url + "/",
+        "content-type": "application/x-www-form-urlencoded; charset=UTF-8"
+    }
+
+    async with httpx.AsyncClient(http2=True, follow_redirects=True, timeout=3) as client:
+        try:
+            landing_resp = await client.get(base_url, headers=headers)
+            token_match = re.search(r'var\s+token\s*=\s*"([^"]+)"', landing_resp.text)
+
+            if not token_match:
+                return Result.error("Failed to extract dynamic token from HTML")
+
+            token = token_match.group(1)
+
+            params = {"token": token}
+            payload = {
+                "check_what": "email",
+                "email": email
+            }
+
+            response = await client.post(
+                check_api,
+                params=params,
+                headers=headers,
+                data=payload
+            )
+
+            if response.status_code == 429:
+                return Result.error("Rate limited, wait for a few minutes")
+
+            if response.status_code != 200:
+                return Result.error(f"HTTP Error: {response.status_code}")
+
+            data = response.json()
+            status = data.get("email")
+            error_msg = data.get("error_message", "")
+
+            if status == "create_account_passed":
+                return Result.available()
+            elif "already in use" in error_msg.lower() or status != "create_account_passed":
+                return Result.taken()
+            else:
+                return Result.error(f"Unexpected API response: {status}")
+
+        except Exception as e:
+            return Result.error(e)
+
+
+async def validate_pornhub(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/adult/xnxx.py

@@ -0,0 +1,46 @@
+import httpx
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    url = "https://www.xnxx.com/account/checkemail"
+    params = {'email': email}
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36",
+        'Accept': "application/json, text/javascript, */*; q=0.01",
+        'Accept-Encoding': "identity",
+        'X-Requested-With': "XMLHttpRequest",
+        'sec-ch-ua-platform': '"Android"',
+        'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+        'sec-ch-ua-mobile': "?1",
+        'Sec-Fetch-Site': "same-origin",
+        'Sec-Fetch-Mode': "cors",
+        'Sec-Fetch-Dest': "empty",
+        'Referer': "https://www.xnxx.com/",
+        'Accept-Language': "en-US,en;q=0.9"
+    }
+
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            response = await client.get(url, params=params, headers=headers)
+
+            if response.status_code == 429:
+                return Result.error("Rate limited wait for few minutes")
+
+            if response.status_code != 200:
+                return Result.error(f"HTTP Error: {response.status_code}")
+
+            data = response.json()
+            exists_bool = data.get("result")
+
+            if exists_bool is True:
+                return Result.available()
+            elif exists_bool is False:
+                return Result.taken()
+            else:
+                return Result.error("Unexpected error, report it via GitHub issues")
+
+        except Exception as e:
+            return Result.error(e)
+
+async def validate_xnxx(email: str) -> Result:
+    return await _check(email)