xapiweb 1.5.0__py3-none-any.whl

xapiweb/resources/engagement.py

@@ -0,0 +1,83 @@
+"""Engagement: like, retweet, bookmark, downvote (all verify by re-read)."""
+from .. import errors as E
+from ._base import BaseResource
+
+
+class Engagement(BaseResource):
+    def _flag(self, tweet_id, key):
+        r = self._client.tweets.get(tweet_id)
+        return r.get("data", "tweetResult", "result", "legacy", key)
+
+    # ---- like ----
+    def like(self, tweet_id, verify=True):
+        """Proven: test_like_pair.py"""
+        resp = self._s.gql_post("FavoriteTweet", {"tweet_id": str(tweet_id)})
+        E.guard(resp, "FavoriteTweet")
+        if verify and self._flag(tweet_id, "favorited") is not True:
+            raise E.XVerifyError(f"Tweet {tweet_id} not favorited on re-read.")
+        return resp
+
+    def unlike(self, tweet_id, verify=True):
+        """Proven: test_like_pair.py"""
+        resp = self._s.gql_post("UnfavoriteTweet", {"tweet_id": str(tweet_id)})
+        E.guard(resp, "UnfavoriteTweet")
+        if verify and self._flag(tweet_id, "favorited") is not False:
+            raise E.XVerifyError(f"Tweet {tweet_id} still favorited on re-read.")
+        return resp
+
+    # ---- retweet ----
+    def retweet(self, tweet_id, verify=True):
+        """Returns Response; wrapper id at .get("data","create_retweet","retweet_results","result","rest_id").
+        Already-retweeted => XAlreadyError (327). Proven: test_retweet_pair.py"""
+        resp = self._s.gql_post("CreateRetweet", {"tweet_id": str(tweet_id)})
+        E.guard(resp, "CreateRetweet")
+        if verify and self._flag(tweet_id, "retweeted") is not True:
+            raise E.XVerifyError(f"Tweet {tweet_id} not retweeted on re-read.")
+        return resp
+
+    def unretweet(self, original_tweet_id, verify=True):
+        """Pass the ORIGINAL id, never the wrapper (wrapper delete is a silent phantom).
+        Proven: test_retweet_pair.py"""
+        resp = self._s.gql_post("DeleteRetweet", {"source_tweet_id": str(original_tweet_id)})
+        E.guard(resp, "DeleteRetweet")
+        if verify and self._flag(original_tweet_id, "retweeted") is not False:
+            raise E.XVerifyError(f"Tweet {original_tweet_id} still retweeted (phantom?).")
+        return resp
+
+    # ---- bookmark ----
+    def bookmark_add(self, tweet_id, verify=True):
+        """CreateBookmark NEEDS txn (404 without). Proven: test_bookmark_pair.py"""
+        resp = self._s.gql_post("CreateBookmark", {"tweet_id": str(tweet_id)})
+        E.guard(resp, "CreateBookmark")
+        if verify and self._flag(tweet_id, "bookmarked") is not True:
+            raise E.XVerifyError(f"Tweet {tweet_id} not bookmarked on re-read.")
+        return resp
+
+    def bookmark_remove(self, tweet_id, verify=True):
+        """Proven: test_bookmark_pair.py"""
+        resp = self._s.gql_post("DeleteBookmark", {"tweet_id": str(tweet_id)})
+        E.guard(resp, "DeleteBookmark")
+        if verify and self._flag(tweet_id, "bookmarked") is not False:
+            raise E.XVerifyError(f"Tweet {tweet_id} still bookmarked on re-read.")
+        return resp
+
+    def bookmark_search(self, query, count=5):
+        """Proven: test_bookmark_search.py"""
+        return self._s.gql_get("BookmarkSearchTimeline", {"rawQuery": query, "count": count})
+
+    # ---- downvote ----
+    def downvote(self, tweet_id, verify=True):
+        """Proven: test_downvote_pair.py"""
+        resp = self._s.gql_post("DownvoteTweet", {"tweet_id": str(tweet_id)})
+        E.guard(resp, "DownvoteTweet")
+        if verify and '"is_downvoted":true' not in resp.raw.replace(" ", ""):
+            raise E.XVerifyError("Downvote ack missing is_downvoted:true.")
+        return resp
+
+    def undo_downvote(self, tweet_id, verify=True):
+        """Proven: test_downvote_pair.py"""
+        resp = self._s.gql_post("UndoDownvoteTweet", {"tweet_id": str(tweet_id)})
+        E.guard(resp, "UndoDownvoteTweet")
+        if verify and '"is_downvoted":false' not in resp.raw.replace(" ", ""):
+            raise E.XVerifyError("Undo-downvote ack missing is_downvoted:false.")
+        return resp

