user-scanner 1.0.10.2__py3-none-any.whl → 1.1.0__py3-none-any.whl

user_scanner/email_scan/dev/bitbucket.py

@@ -0,0 +1,33 @@
+import httpx
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            url = "https://id.atlassian.com/rest/marketing-consent/config"
+            payload = {"email": email}
+            headers = {
+                'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36",
+                'Content-Type': "application/json",
+                'Origin': "https://id.atlassian.com",
+                'Referer': f"https://id.atlassian.com/login?email={email}"
+            }
+
+            response = await client.post(url, json=payload, headers=headers)
+
+            if response.status_code != 200:
+                return Result.error(f"Status {response.status_code}")
+
+            data = response.json()
+            is_reg = data.get("implicitConsent")
+            if is_reg is True:
+                return Result.available()
+            elif is_reg is False:
+                return Result.taken()
+            else:
+                return Result.error(f"Unexpected error occured [{response.status_code}]")
+        except Exception as e:
+            return Result.error(f"Unexpected exception:{e}")
+
+async def validate_bitbucket(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/dev/github.py

@@ -0,0 +1,72 @@
+import httpx
+import re
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=True, follow_redirects=True) as client:
+        try:
+            url1 = "https://github.com/signup"
+            headers1 = {
+                'host': 'github.com',
+                'sec-ch-ua': '"Not(A:Brand";v="8", "Chromium";v="144", "Google Chrome";v="144"',
+                'sec-ch-ua-mobile': '?0',
+                'sec-ch-ua-platform': '"Linux"',
+                'upgrade-insecure-requests': '1',
+                'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.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',
+                'sec-fetch-site': 'cross-site',
+                'sec-fetch-mode': 'navigate',
+                'sec-fetch-user': '?1',
+                'sec-fetch-dest': 'document',
+                'referer': 'https://www.google.com/',
+                'accept-encoding': 'gzip, deflate, br, zstd',
+                'accept-language': 'en-US,en;q=0.9',
+                'priority': 'u=0, i'
+            }
+
+            res1 = await client.get(url1, headers=headers1)
+            html = res1.text
+
+            csrf_match = re.search(r'data-csrf="true"\s+value="([^"]+)"', html)
+
+            if not csrf_match:
+                return Result.error("Failed to extract GitHub authenticity_token")
+
+            csrf_token = csrf_match.group(1)
+
+            url2 = "https://github.com/email_validity_checks"
+            payload = {
+                'authenticity_token': csrf_token,
+                'value': email
+            }
+
+            headers2 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
+                'Accept-Encoding': "gzip, deflate, br, zstd",
+                'sec-ch-ua-platform': '"Linux"',
+                'sec-ch-ua': '"Not(A:Brand";v="8", "Chromium";v="144", "Google Chrome";v="144"',
+                'sec-ch-ua-mobile': "?0",
+                'origin': "https://github.com",
+                'sec-fetch-site': "same-origin",
+                'sec-fetch-mode': "cors",
+                'sec-fetch-dest': "empty",
+                'referer': "https://github.com/signup",
+                'accept-language': "en-US,en;q=0.9",
+                'priority': "u=1, i"
+            }
+
+            response = await client.post(url2, data=payload, headers=headers2)
+            body = response.text
+
+            if "already associated with an account" in body:
+                return Result.taken()
+            elif response.status_code == 200 and "Email is available" in body:
+                return Result.available()
+            else:
+                return Result.error(f"Unexpected status code: {response.status_code}, report this via GitHub issues")
+
+        except Exception as e:
+            return Result.error(f"unexpected exception: {e}")
+
+async def validate_github(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/dev/huggingface.py

@@ -0,0 +1,37 @@
+import httpx
+from user_scanner.core.result import Result
+
+
+async def _check(email: str) -> Result:
+    url = "https://huggingface.co/api/check-user-email"
+    params = {'email': email}
+    headers = {
+        'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+        'Accept-Encoding': "identity",
+        'referer': "https://huggingface.co/join",
+        'priority': "u=1, i"
+    }
+
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            response = await client.get(url, params=params, headers=headers, timeout=5)
+
+            if response.status_code == 429:
+                return Result.error("Rate limited wait for few minutes")
+
+            if response.status_code == 400:
+                data = response.json()
+                if "already exists" in data.get("error", ""):
+                    return Result.taken()
+
+            if response.status_code == 200:
+                return Result.available()
+
+            return Result.error(f"HTTP Error: {response.status_code}")
+
+        except Exception as e:
+            return Result.error(e)
+
+
+async def validate_huggingface(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/shopping/ebay.py.lock

@@ -0,0 +1,97 @@
+import httpx
+import re
+import asyncio
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=True, follow_redirects=False) as client:
+        try:
+            # --- Step 1: GET landing page ---
+            url1 = "https://signin.ebay.com/signin/"
+            headers1 = {
+                'host': 'signin.ebay.com',
+                'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+                'sec-ch-ua-mobile': '?1',
+                'sec-ch-ua-platform': '"Android"',
+                'upgrade-insecure-requests': '1',
+                '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',
+                'sec-fetch-site': 'cross-site',
+                'sec-fetch-mode': 'navigate',
+                'sec-fetch-user': '?1',
+                'sec-fetch-dest': 'document',
+                'referer': 'https://www.google.com/',
+                'accept-encoding': 'gzip, deflate, br, zstd',
+                'accept-language': 'en-US,en;q=0.9',
+                'priority': 'u=0, i'
+            }
+            
+            res1 = await client.get(url1, headers=headers1)
+            html = res1.text
+            
+            # Type-safe extraction for mypy
+            srt_match = re.search(r'name=srt\s+id=srt\s+value=([^\s>]+)', html)
+            if not srt_match:
+                # Quoted fallback
+                srt_match = re.search(r'name="srt".*?value="([^"]+)"', html)
+            
+            if not srt_match:
+                return Result.error("Failed to extract srt")
+                
+            srt = srt_match.group(1)
+
+            # --- Step 2: Identification POST ---
+            url2 = "https://signin.ebay.com/signin/srv/identifer"
+            
+            payload = {
+                'identifier': email,
+                'srt': srt,
+                'webAuthNOptedInKeys': "",
+                'webAuthNCredCheck': "true",
+                'useCase': "AUTH",
+                'flowType': "PSI"
+            }
+
+            headers2 = {
+                '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-Encoding': "gzip, deflate, br, zstd",
+                'x-ebay-requested-with': "XMLHttpRequest",
+                'sec-ch-ua-platform': '"Android"',
+                'x-ebay-c-trackable-id': "01KFK31DZY0KKB2Y0HA1B00DWH",
+                'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+                'sec-ch-ua-model': '"I2404"',
+                'sec-ch-ua-mobile': "?1",
+                'x-requested-with': "XMLHttpRequest",
+                'sec-ch-ua-full-version': '"143.0.7499.192"',
+                'sec-ch-ua-platform-version': '"15.0.0"',
+                'origin': "https://signin.ebay.com",
+                'sec-fetch-site': "same-origin",
+                'sec-fetch-mode': "cors",
+                'sec-fetch-dest': "empty",
+                'referer': "https://signin.ebay.com/signin/",
+                'accept-language': "en-US,en;q=0.9",
+                'priority': "u=1, i"
+            }
+
+            # Optional: Short sleep to mimic human timing before POST
+            await asyncio.sleep(1)
+            
+            response = await client.post(url2, data=payload, headers=headers2)
+            
+            if response.status_code == 483:
+                return Result.error("Security challenge (483)")
+                
+            data = response.json()
+
+            if data.get("signinErrorUpdate") is True and "couldn't find this eBay account" in str(data.get("errorMsg", "")):
+                return Result.available()
+            elif data.get("signinErrorUpdate") is False or "publicUserId" in data:
+                return Result.taken()
+            else:
+                return Result.error("unexpected.... Report it via github issues...")
+
+        except Exception as e:
+            return Result.error(f"unexpected exception: {e}")
+
+async def validate_ebay(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/shopping/flipkart.py

@@ -0,0 +1,52 @@
+import httpx
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    url = "https://1.rome.api.flipkart.com/1/action/view"
+
+    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",
+        'Content-Type': "application/json",
+        'X-User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 FKUA/msite/0.0.3/msite/Mobile channelType/undefined",
+        'Origin': "https://www.flipkart.com",
+        'Referer': "https://www.flipkart.com/"
+    }
+
+    payload = {
+        "actionRequestContext": {
+            "type": "LOGIN_IDENTITY_VERIFY",
+            "loginIdPrefix": "",
+            "loginId": email,
+            "clientQueryParamMap": {"ret": "/"},
+            "loginType": "EMAIL",
+            "verificationType": "PASSWORD",
+            "screenName": "LOGIN_V4_EMAIL",
+            "sourceContext": "DEFAULT"
+        }
+    }
+
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            response = await client.post(url, json=payload, headers=headers)
+
+            if response.status_code == 429:
+                return Result.error("Rate limited wait for few minutes")
+
+            if response.status_code != 200:
+                return Result.error(f"HTTP Error: {response.status_code}")
+
+            response_text = response.text
+
+            if "Looks like you're new here!" in response_text:
+                return Result.available()
+
+            if "LOGIN_P_CHECK" in response_text or '"statusSuccess":true' in response_text:
+                return Result.taken()
+
+            return Result.taken()
+
+        except Exception as e:
+            return Result.error(e)
+
+async def validate_flipkart(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/social/facebook.py

@@ -0,0 +1,96 @@
+import httpx
+import re
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=True, follow_redirects=False) as client:
+        try:
+            url1 = "https://m.facebook.com/login/"
+            headers1 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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': "identity",
+                'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+            }
+            await client.get(url1, headers=headers1)
+
+            url2 = "https://www.facebook.com"
+            params2 = {'_rdr': ""}
+            headers2 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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': "identity",
+                'upgrade-insecure-requests': "1",
+                'sec-fetch-site': "cross-site",
+                'sec-fetch-mode': "navigate",
+                'sec-fetch-user': "?1",
+                'sec-fetch-dest': "document",
+                'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+                'sec-ch-ua-mobile': "?0",
+                'sec-ch-ua-platform': '"Linux"',
+                'referer': "https://www.google.com/",
+                'accept-language': "en-US,en;q=0.9",
+                'priority': "u=0, i"
+            }
+            res2 = await client.get(url2, params=params2, headers=headers2)
+            html = res2.text
+
+            j_match = re.search(r'name="jazoest" value="(\d+)"', html)
+            l_match = re.search(r'name="lsd" value="([^"]+)"', html)
+
+            if not j_match or not l_match:
+                return Result.error("Failed to extract tokens (LSD/Jazoest)")
+
+            jazoest = j_match.group(1)
+            lsd = l_match.group(1)
+
+            url3 = "https://www.facebook.com/ajax/login/help/identify.php"
+            params3 = {'ctx': "recover"}
+
+            payload3 = {
+                'jazoest': jazoest,
+                'lsd': lsd,
+                'email': email,
+                'did_submit': "1",
+                '__user': "0",
+                '__a': "1",
+                '__req': "7"
+            }
+
+            headers3 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+                'Accept-Encoding': "identity",
+                'sec-ch-ua-full-version-list': '"Google Chrome";v="143.0.7499.192", "Chromium";v="143.0.7499.192", "Not A(Brand";v="24.0.0.0"',
+                'sec-ch-ua-platform': '"Linux"',
+                'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+                'sec-ch-ua-model': '""',
+                'sec-ch-ua-mobile': "?0",
+                'x-asbd-id': "359341",
+                'x-fb-lsd': lsd,
+                'sec-ch-prefers-color-scheme': "dark",
+                'sec-ch-ua-platform-version': '""',
+                'origin': "https://www.facebook.com",
+                'sec-fetch-site': "same-origin",
+                'sec-fetch-mode': "cors",
+                'sec-fetch-dest': "empty",
+                'referer': "https://www.facebook.com/login/identify/?ctx=recover&ars=facebook_login&from_login_screen=0",
+                'accept-language': "en-US,en;q=0.9",
+                'priority': "u=1, i"
+            }
+
+            response = await client.post(url3, params=params3, data=payload3, headers=headers3)
+            body = response.text
+
+            if "redirectPageTo" in body and "ServerRedirect" in body:
+                return Result.taken()
+            elif "No search results" in body or "Your search did not return any results." in body:
+                return Result.available()
+            else:
+                return Result.error("Unexpected error, report it via GitHub issues")
+
+        except Exception as e:
+            return Result.error(f"Unexpected exception: {e}")
+
+async def validate_facebook(email: str) -> Result:
+    return await _check(email)
+

