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

user_scanner/gaming/chess_com.py

@@ -1,6 +1,6 @@
-import httpx
-from httpx import ConnectError, TimeoutException
-import json
+from user_scanner.core.orchestrator import generic_validate
+from user_scanner.core.result import Result
+
 
 def validate_chess_com(user):
     url = f"https://www.chess.com/callback/user/valid?username={user}"
@@ -12,43 +12,27 @@ def validate_chess_com(user):
         'Accept-Language': "en-US,en;q=0.9",
     }
 
-    try:
-        response = httpx.get(url, headers=headers, timeout = 3.0)
-        status = response.status_code
-
-        if status == 200:
+    def process(response):
+        if response.status_code == 200:
             data = response.json()
             if data.get('valid') is True:
                 # 'valid': true means the username is NOT taken
-                return 1 
+                return Result.available()
             elif data.get('valid') is False:
                 # 'valid': false means the username IS taken
-                return 0
-            else:
-                return 2
-        else:
-           return 2
-
-    except (ConnectError, TimeoutException):
-        return 2
-    except json.JSONDecodeError:
-        return 2
-    except Exception:
-        return 2
+                return Result.taken()
+        return Result.error("Invalid status code")
+
+    return generic_validate(url, process, headers=headers)
+
 
 if __name__ == "__main__":
-   try:
-       import httpx
-   except ImportError:
-       print("Error: 'httpx' library is not installed.")
-       exit()
-
-   user = input ("Username?: ").strip()
-   result = validate_chess_com(user)
-
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occured!")
+    user = input("Username?: ").strip()
+    result = validate_chess_com(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occured!")

user_scanner/gaming/minecraft.py

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

user_scanner/gaming/monkeytype.py

@@ -1,6 +1,5 @@
-import httpx
-from httpx import ConnectError, TimeoutException
-import json
+from user_scanner.core.orchestrator import generic_validate
+from user_scanner.core.result import Result
 
 def validate_monkeytype(user: str) -> int:
 
@@ -17,11 +16,8 @@ def validate_monkeytype(user: str) -> int:
         "Accept-Language": "en-US,en;q=0.9",
     }
 
-    try:
-        response = httpx.get(url, headers=headers, timeout=3.0)
-        status = response.status_code
-
-        if status == 200:
+    def process(response):
+        if response.status_code == 200:
             data = response.json()
             # Expected shape:
             # { "message": "string", "data": { "available": true/false } }
@@ -29,29 +25,15 @@ def validate_monkeytype(user: str) -> int:
             available = payload.get("available")
 
             if available is True:
-                return 1
+                return Result.available()
             elif available is False:
-                return 0
-            else:
-                return 2
-        else:
-            return 2
+                return Result.taken()
+        return Result.error("Invalid status code")
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except json.JSONDecodeError:
-        return 2
-    except Exception:
-        return 2
+    return generic_validate(url, process, headers=headers)
 
 
 if __name__ == "__main__":
-    try:
-        import httpx  # noqa: F401
-    except ImportError:
-        print("Error: 'httpx' library is not installed.")
-        raise SystemExit(1)
-
     user = input("Username?: ").strip()
     result = validate_monkeytype(user)
 

user_scanner/gaming/osu.py

@@ -1,44 +1,19 @@
-import httpx
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.orchestrator import status_validate
+
 
 def validate_osu(user):
-    """
-    Checks if a Osu username is available.
-    Returns: 1 -> available, 0 -> taken, 2 -> error
-    """
-    
     url = f"https://osu.ppy.sh/users/{user}"