xapiweb/resources/follows.py

@@ -0,0 +1,115 @@
+"""Follows & friendships (REST)."""
+from .. import errors as E
+from ._base import BaseResource
+
+_FULL = {"include_profile_interstitial_type": 1, "include_blocking": 1,
+         "include_blocked_by": 1, "include_followed_by": 1,
+         "include_want_retweets": 1, "skip_status": 1}
+
+
+class Follows(BaseResource):
+    def follow(self, user_id, verify=True):
+        """Follow + verify via lookup. Proven: test_follow_pair.py"""
+        resp = self._s.rest_post_form("friendships/create.json", {**_FULL, "user_id": str(user_id)})
+        if verify:
+            conns = self.lookup(user_id).get(0, "connections", default=[])
+            if "following" not in (conns or []):
+                raise E.XVerifyError(f"Follow of {user_id} not confirmed in lookup.")
+        return resp
+
+    def unfollow(self, user_id, verify=True):
+        """Unfollow + verify lookup == ['none']. Proven: test_follow_pair.py"""
+        resp = self._s.rest_post_form("friendships/destroy.json", {**_FULL, "user_id": str(user_id)})
+        if verify:
+            conns = self.lookup(user_id).get(0, "connections", default=None)
+            if conns != ["none"]:
+                raise E.XVerifyError(f"Unfollow of {user_id} not confirmed: {conns}.")
+        return resp
+
+    def lookup(self, user_ids):
+        """connections:[...] per user. Proven: test_friendship_lookup.py"""
+        if isinstance(user_ids, (list, tuple)):
+            user_ids = ",".join(str(i) for i in user_ids)
+        return self._s.rest_get("friendships/lookup.json", {"user_id": str(user_ids)})
+
+    def show(self, source_id=None, target_id=None):
+        """Pair relationship. Proven: test_friendship_show.py"""
+        return self._s.rest_get("friendships/show.json", {
+            "source_id": str(source_id or self._me()), "target_id": str(target_id)})
+
+    def friends_ids(self, user_id=None):
+        """Following ids. Proven: test_friends_ids.py"""
+        return self._s.rest_get("friends/ids.json",
+                                {"user_id": str(user_id or self._me()), "cursor": -1, "count": 5000})
+
+    def followers_ids(self, user_id=None):
+        """Proven: test_followers_ids.py"""
+        return self._s.rest_get("followers/ids.json",
+                                {"user_id": str(user_id or self._me()), "cursor": -1, "count": 5000})
+
+    def friends_list(self, user_id=None):
+        """Following full objects (THE real list). Proven: test_friends_list.py"""
+        return self._s.rest_get("friends/list.json",
+                                {"user_id": str(user_id or self._me()), "cursor": -1,
+                                 "count": 200, "skip_status": 1})
+
+    def followers_list(self, user_id=None):
+        """Proven: test_followers_list.py"""
+        return self._s.rest_get("followers/list.json",
+                                {"user_id": str(user_id or self._me()), "cursor": -1,
+                                 "count": 200, "skip_status": 1})
+
+    def following_preview(self, user_id=None):
+        """LIMITED preview list (not complete!). Proven: test_following_preview_list.py"""
+        return self._s.rest_get("friends/following/list.json",
+                                {"user_id": str(user_id or self._me()), "cursor": -1,
+                                 "count": 200, "skip_status": 1, "with_total_count": "true"})
+
+    def friendships_list(self, user_id=None):
+        """Proven: test_friendships_list.py"""
+        return self._s.rest_get("friendships/list.json",
+                                {"user_id": str(user_id or self._me()), "cursor": -1})
+
+    def incoming(self):
+        """Incoming follow requests. Proven: test_friendships_incoming.py"""
+        return self._s.rest_get("friendships/incoming.json", {"cursor": -1, "skip_status": 1})
+
+    def outgoing(self):
+        """Outgoing follow requests. Proven: test_friendships_outgoing.py"""
+        return self._s.rest_get("friendships/outgoing.json", {"cursor": -1})
+
+    def no_retweets_ids(self):
+        """Proven: test_no_retweets_ids.py"""
+        return self._s.rest_get("friendships/no_retweets/ids.json", {})
+
+    def set_retweets(self, user_id, enabled, verify=True):
+        """Mute/unmute someone's retweets (mutual). Proven: test_friendship_update_pair.py"""
+        resp = self._s.rest_post_form("friendships/update.json",
+                                      {"user_id": str(user_id),
+                                       "retweets": "true" if enabled else "false"})
+        if verify:
+            want = self.show(self._me(), user_id).get("relationship", "source", "want_retweets")
+            if want is not bool(enabled):
+                raise E.XVerifyError(f"want_retweets={want}, expected {bool(enabled)}.")
+        return resp
+
+    def remove_follower(self, target_user_id, confirm=False):
+        """Remove a follower. NEVER auto-fire: pass confirm=True explicitly.
+        Shape: bogus id => UnfollowInvalidRequestResult. Proven: test_remove_follower_shape.py"""
+        if not confirm:
+            raise E.XError("remove_follower() needs confirm=True (irreversible-ish, unsafe to auto-fire).")
+        return self._s.gql_post("RemoveFollower", {"target_user_id": str(target_user_id)})
+
+    def accept(self, user_id):
+        """Accept a pending follow request. Routing proven live (409 code 49
+        'No follow request pending' when nothing pending); a REAL accept needs
+        an actual pending request to fully prove."""
+        return self._s.rest_post_form("friendships/accept.json", {"user_id": str(user_id)})
+
+    def deny(self, user_id):
+        """Deny a pending follow request. Routing proven live (409/49)."""
+        return self._s.rest_post_form("friendships/deny.json", {"user_id": str(user_id)})
+
+    def cancel(self, user_id):
+        """Cancel an outgoing follow request. Routing proven live (409/49)."""
+        return self._s.rest_post_form("friendships/cancel.json", {"user_id": str(user_id)})