user_scanner/email_scan/social/instagram.py

@@ -0,0 +1,48 @@
+import httpx
+from user_scanner.core.result import Result
+
+
+async def _check(email):
+    USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+    async with httpx.AsyncClient(headers={"user-agent": USER_AGENT}, http2=True) as client:
+        await client.get("https://www.instagram.com/")
+        csrf = client.cookies.get("csrftoken")
+
+        headers = {
+            "x-csrftoken": csrf,
+            'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+            'Accept-Encoding': "identity",
+            'sec-ch-ua-full-version-list': "\"Google Chrome\";v=\"143.0.7499.146\", \"Chromium\";v=\"143.0.7499.146\", \"Not A(Brand\";v=\"24.0.0.0\"",
+            'sec-ch-ua-platform': "\"Linux\"",
+            'sec-ch-ua': "\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"",
+            'sec-ch-ua-model': "\"\"",
+            'sec-ch-ua-mobile': "?0",
+            'x-ig-app-id': "936619743392459",
+            'x-requested-with': "XMLHttpRequest",
+            'x-instagram-ajax': "1031566424",
+            'x-asbd-id': "359341",
+            'x-ig-www-claim': "0",
+            'sec-ch-ua-platform-version': "\"\"",
+            'origin': "https://www.instagram.com",
+            'referer': "https://www.instagram.com/accounts/password/reset/"
+        }
+
+        response = await client.post(
+            "https://www.instagram.com/api/v1/web/accounts/account_recovery_send_ajax/",
+            data={"email_or_username": email},
+            headers=headers
+        )
+
+        data = response.json()
+        status_val = data.get("status")
+        if status_val == "ok":
+            return Result.taken()
+        elif status_val == "fail":
+            return Result.available()
+        else:
+            return Result.error("Unexpected response body, report it on github")
+
+
+
+async def validate_instagram(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/social/mastodon.py

@@ -0,0 +1,57 @@
+import httpx
+import re
+from user_scanner.core.result import Result
+
+
+async def _check(email):
+    base_url = "https://mastodon.social"
+    signup_url = f"{base_url}/auth/sign_up"
+    post_url = f"{base_url}/auth"
+
+    headers = {
+        "user-agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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",
+        "referer": "https://mastodon.social/explore",
+        "origin": "https://mastodon.social"
+    }
+
+    async with httpx.AsyncClient(http2=True, headers=headers, follow_redirects=False) as client:
+        try:
+            initial_resp = await client.get(signup_url)
+            if initial_resp.status_code != 200:
+                return Result.error(f"Failed to access signup page: {initial_resp.status_code}")
+
+            token_match = re.search(
+                r'name="csrf-token" content="([^"]+)"', initial_resp.text)
+            if not token_match:
+                return Result.error("Could not find authenticity token")
+
+            csrf_token = token_match.group(1)
+
+            payload = {
+                "authenticity_token": csrf_token,
+                "user[account_attributes][username]": "no3motions_robot_020102",
+                "user[email]": email,
+                "user[password]": "Theleftalone@me",
+                "user[password_confirmation]": "Theleftalone@me",
+                "user[agreement]": "1",
+                "button": ""
+            }
+
+            response = await client.post(post_url, data=payload)
+            res_text = response.text
+            res_status = response.status_code
+            if "has already been taken" in res_text:
+                return Result.taken()
+            elif "has already been taken" not in res_text and res_status == 200:
+                return Result.available()
+            elif res_status == 429:
+                return Result.error("Rate limited, use '-d' flag to avoid bot detection")
+            else:
+                return Result.error("Unexpected error, report it via GitHub issues")
+        except Exception as e:
+            return Result.error(e)
+
+
+async def validate_mastodon(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/social/x.py

@@ -0,0 +1,41 @@
+import httpx
+from user_scanner.core.result import Result
+
+async def _check(email):
+    url = "https://api.x.com/i/users/email_available.json"
+    params = {"email": email}
+    headers = {
+        "user-agent": "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36",
+        "accept-encoding": "gzip, deflate, br, zstd",
+        "sec-ch-ua-platform": "\"Android\"",
+        "sec-ch-ua": "\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"",
+        "x-twitter-client-language": "en",
+        "sec-ch-ua-mobile": "?1",
+        "x-twitter-active-user": "yes",
+        "origin": "https://x.com",
+        "priority": "u=1, i"
+    }
+
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            response = await client.get(url, params=params, headers=headers)
+
+            if response.status_code == 429:
+                return Result.error("Rate limited wait for few minutes or use '-d' flag")
+
+            data = response.json()
+            taken_bool = data.get("taken")
+
+            if taken_bool is True:
+                return Result.taken()
+            elif taken_bool is False:
+                return Result.available()
+            else:
+                return Result.error("Unexpected error, report it via GitHub issues")
+
+        except Exception as e:
+            return Result.error(e)
+
+
+async def validate_x(email: str) -> Result:
+    return await _check(email)

user_scanner/user_scan/community/lemmy.py

@@ -0,0 +1,30 @@
+import re
+from user_scanner.core.orchestrator import status_validate
+from user_scanner.core.result import Result
+
+
+def validate_lemmy(user: str) -> Result:
+    """Check username availability on Lemmy (lemmy.world instance)"""
+
+    # Lemmy username rules: 3-20 chars, alphanumeric and underscores only
+    if not (3 <= len(user) <= 20):
+        return Result.error("Length must be 3-20 characters")
+
+    if not re.match(r'^[a-zA-Z0-9_]+$', user):
+        return Result.error("Only letters, numbers, and underscores allowed")
+
+    url = f"https://lemmy.world/api/v3/user?username={user}"
+
+    return status_validate(url, [400, 404], 200, timeout=5.0)
+
+
+if __name__ == "__main__":
+    user = input("Username?: ").strip()
+    result = validate_lemmy(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print(f"Error occurred! Reason: {result.get_reason()}")

user_scanner/user_scan/creator/gumroad.py

@@ -0,0 +1,22 @@
+import re
+from user_scanner.core.orchestrator import status_validate, Result
+
+def validate_gumroad(user: str) -> Result:
+    if not re.fullmatch(r"[a-z0-9]{3,20}", user):
+        return Result.error("Username must be between 3 and 20 lowercase alphanumeric characters")
+
+    url = f"https://{user}.gumroad.com/"
+    return status_validate(url, 404, 200, follow_redirects=True)
+
+
+if __name__ == "__main__":
+    user = input("Username?: ").strip()
+    result = validate_gumroad(user)
+
+    if result == 1:
+        print("Available!")
+    elif result == 0:
+        print("Unavailable!")
+    else:
+        print(f"Error occurred! Reason: {result.get_reason()}")
+

user_scanner/{creator → user_scan/creator}/producthunt.py

@@ -1,7 +1,15 @@
-from user_scanner.core.orchestrator import status_validate
+import re
+from user_scanner.core.orchestrator import status_validate, Result
 
 
-def validate_producthunt(user):
+def validate_producthunt(user: str) -> Result:
+    if not (2 <= len(user) <= 32):
+        return Result.error("Length must be 2-32 characters.")
+
+    # Rules: Letters, numbers, and underscores only.
+    if not re.match(r'^[a-zA-Z0-9_]+$', user):
+        return Result.error("Only use letters, numbers, and underscores.")
+
     url = f"https://www.producthunt.com/@{user}"
 
     headers = {
@@ -11,7 +19,8 @@ def validate_producthunt(user):
         'Accept-Language': "en-US,en;q=0.9",
     }
 
-    status_validate(url, 404, 200, headers=headers, follow_redirects=True)
+    return status_validate(url, 404, 200, headers=headers, follow_redirects=True)
+
 
 if __name__ == "__main__":
     user = input("Username?: ").strip()
@@ -22,4 +31,4 @@ if __name__ == "__main__":
     elif result == 0:
         print("Unavailable!")
     else:
-        print("Error occured!")
+        print(f"Error occurred! Reason: {result.get_reason()}")