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

user_scanner/core/orchestrator.py

@@ -1,93 +1,144 @@
 import importlib
-import pkgutil
+import importlib.util
 from colorama import Fore, Style
-import threading
-
+from concurrent.futures import ThreadPoolExecutor
+from itertools import permutations
 import httpx
-from httpx import ConnectError, TimeoutException
-
-lock = threading.Condition()
-#Basically which thread is the one to print
-print_queue = 0
+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
+from user_scanner.core.utils import get_site_name, is_last_value
 
-def load_modules(package):
 
+def load_modules(category_path: Path):
     modules = []
-    for _, name, _ in pkgutil.iter_modules(package.__path__, package.__name__ + "."):
-        try:
-            module = importlib.import_module(name)
-            modules.append(module)
-        except Exception as e:
-            print(f"Failed to import {name}: {e}")
+    for file in category_path.glob("*.py"):
+        if file.name == "__init__.py":
+            continue
+        spec = importlib.util.spec_from_file_location(file.stem, str(file))
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+
+        modules.append(module)
     return modules
 
-def worker_single(module, username, i):
-    global print_queue
 
+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 \
+                not subfolder.name.lower() 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:
     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)
-            if result == 1:
-                output = f"  {Fore.GREEN}[✔] {site_name}: Available{Style.RESET_ALL}"
-            elif result == 0:
-                output = f"  {Fore.RED}[✘] {site_name}: Taken{Style.RESET_ALL}"
-            else:
-                output = f"  {Fore.YELLOW}[!] {site_name}: Error{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}"
-
-    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):
-    #Just executes as if it was a thread
-    worker_single(module, username, print_queue)
-    
-def run_checks_category(package, username, verbose=False):
-    global print_queue
-    
-    modules = load_modules(package)
-    category_name = package.__name__.split('.')[-1].capitalize()
-    print(f"{Fore.MAGENTA}== {category_name} SITES =={Style.RESET_ALL}")
-
-    print_queue = 0
-
-    threads = []
-    for i, module in enumerate(modules):
-        t = threading.Thread(target=worker_single, args=(module, username, i))
-        threads.append(t)
-        t.start()
-
-    for t in threads:
-        t.join()
-
-def run_checks(username):
-    from user_scanner import dev, social, creator, community, gaming, donation
-
-    packages = [dev, social, creator, community, gaming, donation]
-
-    print(f"\n{Fore.CYAN} Checking username: {username}{Style.RESET_ALL}\n")
-
-    for package in packages:
-        run_checks_category(package, username)
-        print()
-
-def make_get_request(url, **kwargs):
+
+    site_name = get_site_name(module)
+
+    if not func:
+        return Result.error(f"{site_name} has no validate_ function", site_name=site_name, username=username)
+
+    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)
+
+
+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)
+
+    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, printer: Printer, last: bool = True) -> List[Result]:
+    modules = load_modules(category_path)
+
+    category_name = category_path.stem.capitalize()
+    if printer.is_console:
+        print(f"\n{Fore.MAGENTA}== {category_name} SITES =={Style.RESET_ALL}")
+
+    results = []
+
+    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)
+
+            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: 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:
     """Simple wrapper to **httpx.get** that predefines headers and timeout"""
     if not "headers" in kwargs:
         kwargs["headers"] = {
@@ -103,38 +154,59 @@ def make_get_request(url, **kwargs):
 
     return httpx.get(url, **kwargs)
 
-def generic_validate(url, func, **kwargs):
+
+def generic_validate(url: str, func: Callable[[httpx.Response], AnyResult], **kwargs) -> AnyResult:
     """
     A generic validate function that makes a request and executes the provided function on the response.
     """
     try:
         response = make_get_request(url, **kwargs)
-        return func(response)
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception:
-        return 2
-    
-def status_validate(url, available, taken, **kwargs):
+        result = func(response)
+        result.url = url
+        return result
+    except Exception as e:
+        return Result.error(e, url=url)
+
+
+def status_validate(url: str, available: int | List[int], taken: int | List[int], **kwargs) -> Result:
     """
     Function that takes a **url** and **kwargs** for the request and 
     checks if the request status matches the availabe or taken.
     **Available** and **Taken** must either be whole numbers or lists of whole numbers.
     """
-    def inner(response):
-        #Checks if a number is equal or is contained inside
-        contains = lambda a,b: (isinstance(a,list) and b in a) or (a == b)
-
+    def inner(response: httpx.Response):
+        # Checks if a number is equal or is contained inside
+        def contains(a, b): return (isinstance(a, list) and b in a) or (a == b)
         status = response.status_code
         available_value = contains(available, status)
         taken_value = contains(taken, status)
 
         if available_value and taken_value:
-            return 2 # Can't be both available and taken
+            # Can't be both available and taken
+            return Result.error("Invalid status match. Report this on Github.")
         elif available_value:
-            return 1
+            return Result.available()
         elif taken_value:
-            return 0
-        return 2
+            return Result.taken()
+        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

@@ -0,0 +1,128 @@
+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()
+
+    if "10054" in msg:
+        return "Connection closed by remote server"
+    if "11001" in msg:
+        return "Could not resolve hostname"
+
+    return str(e)
+
+
+class Status(Enum):
+    TAKEN = 0
+    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, **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, **kwargs):
+        return cls(Status.TAKEN, **kwargs)
+
+    @classmethod
+    def available(cls, **kwargs):
+        return cls(Status.AVAILABLE, **kwargs)
+
+    @classmethod
+    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):
+        try:
+            status = Status(i)
+        except ValueError:
+            return cls(Status.ERROR, "Invalid status. Please contact maintainers.")
+
+        return cls(status,  reason if status == Status.ERROR else None)
+
+    def to_number(self) -> int:
+        return self.status.value
+
+    def has_reason(self) -> bool:
+        return self.reason != None
+
+    def get_reason(self) -> str:
+        if self.reason == None:
+            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,
+            "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()
+
+    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
+
+
+AnyResult = Literal[0, 1, 2] | Result

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/creator/devto.py

