socially 0.2.0__py3-none-any.whl

socially/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from .client import Socially
+from .exceptions import (
+    PlatformError,
+    RateLimited,
+    RequestError,
+    SociallyError,
+    UserNotFound,
+)
+from .models.user import User
+from .platforms import PLATFORMS
+
+__all__ = [
+    "PLATFORMS",
+    "PlatformError",
+    "RateLimited",
+    "RequestError",
+    "Socially",
+    "SociallyError",
+    "User",
+    "UserNotFound",
+    "lookup",
+]
+
+__version__ = "0.2.0"
+
+
+def lookup(platform: str, username: str) -> User:
+    return Socially().lookup(platform, username)

socially/__init__.pyi

@@ -0,0 +1,15 @@
+from .client import Socially as Socially
+from .exceptions import (
+    PlatformError as PlatformError,
+    RateLimited as RateLimited,
+    RequestError as RequestError,
+    SociallyError as SociallyError,
+    UserNotFound as UserNotFound,
+)
+from .models.user import User as User
+from .platforms import PLATFORMS as PLATFORMS
+
+__version__: str
+__all__: list[str]
+
+def lookup(platform: str, username: str) -> User: ...

socially/client.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Iterable
+
+from .exceptions import SociallyError
+from .models.user import User
+from .platforms import PLATFORMS, Platform
+
+_ALIASES = {
+    "twitter": "x",
+    "ig": "instagram",
+    "gh": "github",
+    "bsky": "bluesky",
+    "yt": "youtube",
+}
+
+
+class Socially:
+    __slots__ = ("_providers",)
+
+    def __init__(self, platforms: Iterable[str] | None = None) -> None:
+        self._providers: dict[str, Platform] = {}
+        names = platforms if platforms is not None else PLATFORMS.keys()
+        seen: set[type[Platform]] = set()
+        for name in names:
+            key = name.lower().strip()
+            cls = PLATFORMS.get(key)
+            if cls is None or cls in seen:
+                continue
+            seen.add(cls)
+            self._providers[cls.name] = cls()
+
+    def platforms(self) -> list[str]:
+        return sorted(self._providers)
+
+    def lookup(self, platform: str, username: str) -> User:
+        key = _ALIASES.get(platform.lower().strip(), platform.lower().strip())
+        provider = self._providers.get(key)
+        if provider is None:
+            cls = PLATFORMS.get(key)
+            if cls is None:
+                raise SociallyError(f"unknown platform: {platform}")
+            provider = cls()
+            self._providers[cls.name] = provider
+            key = cls.name
+        return provider.lookup(username)
+
+    def lookup_many(
+        self,
+        username: str,
+        platforms: Iterable[str] | None = None,
+    ) -> dict[str, User | BaseException]:
+        targets = list(platforms) if platforms is not None else self.platforms()
+        out: dict[str, User | BaseException] = {}
+        for p in targets:
+            try:
+                out[p] = self.lookup(p, username)
+            except BaseException as e:
+                out[p] = e
+        return out

socially/client.pyi

@@ -0,0 +1,15 @@
+from collections.abc import Iterable
+from typing import BaseException
+
+from .models.user import User
+from .platforms.base import Platform
+
+class Socially:
+    def __init__(self, platforms: Iterable[str] | None = ...) -> None: ...
+    def platforms(self) -> list[str]: ...
+    def lookup(self, platform: str, username: str) -> User: ...
+    def lookup_many(
+        self,
+        username: str,
+        platforms: Iterable[str] | None = ...,
+    ) -> dict[str, User | BaseException]: ...

socially/exceptions.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+
+class SociallyError(Exception):
+    pass
+
+
+class PlatformError(SociallyError):
+    def __init__(self, platform: str, message: str) -> None:
+        self.platform = platform
+        super().__init__(f"[{platform}] {message}")
+
+
+class UserNotFound(PlatformError):
+    pass
+
+
+class RateLimited(PlatformError):
+    pass
+
+
+class RequestError(PlatformError):
+    pass

socially/exceptions.pyi

@@ -0,0 +1,9 @@
+class SociallyError(Exception): ...
+
+class PlatformError(SociallyError):
+    platform: str
+    def __init__(self, platform: str, message: str) -> None: ...
+
+class UserNotFound(PlatformError): ...
+class RateLimited(PlatformError): ...
+class RequestError(PlatformError): ...