-    
-    headers = {
-        'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
-        'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        'Accept-Encoding': "gzip, deflate, br",
-        'Accept-Language': "en-US,en;q=0.9",
-        'sec-fetch-dest': "document",
-    }
-    
-    try:
-        response = httpx.get(url, headers = headers, timeout = 5.0, follow_redirects = True)
-        status = response.status_code
-        
-        if status == 200:
-            return 0 
-        elif status == 404:
-            return 1
-        else:
-            return 2
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception:
-        return 2
+
+    return status_validate(url, 404, [200, 302], follow_redirects=True)
+
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_osu(user)
+    user = input("Username?: ").strip()
+    result = validate_osu(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/gaming/roblox.py

@@ -1,48 +1,43 @@
-import httpx
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.orchestrator import generic_validate
+from user_scanner.core.result import Result
+
 
 def validate_roblox(user):
-    """
-    Checks if a roblox username is available.
-    Returns: 1 -> available, 0 -> taken, 2 -> error
-    """
-
-    url = f"https://users.roblox.com/v1/users/search?keyword={user}&limit=10" # official api
-
-    headers = {
-        'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
-        'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-        'Accept-Encoding': "gzip, deflate, br",
-        'Accept-Language': "en-US,en;q=0.9",
-        'sec-fetch-dest': "document",
-    }
-
-    try:
-        response = httpx.get(url, headers = headers, timeout = 5.5, follow_redirects = True)
-        status = response.status_code
-        search_results = response.json() # api response
-
-        if "errors" in search_results: # this usually triggers when timeout or ratelimit
-            return 2
-
-        for entry in search_results["data"]: # iterates through the entries in the search results
+    # official api
+    url = f"https://users.roblox.com/v1/users/search?keyword={user}&limit=10"
+
+    def process(response):
+        search_results = response.json()  # api response
+
+        if response.status_code == 429:
+            return Result.error("Too many requests")
+
+        if response.status_code == 400:
+            error = search_results["errors"][0] #Api states theres always an error
+            if error["code"] == 6:
+                return Result.error("Username is too short")
+            if error["code"] == 5:
+                return Result.error("Username was filtered")
+            #Shouldn't be able to reach this
+            return Result.error("Invalid username")
+
+        # iterates through the entries in the search results
+        for entry in search_results["data"]:
             # .lower() so casing from the API doesn't matter
-            if entry["name"].lower() == user.lower(): # if a username matches the user
-                return 0
-        return 1
+            if entry["name"].lower() == user.lower():  # if a username matches the user
+                return Result.taken()
+        return Result.available()
+
+    return generic_validate(url, process, follow_redirects=True)
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception as e:
-        return 2
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_roblox(user)
-
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occurred!")
+    user = input("Username?: ").strip()
+    result = validate_roblox(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occurred!")

user_scanner/gaming/steam.py

@@ -0,0 +1,29 @@
+from user_scanner.core.orchestrator import generic_validate
+from user_scanner.core.result import Result
+
+
+def validate_steam(user):
+    url = f"https://steamcommunity.com/id/{user}/"
+
+    def process(response):
+        if response.status_code == 200:
+            if "Error</title>" in response.text:
+                return Result.available()
+            else:
+                return Result.taken()
+
+        return Result.error("Invalid status code")
+
+    return generic_validate(url, process)
+
+
+if __name__ == "__main__":
+    user = input("Username?: ").strip()
+    result = validate_steam(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occurred!")

user_scanner/social/bluesky.py

@@ -1,7 +1,6 @@
-import httpx
-from httpx import ConnectError, TimeoutException
-import re
-import json
+from user_scanner.core.orchestrator import generic_validate
+from user_scanner.core.result import Result
+
 
 def validate_bluesky(user):
     handle = user if user.endswith('.bsky.social') else f"{user}.bsky.social"
@@ -26,46 +25,30 @@ def validate_bluesky(user):
         'handle': handle,
     }
 
-    if not re.fullmatch(r"^[a-zA-Z0-9\.-]{1,64}$", user):
-        return 2
-
-    try:
-        response = httpx.get(url, headers=headers, params=params, timeout = 15.0)
-        status = response.status_code
-
-        if status == 200:
+    def process(response):
+        if response.status_code == 200:
             data = response.json()
             result_type = data.get('result', {}).get('$type')
 
             if result_type == "com.atproto.temp.checkHandleAvailability#resultAvailable":
-                return 1
+                return Result.available()
             elif result_type == "com.atproto.temp.checkHandleAvailability#resultUnavailable":
-                return 0
-            else:
-                return 2
-        else:
-            return 2
+                return Result.taken()
+        elif response.status_code == 400:
+            return Result.error("Username can only contain letters, numbers, hyphens (no leading/trailing)")
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except json.JSONDecodeError:
-        return 2
-    except Exception:
-        return 2
+        return Result.error("Invalid status code!")
 
-if __name__ == "__main__":
-   try:
-       import httpx
-   except ImportError:
-       print("Error: 'httpx' library is not installed.")
-       exit()
+    return generic_validate(url, process, headers=headers, params=params, timeout=15.0)
 
-   user = input ("Username?: ").strip()
-   result = validate_bluesky(user)
 
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occured!")
+if __name__ == "__main__":
+    user = input("Username?: ").strip()
+    result = validate_bluesky(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occured!")

user_scanner/social/discord.py

@@ -1,5 +1,5 @@
 import httpx
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.result import Result
 
 def validate_discord(user):
     url = "https://discord.com/api/v9/unique-username/username-attempt-unauthed"
@@ -12,33 +12,29 @@ def validate_discord(user):
         "origin": "https://discord.com",
         "referer": "https://discord.com/register"
     }
-    
+
     data = {"username": user}
-    
+
     try:
         response = httpx.post(url, headers=headers, json=data, timeout=3.0)
         if response.status_code == 200:
             status = response.json().get("taken")
             if status is True:
-                return 0
+                return Result.taken()
             elif status is False:
-                return 1
-        return 2
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception:
-        return 2
-
-if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_discord(user)
-   
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occured!")
+                return Result.available()
+        return Result.error("Invalid status code")
+    except Exception as e:
+        return Result.error(e)
 
 
+if __name__ == "__main__":
+    user = input("Username?: ").strip()
+    result = validate_discord(user)
 
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occured!")

user_scanner/social/instagram.py

@@ -1,5 +1,5 @@
-import httpx
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.orchestrator import status_validate
+
 
 def validate_instagram(user):
     url = f"https://www.instagram.com/api/v1/users/web_profile_info/?username={user}"
@@ -14,29 +14,16 @@ def validate_instagram(user):
         'Referer': f"https://www.instagram.com/{user}/",
     }
 
-    try:
-        response = httpx.get(url, headers=headers, timeout = 3.0)
-        status = response.status_code
-
-        if status == 200:
-           return 0
-        elif status == 404:
-           return 1
-        else:
-           return 2
+    return status_validate(url, 404, 200, headers=headers)
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception:
-        return 2
 
 if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_instagram(user)
+    user = input("Username?: ").strip()
+    result = validate_instagram(user)
 
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occured!")
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occured!")

user_scanner/social/mastodon.py

@@ -1,45 +1,19 @@
-import httpx
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.orchestrator import status_validate
+
 
 def validate_mastodon(user):
     url = f"https://mastodon.social/@{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 = 3.0, follow_redirects=True)
-        status = response.status_code
-
-        if status == 200:
-           return 0
-        elif status == 404:
-           return 1
-        else:
-           return 2
+    return status_validate(url, 404, 200, follow_redirects=True)
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception:
-        return 2
 
 if __name__ == "__main__":
-   try:
-       import httpx
-   except ImportError:
-       print("Error: 'httpx' library is not installed.")
-       exit()
-
-   user = input ("Username?: ").strip()
-   result = validate_mastodon(user)
-
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occured!")
+    user = input("Username?: ").strip()
+    result = validate_mastodon(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occured!")

user_scanner/social/pinterest.py

@@ -1,42 +1,28 @@
-import httpx
-from httpx import ConnectError, TimeoutException
+from user_scanner.core.orchestrator import generic_validate
+from user_scanner.core.result import Result
 
 def validate_pinterest(user):
     url = f"https://www.pinterest.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",
-      'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-      'Accept-Encoding': "gzip",
-      'Accept-Language': "en-US,en;q=0.9",
-      'sec-fetch-dest': "document",
-    }
-
-    NOT_FOUND_STRING = "User not found."
-
-    try:
-        response = httpx.get(url, headers=headers, follow_redirects=True, timeout = 3.0)
-
+    def process(response):
         if response.status_code == 200:
-            if NOT_FOUND_STRING in response.text:
-                return 1
+            if "User not found." in response.text:
+                return Result.available()
             else:
-                return 0
+                return Result.taken()
         else:
-           return 2
+            return Result.error("Invalid status code")
 
-    except (ConnectError, TimeoutException):
-        return 2
-    except Exception:
-        return 2
+    return generic_validate(url, process, follow_redirects=True)
 
-if __name__ == "__main__":
-   user = input ("Username?: ").strip()
-   result = validate_pinterest(user)
 
-   if result == 1:
-      print("Available!")
-   elif result == 0:
-      print("Unavailable!")
-   else:
-      print("Error occured!")
+if __name__ == "__main__":
+    user = input("Username?: ").strip()
+    result = validate_pinterest(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print("Error occured!")