xapiweb/resources/lists.py

@@ -0,0 +1,75 @@
+"""Lists (REST) + profile timeline pins (GraphQL)."""
+from .. import errors as E
+from ._base import BaseResource
+
+
+class Lists(BaseResource):
+    def create(self, name, mode="private", description=""):
+        """Returns Response; id at .get("id_str"). Proven: test_list_cycle.py"""
+        return self._s.rest_post_form("lists/create.json",
+                                      {"name": name, "mode": mode, "description": description})
+
+    def destroy(self, list_id):
+        """Proven: test_list_cycle.py"""
+        return self._s.rest_post_form("lists/destroy.json", {"list_id": str(list_id)})
+
+    def add_member(self, list_id, user_id):
+        """Proven: test_list_cycle.py"""
+        return self._s.rest_post_form("lists/members/create.json",
+                                      {"list_id": str(list_id), "user_id": str(user_id)})
+
+    def remove_member(self, list_id, user_id):
+        """Proven: test_list_cycle.py"""
+        return self._s.rest_post_form("lists/members/destroy.json",
+                                      {"list_id": str(list_id), "user_id": str(user_id)})
+
+    def mine(self, user_id=None):
+        """Own lists (verify [] when clean). Proven: test_lists_mine.py"""
+        return self._s.rest_get("lists/list.json", {"user_id": str(user_id or self._me())})
+
+    def ownerships(self, user_id=None, count=5):
+        """Proven: test_lists_ownerships.py"""
+        return self._s.rest_get("lists/ownerships.json",
+                                {"user_id": str(user_id or self._me()), "count": count})
+
+    def memberships(self, user_id=None, count=5):
+        """Proven: test_lists_memberships.py"""
+        return self._s.rest_get("lists/memberships.json",
+                                {"user_id": str(user_id or self._me()), "count": count})
+
+    def subscriptions(self, user_id=None):
+        """Proven: test_lists_subscriptions.py"""
+        return self._s.rest_get("lists/subscriptions.json",
+                                {"user_id": str(user_id or self._me())})
+
+    def search(self, list_id, raw_query, count=5):
+        """Proven: test_list_search.py"""
+        return self._s.gql_get("ListSearchTimeline",
+                               {"listId": str(list_id), "rawQuery": raw_query, "count": count})
+
+    # NOTE: lists/members.json READ 404s with every variant — add/remove work, reading does not.
+
+    # ---- profile pins ----
+    def pin(self, item_id, item_type="List", verify=True):
+        """Pin a List/Community to the profile (Tag pins are silently ignored).
+        Proven: test_pin_timeline_pair.py"""
+        item = {"id": str(item_id), "pinned_timeline_type": item_type}
+        resp = self._s.gql_post("PinTimeline", {"pinnedTimelineItem": item})
+        E.guard(resp, "PinTimeline")
+        if verify and "PinTimelineSuccessResult" not in resp.raw:
+            raise E.XVerifyError("Pin ack missing PinTimelineSuccessResult.")
+        return resp
+
+    def unpin(self, item_id, item_type="List", verify=True):
+        """Proven: test_pin_timeline_pair.py"""
+        item = {"id": str(item_id), "pinned_timeline_type": item_type}
+        resp = self._s.gql_post("UnpinTimeline", {"pinnedTimelineItem": item})
+        E.guard(resp, "UnpinTimeline")
+        if verify and "UnpinTimelineSuccessResult" not in resp.raw:
+            raise E.XVerifyError("Unpin ack missing UnpinTimelineSuccessResult.")
+        return resp
+
+    def update_pins(self, items):
+        """Echo current list = safe no-op. Proven: test_pin_timeline_pair.py"""
+        resp = self._s.gql_post("UpdatePinnedTimelines", {"pinnedTimelineItems": items})
+        return E.guard(resp, "UpdatePinnedTimelines")