socially/http.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from typing import Any
+
+try:
+    import orjson as _json
+
+    def loads(data: bytes | str) -> Any:
+        if isinstance(data, str):
+            data = data.encode()
+        return _json.loads(data)
+
+    def dumps(obj: Any) -> str:
+        return _json.dumps(obj).decode()
+
+except ImportError:
+    import json as _json
+
+    def loads(data: bytes | str) -> Any:
+        if isinstance(data, bytes):
+            data = data.decode()
+        return _json.loads(data)
+
+    def dumps(obj: Any) -> str:
+        return _json.dumps(obj, separators=(",", ":"))
+
+UA = (
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+    "AppleWebKit/537.36 (KHTML, like Gecko) "
+    "Chrome/131.0.0.0 Safari/537.36"
+)
+
+
+def session(impersonate: str | None = "chrome"):
+    try:
+        from curl_cffi import requests as creq
+
+        return creq.Session(impersonate=impersonate or "chrome")
+    except ImportError:
+        import requests
+
+        s = requests.Session()
+        s.headers["User-Agent"] = UA
+        return s
+
+
+def get(
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    timeout: float = 15.0,
+    impersonate: str | None = "chrome",
+) -> Any:
+    s = session(impersonate)
+    h = {"User-Agent": UA, "Accept": "*/*"}
+    if headers:
+        h.update(headers)
+    return s.get(url, headers=h, timeout=timeout)
+
+
+def post(
+    url: str,
+    *,
+    headers: dict[str, str] | None = None,
+    data: Any = None,
+    json_body: Any = None,
+    timeout: float = 15.0,
+    impersonate: str | None = "chrome",
+) -> Any:
+    s = session(impersonate)
+    h = {"User-Agent": UA, "Accept": "*/*"}
+    if headers:
+        h.update(headers)
+    kwargs: dict[str, Any] = {"headers": h, "timeout": timeout}
+    if json_body is not None:
+        kwargs["data"] = dumps(json_body).encode() if not isinstance(json_body, (str, bytes)) else json_body
+        h.setdefault("Content-Type", "application/json")
+    elif data is not None:
+        kwargs["data"] = data
+    return s.post(url, **kwargs)

socially/models/__init__.py

@@ -0,0 +1,3 @@
+from .user import User
+
+__all__ = ["User"]

socially/models/user.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+
+@dataclass(slots=True)
+class User:
+    platform: str
+    id: str | None = None
+    username: str | None = None
+    display_name: str | None = None
+    bio: str | None = None
+    url: str | None = None
+    avatar_url: str | None = None
+    banner_url: str | None = None
+    followers: int | None = None
+    following: int | None = None
+    posts: int | None = None
+    likes: int | None = None
+    verified: bool | None = None
+    protected: bool | None = None
+    location: str | None = None
+    website: str | None = None
+    created_at: str | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)

socially/models/user.pyi

@@ -0,0 +1,44 @@
+from typing import Any
+
+class User:
+    platform: str
+    id: str | None
+    username: str | None
+    display_name: str | None
+    bio: str | None
+    url: str | None
+    avatar_url: str | None
+    banner_url: str | None
+    followers: int | None
+    following: int | None
+    posts: int | None
+    likes: int | None
+    verified: bool | None
+    protected: bool | None
+    location: str | None
+    website: str | None
+    created_at: str | None
+    raw: dict[str, Any]
+
+    def __init__(
+        self,
+        platform: str,
+        id: str | None = ...,
+        username: str | None = ...,
+        display_name: str | None = ...,
+        bio: str | None = ...,
+        url: str | None = ...,
+        avatar_url: str | None = ...,
+        banner_url: str | None = ...,
+        followers: int | None = ...,
+        following: int | None = ...,
+        posts: int | None = ...,
+        likes: int | None = ...,
+        verified: bool | None = ...,
+        protected: bool | None = ...,
+        location: str | None = ...,
+        website: str | None = ...,
+        created_at: str | None = ...,
+        raw: dict[str, Any] = ...,
+    ) -> None: ...
+    def to_dict(self) -> dict[str, Any]: ...

socially/platforms/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from .base import Platform
+from .bluesky import Bluesky
+from .github import GitHub
+from .instagram import Instagram
+from .mastodon import Mastodon
+from .reddit import Reddit
+from .tiktok import TikTok
+from .x import X
+from .youtube import YouTube
+
+PLATFORMS: dict[str, type[Platform]] = {
+    "x": X,
+    "twitter": X,
+    "tiktok": TikTok,
+    "instagram": Instagram,
+    "ig": Instagram,
+    "github": GitHub,
+    "gh": GitHub,
+    "reddit": Reddit,
+    "bluesky": Bluesky,
+    "bsky": Bluesky,
+    "mastodon": Mastodon,
+    "youtube": YouTube,
+    "yt": YouTube,
+}
+
+__all__ = [
+    "PLATFORMS",
+    "Platform",
+    "X",
+    "TikTok",
+    "Instagram",
+    "GitHub",
+    "Reddit",
+    "Bluesky",
+    "Mastodon",
+    "YouTube",
+]

socially/platforms/base.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from ..models.user import User
+
+
+class Platform(ABC):
+    name: str
+
+    @abstractmethod
+    def lookup(self, username: str) -> User:
+        ...

socially/platforms/base.pyi

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+
+from ..models.user import User
+
+class Platform(ABC):
+    name: str
+    @abstractmethod
+    def lookup(self, username: str) -> User: ...