@@ -1,17 +1,19 @@
-from ..core.orchestrator import status_validate
+from user_scanner.core.orchestrator import status_validate
+
 
 def validate_devto(user):
-   url = f"https://dev.to/{user}"
+    url = f"https://dev.to/{user}"
+
+    return status_validate(url, 404, 200, follow_redirects=True)
 
-   return status_validate(url, 404, 200, follow_redirects = True)
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_devto(user)
+    user = input("Username?: ").strip()
+    result = validate_devto(user)
 
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occurred!")
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occurred!")

user_scanner/creator/hashnode.py

@@ -1,21 +1,21 @@
 import httpx
-import json
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.result import Result
+
 
 def validate_hashnode(user):
     url = "https://hashnode.com/utility/ajax/check-username"
 
     payload = {
-      "username": user,
-      "name": "Dummy Dummy"
+        "username": user,
+        "name": "Dummy Dummy"
     }
 
     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",
-      'Accept': "application/json",
-      'Content-Type': "application/json",
-      'Origin': "https://hashnode.com",
-      'Referer': "https://hashnode.com/signup",
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+        'Accept': "application/json",
+        'Content-Type': "application/json",
+        'Origin': "https://hashnode.com",
+        'Referer': "https://hashnode.com/signup",
     }
 
     try:
@@ -26,29 +26,26 @@ def validate_hashnode(user):
 
             if 'status' in data:
                 if data['status'] == 1:
-                    return 1
+                    return Result.available()
                 elif data['status'] == 0:
-                    return 0
+                    return Result.taken()
 
-            return 2
+            return Result.error("Status not found")
 
         else:
-           return 2
+            return Result.error("Invalid status code")
+
+    except Exception as e:
+        return Result.error(e)
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except json.JSONDecodeError:
-        return 2
-    except Exception:
-        return 2
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_hashnode(user)
-
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occurred!")
+    user = input("Username?: ").strip()
+    result = validate_hashnode(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occurred!")

user_scanner/creator/itch_io.py

@@ -1,22 +1,19 @@
-from ..core.orchestrator import status_validate
+from user_scanner.core.orchestrator import status_validate
 
-def validate_itch_io(user):
-    """
-    Checks if a itch.io username is available.
-    Returns: 1 -> available, 0 -> taken, 2 -> error
-    """
 
+def validate_itch_io(user):
     url = f"https://{user}.itch.io"
 
-    return  status_validate(url, 404, 200, follow_redirects = True)
+    return status_validate(url, 404, 200, follow_redirects=True)
+
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_itch_io(user)
+    user = input("Username?: ").strip()
+    result = validate_itch_io(user)
 
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occurred!")
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occurred!")

user_scanner/creator/kaggle.py

@@ -1,18 +1,19 @@
-from ..core.orchestrator import status_validate
+from user_scanner.core.orchestrator import status_validate
+
 
 def validate_kaggle(user):
-   url = f"https://www.kaggle.com/{user}"
+    url = f"https://www.kaggle.com/{user}"
 
-   return status_validate(url, 404, 200, follow_redirects=True)
+    return status_validate(url, 404, 200, follow_redirects=True)
 
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_kaggle(user)
+    user = input("Username?: ").strip()
+    result = validate_kaggle(user)
 
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occurred!")
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occurred!")

user_scanner/creator/medium.py

@@ -1,5 +1,6 @@
-import httpx
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.orchestrator import generic_validate
+from user_scanner.core.result import Result
+
 
 def validate_medium(user):
     url = f"https://medium.com/@{user}"
@@ -9,33 +10,28 @@ def validate_medium(user):
         'Accept': "text/html",
     }
 
-    try:
-        response = httpx.get(url, headers=headers, timeout=3.0)
-
+    def process(response):
         if response.status_code == 200:
             html_text = response.text
 
-
             username_tag = f'property="profile:username" content="{user}"'
 
             if username_tag in html_text:
-                return 0
+                return Result.taken()
             else:
-                return 1
-        return 2
+                return Result.available()
+        return Result.error()
+
+    return generic_validate(url, process, headers=headers)
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception:
-        return 2
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_medium(user)
-
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occurred!")
+    user = input("Username?: ").strip()
+    result = validate_medium(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occurred!")