user-scanner 1.0.8.0__tar.gz → 1.0.9.0__tar.gz

{user_scanner-1.0.8.0 → user_scanner-1.0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: user-scanner
-Version: 1.0.8.0
+Version: 1.0.9.0
 Summary: Check username availability across multiple popular platforms
 Keywords: username,checker,availability,social,tech,python,user-scanner
 Author-email: Kaif <kafcodec@gmail.com>
@@ -15,7 +15,7 @@ Project-URL: Homepage, https://github.com/kaifcodec/user-scanner
 
 ![1000136215](https://github.com/user-attachments/assets/49ec8d24-665b-4115-8525-01a8d0ca2ef4)
 <p align="center">
-  <img src="https://img.shields.io/badge/Version-1.0.8.0-blueviolet?style=for-the-badge&logo=github" />
+  <img src="https://img.shields.io/badge/Version-1.0.9.0-blueviolet?style=for-the-badge&logo=github" />
   <img src="https://img.shields.io/github/issues/kaifcodec/user-scanner?style=for-the-badge&logo=github" />
   <img src="https://img.shields.io/badge/Tested%20on-Termux-black?style=for-the-badge&logo=termux" />
   <img src="https://img.shields.io/badge/Tested%20on-Windows-cyan?style=for-the-badge&logo=Windows" />
@@ -31,13 +31,16 @@ Perfect for finding a **unique username** across GitHub, Twitter, Reddit, Instag
 
 ### Features
 
-- ✅ Check usernames across **social networks**, **developer platforms**, and **creator communities**.
-- ✅ Clear **Available / Taken / Error** output for each platform.
-- ✅ Fully modular: add new platform modules easily.
-- ✅ Wildcard-based username permutations for automatic variation generation
-- ✅ Command-line interface ready: works directly after `pip install`.
-- ✅ Can be used as username OSINT tool.
-- ✅ Very low and lightweight dependencies, can be run on any machine.
+- ✅ Check usernames across **social networks**, **developer platforms**, and **creator communities**
+- ✅ Clear **Available / Taken / Error** output for each platform
+- ✅ Robust error handling: It prints the exact reason (e.g. Cannot use underscores, hyphens at the start/end)
+- ✅ Fully modular: add new platform modules easily
+- ✅ Wildcard-based username permutations for automatic variation generation using provided suffix
+- ✅ Selection of results format (e.g. json, csv, console (default))
+- ✅ Get the scanning results in preferred format (json/csv) in specified output file (suitable for power users)
+- ✅ Command-line interface ready: works directly after `pip install`
+- ✅ Can be used as username OSINT tool
+- ✅ Very low and lightweight dependencies, can be run on any machine
 ---
 
 ### Installation
@@ -61,15 +64,21 @@ Optionally, scan a specific category or single module:
 user-scanner -u <username> -c dev
 user-scanner -l # Lists all available modules
 user-scanner -u <username> -m github
-user-scanner -u <username> -p <suffix> 
+```
 
+Also, the output file and format can be specified: <br>
+\* Errors and warnings will only appear when the format is set to "console"
+```bash
+user-scanner -u <username> -f console #Default format
+user-scanner -u <username> -f csv
+user-scanner -u <username> -f json
+user-scanner -u <username> -f <format> -o <output-file>
 ```
 
 Generate multiple username variations by appending a suffix:
 
 ```bash
 user-scanner -u <username> -p <suffix> 
-
 ```
 Optionally, scan a specific category or single module with limit:
 
@@ -77,7 +86,7 @@ Optionally, scan a specific category or single module with limit:
 user-scanner -u <username> -p <suffix> -c dev
 user-scanner -u <username> -p <suffix> -m github
 user-scanner -u <username> -p <suffix> -s <number> # limit generation of usernames
-user-scanner -u <username> -p <suffix> -d <seconds> #delay to avoid rate-limits
+user-scanner -u <username> -p <suffix> -d <seconds> # delay to avoid rate-limits (can be 0s-1s)
 ```
 
 ---
@@ -93,6 +102,10 @@ user-scanner -u <username> -p <suffix> -d <seconds> #delay to avoid rate-limits
 
 <img width="1080" height="352" alt="1000140393" src="https://github.com/user-attachments/assets/578b248c-2a05-4917-aab3-6372a7c28045" />
 
+---
+
+<img width="992" height="556" alt="1000141265" src="https://github.com/user-attachments/assets/9babb19f-bc87-4e7b-abe5-c52b8b1b672c" />
+
 
 ### Contributing: 
 
@@ -109,12 +122,14 @@ user_scanner/
 ```
 
 **Module guidelines:**
-- Each module must define a `validate_<site>()` function that takes a `username` and returns:
-  - `1` → Available  
-  - `0` → Taken  
-  - `2` → Error / Could not check
-- Use `httpx` for requests, `colorama` for colored output.
-- Optional: modules can define a CLI parser if they support custom arguments.
+This project contains small "validator" modules that check whether a username exists on a given platform. Each validator is a single function that returns a Result object (see `core/orchestrator.py`).
+
+Result semantics:
+- Result.available() → `available`
+- Result.taken() → `taken`
+- Result.error(message: Optional[str]) → `error`, blocked, unknown, or request failure (include short diagnostic message when helpful)
+
+Follow this document when adding or updating validators.
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for examples.
 

{user_scanner-1.0.8.0 → user_scanner-1.0.9.0}/README.md

@@ -2,7 +2,7 @@
 
 ![1000136215](https://github.com/user-attachments/assets/49ec8d24-665b-4115-8525-01a8d0ca2ef4)
 <p align="center">
-  <img src="https://img.shields.io/badge/Version-1.0.8.0-blueviolet?style=for-the-badge&logo=github" />
+  <img src="https://img.shields.io/badge/Version-1.0.9.0-blueviolet?style=for-the-badge&logo=github" />
   <img src="https://img.shields.io/github/issues/kaifcodec/user-scanner?style=for-the-badge&logo=github" />
   <img src="https://img.shields.io/badge/Tested%20on-Termux-black?style=for-the-badge&logo=termux" />
   <img src="https://img.shields.io/badge/Tested%20on-Windows-cyan?style=for-the-badge&logo=Windows" />
@@ -18,13 +18,16 @@ Perfect for finding a **unique username** across GitHub, Twitter, Reddit, Instag
 
 ### Features
 
-- ✅ Check usernames across **social networks**, **developer platforms**, and **creator communities**.
-- ✅ Clear **Available / Taken / Error** output for each platform.
-- ✅ Fully modular: add new platform modules easily.
-- ✅ Wildcard-based username permutations for automatic variation generation
-- ✅ Command-line interface ready: works directly after `pip install`.
-- ✅ Can be used as username OSINT tool.
-- ✅ Very low and lightweight dependencies, can be run on any machine.
+- ✅ Check usernames across **social networks**, **developer platforms**, and **creator communities**
+- ✅ Clear **Available / Taken / Error** output for each platform
+- ✅ Robust error handling: It prints the exact reason (e.g. Cannot use underscores, hyphens at the start/end)
+- ✅ Fully modular: add new platform modules easily
+- ✅ Wildcard-based username permutations for automatic variation generation using provided suffix
+- ✅ Selection of results format (e.g. json, csv, console (default))
+- ✅ Get the scanning results in preferred format (json/csv) in specified output file (suitable for power users)
+- ✅ Command-line interface ready: works directly after `pip install`
+- ✅ Can be used as username OSINT tool
+- ✅ Very low and lightweight dependencies, can be run on any machine
 ---
 
 ### Installation
@@ -48,15 +51,21 @@ Optionally, scan a specific category or single module:
 user-scanner -u <username> -c dev
 user-scanner -l # Lists all available modules
 user-scanner -u <username> -m github
-user-scanner -u <username> -p <suffix> 
+```
 
+Also, the output file and format can be specified: <br>
+\* Errors and warnings will only appear when the format is set to "console"
+```bash
+user-scanner -u <username> -f console #Default format
+user-scanner -u <username> -f csv
+user-scanner -u <username> -f json
+user-scanner -u <username> -f <format> -o <output-file>
 ```
 
 Generate multiple username variations by appending a suffix:
 
 ```bash
 user-scanner -u <username> -p <suffix> 
-
 ```
 Optionally, scan a specific category or single module with limit:
 
@@ -64,7 +73,7 @@ Optionally, scan a specific category or single module with limit:
 user-scanner -u <username> -p <suffix> -c dev
 user-scanner -u <username> -p <suffix> -m github
 user-scanner -u <username> -p <suffix> -s <number> # limit generation of usernames
-user-scanner -u <username> -p <suffix> -d <seconds> #delay to avoid rate-limits
+user-scanner -u <username> -p <suffix> -d <seconds> # delay to avoid rate-limits (can be 0s-1s)
 ```
 
 ---
@@ -80,6 +89,10 @@ user-scanner -u <username> -p <suffix> -d <seconds> #delay to avoid rate-limits
 
 <img width="1080" height="352" alt="1000140393" src="https://github.com/user-attachments/assets/578b248c-2a05-4917-aab3-6372a7c28045" />
 
+---
+
+<img width="992" height="556" alt="1000141265" src="https://github.com/user-attachments/assets/9babb19f-bc87-4e7b-abe5-c52b8b1b672c" />
+
 
 ### Contributing: 
 
@@ -96,12 +109,14 @@ user_scanner/
 ```
 
 **Module guidelines:**
-- Each module must define a `validate_<site>()` function that takes a `username` and returns:
-  - `1` → Available  
-  - `0` → Taken  
-  - `2` → Error / Could not check
-- Use `httpx` for requests, `colorama` for colored output.
-- Optional: modules can define a CLI parser if they support custom arguments.
+This project contains small "validator" modules that check whether a username exists on a given platform. Each validator is a single function that returns a Result object (see `core/orchestrator.py`).
+
+Result semantics:
+- Result.available() → `available`
+- Result.taken() → `taken`
+- Result.error(message: Optional[str]) → `error`, blocked, unknown, or request failure (include short diagnostic message when helpful)
+
+Follow this document when adding or updating validators.
 
 See [CONTRIBUTING.md](CONTRIBUTING.md) for examples.
 

{user_scanner-1.0.8.0 → user_scanner-1.0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "user-scanner"
-version = "1.0.8.0"
+version = "1.0.9.0"
 description = "Check username availability across multiple popular platforms"
 readme = "README.md"
 license = {file = "LICENSE"}

{user_scanner-1.0.8.0 → user_scanner-1.0.9.0}/user_scanner/__main__.py

@@ -1,27 +1,16 @@
 import argparse
 import time
 import re
-from user_scanner.core.orchestrator import run_checks, load_modules , generate_permutations, load_categories
+from user_scanner.cli import printer
+from user_scanner.core.orchestrator import generate_permutations, load_categories
 from colorama import Fore, Style
-from .cli import banner
-from .cli.banner import print_banner
+from user_scanner.cli.banner import print_banner
+from typing import List
+from user_scanner.core.result import Result
+from user_scanner.core.utils import is_last_value
 
 MAX_PERMUTATIONS_LIMIT = 100 # To prevent excessive generation
 
-def list_modules(category=None):
-    categories = load_categories()
-    categories_to_list = [category] if category else categories.keys()
-
-    for cat_name in categories_to_list:
-        path = categories[cat_name]
-        modules = load_modules(path)
-        print(Fore.MAGENTA +
-            f"\n== {cat_name.upper()} SITES =={Style.RESET_ALL}")
-        for module in modules:
-            site_name = module.__name__.split(".")[-1]
-            print(f"  - {site_name}")
-
-
 def main():
     parser = argparse.ArgumentParser(
         prog="user-scanner",
@@ -43,91 +32,127 @@ def main():
     parser.add_argument(
         "-v", "--verbose", action="store_true", help="Enable verbose output"
     )
-    
+
     parser.add_argument(
         "-p", "--permute",type=str,help="Generate username permutations using a string pattern (e.g -p 234)"
     )
     parser.add_argument(
         "-s", "--stop",type=int,default=MAX_PERMUTATIONS_LIMIT,help="Limit the number of username permutations generated"
     )
-    
+
     parser.add_argument(
         "-d", "--delay",type=float,default=0,help="Delay in seconds between requests (recommended: 1-2 seconds)"
     )
-    
+
+    parser.add_argument(
+        "-f", "--format", choices=["console", "csv", "json"], default="console", help="Specify the output format (default: console)"
+    )
+
+    parser.add_argument(
+        "-o", "--output", type=str, help="Specify the output file"
+    )
+
     args = parser.parse_args()
-        
+
+    Printer = printer.Printer(args.format)
+
     if args.list:
-        list_modules(args.category)
+        Printer.print_modules(args.category)
         return
-    
+
     if not args.username:
         parser.print_help()
         return
-        
-    # Special username checks before run
-    if (args.module == "x" or args.category == "social"):
-        if re.search(r"[^a-zA-Z0-9._-]", args.username):
-            print(
-                Fore.RED + f"[!] Username '{args.username}' contains unsupported special characters. X (Twitter) doesn't support these." + Style.RESET_ALL)
-    if (args.module == "bluesky" or args.category == "social"):
-        if re.search(r"[^a-zA-Z0-9\.-]", args.username):
-            print(
-                Fore.RED + f"[!] Username '{args.username}' contains unsupported special characters. Bluesky will throw error. (Supported: only hyphens and digits)" + Style.RESET_ALL + "\n")
-    print_banner()
 
-    if args.permute and args.delay == 0:
+
+    if Printer.is_console:
+        print_banner()
+
+    if args.permute and args.delay == 0 and Printer.is_console:
         print(
         Fore.YELLOW
         + "[!] Warning: You're generating multiple usernames with NO delay between requests. "
         "This may trigger rate limits or IP bans. Use --delay 1 or higher. (Use only if the sites throw errors otherwise ignore)\n"
         + Style.RESET_ALL)
-        
+
     usernames = [args.username]  # Default single username list
-    
+
     #Added permutation support , generate all possible permutation of given sequence.
     if args.permute:
         usernames = generate_permutations(args.username, args.permute , args.stop)
-        print(Fore.CYAN + f"[+] Generated {len(usernames)} username permutations" + Style.RESET_ALL)
+        if Printer.is_console:
+            print(
+                Fore.CYAN + f"[+] Generated {len(usernames)} username permutations" + Style.RESET_ALL)
 
-    
-    
     if args.module and "." in args.module:
         args.module = args.module.replace(".", "_")
 
+    def run_all_usernames(func, arg = None) -> List[Result]:
+        """
+        Executes a function for all given usernames.
+        Made in order to simplify main()
+        """
+        results = []
+        print(Printer.get_start())
+        for i, name in enumerate(usernames):
+            is_last = i == len(usernames) - 1
+            if arg == None:
+                results.extend(func(name, Printer, is_last))
+            else:
+                results.extend(func(arg, name, Printer, is_last))
+            if args.delay > 0 and not is_last:
+                time.sleep(args.delay)
+        if Printer.is_json:
+            print(Printer.get_end())
+        return results
+
+    results =  []
 
     if args.module:
         # Single module search across all categories
-        found = False
-        for cat_path in load_categories().values():
-            modules = load_modules(cat_path)
+        from user_scanner.core.orchestrator import run_module_single, find_module
+        modules = find_module(args.module)
+
+        if len(modules) > 0:
             for module in modules:
-                site_name = module.__name__.split(".")[-1]
-                if site_name.lower() == args.module.lower():
-                    from user_scanner.core.orchestrator import run_module_single
-                    for name in usernames:   # <-- permutation support here
-                        run_module_single(module, name)
-                        if args.delay > 0:
-                            time.sleep(args.delay)
-                    found = True
-        if not found:
+                results.extend(run_all_usernames(run_module_single, module))
+        else:
             print(
                 Fore.RED + f"[!] Module '{args.module}' not found in any category." + Style.RESET_ALL)
+
     elif args.category:
         # Category-wise scan
         category_package = load_categories().get(args.category)
         from user_scanner.core.orchestrator import run_checks_category
-        
-        for name in usernames:   # <-- permutation support here
-            run_checks_category(category_package, name, args.verbose)
-            if args.delay > 0:
-                time.sleep(args.delay)
+        results = run_all_usernames(run_checks_category, category_package)
+
     else:
         # Full scan
-        for name in usernames:
-            run_checks(name)
-            if args.delay > 0:
-                time.sleep(args.delay)
+        from user_scanner.core.orchestrator import run_checks
+        results = run_all_usernames(run_checks)
+
+    if not args.output:
+        return
+
+    if args.output and Printer.is_console:
+        msg = (
+            "\n[!] The console format cannot be "
+            f"written to file: '{args.output}'."
+        )
+        print(Fore.RED + msg + Style.RESET_ALL)
+        return
+
+    content = Printer.get_start()
+
+    for i,result in enumerate(results):
+        char = "" if Printer.is_csv or is_last_value(results, i) else ","
+        content += "\n" + Printer.get_result_output(result) + char
+
+    if Printer.is_json:
+        content += "\n" + Printer.get_end()
+
+    with open(args.output, "a", encoding="utf-8") as f:
+        f.write(content)
 
 
 if __name__ == "__main__":

user_scanner-1.0.9.0/user_scanner/cli/printer.py

@@ -0,0 +1,117 @@
+from colorama import Fore, Style
+from typing import Literal
+from user_scanner.core.result import Result, Status
+
+INDENT = "  "
+CSV_HEADER = "username,category,site_name,status,url,reason"
+
+
+def indentate(msg: str, indent: int):
+    if indent <= 0:
+        return msg
+    tabs = INDENT * indent
+    return "\n".join([f"{tabs}{line}" for line in msg.split("\n")])
+
+
+class Printer:
+    def __init__(self, format: Literal["console", "csv", "json"]) -> None:
+        if not format in ["console", "csv", "json"]:
+            raise ValueError(f"Invalid output-format: {format}")
+        self.mode: str = format
+        self.indent: int = 0
+
+    @property
+    def is_console(self) -> bool:
+        return self.mode == "console"
+
+    @property
+    def is_csv(self) -> bool:
+        return self.mode == "csv"
+
+    @property
+    def is_json(self) -> bool:
+        return self.mode == "json"
+
+    def get_start(self, json_char: str = "[") -> str:
+        if self.is_json:
+            self.indent += 1
+            return indentate(json_char, self.indent - 1)
+        elif self.is_csv:
+            return CSV_HEADER
+        return ""
+
+    def get_end(self, json_char: str = "]") -> str:
+        if not self.is_json:
+            return
+        self.indent = max(self.indent - 1, 0)
+        return indentate(json_char, self.indent)
+
+    def get_result_output(self, result: Result) -> str:
+        #In principle result should always have this
+        site_name = result.site_name
+        username = result.username
+
+        match (result.status, self.mode):
+            case (Status.AVAILABLE, "console"):
+                return f"{INDENT}{Fore.GREEN}[✔] {site_name} ({username}): Available{Style.RESET_ALL}"
+
+            case (Status.TAKEN, "console"):
+                return f"{INDENT}{Fore.RED}[✘] {site_name} ({username}): Taken{Style.RESET_ALL}"
+
+            case (Status.ERROR, "console"):
+                reason = ""
+                if isinstance(result, Result) and result.has_reason():
+                    reason = f" ({result.get_reason()})"
+                return f"{INDENT}{Fore.YELLOW}[!] {site_name} ({username}): Error{reason}{Style.RESET_ALL}"
+
+            case (_, "json"):
+                return indentate(result.to_json().replace("\t", INDENT), self.indent)
+
+            case (_, "csv"):
+                return result.to_csv()
+
+        return ""
+
+    def print_modules(self, category: str | None = None):
+        from user_scanner.core.orchestrator import load_categories, load_modules
+        categories = load_categories()
+        categories_to_list = [category] if category else categories.keys()
+
+        # Print the start
+        if self.is_json:
+            print(self.get_start("{"))
+        elif self.is_csv:
+            print("category,site_name")
+
+        for i, cat_name in enumerate(categories_to_list):
+            path = categories[cat_name]
+            modules = load_modules(path)
+
+            # Print for each category
+            match self.mode:
+                case "console":
+                    print(Fore.MAGENTA +
+                          f"\n== {cat_name.upper()} SITES =={Style.RESET_ALL}")
+                case "json":
+                    print(self.get_start(f"\"{cat_name}\": ["))
+
+            for j, module in enumerate(modules):
+                is_last = j == len(modules) - 1
+                site_name = module.__name__.split(".")[-1].capitalize()
+
+                # Print for each site name
+                match self.mode:
+                    case "console":
+                        print(f"{INDENT}- {site_name}")
+                    case "json":
+                        msg = f"\"{site_name}\"" + ("" if is_last else ",")
+                        print(indentate(msg, self.indent))
+                    case "csv":
+                        print(f"{cat_name},{site_name}")
+
+            if self.is_json:
+                is_last = i == len(categories_to_list) - 1
+                print(self.get_end("]" if is_last else "],"))
+
+        if self.is_json:
+            print(self.get_end("}"))

user_scanner-1.0.9.0/user_scanner/community/__init__.py

@@ -0,0 +1 @@
+# community

user_scanner-1.0.9.0/user_scanner/community/stackoverflow.py

@@ -0,0 +1,35 @@
+from user_scanner.core.orchestrator import generic_validate
+from user_scanner.core.result import Result
+
+def validate_stackoverflow(user: str) -> Result:
+    url = f"https://stackoverflow.com/users/filter?search={user}"
+
+    def process(response):
+        if response.status_code == 200:
+            text = response.text
+
+            if "No users matched your search." in text:
+                return Result.available()
+
+            pattern = f'>{user}<'
+            if pattern in text:
+                return Result.taken()
+
+            return Result.available()
+
+        return Result.error("Unexpected status code from Stack Overflow")
+
+    return generic_validate(url, process)
+
+
+if __name__ == "__main__":
+    user = input("Username?: ").strip()
+    result = validate_stackoverflow(user)
+
+    if result == Result.available():
+        print("Available!")
+    elif result == Result.taken():
+        print("Unavailable!")
+    else:
+        msg = result.get_reason()
+        print("Error occurred!" + msg)

{user_scanner-1.0.8.0 → user_scanner-1.0.9.0}/user_scanner/core/orchestrator.py

@@ -1,15 +1,14 @@
 import importlib
+import importlib.util
 from colorama import Fore, Style
-import threading
+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, AnyResult
 from typing import Callable, Dict, List
-
-lock = threading.Condition()
-# Basically which thread is the one to print
-print_queue = 0
+from user_scanner.core.utils import get_site_name, is_last_value
 
 
 def load_modules(category_path: Path):
@@ -38,75 +37,105 @@ def load_categories() -> Dict[str, Path]:
     return categories
 
 
-def worker_single(module, username, i):
-    global print_queue
+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:
     func = next((getattr(module, f) for f in dir(module)
                  if f.startswith("validate_") and callable(getattr(module, f))), None)
-    site_name = module.__name__.split('.')[-1].capitalize().replace("_", ".")
-    if site_name == "X":
-        site_name = "X (Twitter)"
 
-    output = ""
-    if func:
-        try:
-            result = func(username)
-            reason = ""
+    site_name = get_site_name(module)
 
-            if isinstance(result, Result) and result.has_reason():
-                reason = f" ({result.get_reason()})"
+    if not func:
+        return Result.error(f"{site_name} has no validate_ function", site_name=site_name, username=username)
 
-            if result == 1:
-                output = f"  {Fore.GREEN}[✔] {site_name} ({username}): Available{Style.RESET_ALL}"
-            elif result == 0:
-                output = f"  {Fore.RED}[✘] {site_name} ({username}): Taken{Style.RESET_ALL}"
-            else:
-                output = f"  {Fore.YELLOW}[!] {site_name} ({username}): Error{reason}{Style.RESET_ALL}"
-        except Exception as e:
-            output = f"  {Fore.YELLOW}[!] {site_name}: Exception - {e}{Style.RESET_ALL}"
-    else:
-        output = f"  {Fore.YELLOW}[!] {site_name} has no validate_ function{Style.RESET_ALL}"
+    try:
+        result: Result = func(username)
+        result.update(site_name=site_name, username=username)
+        return result
+    except Exception as e:
+        return Result.error(e, site_name=site_name, username=username)
 
-    with lock:
-        # Waits for in-order printing
-        while i != print_queue:
-            lock.wait()
 
-        print(output)
-        print_queue += 1
-        lock.notify_all()
+def run_module_single(module, username: str, printer: Printer, last: bool = True) -> List[Result]:
+    result = worker_single(module, username)
 
+    category = find_category(module)
+    if category:
+        result.update(category=category)
 
-def run_module_single(module, username):
-    # Just executes as if it was a thread
-    worker_single(module, username, print_queue)
+    site_name = get_site_name(module)
+    msg = printer.get_result_output(result)
+    if last == False and printer.is_json:
+        msg += ","
+    print(msg)
 
+    return [result]
 
-def run_checks_category(category_path:Path, username:str, verbose=False):
-    global print_queue
 
+
+def run_checks_category(category_path: Path, username: str, printer: Printer, last: bool = True) -> List[Result]:
     modules = load_modules(category_path)
+
     category_name = category_path.stem.capitalize()
-    print(f"{Fore.MAGENTA}== {category_name} SITES =={Style.RESET_ALL}")
+    if printer.is_console:
+        print(f"\n{Fore.MAGENTA}== {category_name} SITES =={Style.RESET_ALL}")
 
-    print_queue = 0
+    results = []
 
-    threads = []
-    for i, module in enumerate(modules):
-        t = threading.Thread(target=worker_single, args=(module, username, i))
-        threads.append(t)
-        t.start()
+    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)
+            results.append(result)
 
-    for t in threads:
-        t.join()
+            is_last = last and is_last_value(modules, i)
+            site_name = get_site_name(modules[i])
+            msg = printer.get_result_output(result)
+            if is_last == False and printer.is_json:
+                msg += ","
+            print(msg)
 
+    return results
 
-def run_checks(username):
-    print(f"\n{Fore.CYAN} Checking username: {username}{Style.RESET_ALL}\n")
 
-    for category_path in load_categories().values():
-        run_checks_category(category_path, username)
-        print()
+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}")
+
+    results = []
+
+    categories = list(load_categories().values())
+    for i, category_path in enumerate(categories):
+        last_cat: int = last and (i == len(categories) - 1)
+        temp = run_checks_category(category_path, username, printer, last_cat)
+        results.extend(temp)
+
+    return results
 
 
 def make_get_request(url: str, **kwargs) -> httpx.Response:
@@ -132,9 +161,11 @@ def generic_validate(url: str, func: Callable[[httpx.Response], AnyResult], **kw
     """
     try:
         response = make_get_request(url, **kwargs)
-        return func(response)
+        result = func(response)
+        result.url = url
+        return result
     except Exception as e:
-        return Result.error(e)
+        return Result.error(e, url=url)
 
 
 def status_validate(url: str, available: int | List[int], taken: int | List[int], **kwargs) -> Result:
@@ -161,6 +192,7 @@ def status_validate(url: str, available: int | List[int], taken: int | List[int]
 
     return generic_validate(url, inner, **kwargs)
 
+
 def generate_permutations(username, pattern, limit=None):
     """
     Generate all order-based permutations of characters in `pattern`

{user_scanner-1.0.8.0 → user_scanner-1.0.9.0}/user_scanner/core/result.py

@@ -1,6 +1,24 @@
 from enum import Enum
 from typing import Literal
 
+DEBUG_MSG = """Result {{
+  status: {status},
+  reason: "{reason}",
+  username: "{username}",
+  site_name: "{site_name}",
+  category: "{category}",
+}}"""
+
+JSON_TEMPLATE = """{{
+\t"username": "{username}",
+\t"category": "{category}",
+\t"site_name": "{site_name}",
+\t"status": "{status}",
+\t"reason": "{reason}"
+}}"""
+
+CSV_TEMPLATE = "{username},{category},{site_name},{status},{reason}"
+
 
 def humanize_exception(e: Exception) -> str:
     msg = str(e).lower()
@@ -18,23 +36,36 @@ class Status(Enum):
     AVAILABLE = 1
     ERROR = 2
 
+    def __str__(self):
+        return super().__str__().split(".")[1].capitalize()
+
 
 class Result:
-    def __init__(self, status: Status, reason: str | Exception | None = None):
+    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.update(**kwargs)
+
+    def update(self, **kwargs):
+        for field in ("username", "site_name", "category"):
+            if field in kwargs and kwargs[field] is not None:
+                setattr(self, field, kwargs[field])
+
     @classmethod
-    def taken(cls):
-        return cls(Status.TAKEN)
+    def taken(cls, **kwargs):
+        return cls(Status.TAKEN, **kwargs)
 
     @classmethod
-    def available(cls):
-        return cls(Status.AVAILABLE)
+    def available(cls, **kwargs):
+        return cls(Status.AVAILABLE, **kwargs)
 
     @classmethod
-    def error(cls, reason: str | Exception | None = None):
-        return cls(Status.ERROR, reason)
+    def error(cls, reason: str | Exception | None = None, **kwargs):
+        return cls(Status.ERROR, reason, **kwargs)
 
     @classmethod
     def from_number(cls, i: int, reason: str | Exception | None = None):
@@ -56,10 +87,28 @@ class Result:
             return ""
         if isinstance(self.reason, str):
             return self.reason
-        #Format the exception
+        # 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,
+            "reason": self.get_reason(),
+            "username": self.username,
+            "site_name": self.site_name,
+            "category": self.category
+        }
+
+    def debug(self) -> str:
+        return DEBUG_MSG.format(**self.as_dict())
+
+    def to_json(self) -> str:
+        return JSON_TEMPLATE.format(**self.as_dict())
+
+    def to_csv(self) -> str:
+        return CSV_TEMPLATE.format(**self.as_dict())
+
     def __str__(self):
         return self.get_reason()
 

user_scanner-1.0.9.0/user_scanner/core/utils.py

@@ -0,0 +1,9 @@
+def get_site_name(module) -> str:
+    name = module.__name__.split('.')[-1].capitalize().replace("_", ".")
+    if name == "X":
+        return "X (Twitter)"
+    return name
+
+
+def is_last_value(values, i: int) -> bool:
+    return i == len(values) - 1

user_scanner-1.0.8.0/user_scanner/social/youtube.py → user_scanner-1.0.9.0/user_scanner/creator/producthunt.py

@@ -1,25 +1,28 @@
-from user_scanner.core.orchestrator import status_validate
+from user_scanner.core.orchestrator import status_validate, Result
 
 
-def validate_youtube(user):
+def validate_youtube(user) -> Result:
     url = f"https://m.youtube.com/@{user}"
-
     headers = {
-        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+        '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': "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-        'Accept-Encoding': "gzip, deflate, br, zstd",
-        'device-memory': "4",
-        'sec-ch-ua': "\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"",
+        'Accept-Encoding': "identity",
+        'sec-ch-dpr': "2.75",
+        'sec-ch-viewport-width': "980",
+        'sec-ch-ua': "\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"",
         'sec-ch-ua-mobile': "?1",
-        'sec-ch-ua-full-version': "\"141.0.7390.111\"",
+        'sec-ch-ua-full-version': "\"143.0.7499.52\"",
         'sec-ch-ua-arch': "\"\"",
         'sec-ch-ua-platform': "\"Android\"",
         'sec-ch-ua-platform-version': "\"15.0.0\"",
         'sec-ch-ua-bitness': "\"\"",
         'sec-ch-ua-wow64': "?0",
-        'sec-ch-ua-full-version-list': "\"Google Chrome\";v=\"141.0.7390.111\", \"Not?A_Brand\";v=\"8.0.0.0\", \"Chromium\";v=\"141.0.7390.111\"",
+        'sec-ch-ua-full-version-list': "\"Google Chrome\";v=\"143.0.7499.52\", \"Chromium\";v=\"143.0.7499.52\", \"Not A(Brand\";v=\"24.0.0.0\"",
         'sec-ch-ua-form-factors': "\"Mobile\"",
         'upgrade-insecure-requests': "1",
+        'x-browser-channel': "stable",
+        'x-browser-year': "2025",
+        'x-browser-copyright': "Copyright 2025 Google LLC. All Rights reserved.",
         'sec-fetch-site': "none",
         'sec-fetch-mode': "navigate",
         'sec-fetch-user': "?1",
@@ -28,7 +31,7 @@ def validate_youtube(user):
         'priority': "u=0, i"
     }
 
-    status_validate(url, 404, 200, headers=headers, follow_redirects=True)
+    return status_validate(url, 404, 200, headers=headers)
 
 
 if __name__ == "__main__":
@@ -40,4 +43,5 @@ if __name__ == "__main__":
     elif result == 0:
         print("Unavailable!")
     else:
-        print("Error occured!")
+        reason = result.get_reason()
+        print(f"Error occurred! Reason: {reason}")

user_scanner-1.0.9.0/user_scanner/social/youtube.py

@@ -0,0 +1,50 @@
+from user_scanner.core.orchestrator import status_validate, Result
+
+
+def validate_youtube(user) -> Result:
+    url = f"https://m.youtube.com/@{user}"
+    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': "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+        'Accept-Encoding': "identity",
+        'sec-ch-dpr': "2.75",
+        'sec-ch-viewport-width': "980",
+        'sec-ch-ua': "\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"",
+        'sec-ch-ua-mobile': "?1",
+        'sec-ch-ua-full-version': "\"143.0.7499.52\"",
+        'sec-ch-ua-arch': "\"\"",
+        'sec-ch-ua-platform': "\"Android\"",
+        'sec-ch-ua-platform-version': "\"15.0.0\"",
+        'sec-ch-ua-model': "\"I2404\"",
+        'sec-ch-ua-bitness': "\"\"",
+        'sec-ch-ua-wow64': "?0",
+        'sec-ch-ua-full-version-list': "\"Google Chrome\";v=\"143.0.7499.52\", \"Chromium\";v=\"143.0.7499.52\", \"Not A(Brand\";v=\"24.0.0.0\"",
+        'sec-ch-ua-form-factors': "\"Mobile\"",
+        'upgrade-insecure-requests': "1",
+        'x-browser-channel': "stable",
+        'x-browser-year': "2025",
+        'x-browser-copyright': "Copyright 2025 Google LLC. All Rights reserved.",
+        'sec-fetch-site': "none",
+        'sec-fetch-mode': "navigate",
+        'sec-fetch-user': "?1",
+        'sec-fetch-dest': "document",
+        'accept-language': "en-US,en;q=0.9",
+        'priority': "u=0, i"
+    }
+
+
+    return status_validate(url, 404, 200, headers=headers)
+
+
+if __name__ == "__main__":
+    user = input("Username?: ").strip()
+    result = validate_youtube(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        reason = result.get_reason()
+        print(f"Error occurred! Reason: {reason}")
+

{user_scanner-1.0.8.0 → user_scanner-1.0.9.0}/user_scanner/version.json

@@ -1,4 +1,4 @@
 {
-"version": "1.0.8.0",
+"version": "1.0.9.0",
 "version_type": "pypi"
 }

user_scanner-1.0.8.0/user_scanner/creator/producthunt.py

@@ -1,25 +0,0 @@
-from user_scanner.core.orchestrator import status_validate
-
-
-def validate_producthunt(user):
-    url = f"https://www.producthunt.com/@{user}"
-
-    headers = {
-        'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
-        'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
-        'Accept-Encoding': "gzip, deflate, br",
-        'Accept-Language': "en-US,en;q=0.9",
-    }
-
-    status_validate(url, 404, 200, headers=headers, follow_redirects=True)
-
-if __name__ == "__main__":
-    user = input("Username?: ").strip()
-    result = validate_producthunt(user)
-
-    if result == 1:
-        print("Available!")
-    elif result == 0:
-        print("Unavailable!")
-    else:
-        print("Error occured!")