birdapi 0.0.2__tar.gz → 0.0.3__tar.gz

{birdapi-0.0.2 → birdapi-0.0.3}/CLAUDE.md

@@ -79,6 +79,7 @@ client.get_home_timeline(count)             # → list[Tweet]
 client.get_home_latest_timeline(count)      # → list[Tweet]
 client.get_current_user()                   # → User | None
 client.get_user_id_by_username(handle)      # → User | None
+client.get_user_profile(handle)             # → UserProfile | None (full profile via UserByScreenName)
 client.get_following(user_id, count)        # → (list[User], next_cursor)
 client.get_followers(user_id, count)        # → (list[User], next_cursor)
 client.like/unlike/retweet/unretweet/bookmark/unbookmark(tweet_id)  # → bool

{birdapi-0.0.2 → birdapi-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: birdapi
-Version: 0.0.2
+Version: 0.0.3
 Summary: CLI and library for X/Twitter GraphQL API (cookie auth, no API key required)
 Project-URL: Homepage, https://github.com/dvermaas/birdapi
 Project-URL: Repository, https://github.com/dvermaas/birdapi

{birdapi-0.0.2 → birdapi-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "birdapi"
-version = "0.0.2"
+version = "0.0.3"
 description = "CLI and library for X/Twitter GraphQL API (cookie auth, no API key required)"
 readme = "README.md"
 license = { text = "MIT" }

{birdapi-0.0.2 → birdapi-0.0.3}/src/bird/__init__.py

@@ -1,12 +1,23 @@
 """bird — X/Twitter GraphQL client library."""
 
 from .client import TwitterClient
-from ._models import AboutProfile, ArticleMetadata, Author, MediaItem, NewsItem, Tweet, TwitterList, User
+from ._models import (
+    AboutProfile,
+    ArticleMetadata,
+    Author,
+    MediaItem,
+    NewsItem,
+    Tweet,
+    TwitterList,
+    User,
+    UserProfile,
+)
 
 __all__ = [
     "TwitterClient",
     "Tweet",
     "User",
+    "UserProfile",
     "Author",
     "MediaItem",
     "ArticleMetadata",

{birdapi-0.0.2 → birdapi-0.0.3}/src/bird/_constants.py

@@ -41,6 +41,7 @@ FALLBACK_QUERY_IDS: dict[str, str] = {
     "GenericTimelineById": "uGSr7alSjR9v6QJAIaqSKQ",
     "TrendHistory": "Sj4T-jSB9pr0Mxtsc1UKZQ",
     "AboutAccountQuery": "zs_jFPFT78rBpXv9Z3U2YQ",
+    "UserByScreenName": "681MIj51w00Aj6dY0GXnHw",
 }
 
 SETTINGS_SCREEN_NAME_RE = re.compile(r'"screen_name":"([^"]+)"')

{birdapi-0.0.2 → birdapi-0.0.3}/src/bird/_models.py

@@ -8,6 +8,7 @@ from typing import Any, Optional
 class Author:
     username: str
     name: str
+    profile_image_url: Optional[str] = None
 
 
 @dataclass
@@ -36,6 +37,7 @@ class Tweet:
     reply_count: Optional[int] = None
     retweet_count: Optional[int] = None
     like_count: Optional[int] = None
+    view_count: Optional[int] = None
     conversation_id: Optional[str] = None
     in_reply_to_status_id: Optional[str] = None
     author_id: Optional[str] = None
@@ -58,6 +60,38 @@ class User:
     created_at: Optional[str] = None
 
 
+@dataclass
+class UserProfile:
+    """Full profile information from the UserByScreenName endpoint."""
+
+    id: str
+    username: str
+    name: str
+    description: Optional[str] = None
+    location: Optional[str] = None
+    website: Optional[str] = None
+    created_at: Optional[str] = None
+    followers_count: Optional[int] = None
+    following_count: Optional[int] = None
+    tweet_count: Optional[int] = None
+    media_count: Optional[int] = None
+    listed_count: Optional[int] = None
+    likes_count: Optional[int] = None
+    is_blue_verified: Optional[bool] = None
+    is_verified: Optional[bool] = None
+    verified_type: Optional[str] = None
+    is_identity_verified: Optional[bool] = None
+    verified_since: Optional[str] = None
+    profile_image_url: Optional[str] = None
+    profile_banner_url: Optional[str] = None
+    is_protected: Optional[bool] = None
+    can_dm: Optional[bool] = None
+    pinned_tweet_ids: Optional[list[str]] = None
+    professional_type: Optional[str] = None
+    professional_category: Optional[str] = None
+    _raw: Optional[Any] = field(default=None, repr=False)
+
+
 @dataclass
 class TwitterList:
     id: str

{birdapi-0.0.2 → birdapi-0.0.3}/src/bird/_utils.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import re
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Optional
 
 from ._models import (
@@ -12,6 +12,7 @@ from ._models import (
     MediaItem,
     Tweet,
     User,
+    UserProfile,
 )
 
 
@@ -360,6 +361,24 @@ def _unwrap_tweet_result(result: Optional[dict]) -> Optional[dict]:
     return result.get("tweet") or result
 
 
+def _extract_view_count(result: dict, legacy: dict) -> Optional[int]:
+    """Pull the impression count from views.count (or legacy ext_views)."""
+    raw = (result.get("views") or {}).get("count")
+    if raw is None:
+        raw = (legacy.get("ext_views") or {}).get("count")
+    try:
+        return int(raw) if raw is not None else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _extract_user_avatar(user_result: dict) -> Optional[str]:
+    return (
+        (user_result.get("avatar") or {}).get("image_url")
+        or (user_result.get("legacy") or {}).get("profile_image_url_https")
+    )
+
+
 def map_tweet_result(
     result: Optional[dict],
     quote_depth: int = 1,
@@ -397,11 +416,16 @@ def map_tweet_result(
     tweet = Tweet(
         id=result["rest_id"],
         text=text,
-        author=Author(username=username, name=name or username),
+        author=Author(
+            username=username,
+            name=name or username,
+            profile_image_url=_extract_user_avatar(user_result),
+        ),
         created_at=legacy.get("created_at"),
         reply_count=legacy.get("reply_count"),
         retweet_count=legacy.get("retweet_count"),
         like_count=legacy.get("favorite_count"),
+        view_count=_extract_view_count(result, legacy),
         conversation_id=legacy.get("conversation_id_str"),
         in_reply_to_status_id=legacy.get("in_reply_to_status_id_str") or None,
         author_id=user_id,
@@ -478,6 +502,89 @@ def find_tweet_in_instructions(
     return None
 
 
+def map_user_profile_result(
+    result: Optional[dict],
+    include_raw: bool = False,
+) -> Optional[UserProfile]:
+    """Map a UserByScreenName ``user.result`` payload to a UserProfile.
+
+    Handles both the new schema (core/avatar/privacy/location/profile_bio)
+    and the legacy field layout.
+    """
+    if not result:
+        return None
+    if result.get("__typename") == "UserWithVisibilityResults" and result.get("user"):
+        result = result["user"]
+    legacy = result.get("legacy") or {}
+    core = result.get("core") or {}
+    username = core.get("screen_name") or legacy.get("screen_name")
+    if not result.get("rest_id") or not username:
+        return None
+
+    website: Optional[str] = None
+    for u in ((legacy.get("entities") or {}).get("url") or {}).get("urls") or []:
+        if u.get("expanded_url"):
+            website = u["expanded_url"]
+            break
+    if not website:
+        website = legacy.get("url")
+
+    verification = result.get("verification") or {}
+    verification_info = result.get("verification_info") or {}
+    verified_since: Optional[str] = None
+    msec = (verification_info.get("reason") or {}).get("verified_since_msec")
+    try:
+        if msec is not None:
+            verified_since = datetime.fromtimestamp(
+                int(msec) / 1000, tz=timezone.utc
+            ).isoformat()
+    except (TypeError, ValueError, OSError, OverflowError):
+        verified_since = None
+
+    privacy = result.get("privacy") or {}
+    is_protected = privacy.get("protected")
+    if is_protected is None:
+        is_protected = legacy.get("protected")
+
+    professional = result.get("professional") or {}
+    categories = professional.get("category") or []
+    professional_category = next(
+        (c.get("name") for c in categories if c.get("name")), None
+    )
+
+    profile = UserProfile(
+        id=result["rest_id"],
+        username=username,
+        name=core.get("name") or legacy.get("name") or username,
+        description=(result.get("profile_bio") or {}).get("description")
+        or legacy.get("description"),
+        location=(result.get("location") or {}).get("location") or legacy.get("location"),
+        website=website,
+        created_at=core.get("created_at") or legacy.get("created_at"),
+        followers_count=legacy.get("followers_count"),
+        following_count=legacy.get("friends_count"),
+        tweet_count=legacy.get("statuses_count"),
+        media_count=legacy.get("media_count"),
+        listed_count=legacy.get("listed_count"),
+        likes_count=legacy.get("favourites_count"),
+        is_blue_verified=result.get("is_blue_verified"),
+        is_verified=verification.get("verified"),
+        verified_type=verification.get("verified_type"),
+        is_identity_verified=verification_info.get("is_identity_verified"),
+        verified_since=verified_since,
+        profile_image_url=_extract_user_avatar(result),
+        profile_banner_url=legacy.get("profile_banner_url"),
+        is_protected=is_protected,
+        can_dm=(result.get("dm_permissions") or {}).get("can_dm"),
+        pinned_tweet_ids=legacy.get("pinned_tweet_ids_str") or None,
+        professional_type=professional.get("professional_type"),
+        professional_category=professional_category,
+    )
+    if include_raw:
+        profile._raw = result
+    return profile
+
+
 def parse_users_from_instructions(instructions: Optional[list]) -> list[User]:
     users: list[User] = []
     for instruction in instructions or []:

{birdapi-0.0.2 → birdapi-0.0.3}/src/bird/cli.py

@@ -171,6 +171,11 @@ def _format_tweet(tweet, plain: bool = False, show_stats: bool = False) -> str:
         lines.append(f"url: {url}")
     else:
         lines.append(f"\U0001f517 {url}")
+    if tweet.author.profile_image_url:
+        if plain:
+            lines.append(f"avatar: {tweet.author.profile_image_url}")
+        else:
+            lines.append(f"\U0001f464 {tweet.author.profile_image_url}")
 
     # Engagement stats (shown for single-tweet read, not list views)
     if show_stats and not plain:
@@ -181,9 +186,16 @@ def _format_tweet(tweet, plain: bool = False, show_stats: bool = False) -> str:
             parts.append(f"\U0001f501 {tweet.retweet_count}")
         if tweet.reply_count is not None:
             parts.append(f"\U0001f4ac {tweet.reply_count}")
+        if tweet.view_count is not None:
+            parts.append(f"\U0001f441\ufe0f {tweet.view_count}")
         if parts:
             lines.append("  ".join(parts))
     else:
+        if tweet.view_count is not None:
+            if plain:
+                lines.append(f"views: {tweet.view_count}")
+            else:
+                lines.append(f"\U0001f441\ufe0f {tweet.view_count} views")
         lines.append(_SEPARATOR)
 
     return "\n".join(lines)
@@ -213,11 +225,16 @@ def _tweet_to_dict(tweet, include_raw: bool = False) -> dict:
         "replyCount": tweet.reply_count,
         "retweetCount": tweet.retweet_count,
         "likeCount": tweet.like_count,
+        "viewCount": tweet.view_count,
         "conversationId": tweet.conversation_id,
     }
     if tweet.in_reply_to_status_id:
         d["inReplyToStatusId"] = tweet.in_reply_to_status_id
-    d["author"] = {"username": tweet.author.username, "name": tweet.author.name}
+    d["author"] = {
+        "username": tweet.author.username,
+        "name": tweet.author.name,
+        "profileImageUrl": tweet.author.profile_image_url,
+    }
     d["authorId"] = tweet.author_id
     if tweet.quoted_tweet:
         d["quotedTweet"] = _tweet_to_dict(tweet.quoted_tweet, include_raw=include_raw)
@@ -796,9 +813,132 @@ def trending(ctx, count, as_json):
 
 
 # ---------------------------------------------------------------------------
-# about / whoami / check
+# user / about / whoami / check
 # ---------------------------------------------------------------------------
 
+def _profile_to_dict(p, include_raw: bool = False) -> dict:
+    d: dict = {
+        "id": p.id,
+        "username": p.username,
+        "name": p.name,
+        "description": p.description,
+        "location": p.location,
+        "website": p.website,
+        "createdAt": p.created_at,
+        "followersCount": p.followers_count,
+        "followingCount": p.following_count,
+        "tweetCount": p.tweet_count,
+        "mediaCount": p.media_count,
+        "listedCount": p.listed_count,
+        "likesCount": p.likes_count,
+        "isBlueVerified": p.is_blue_verified,
+        "isVerified": p.is_verified,
+        "verifiedType": p.verified_type,
+        "isIdentityVerified": p.is_identity_verified,
+        "verifiedSince": p.verified_since,
+        "profileImageUrl": p.profile_image_url,
+        "profileBannerUrl": p.profile_banner_url,
+        "isProtected": p.is_protected,
+        "canDm": p.can_dm,
+        "pinnedTweetIds": p.pinned_tweet_ids,
+        "professionalType": p.professional_type,
+        "professionalCategory": p.professional_category,
+    }
+    if include_raw and p._raw is not None:
+        d["_raw"] = p._raw
+    return d
+
+
+def _format_profile(p, plain: bool = False) -> str:
+    def line(emoji: str, label: str, value) -> str:
+        return f"{label}: {value}" if plain else f"{emoji} {value}"
+
+    lines = [f"@{p.username} ({p.name})"]
+    if p.description:
+        lines.append(_unescape(p.description))
+    if p.location:
+        lines.append(line("\U0001f4cd", "location", p.location))
+    if p.website:
+        lines.append(line("\U0001f517", "website", p.website))
+    if p.created_at:
+        lines.append(line("\U0001f4c5", "joined", p.created_at))
+
+    counts = []
+    if p.followers_count is not None:
+        counts.append(f"{p.followers_count:,} followers")
+    if p.following_count is not None:
+        counts.append(f"{p.following_count:,} following")
+    if p.tweet_count is not None:
+        counts.append(f"{p.tweet_count:,} tweets")
+    if p.media_count is not None:
+        counts.append(f"{p.media_count:,} media")
+    if p.likes_count is not None:
+        counts.append(f"{p.likes_count:,} likes")
+    if p.listed_count is not None:
+        counts.append(f"{p.listed_count:,} listed")
+    if counts:
+        lines.append(line("\U0001f465", "stats", " · ".join(counts)))
+
+    badges = []
+    if p.verified_type:
+        badges.append(f"{p.verified_type} verified")
+    elif p.is_verified:
+        badges.append("verified")
+    if p.is_blue_verified:
+        badges.append("blue check")
+    if p.is_identity_verified:
+        badges.append("identity verified")
+    if p.is_protected:
+        badges.append("protected")
+    if badges:
+        lines.append(line("✅", "verified", ", ".join(badges)))
+    if p.verified_since:
+        lines.append(line("\U0001f4ce", "verified since", p.verified_since))
+    if p.professional_type:
+        prof = p.professional_type
+        if p.professional_category:
+            prof += f" ({p.professional_category})"
+        lines.append(line("\U0001f4bc", "professional", prof))
+    if p.can_dm is not None:
+        dm = "open" if p.can_dm else "closed"
+        lines.append(f"dms: {dm}" if plain else f"\U0001f4e9 DMs {dm}")
+    if p.pinned_tweet_ids:
+        lines.append(line("\U0001f4cc", "pinned", ", ".join(p.pinned_tweet_ids)))
+    if p.profile_image_url:
+        lines.append(f"avatar: {p.profile_image_url}" if plain
+                     else f"\U0001f464 {p.profile_image_url}")
+    if p.profile_banner_url:
+        lines.append(f"banner: {p.profile_banner_url}" if plain
+                     else f"\U0001f5bc\ufe0f {p.profile_banner_url}")
+    lines.append(f"id: {p.id}")
+    return "\n".join(lines)
+
+
+@main.command("user")
+@click.argument("handle")
+@click.option("--json", "as_json", is_flag=True)
+@click.option("--json-full", "json_full", is_flag=True,
+              help="Include raw API response in _raw field.")
+@click.pass_context
+def user_profile(ctx, handle, as_json, json_full):
+    """Show full profile information for a user."""
+    as_json = as_json or json_full or ctx.obj.get("as_json")
+    plain = ctx.obj.get("plain", False)
+    norm = normalize_handle(handle)
+    if not norm:
+        click.echo(f"Invalid handle: {handle!r}", err=True)
+        sys.exit(1)
+    with _client(ctx) as client:
+        profile = client.get_user_profile(norm, include_raw=json_full)
+    if not profile:
+        click.echo(f"User @{norm} not found.", err=True)
+        sys.exit(1)
+    if as_json:
+        click.echo(json.dumps(_profile_to_dict(profile, include_raw=json_full),
+                               ensure_ascii=False, indent=2))
+    else:
+        click.echo(_format_profile(profile, plain=plain))
+
 @main.command()
 @click.argument("handle")
 @click.option("--json", "as_json", is_flag=True)

{birdapi-0.0.2 → birdapi-0.0.3}/src/bird/client.py

@@ -44,10 +44,12 @@ from ._features import (
 )
 from ._models import (
     AboutProfile,
+    Author,
     NewsItem,
     Tweet,
     TwitterList,
     User,
+    UserProfile,
 )
 from ._query_ids import query_id_store
 from ._utils import (
@@ -56,6 +58,7 @@ from ._utils import (
     extract_cursor_from_instructions,
     find_tweet_in_instructions,
     map_tweet_result,
+    map_user_profile_result,
     normalize_handle,
     parse_tweet_datetime,
     parse_tweets_from_instructions,
@@ -483,6 +486,69 @@ class TwitterClient:
                 pass
         return None
 
+    def get_user_profile(
+        self, username: str, include_raw: bool = False
+    ) -> Optional[UserProfile]:
+        """Fetch full profile information for a user via UserByScreenName."""
+        handle = normalize_handle(username)
+        if not handle:
+            return None
+        qids = list(dict.fromkeys([
+            self._get_query_id("UserByScreenName"),
+            "681MIj51w00Aj6dY0GXnHw",
+            "xc8f1g7BYqr6VTzTbvNlGw",
+        ]))
+        variables = {"screen_name": handle, "withGrokTranslatedBio": True}
+        features = {
+            "hidden_profile_subscriptions_enabled": True,
+            "profile_label_improvements_pcf_label_in_post_enabled": True,
+            "responsive_web_profile_redirect_enabled": False,
+            "rweb_tipjar_consumption_enabled": False,
+            "verified_phone_label_enabled": False,
+            "subscriptions_verification_info_is_identity_verified_enabled": True,
+            "subscriptions_verification_info_verified_since_enabled": True,
+            "highlights_tweets_tab_ui_enabled": True,
+            "responsive_web_twitter_article_notes_tab_enabled": True,
+            "subscriptions_feature_can_gift_premium": True,
+            "creator_subscriptions_tweet_preview_api_enabled": True,
+            "responsive_web_graphql_skip_user_profile_image_extensions_enabled": False,
+            "responsive_web_graphql_timeline_navigation_enabled": True,
+        }
+        params = httpx.QueryParams(
+            variables=json.dumps(variables),
+            features=json.dumps(features),
+            fieldToggles=json.dumps({"withPayments": False, "withAuxiliaryUserLabels": True}),
+        )
+        had_404 = False
+        for qid in qids:
+            try:
+                r = self._get(f"{TWITTER_API_BASE}/{qid}/UserByScreenName?{params}")
+                if r.status_code == 404:
+                    had_404 = True
+                    continue
+                if not r.is_success:
+                    continue
+                data = r.json()
+                result = (data.get("data") or {}).get("user", {}).get("result") or {}
+                if result.get("__typename") == "UserUnavailable":
+                    return None
+                profile = map_user_profile_result(result, include_raw)
+                if profile:
+                    return profile
+            except Exception:
+                pass
+        if had_404:
+            self._refresh_query_ids()
+            try:
+                qid = self._get_query_id("UserByScreenName")
+                r = self._get(f"{TWITTER_API_BASE}/{qid}/UserByScreenName?{params}")
+                if r.is_success:
+                    result = (r.json().get("data") or {}).get("user", {}).get("result") or {}
+                    return map_user_profile_result(result, include_raw)
+            except Exception:
+                pass
+        return None
+
     # ------------------------------------------------------------------
     # Tweet detail / thread / replies
     # ------------------------------------------------------------------

{birdapi-0.0.2 → birdapi-0.0.3}/tests/test_utils.py

@@ -9,6 +9,7 @@ from bird._utils import (
     extract_list_id,
     extract_tweet_id,
     map_tweet_result,
+    map_user_profile_result,
     normalize_handle,
     parse_tweet_datetime,
     parse_tweets_from_instructions,
@@ -153,6 +154,42 @@ def test_map_tweet_result_missing_username():
     raw["core"]["user_results"]["result"]["legacy"].pop("screen_name")
     assert map_tweet_result(raw) is None
 
+def test_map_tweet_result_view_count():
+    raw = _make_raw_tweet()
+    raw["views"] = {"count": "12345", "state": "EnabledWithCount"}
+    tweet = map_tweet_result(raw)
+    assert tweet.view_count == 12345
+
+def test_map_tweet_result_view_count_legacy_ext_views():
+    raw = _make_raw_tweet()
+    raw["legacy"]["ext_views"] = {"count": "777"}
+    tweet = map_tweet_result(raw)
+    assert tweet.view_count == 777
+
+def test_map_tweet_result_view_count_missing_or_invalid():
+    raw = _make_raw_tweet()
+    assert map_tweet_result(raw).view_count is None
+    raw["views"] = {"state": "Enabled"}  # no count
+    assert map_tweet_result(raw).view_count is None
+    raw["views"] = {"count": "not-a-number"}
+    assert map_tweet_result(raw).view_count is None
+
+def test_map_tweet_result_author_avatar_new_schema():
+    raw = _make_raw_tweet()
+    raw["core"]["user_results"]["result"]["avatar"] = {
+        "image_url": "https://pbs.twimg.com/profile_images/1/x_normal.jpg"
+    }
+    tweet = map_tweet_result(raw)
+    assert tweet.author.profile_image_url == "https://pbs.twimg.com/profile_images/1/x_normal.jpg"
+
+def test_map_tweet_result_author_avatar_legacy():
+    raw = _make_raw_tweet()
+    raw["core"]["user_results"]["result"]["legacy"]["profile_image_url_https"] = (
+        "https://pbs.twimg.com/profile_images/2/y_normal.jpg"
+    )
+    tweet = map_tweet_result(raw)
+    assert tweet.author.profile_image_url == "https://pbs.twimg.com/profile_images/2/y_normal.jpg"
+
 def test_map_tweet_result_quoted_tweet():
     inner = _make_raw_tweet("2", "Quoted", "bob", "Bob", "u2")
     outer = _make_raw_tweet("1", "Outer")
@@ -265,3 +302,114 @@ def test_extract_cursor():
 def test_extract_cursor_missing():
     assert extract_cursor_from_instructions([]) is None
     assert extract_cursor_from_instructions(None) is None
+
+
+# ---------------------------------------------------------------------------
+# map_user_profile_result
+# ---------------------------------------------------------------------------
+
+def _make_raw_user_profile():
+    """Trimmed UserByScreenName user.result payload (new schema)."""
+    return {
+        "__typename": "User",
+        "rest_id": "1120633726478823425",
+        "avatar": {"image_url": "https://pbs.twimg.com/profile_images/1/a_normal.jpg"},
+        "core": {
+            "created_at": "Tue Apr 23 10:21:15 +0000 2019",
+            "name": "Volodymyr Zelenskyy",
+            "screen_name": "ZelenskyyUa",
+        },
+        "dm_permissions": {"can_dm": False},
+        "is_blue_verified": True,
+        "legacy": {
+            "description": "President of Ukraine",
+            "entities": {
+                "url": {
+                    "urls": [
+                        {
+                            "display_url": "president.gov.ua",
+                            "expanded_url": "https://www.president.gov.ua",
+                            "url": "https://t.co/ctVL0atMBQ",
+                        }
+                    ]
+                }
+            },
+            "favourites_count": 214,
+            "followers_count": 8515293,
+            "friends_count": 1,
+            "listed_count": 18781,
+            "media_count": 7501,
+            "profile_banner_url": "https://pbs.twimg.com/profile_banners/1/1692773060",
+            "statuses_count": 15669,
+            "url": "https://t.co/ctVL0atMBQ",
+        },
+        "location": {"location": "Україна"},
+        "privacy": {"protected": False},
+        "profile_bio": {"description": "President of Ukraine"},
+        "verification": {"verified": False, "verified_type": "Government"},
+        "verification_info": {
+            "is_identity_verified": False,
+            "reason": {"verified_since_msec": "1559215763761"},
+        },
+    }
+
+
+def test_map_user_profile_result_full():
+    p = map_user_profile_result(_make_raw_user_profile())
+    assert p is not None
+    assert p.id == "1120633726478823425"
+    assert p.username == "ZelenskyyUa"
+    assert p.name == "Volodymyr Zelenskyy"
+    assert p.description == "President of Ukraine"
+    assert p.location == "Україна"
+    assert p.website == "https://www.president.gov.ua"
+    assert p.created_at == "Tue Apr 23 10:21:15 +0000 2019"
+    assert p.followers_count == 8515293
+    assert p.following_count == 1
+    assert p.tweet_count == 15669
+    assert p.media_count == 7501
+    assert p.listed_count == 18781
+    assert p.likes_count == 214
+    assert p.is_blue_verified is True
+    assert p.is_verified is False
+    assert p.verified_type == "Government"
+    assert p.is_identity_verified is False
+    assert p.verified_since == "2019-05-30T11:29:23.761000+00:00"
+    assert p.profile_image_url == "https://pbs.twimg.com/profile_images/1/a_normal.jpg"
+    assert p.profile_banner_url == "https://pbs.twimg.com/profile_banners/1/1692773060"
+    assert p.is_protected is False
+    assert p.can_dm is False
+    assert p._raw is None
+
+
+def test_map_user_profile_result_include_raw():
+    raw = _make_raw_user_profile()
+    p = map_user_profile_result(raw, include_raw=True)
+    assert p._raw is raw
+
+
+def test_map_user_profile_result_legacy_schema():
+    # Older payloads carry name/screen_name under legacy instead of core.
+    p = map_user_profile_result({
+        "rest_id": "42",
+        "legacy": {
+            "screen_name": "alice",
+            "name": "Alice",
+            "description": "hi",
+            "followers_count": 5,
+            "profile_image_url_https": "https://pbs.twimg.com/profile_images/2/b_normal.jpg",
+            "protected": True,
+        },
+    })
+    assert p is not None
+    assert p.username == "alice"
+    assert p.name == "Alice"
+    assert p.followers_count == 5
+    assert p.profile_image_url == "https://pbs.twimg.com/profile_images/2/b_normal.jpg"
+    assert p.is_protected is True
+
+
+def test_map_user_profile_result_invalid():
+    assert map_user_profile_result(None) is None
+    assert map_user_profile_result({}) is None
+    assert map_user_profile_result({"rest_id": "1"}) is None  # no screen_name