socially/platforms/bluesky.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from ..exceptions import RequestError, UserNotFound
+from ..http import get, loads
+from ..models.user import User
+from .base import Platform
+
+
+class Bluesky(Platform):
+    name = "bluesky"
+
+    def lookup(self, username: str) -> User:
+        handle = username.lstrip("@").strip()
+        if "." not in handle:
+            handle = f"{handle}.bsky.social"
+        r = get(
+            f"https://public.api.bsky.app/xrpc/app.bsky.actor.getProfile?actor={handle}",
+            headers={"Accept": "application/json"},
+            impersonate=None,
+        )
+        if r.status_code == 400 or r.status_code == 404:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        if r.status_code != 200:
+            raise RequestError(self.name, f"HTTP {r.status_code}")
+        data = loads(r.content)
+        return User(
+            platform=self.name,
+            id=data.get("did"),
+            username=data.get("handle"),
+            display_name=data.get("displayName"),
+            bio=data.get("description"),
+            url=f"https://bsky.app/profile/{data.get('handle')}",
+            avatar_url=data.get("avatar"),
+            banner_url=data.get("banner"),
+            followers=data.get("followersCount"),
+            following=data.get("followsCount"),
+            posts=data.get("postsCount"),
+            created_at=data.get("createdAt"),
+            raw=data,
+        )

socially/platforms/github.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from ..exceptions import RequestError, UserNotFound
+from ..http import get, loads
+from ..models.user import User
+from .base import Platform
+
+
+class GitHub(Platform):
+    name = "github"
+
+    def lookup(self, username: str) -> User:
+        username = username.lstrip("@").strip()
+        r = get(
+            f"https://api.github.com/users/{username}",
+            headers={
+                "Accept": "application/vnd.github+json",
+                "User-Agent": "socially/0.2",
+            },
+            impersonate=None,
+        )
+        if r.status_code == 404:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        if r.status_code == 403:
+            raise RequestError(self.name, "rate limited")
+        if r.status_code != 200:
+            raise RequestError(self.name, f"HTTP {r.status_code}")
+        data = loads(r.content)
+        return User(
+            platform=self.name,
+            id=str(data["id"]) if data.get("id") is not None else None,
+            username=data.get("login"),
+            display_name=data.get("name"),
+            bio=data.get("bio"),
+            url=data.get("html_url"),
+            avatar_url=data.get("avatar_url"),
+            followers=data.get("followers"),
+            following=data.get("following"),
+            posts=data.get("public_repos"),
+            location=data.get("location"),
+            website=data.get("blog") or None,
+            created_at=data.get("created_at"),
+            raw=data,
+        )

socially/platforms/instagram.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..exceptions import RequestError, UserNotFound
+from ..http import get, loads
+from ..models.user import User
+from .base import Platform
+
+
+class Instagram(Platform):
+    name = "instagram"
+
+    def lookup(self, username: str) -> User:
+        username = username.lstrip("@").strip()
+        r = get(
+            f"https://i.instagram.com/api/v1/users/web_profile_info/?username={username}",
+            headers={
+                "X-IG-App-ID": "936619743392459",
+                "Accept": "*/*",
+            },
+        )
+        if r.status_code == 404:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        if r.status_code in (401, 403, 429):
+            raise RequestError(self.name, f"HTTP {r.status_code}")
+        if r.status_code != 200:
+            raise RequestError(self.name, f"HTTP {r.status_code}")
+        try:
+            payload = loads(r.content)
+        except Exception as e:
+            raise RequestError(self.name, f"invalid JSON: {e}") from e
+        user = (payload.get("data") or {}).get("user")
+        if not user:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        return self._map(user)
+
+    def _map(self, user: dict[str, Any]) -> User:
+        followers = (user.get("edge_followed_by") or {}).get("count")
+        if followers is None:
+            followers = user.get("follower_count")
+        following = (user.get("edge_follow") or {}).get("count")
+        if following is None:
+            following = user.get("following_count")
+        posts = (user.get("edge_owner_to_timeline_media") or {}).get("count")
+        if posts is None:
+            posts = user.get("media_count")
+        return User(
+            platform=self.name,
+            id=str(user["id"]) if user.get("id") is not None else None,
+            username=user.get("username"),
+            display_name=user.get("full_name"),
+            bio=user.get("biography"),
+            url=f"https://www.instagram.com/{user.get('username')}/",
+            avatar_url=user.get("profile_pic_url_hd") or user.get("profile_pic_url"),
+            followers=followers,
+            following=following,
+            posts=posts,
+            verified=user.get("is_verified"),
+            protected=user.get("is_private"),
+            website=user.get("external_url"),
+            raw=user,
+        )