xapiweb/resources/media.py

@@ -0,0 +1,150 @@
+"""Media: image/video upload + tweet media (photo/video) download."""
+import json
+import os
+import time
+import urllib.parse
+import urllib.request
+
+from .. import errors as E
+from ._base import BaseResource
+
+
+class Media(BaseResource):
+    def upload_image(self, image_bytes, media_type="image/png",
+                     category="tweet_image", alt_text=None):
+        """Upload image bytes; returns media_id_string. Orphaned uploads (never attached
+        to a tweet) expire unattached. Proven: test_media_upload_cycle.py"""
+        p = "/i/media/upload.json"
+        init = self._s.call(
+            "POST", f"https://upload.x.com{p}?command=INIT&total_bytes={len(image_bytes)}"
+                    f"&media_type={media_type}&media_category={category}", "")
+        mid = init.get("media_id_string")
+        if init.status != 202 or not mid:
+            raise E.XError(f"Media INIT failed: {init.status} {init.raw[:200]}")
+        boundary = "----xapiweb1234"
+        mp = (f"--{boundary}\r\nContent-Disposition: form-data; name=\"media\"; "
+              f"filename=\"p.png\"\r\nContent-Type: application/octet-stream\r\n\r\n").encode() \
+             + image_bytes + f"\r\n--{boundary}--\r\n".encode()
+        app = self._s.call(
+            "POST", f"https://upload.x.com{p}?command=APPEND&media_id={mid}&segment_index=0",
+            mp, f"multipart/form-data; boundary={boundary}")
+        if app.status != 204:
+            raise E.XError(f"Media APPEND failed: {app.status} {app.raw[:200]}")
+        fin = self._s.call("POST", f"https://upload.x.com{p}?command=FINALIZE&media_id={mid}", "")
+        if fin.status != 201:
+            raise E.XError(f"Media FINALIZE failed: {fin.status} {fin.raw[:200]}")
+        if alt_text:
+            meta = self._s.call("POST", "https://x.com/i/api/1.1/media/metadata/create.json",
+                                json.dumps({"media_id": mid, "alt_text": {"text": alt_text}}))
+            if meta.status != 200:
+                raise E.XError(f"Alt-text failed: {meta.status} {meta.raw[:200]}")
+        return mid
+
+    def upload_video(self, video_bytes, media_type="video/mp4", category="tweet_video",
+                     chunk_size=1024 * 1024, poll_timeout=180):
+        """Chunked video upload (INIT->APPEND*->FINALIZE) + processing poll.
+
+        Returns media_id_string once processing succeeds; attach via
+        tweets.post(text, media_ids=[mid]). Orphaned uploads expire unattached.
+        Proven live by xapiweb 2026-09-20."""
+        p = "/i/media/upload.json"
+        total = len(video_bytes)
+        init = self._s.call(
+            "POST", f"https://upload.x.com{p}?command=INIT&total_bytes={total}"
+                    f"&media_type={media_type}&media_category={category}", "")
+        mid = init.get("media_id_string")
+        if init.status != 202 or not mid:
+            raise E.XError(f"Video INIT failed: {init.status} {init.raw[:200]}")
+        boundary = "----xapiwebvid"
+        for n, start in enumerate(range(0, total, chunk_size)):
+            mp = (f"--{boundary}\r\nContent-Disposition: form-data; name=\"media\"; "
+                  f"filename=\"v.mp4\"\r\nContent-Type: application/octet-stream\r\n\r\n").encode() \
+                 + video_bytes[start:start + chunk_size] + f"\r\n--{boundary}--\r\n".encode()
+            app = self._s.call(
+                "POST", f"https://upload.x.com{p}?command=APPEND&media_id={mid}&segment_index={n}",
+                mp, f"multipart/form-data; boundary={boundary}", timeout=90)
+            if app.status != 204:
+                raise E.XError(f"Video APPEND seg {n} failed: {app.status} {app.raw[:200]}")
+        fin = self._s.call("POST", f"https://upload.x.com{p}?command=FINALIZE&media_id={mid}",
+                           "", timeout=90)
+        if fin.status not in (200, 201):  # video: 200, image: 201
+            raise E.XError(f"Video FINALIZE failed: {fin.status} {fin.raw[:200]}")
+        info = fin.get("processing_info") or {}
+        state = info.get("state")
+        t0 = time.time()
+        while state in ("pending", "in_progress"):
+            if time.time() - t0 > poll_timeout:
+                raise E.XError(f"Video processing timed out (media_id={mid}, last={state})")
+            time.sleep(info.get("check_after_secs") or 3)
+            st = self._s.call("GET", f"https://upload.x.com{p}?command=STATUS&media_id={mid}")
+            info = st.get("processing_info") or {}
+            state = info.get("state")
+        if state == "failed":
+            raise E.XError(f"Video processing failed: {json.dumps(info.get('error', info))[:250]}")
+        if state != "succeeded":
+            raise E.XError(f"Video processing state={state} (media_id={mid})")
+        return mid
+
+    def download(self, url, dest_path, timeout=60):
+        """Download a media URL (pbs/video CDN, no auth needed) to dest_path.
+        Returns dest_path. Proven live by xapiweb 2026-09-20."""
+        req = urllib.request.Request(url, headers={"User-Agent": self._s.user_agent})
+        total = 0
+        with urllib.request.urlopen(req, timeout=timeout) as resp, open(dest_path, "wb") as f:
+            while True:
+                chunk = resp.read(65536)
+                if not chunk:
+                    break
+                f.write(chunk)
+                total += len(chunk)
+        if total == 0:
+            raise E.XError(f"Downloaded 0 bytes from {url}")
+        return dest_path
+
+    def download_tweet_media(self, tweet_id, dest_dir="."):
+        """Download ALL media of a tweet into dest_dir (photo/video/gif).
+        Returns [paths]. Proven live by xapiweb 2026-09-20."""
+        os.makedirs(dest_dir, exist_ok=True)
+        paths = []
+        for i, m in enumerate(self._client.tweets.media(tweet_id)):
+            if not m.get("url"):
+                continue
+            if m["type"] in ("video", "animated_gif"):
+                ext = ".mp4"
+            else:
+                ext = os.path.splitext(urllib.parse.urlparse(m["url"]).path)[1] or ".jpg"
+            paths.append(self.download(m["url"], os.path.join(dest_dir, f"{tweet_id}_{i}{ext}")))
+        return paths
+
+    # NOTE: image upload stays single-segment (proven); video uses upload_video().
+
+
+def parse_media_entities(leg):
+    """legacy -> [{type, url, thumb, width, height, duration_ms, bitrate, variants}].
+
+    photo -> direct image url; video/animated_gif -> best (max-bitrate) mp4 url.
+    Pure function (offline-testable). Proven live by xapiweb 2026-09-20."""
+    out = []
+    entities = leg.get("extended_entities") or leg.get("entities") or {}
+    for m in entities.get("media") or []:
+        if not isinstance(m, dict):
+            continue
+        typ = m.get("type")
+        info = m.get("original_info") or {}
+        item = {"type": typ, "id": m.get("id_str"), "thumb": m.get("media_url_https"),
+                "width": info.get("width"), "height": info.get("height"),
+                "allow_download": ((m.get("allow_download_status") or {}).get("allow_download"))}
+        if typ == "photo":
+            item["url"] = m.get("media_url_https")
+        else:
+            vinfo = m.get("video_info") or {}
+            variants = vinfo.get("variants") or []
+            mp4s = [v for v in variants
+                    if isinstance(v, dict) and v.get("content_type") == "video/mp4" and v.get("url")]
+            best = max(mp4s, key=lambda v: v.get("bitrate") or 0) if mp4s else None
+            item["url"] = best["url"] if best else None
+            item["bitrate"] = best.get("bitrate") if best else None
+            item["duration_ms"] = vinfo.get("duration_millis")
+            item["variants"] = variants
+        out.append(item)
+    return out

