user-scanner 1.0.2.1__py3-none-any.whl → 1.0.9.0__py3-none-any.whl

user_scanner/__init__.py

@@ -1 +0,0 @@
-

user_scanner/__main__.py

@@ -1,38 +1,15 @@
 import argparse
+import time
 import re
-from user_scanner.core.orchestrator import run_checks, load_modules
+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
-
-
-CATEGORY_MAPPING = {
-    "dev": "dev",
-    "social": "social",
-    "creator": "creator",
-    "community": "community",
-    "gaming": "gaming"
-}
-
-def list_modules(category=None):
-    from user_scanner import dev, social, creator, community, gaming
-    packages = {
-        "dev": dev,
-        "social": social,
-        "creator": creator,
-        "community": community,
-        "gaming": gaming
-    }
-
-    categories_to_list = [category] if category else packages.keys()
-
-    for cat_name in categories_to_list:
-        package = packages[cat_name]
-        modules = load_modules(package)
-        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}")
+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 main():
     parser = argparse.ArgumentParser(
@@ -43,7 +20,7 @@ def main():
         "-u", "--username",  help="Username to scan across platforms"
     )
     parser.add_argument(
-        "-c", "--category", choices=CATEGORY_MAPPING.keys(),
+        "-c", "--category", choices=load_categories().keys(),
         help="Scan all platforms in a category"
     )
     parser.add_argument(
@@ -56,51 +33,127 @@ def main():
         "-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
 
-
-    # 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")
     if not args.username:
-       parser.print_help()
-       return
-    else:
-       print_banner()
+        parser.print_help()
+        return
 
 
-    from user_scanner import dev, social, creator, community, gaming
+    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)
+        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
-        packages = [dev, social, creator, community, gaming]
-        found = False
-        for package in packages:
-            modules = load_modules(package)
+        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
-                    run_module_single(module, args.username)
-                    found = True
-        if not found:
-            print(Fore.RED + f"[!] Module '{args.module}' not found in any category." + Style.RESET_ALL)
+                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 = eval(CATEGORY_MAPPING[args.category])
+        category_package = load_categories().get(args.category)
         from user_scanner.core.orchestrator import run_checks_category
-        run_checks_category(category_package, args.username, args.verbose)
+        results = run_all_usernames(run_checks_category, category_package)
+
     else:
         # Full scan
-        run_checks(args.username)
+        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__":
     main()

user_scanner/cli/banner.py

@@ -23,17 +23,12 @@ INFO_BOX = f"""{C_MAGENTA}      ╔═══════════════
       ║ {C_RED}♚ {C_GREEN}Email{C_WHITE}  : kaifcodec@gmail.com         {C_MAGENTA}║
       ══════════════════════════════════════════{Style.RESET_ALL}""".strip()
 
+
 def print_banner():
     print(BANNER_ASCII)
     print(INFO_BOX)
     print(" ")
-if __name__ == "__main__":
-    print_banner()
-
-
-
-
-
-
 
 
+if __name__ == "__main__":
+    print_banner()

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/community/__init__.py

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

user_scanner/community/coderlegion.py

@@ -1,39 +1,19 @@
-import httpx
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.orchestrator import status_validate
+
 
 def validate_coderlegion(user):
     url = f"https://coderlegion.com/user/{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",
-    }
-    try:
-        response = httpx.get(url, headers=headers, timeout = 15.0)
-        status = response.status_code
-
-        if status == 200:
-           return 0
-        elif status == 404:
-           return 1
-        else:
-           return 2
+    return status_validate(url, 404, 200, timeout=15.0)
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception:
-        return 2
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_coderlegion(user)
-
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occured!")
+    user = input("Username?: ").strip()
+    result = validate_coderlegion(user)
 
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occured!")

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)