socially/platforms/mastodon.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from urllib.parse import quote
+
+from ..exceptions import RequestError, UserNotFound
+from ..http import get, loads
+from ..models.user import User
+from .base import Platform
+
+
+class Mastodon(Platform):
+    name = "mastodon"
+
+    def lookup(self, username: str) -> User:
+        raw = username.lstrip("@").strip()
+        if "@" in raw:
+            local, instance = raw.rsplit("@", 1)
+        else:
+            local, instance = raw, "mastodon.social"
+        r = get(
+            f"https://{instance}/api/v1/accounts/lookup?acct={local}",
+            headers={"Accept": "application/json"},
+            impersonate=None,
+        )
+        if r.status_code == 404:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        if r.status_code != 200:
+            acct = quote(f"{local}@{instance}")
+            r = get(
+                f"https://{instance}/api/v1/accounts/lookup?acct={acct}",
+                headers={"Accept": "application/json"},
+                impersonate=None,
+            )
+        if r.status_code == 404:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        if r.status_code != 200:
+            raise RequestError(self.name, f"HTTP {r.status_code}")
+        data = loads(r.content)
+        return User(
+            platform=self.name,
+            id=str(data["id"]) if data.get("id") is not None else None,
+            username=data.get("acct") or data.get("username"),
+            display_name=data.get("display_name"),
+            bio=data.get("note"),
+            url=data.get("url"),
+            avatar_url=data.get("avatar"),
+            banner_url=data.get("header"),
+            followers=data.get("followers_count"),
+            following=data.get("following_count"),
+            posts=data.get("statuses_count"),
+            created_at=data.get("created_at"),
+            raw=data,
+        )

socially/platforms/reddit.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from ..exceptions import RequestError, UserNotFound
+from ..http import get, loads
+from ..models.user import User
+from .base import Platform
+
+_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+    "Accept": "application/json",
+}
+
+
+class Reddit(Platform):
+    name = "reddit"
+
+    def lookup(self, username: str) -> User:
+        username = username.lstrip("u/").lstrip("/").strip()
+        for base in (
+            f"https://www.reddit.com/user/{username}/about.json",
+            f"https://old.reddit.com/user/{username}/about.json",
+            f"https://api.reddit.com/user/{username}/about",
+        ):
+            r = get(base, headers=_HEADERS, impersonate="chrome")
+            if r.status_code == 404:
+                raise UserNotFound(self.name, f"user '{username}' not found")
+            if r.status_code == 200:
+                return self._map(loads(r.content), username)
+            if r.status_code not in (403, 429):
+                raise RequestError(self.name, f"HTTP {r.status_code}")
+        raise RequestError(self.name, "blocked or rate limited")
+
+    def _map(self, data: dict, username: str) -> User:
+        d = data.get("data") or data
+        if d.get("is_suspended") or not d.get("name"):
+            raise UserNotFound(self.name, f"user '{username}' not found or suspended")
+        sub = d.get("subreddit") or {}
+        return User(
+            platform=self.name,
+            id=d.get("id") or d.get("name"),
+            username=d.get("name"),
+            display_name=sub.get("title") or d.get("name"),
+            bio=sub.get("public_description"),
+            url=f"https://www.reddit.com/user/{d.get('name')}",
+            avatar_url=d.get("icon_img") or d.get("snoovatar_img"),
+            banner_url=sub.get("banner_img"),
+            followers=d.get("total_karma"),
+            posts=d.get("link_karma"),
+            likes=d.get("comment_karma"),
+            created_at=str(d["created_utc"]) if d.get("created_utc") is not None else None,
+            raw=data,
+        )