xapiweb/resources/misc.py

@@ -0,0 +1,164 @@
+"""Misc: mixers, beacons, probes, and one-off queries."""
+import json
+import urllib.error
+from ._base import BaseResource
+
+
+class Misc(BaseResource):
+    def authenticate_periscope(self):
+        """JWT for live/periscope calls. Proven: test_authenticate_periscope.py"""
+        return self._s.gql_get("AuthenticatePeriscope", {}, with_features=False, with_toggles=False)
+
+    def urt_fixtures(self):
+        """Proven: test_urt_fixtures.py"""
+        return self._s.gql_get("UrtFixtures", {}, with_features=False, with_toggles=False)
+
+    def bakery(self):
+        """Cookie catalog. Proven: test_bakery_cookies.py"""
+        return self._s.gql_get("BakeryQuery", {})
+
+    def supported_languages(self):
+        """Proven: test_supported_languages.py"""
+        return self._s.gql_get("SupportedLanguages", {})
+
+    def story_topic(self, rest_id="For You", limit=3):
+        """Proven: test_story_topic.py"""
+        return self._s.gql_get("useStoryTopicQuery", {"rest_id": rest_id, "limit": limit},
+                               with_features=False, with_toggles=False)
+
+    def nfl_follow(self):
+        """Proven: test_nfl_follow.py"""
+        return self._s.gql_get("NflScoresSidebarFollow", {}, with_features=False, with_toggles=False)
+
+    def tv_home_mixer(self):
+        """Proven: test_tv_home_mixer.py"""
+        return self._s.gql_get("TVHomeMixer", {})
+
+    def payments_typeahead(self, prefix="e"):
+        """Proven: test_payments_typeahead.py"""
+        return self._s.gql_get("PaymentsUsersTypeahead", {"prefix": prefix})
+
+    def media_tab_videos(self, user_id=None):
+        """Proven: test_media_tab_videos.py"""
+        return self._s.gql_get("MediaTabVideoMixer", {"userId": str(user_id or self._me())})
+
+    def fleetline(self):
+        """Proven: test_fleetline.py"""
+        return self._s.rest_get("fleets/v1/fleetline", {"only_spaces": "true"},
+                                host="https://x.com", prefix="/i/api/")
+
+    def avatar_content(self, user_id=None):
+        """Proven: test_avatar_content.py"""
+        return self._s.rest_get("fleets/v1/avatar_content",
+                                {"user_ids": str(user_id or self._me()), "only_spaces": "true"},
+                                host="https://x.com", prefix="/i/api/")
+
+    def biz_team_timeline(self, team_name="x", user_id=None):
+        """Bogus team => empty timeline. Proven: test_biz_team_timeline.py"""
+        return self._s.gql_post("UserBusinessProfileTeamTimeline", {
+            "userId": str(user_id or self._me()), "teamName": team_name,
+            "includePromotedContent": False})
+
+    def sidebar_recommendations(self, user_id=None):
+        """Proven: test_sidebar_recommendations.py"""
+        return self._s.gql_get("SidebarUserRecommendations",
+                               {"profileUserId": str(user_id or self._me())}, with_toggles=False)
+
+    def super_followers(self, user_id=None, count=5):
+        """Proven: test_super_followers.py"""
+        return self._s.gql_get("SuperFollowers", {
+            "userId": str(user_id or self._me()), "count": count, "includePromotedContent": False})
+
+    def premium_paywall(self):
+        """Proven: test_premium_paywall.py"""
+        return self._s.gql_post("usePremiumPaywallOnLoadMutation", {})
+
+    def season_schedule(self, user_id=None, days_back=7, days_fwd=14):
+        """Proven: test_profile_season_schedule.py"""
+        import time
+        now = int(time.time() * 1000)
+        return self._s.gql_get("ProfileSeasonSchedule", {
+            "rest_id": str(user_id or self._me()),
+            "start_time": str(now - days_back * 86400 * 1000),
+            "end_time": str(now + days_fwd * 86400 * 1000)},
+            with_features=False, with_toggles=False)
+
+    def team_roster(self, user_id=None):
+        """Proven: test_profile_team_roster.py"""
+        return self._s.gql_get("ProfileTeamRoster", {"rest_id": str(user_id or self._me())},
+                               with_features=False, with_toggles=False)
+
+    def vo_upsell(self, screen_name):
+        """Proven: test_vo_upsell_eligibility.py"""
+        return self._s.gql_get("isEligibleForVoButtonUpsellQuery",
+                               {"screenName": screen_name,
+                                "promptPurpose": "x_vo_business_promotion"},
+                               with_features=False, with_toggles=False)
+
+    def csp_report(self):
+        """CSP beacon sink. Proven: test_csp_report.py"""
+        payload = json.dumps({"csp-report": {
+            "document-uri": "https://x.com/home", "blocked-uri": "https://example.com/x.js",
+            "violated-directive": "script-src", "original-policy": "test",
+            "disposition": "enforce"}})
+        return self._s.call("POST", "https://x.com/i/csp_report?a=1&ro=0", payload)
+
+    def log_promoted_view(self, trend_id="117896", impression_id="6752072595616677896",
+                          event="trend_view"):
+        """Promoted-trend impression beacon.
+
+        NOTE: this is for PROMOTED (ad) content, NOT organic tweet views — it takes a
+        trend id, not a tweet id, so it cannot register a view for a post. There is no
+        proven endpoint for organic view-logging in the pack. Proven: test_promoted_log.py"""
+        return self._s.rest_post_form("promoted_content/log.json", {
+            "promoted_trend_id": str(trend_id), "event": event,
+            "impression_id": str(impression_id)})
+
+    def promoted_log(self, trend_id="117896", impression_id="6752072595616677896"):
+        """Alias of log_promoted_view() with default test params. Proven: test_promoted_log.py"""
+        return self.log_promoted_view(trend_id, impression_id)
+
+    def manifest_sw(self):
+        """Returns (manifest_resp, sw_resp). Proven: test_manifest_sw.py"""
+        return (self._s.call("GET", "https://x.com/manifest.json"),
+                self._s.call("GET", "https://x.com/sw.js"))
+
+    def feedback_shape(self):
+        """Bogus-token shape only (real fire = irreversible algo signal).
+        Proven: test_timelines_feedback_shape.py"""
+        return self._s.gql_post("timelinesFeedback",
+                                {"encoded_feedback_request": "x", "undo": False})
+
+    def unmention_shape(self, tweet_id):
+        """Proven: test_unmention_shape.py (clean error when not mentioned)."""
+        return self._s.gql_post("UnmentionUserFromConversation", {"tweet_id": str(tweet_id)})
+
+    def probe_removed(self):
+        """Re-verify legacy endpoints are still gone (expect 404/410, enrollment 403).
+        Proven: test_removed_endpoints.py"""
+        paths = ["statuses/show.json?id=1", "statuses/lookup.json?id=1", "favorites/list.json",
+                 "search/adaptive.json?q=x", "guide/topic.json?slug=news", "topics/discover.json",
+                 "collections/list.json", "people_discovery/modules_urt.json",
+                 "settings/trends.json", "settings/devices.json", "notifications/all.json",
+                 "account/login_verification_enrollment.json", "graphql/viewer_context.json"]
+        got = {}
+        for p in paths:
+            try:
+                got[p] = self._s.rest_get(p).status
+            except urllib.error.HTTPError as e:
+                got[p] = e.code
+            except Exception as e:
+                got[p] = getattr(e, "status", f"ERR {e}"[:40])
+        return got
+
+    def probe_deprecated(self):
+        """Re-verify deprecated endpoints still 200-empty. Proven: test_deprecated_empty.py"""
+        out = {}
+        r1 = self._s.rest_get("users/search.json", {"q": "elon"})
+        out["users/search"] = (r1.status, len(r1.raw))
+        r2 = self._s.rest_get("statuses/home_timeline.json", {"count": 3})
+        out["statuses/home_timeline"] = (r2.status, len(r2.raw))
+        r3 = self._s.rest_get("statuses/user_timeline.json",
+                              {"user_id": self._me(), "count": 3})
+        out["statuses/user_timeline"] = (r3.status, len(r3.raw))
+        return out