socially/platforms/tiktok.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..exceptions import RequestError, UserNotFound
+from ..http import get, loads
+from ..models.user import User
+from .base import Platform
+
+_RE_UNIVERSAL = re.compile(
+    r'<script[^>]*id="__UNIVERSAL_DATA_FOR_REHYDRATION__"[^>]*>(.*?)</script>',
+    re.DOTALL,
+)
+_RE_SIGI = re.compile(r'<script[^>]*id="SIGI_STATE"[^>]*>(.*?)</script>', re.DOTALL)
+
+
+def _int(v: Any) -> int | None:
+    if v is None:
+        return None
+    try:
+        return int(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def _extract(html: str) -> dict[str, Any] | None:
+    m = _RE_UNIVERSAL.search(html)
+    if m:
+        try:
+            data = loads(m.group(1))
+            info = (data.get("__DEFAULT_SCOPE__") or {}).get("webapp.user-detail", {}).get("userInfo")
+            if info:
+                return info
+        except Exception:
+            pass
+    m = _RE_SIGI.search(html)
+    if m:
+        try:
+            data = loads(m.group(1))
+            users = (data.get("UserModule") or {}).get("users") or {}
+            if users:
+                first = next(iter(users.values()))
+                stats = ((data.get("UserModule") or {}).get("stats") or {}).get(first.get("id") or "", {})
+                return {"user": first, "stats": stats}
+        except Exception:
+            pass
+    return None
+
+
+class TikTok(Platform):
+    name = "tiktok"
+
+    def lookup(self, username: str) -> User:
+        username = username.lstrip("@").strip()
+        r = get(
+            f"https://www.tiktok.com/@{username}",
+            headers={"Accept": "text/html", "Accept-Language": "en-US,en;q=0.9"},
+        )
+        if r.status_code == 404:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        if r.status_code != 200:
+            raise RequestError(self.name, f"HTTP {r.status_code}")
+        info = _extract(r.text)
+        if not info:
+            raise UserNotFound(self.name, f"could not parse '{username}'")
+        user = info.get("user") or {}
+        stats = info.get("stats") or info.get("statsV2") or {}
+        uid = user.get("uniqueId") or username
+        return User(
+            platform=self.name,
+            id=str(user["id"]) if user.get("id") is not None else None,
+            username=uid,
+            display_name=user.get("nickname"),
+            bio=user.get("signature"),
+            url=f"https://www.tiktok.com/@{uid}",
+            avatar_url=user.get("avatarLarger") or user.get("avatarMedium"),
+            followers=_int(stats.get("followerCount")),
+            following=_int(stats.get("followingCount")),
+            posts=_int(stats.get("videoCount")),
+            likes=_int(stats.get("heartCount") or stats.get("heart")),
+            verified=bool(user["verified"]) if "verified" in user else None,
+            protected=bool(user["privateAccount"]) if "privateAccount" in user else None,
+            raw=info,
+        )

socially/platforms/x.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from ..exceptions import RequestError, UserNotFound
+from ..http import dumps, get, loads, session
+from ..models.user import User
+from .base import Platform
+
+BEARER = (
+    "AAAAAAAAAAAAAAAAAAAAANRILgAAAAAAnNwIzUejRCOuH5E6I8xnZz4puTs"
+    "%3D1Zv7ttfk8LF81IUq16cHjhLTvJu4FA33AGWWjCpTnA"
+)
+
+PROFILE_FEATURES: dict[str, bool] = {
+    "creator_subscriptions_tweet_preview_api_enabled": True,
+    "hidden_profile_subscriptions_enabled": True,
+    "highlights_tweets_tab_ui_enabled": True,
+    "profile_label_improvements_pcf_label_in_post_enabled": True,
+    "responsive_web_graphql_timeline_navigation_enabled": True,
+    "responsive_web_profile_redirect_enabled": True,
+    "responsive_web_twitter_article_notes_tab_enabled": True,
+    "rweb_tipjar_consumption_enabled": False,
+    "subscriptions_feature_can_gift_premium": True,
+    "subscriptions_verification_info_is_identity_verified_enabled": True,
+    "subscriptions_verification_info_verified_since_enabled": True,
+    "verified_phone_label_enabled": False,
+}
+
+PROFILE_TOGGLES: dict[str, bool] = {
+    "withAuxiliaryUserLabels": True,
+    "withPayments": False,
+}
+
+OPS = (
+    ("Gb-d6r0vxPOADdG62OEBpQ", "UserByScreenName", True),
+    ("L_eCyvUxu-QprwFaWK0Wyg", "UserByScreenName", False),
+)
+
+
+class X(Platform):
+    name = "x"
+
+    __slots__ = ("_guest",)
+
+    def __init__(self) -> None:
+        self._guest: str | None = None
+
+    def _mint_guest(self) -> str:
+        s = session("chrome")
+        r = s.post(
+            "https://api.x.com/1.1/guest/activate.json",
+            headers={"Authorization": f"Bearer {BEARER}"},
+            timeout=15,
+        )
+        if r.status_code != 200:
+            raise RequestError(self.name, f"guest activate HTTP {r.status_code}")
+        token = loads(r.content).get("guest_token")
+        if not token:
+            raise RequestError(self.name, "missing guest_token")
+        self._guest = str(token)
+        return self._guest
+
+    def _guest_token(self) -> str:
+        return self._guest or self._mint_guest()
+
+    def lookup(self, username: str) -> User:
+        username = username.lstrip("@").strip()
+        guest = self._guest_token()
+        last_err: Exception | None = None
+        for query_id, op_name, full in OPS:
+            try:
+                return self._graphql_user(username, guest, query_id, op_name, full)
+            except UserNotFound:
+                raise
+            except Exception as e:
+                last_err = e
+                self._guest = None
+                guest = self._guest_token()
+        try:
+            return self._html_user(username)
+        except Exception:
+            if last_err:
+                raise last_err
+            raise
+
+    def _graphql_user(
+        self,
+        username: str,
+        guest: str,
+        query_id: str,
+        op_name: str,
+        full: bool,
+    ) -> User:
+        variables: dict[str, Any] = (
+            {"screen_name": username, "withGrokTranslatedBio": False}
+            if full
+            else {"screen_name": username}
+        )
+        params = f"variables={quote(dumps(variables))}"
+        if full:
+            params += f"&features={quote(dumps(PROFILE_FEATURES))}"
+            params += f"&fieldToggles={quote(dumps(PROFILE_TOGGLES))}"
+        url = f"https://api.x.com/graphql/{query_id}/{op_name}?{params}"
+        s = session("chrome")
+        r = s.get(
+            url,
+            headers={
+                "Authorization": f"Bearer {BEARER}",
+                "x-guest-token": guest,
+                "Content-Type": "application/json",
+            },
+            timeout=15,
+        )
+        if r.status_code == 404:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        if r.status_code == 429:
+            raise RequestError(self.name, "rate limited")
+        if r.status_code != 200:
+            raise RequestError(self.name, f"GraphQL HTTP {r.status_code}")
+        data = loads(r.content)
+        result = ((data.get("data") or {}).get("user") or {}).get("result") or {}
+        if not result or result.get("__typename") == "UserUnavailable":
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        return self._from_result(result, username)
+
+    def _from_result(self, result: dict[str, Any], username: str) -> User:
+        legacy = result.get("legacy") or {}
+        core = result.get("core") or {}
+        website = None
+        try:
+            urls = ((legacy.get("entities") or {}).get("url") or {}).get("urls") or []
+            if urls:
+                website = urls[0].get("expanded_url")
+        except Exception:
+            pass
+        screen = legacy.get("screen_name") or core.get("screen_name") or username
+        avatar = legacy.get("profile_image_url_https") or ""
+        if avatar:
+            avatar = avatar.replace("_normal", "")
+        return User(
+            platform=self.name,
+            id=str(result.get("rest_id") or legacy.get("id_str") or ""),
+            username=screen,
+            display_name=legacy.get("name") or core.get("name"),
+            bio=legacy.get("description"),
+            url=f"https://x.com/{screen}",
+            avatar_url=avatar or None,
+            banner_url=legacy.get("profile_banner_url"),
+            followers=legacy.get("followers_count"),
+            following=legacy.get("friends_count"),
+            posts=legacy.get("statuses_count"),
+            likes=legacy.get("favourites_count"),
+            verified=bool(result.get("is_blue_verified") or legacy.get("verified")),
+            protected=legacy.get("protected"),
+            location=legacy.get("location"),
+            website=website,
+            created_at=legacy.get("created_at"),
+            raw=result,
+        )
+
+    def _html_user(self, username: str) -> User:
+        import re
+
+        r = get(f"https://x.com/{username}")
+        if r.status_code == 404:
+            raise UserNotFound(self.name, f"user '{username}' not found")
+        if r.status_code != 200:
+            raise RequestError(self.name, f"HTML HTTP {r.status_code}")
+        text = r.text
+        title_m = re.search(r'property="og:title"\s+content="([^"]+)"', text)
+        desc_m = re.search(r'property="og:description"\s+content="([^"]*)"', text)
+        img_m = re.search(r'property="og:image"\s+content="([^"]+)"', text)
+        if not title_m:
+            raise UserNotFound(self.name, f"could not resolve '{username}'")
+        title = title_m.group(1)
+        display = title.split("(")[0].strip() if "(" in title else title
+        return User(
+            platform=self.name,
+            username=username,
+            display_name=display,
+            bio=desc_m.group(1) if desc_m else None,
+            url=f"https://x.com/{username}",
+            avatar_url=img_m.group(1) if img_m else None,
+            raw={"source": "html_meta", "title": title},
+        )

socially/platforms/youtube.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..exceptions import RequestError, UserNotFound
+from ..http import get, loads
+from ..models.user import User
+from .base import Platform
+
+_RE_INIT = re.compile(r"ytInitialData\s*=\s*(\{.+?\})\s*;", re.DOTALL)
+_RE_OG_TITLE = re.compile(r'<meta\s+property="og:title"\s+content="([^"]+)"')
+_RE_OG_DESC = re.compile(r'<meta\s+property="og:description"\s+content="([^"]*)"')
+_RE_OG_IMAGE = re.compile(r'<meta\s+property="og:image"\s+content="([^"]+)"')
+_RE_CHANNEL_ID = re.compile(r'"channelId"\s*:\s*"(UC[\w-]+)"')
+_RE_META_TITLE = re.compile(r'"channelMetadataRenderer"\s*:\s*\{[^}]*?"title"\s*:\s*"([^"]+)"')
+_RE_SUBS = re.compile(r'"subscriberCountText"\s*:\s*\{[^}]*?"simpleText"\s*:\s*"([^"]+)"')
+
+
+class YouTube(Platform):
+    name = "youtube"
+
+    def lookup(self, username: str) -> User:
+        handle = username.lstrip("@").strip()
+        r = get(
+            f"https://www.youtube.com/@{handle}",
+            headers={"Accept-Language": "en-US,en;q=0.9"},
+        )
+        if r.status_code == 404:
+            raise UserNotFound(self.name, f"channel '{username}' not found")
+        if r.status_code != 200:
+            raise RequestError(self.name, f"HTTP {r.status_code}")
+        text = r.text
+        meta = self._parse(text, handle)
+        if not meta.get("channelId") and not meta.get("title"):
+            raise UserNotFound(self.name, f"channel '{username}' not found")
+        return User(
+            platform=self.name,
+            id=meta.get("channelId"),
+            username=meta.get("vanity") or handle,
+            display_name=meta.get("title"),
+            bio=meta.get("description"),
+            url=f"https://www.youtube.com/@{handle}",
+            avatar_url=meta.get("avatar"),
+            followers=meta.get("subscribers"),
+            raw=meta,
+        )
+
+    def _parse(self, text: str, handle: str) -> dict[str, Any]:
+        out: dict[str, Any] = {"vanity": handle}
+        m = _RE_OG_TITLE.search(text)
+        if m:
+            out["title"] = m.group(1)
+        m = _RE_META_TITLE.search(text)
+        if m:
+            out["title"] = m.group(1)
+        m = _RE_OG_DESC.search(text)
+        if m:
+            out["description"] = m.group(1)
+        m = _RE_OG_IMAGE.search(text)
+        if m:
+            out["avatar"] = m.group(1)
+        m = _RE_CHANNEL_ID.search(text)
+        if m:
+            out["channelId"] = m.group(1)
+        m = _RE_SUBS.search(text)
+        if m:
+            out["subscribers"] = _parse_count(m.group(1))
+        try:
+            jm = _RE_INIT.search(text)
+            if jm:
+                data = loads(jm.group(1))
+                header = (data.get("header") or {}).get("c4TabbedHeaderRenderer") or {}
+                if header.get("title"):
+                    out["title"] = header["title"]
+                if header.get("channelId"):
+                    out["channelId"] = header["channelId"]
+                thumbs = (header.get("avatar") or {}).get("thumbnails") or []
+                if thumbs:
+                    out["avatar"] = thumbs[-1].get("url")
+                subs = (header.get("subscriberCountText") or {}).get("simpleText") or ""
+                if subs:
+                    out["subscribers"] = _parse_count(subs)
+        except Exception:
+            pass
+        return out
+
+
+def _parse_count(text: str) -> int | None:
+    if not text:
+        return None
+    t = text.lower().replace("subscribers", "").replace(",", "").strip()
+    mult = 1.0
+    if t.endswith("k"):
+        mult, t = 1_000.0, t[:-1]
+    elif t.endswith("m"):
+        mult, t = 1_000_000.0, t[:-1]
+    elif t.endswith("b"):
+        mult, t = 1_000_000_000.0, t[:-1]
+    try:
+        return int(float(t) * mult)
+    except ValueError:
+        return None

socially-0.2.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.5
+Name: socially
+Version: 0.2.0
+Summary: Authless social media user lookup — X, TikTok, Instagram, GitHub, Reddit, Bluesky, Mastodon, YouTube
+Project-URL: Homepage, https://github.com/lmaohi7181828/socially
+Project-URL: Repository, https://github.com/lmaohi7181828/socially
+Project-URL: Issues, https://github.com/lmaohi7181828/socially/issues
+Author: socially
+License-Expression: MIT
+License-File: LICENSE
+Keywords: bluesky,github,instagram,mastodon,osint,reddit,social,tiktok,twitter,x,youtube
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: curl-cffi>=0.7; extra == 'dev'
+Requires-Dist: orjson>=3.10; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Provides-Extra: fast
+Requires-Dist: curl-cffi>=0.7; extra == 'fast'
+Requires-Dist: orjson>=3.10; extra == 'fast'
+Description-Content-Type: text/markdown
+
+# socially
+
+Authless multi-platform user lookup for Python.
+
+**X · TikTok · Instagram · GitHub · Reddit · Bluesky · Mastodon · YouTube**
+
+No API keys. No login. Normalized `User` + full `raw` payload.
+
+X user lookup follows the guest GraphQL pattern used by [xtekky/x-noauth-api](https://github.com/xtekky/x-noauth-api) (`UserByScreenName`, public bearer + guest token, feature flags).
+
+## Install
+
+```bash
+pip install socially
+# or with speed extras:
+pip install "socially[fast]"
+```
+
+From source:
+
+```bash
+pip install -e ".[fast]"
+```
+
+`fast` extra: `orjson` + `curl_cffi` (TLS fingerprint).
+
+## Usage
+
+```python
+from socially import Socially, lookup
+
+u = lookup("tiktok", "tiktok")
+print(u.username, u.followers, u.display_name)
+
+u = lookup("bluesky", "jay.bsky.team")
+print(u.id, u.followers)
+
+s = Socially()
+print(s.platforms())
+results = s.lookup_many("nasa", platforms=["github", "youtube", "bluesky"])
+```
+
+## Platforms
+
+| Name | Authless method |
+|------|-----------------|
+| `x` / `twitter` | Guest token + GraphQL `UserByScreenName` (xtekky-style) |
+| `tiktok` | Profile HTML `__UNIVERSAL_DATA_FOR_REHYDRATION__` |
+| `instagram` / `ig` | `web_profile_info` |
+| `github` / `gh` | Public REST `/users/{user}` |
+| `reddit` | `/user/{user}/about.json` |
+| `bluesky` / `bsky` | `app.bsky.actor.getProfile` |
+| `mastodon` | `/api/v1/accounts/lookup` (`user@instance`) |
+| `youtube` / `yt` | Channel `@handle` `ytInitialData` + og meta |
+
+## User fields
+
+`platform`, `id`, `username`, `display_name`, `bio`, `url`, `avatar_url`, `banner_url`,  
+`followers`, `following`, `posts`, `likes`, `verified`, `protected`, `location`, `website`, `created_at`, `raw`
+
+## Publish (maintainers)
+
+1. Create a PyPI API token (Account settings → API tokens).
+2. GitHub repo **Settings → Secrets and variables → Actions** → New secret:
+   - Name: `PYPI_API_TOKEN`
+   - Value: `pypi-...` (full token; never commit it)
+3. Optional: GitHub **Environments** → create `pypi` (workflow references it).
+4. Ship a release by tag:
+
+```bash
+git tag v0.2.0
+git push origin v0.2.0
+```
+
+`.github/workflows/publish.yml` builds the wheel/sdist and runs `twine upload`.
+
+Manual: **Actions → Publish to PyPI → Run workflow**.
+
+## Notes
+
+Public data only. Some hosts rate-limit datacenter IPs (Instagram, Reddit). Respect each site’s ToS.
+
+## License
+
+MIT

socially-0.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+socially/__init__.py,sha256=P7IUyHF4OQYTvw_VbbXkCf1VhLykCaEPzKQH5ntIjQw,546
+socially/__init__.pyi,sha256=UOI37SzgoXRh9cvo1rk60rnU-IvpThzi2v-BAeef3lA,417
+socially/client.py,sha256=5Fmr8G1koZQTmgvb_TKvaR4KtsRWk9KtzXaHXYKyi88,1859
+socially/client.pyi,sha256=awKeQTiT7IX9lVGmB5aaw26q9Bli-Y0bgcxC2UpXkBw,487
+socially/exceptions.py,sha256=qtJp_feIB1miGyl7aGXokgr1z666VhGMi9gebwSFIrw,399
+socially/exceptions.pyi,sha256=pACdPs_L7RWY0OXfksdQlHjMheTYtFfVTZ4K3kKGDYE,273
+socially/http.py,sha256=uJUvdgDuXt-fJhFPPHgPpOHFDQrcIFhCQZ8yppji2w8,2019
+socially/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+socially/models/__init__.py,sha256=l9ueTdsKVif6Ufh5a4ikcgFWncsnPbMtfbjgg5G660o,43
+socially/models/user.py,sha256=lwX7fiewOrUfzPcjMI987L6soBEMH9zHtA7_TfZi3XA,791
+socially/models/user.pyi,sha256=8mO82K38C0AbhSORJUWg-KhfLr9vkZ3fxwMbQ_ZHdNk,1193
+socially/platforms/__init__.py,sha256=zhcu7pXsLO7d5zArHtq4tFU1TlqCPh_6Zn6imkLhSgA,766
+socially/platforms/base.py,sha256=a7zRrN48VcKpsNtQomBfidgE30wL7bgLUNTpJA1Ae4I,219
+socially/platforms/base.pyi,sha256=-avYNbiCy4g1TkOPl6hKgGmZhjRf5xBN3Ye-rROsIb4,173
+socially/platforms/bluesky.py,sha256=kK0N8A5wr7jkZfETCYuYMzJGwM1p_TbByh4hznE3_vs,1440
+socially/platforms/github.py,sha256=vWabiLHGLUsjx3Qn1TubsYRbDT6VA2GhzxT4VDmYfuc,1527
+socially/platforms/instagram.py,sha256=uRQE9okl6lQn4wTanzlYp7-uw6zwaK-y_QUxsSUZX2o,2407
+socially/platforms/mastodon.py,sha256=8Mc8eBPyz0dUCM2kQnaHePVG099ghfWQ7Ujucpicpfs,1911
+socially/platforms/reddit.py,sha256=N-t0WWlIUROzuM8fJG0uVoAc3FXe8bsXgEsJlrEqo7o,2143
+socially/platforms/tiktok.py,sha256=ZaZuIe_08RYaUSzCZG-TfrLCi0031EFH-TaxJawIARA,2955
+socially/platforms/x.py,sha256=DPj26SyvKh7zS9oPO9kO9nm8RDhazULiO7KLpTGpRr0,6947
+socially/platforms/youtube.py,sha256=WsxP_c0pMIIA6sZ1-hEnF8zBJVr7XR3geSY8ri9LHLM,3790
+socially-0.2.0.dist-info/METADATA,sha256=u_OyVaJ2prwiu1rdrGydykynJxW2q4bUZGPfAcP65-4,3616
+socially-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+socially-0.2.0.dist-info/licenses/LICENSE,sha256=R5pBnXRgZnK_b4Z5ZTReTIC3T7MMUYg-I9pGRQbdeEM,1065
+socially-0.2.0.dist-info/RECORD,,

socially-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

socially-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 socially
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.