xapiweb 1.5.0__tar.gz

xapiweb-1.5.0/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: xapiweb
+Version: 1.5.0
+Summary: Unified Python library for the X web API (stdlib only, 157 proven endpoints)
+Requires-Python: >=3.8

xapiweb-1.5.0/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "xapiweb"
+version = "1.5.0"
+description = "Unified Python library for the X web API (stdlib only, 157 proven endpoints)"
+requires-python = ">=3.8"
+dependencies = []
+
+[build-system]
+requires = ["setuptools"]

xapiweb-1.5.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xapiweb-1.5.0/xapiweb/__init__.py

@@ -0,0 +1,13 @@
+"""xapiweb — unified Python library for the X web API (stdlib only).
+
+Built from the proven x_api_pack (157/157 tests live 2026-09-19):
+every method maps to a live-tested endpoint; writes verify by re-reading.
+"""
+from .client import XClient
+from .session import Session
+from .response import Response
+from . import errors
+from .qids import QIDS
+
+__version__ = "1.5.0"
+__all__ = ["XClient", "Session", "Response", "errors", "QIDS"]

xapiweb-1.5.0/xapiweb/_txn.py

@@ -0,0 +1,224 @@
+"""x-client-transaction-id generator (stdlib only, no third-party deps).
+
+Generates the per-request anti-bot token X's web client attaches to API calls.
+Valid tokens REQUIRE the key + animation frames from the *logged-in* homepage
+(https://x.com/home fetched with session cookies) - the logged-out page yields
+tokens the server rejects.
+
+Algorithm ported from twikit's twikit/x_client_transaction (MIT, by twikit
+contributors) with BeautifulSoup replaced by regex + urllib so this file has
+zero dependencies. Tested live 2026-09-19: tokens accepted (200) on
+txn-gated endpoints (CreateTweet, users/show, account/settings, ...).
+
+Key-byte indices [47, 41, 13, 12] were extracted 2026-09-19 from
+abs.twimg.com/.../ondemand.s.0cc29d94ce9e97eea.js with the regex below.
+If X rotates the deploy and tokens start failing, re-derive:
+  1. DevTools Network tab -> find ondemand.s.<hash>a.js -> download it
+  2. indices = re.findall(r"\\(\\w\\[(\\d{1,2})\\],\\s*16\\)", src)
+  3. row_index, key_indices = indices[0], indices[1:]
+"""
+import base64
+import hashlib
+import math
+import random
+import re
+import time
+import urllib.request
+from functools import reduce
+from typing import List, Union
+
+INDICES_REGEX = re.compile(r"(\(\w{1}\[(\d{1,2})\],\s*16\))+")
+
+# ---------------------------------------------------------------- cubic ---
+class Cubic:
+    def __init__(self, curves: List[Union[float, int]]):
+        self.curves = curves
+
+    def get_value(self, time_: Union[float, int]):
+        start_gradient = end_gradient = start = mid = 0.0
+        end = 1.0
+        if time_ <= 0.0:
+            if self.curves[0] > 0.0:
+                start_gradient = self.curves[1] / self.curves[0]
+            elif self.curves[1] == 0.0 and self.curves[2] > 0.0:
+                start_gradient = self.curves[3] / self.curves[2]
+            return start_gradient * time_
+        if time_ >= 1.0:
+            if self.curves[2] < 1.0:
+                end_gradient = (self.curves[3] - 1.0) / (self.curves[2] - 1.0)
+            elif self.curves[2] == 1.0 and self.curves[0] < 1.0:
+                end_gradient = (self.curves[1] - 1.0) / (self.curves[0] - 1.0)
+            return 1.0 + end_gradient * (time_ - 1.0)
+        while start < end:
+            mid = (start + end) / 2
+            x_est = self.calculate(self.curves[0], self.curves[2], mid)
+            if abs(time_ - x_est) < 0.00001:
+                return self.calculate(self.curves[1], self.curves[3], mid)
+            if x_est < time_:
+                start = mid
+            else:
+                end = mid
+        return self.calculate(self.curves[1], self.curves[3], mid)
+
+    @staticmethod
+    def calculate(a, b, m):
+        return 3.0 * a * (1 - m) * (1 - m) * m + 3.0 * b * (1 - m) * m * m + m * m * m
+
+
+# ---------------------------------------------------------- interpolate ---
+def _interpolate_num(from_val, to_val, f):
+    if all(isinstance(n, (int, float)) for n in (from_val, to_val)):
+        return from_val * (1 - f) + to_val * f
+    if all(isinstance(n, bool) for n in (from_val, to_val)):
+        return from_val if f < 0.5 else to_val
+
+
+def interpolate(from_list, to_list, f):
+    if len(from_list) != len(to_list):
+        raise Exception(f"Mismatched interpolation arguments {from_list}: {to_list}")
+    return [_interpolate_num(a, b, f) for a, b in zip(from_list, to_list)]
+
+
+# ------------------------------------------------------------- rotation ---
+def convert_rotation_to_matrix(rotation: Union[float, int]):
+    rad = math.radians(rotation)
+    return [math.cos(rad), -math.sin(rad), math.sin(rad), math.cos(rad)]
+
+
+# ---------------------------------------------------------------- utils ---
+def float_to_hex(x):
+    result = []
+    quotient = int(x)
+    fraction = x - quotient
+    while quotient > 0:
+        quotient = int(x / 16)
+        remainder = int(x - (float(quotient) * 16))
+        result.insert(0, chr(remainder + 55) if remainder > 9 else str(remainder))
+        x = float(quotient)
+    if fraction == 0:
+        return ''.join(result)
+    result.append('.')
+    while fraction > 0:
+        fraction *= 16
+        integer = int(fraction)
+        fraction -= float(integer)
+        result.append(chr(integer + 55) if integer > 9 else str(integer))
+    return ''.join(result)
+
+
+def is_odd(num: Union[int, float]):
+    return -1.0 if num % 2 else 0.0
+
+
+def base64_encode(data) -> str:
+    data = data.encode() if isinstance(data, str) else data
+    return base64.b64encode(data).decode()
+
+
+# ---------------------------------------------------- transaction (sync) ---
+class ClientTransaction:
+    ADDITIONAL_RANDOM_NUMBER = 3
+    DEFAULT_KEYWORD = "obfiowerehiring"
+
+    def __init__(self, row_index: int = 47, key_indices=(41, 13, 12)):
+        self.home_html = None
+        self.frames_d = []
+        self.key = None
+        self.key_bytes = None
+        self.animation_key = None
+        self.row_index = row_index
+        self.key_indices = list(key_indices)
+
+    # -- stdlib replacements for the BeautifulSoup parts -------------------
+    @staticmethod
+    def extract_key(html: str) -> str:
+        m = re.search(r'<meta[^>]*twitter-site-verification[^>]*content="([^"]+)"', html)
+        if not m:
+            m = re.search(r'<meta[^>]*content="([^"]+)"[^>]*twitter-site-verification', html)
+        if not m:
+            raise Exception("Couldn't get key from the page source")
+        return m.group(1)
+
+    @staticmethod
+    def extract_frames(html: str) -> List[str]:
+        """Return the animation-path `d` attr (2nd <path>) of each loading-x-anim svg."""
+        ds = []
+        for i in range(4):
+            m = re.search(r'id="loading-x-anim-%d".*?</svg>' % i, html, re.S)
+            if not m:
+                raise Exception(f"loading-x-anim-{i} not found in page")
+            paths = re.findall(r'<path[^>]*\sd="([^"]+)"', m.group(0))
+            if len(paths) < 2:
+                raise Exception(f"animation path missing in frame {i}")
+            ds.append(paths[1])
+        return ds
+
+    def init_from_html(self, html: str):
+        self.home_html = html
+        self.key = self.extract_key(html)
+        self.key_bytes = list(base64.b64decode(bytes(self.key, "utf-8")))
+        self.frames_d = self.extract_frames(html)
+        self.animation_key = self.get_animation_key(self.key_bytes)
+
+    def init_logged_in(self, cookie: str, user_agent: str):
+        req = urllib.request.Request(
+            "https://x.com/home", headers={"User-Agent": user_agent, "Cookie": cookie})
+        html = urllib.request.urlopen(req, timeout=25).read().decode("utf-8", "replace")
+        self.init_from_html(html)
+
+    # -- math (ported verbatim) --------------------------------------------
+    def get_2d_array(self, key_bytes):
+        d = self.frames_d[key_bytes[5] % 4]
+        return [[int(x) for x in re.sub(r"[^\d]+", " ", item).strip().split()]
+                for item in d[9:].split("C")]
+
+    def solve(self, value, min_val, max_val, rounding: bool):
+        result = value * (max_val - min_val) / 255 + min_val
+        return math.floor(result) if rounding else round(result, 2)
+
+    def animate(self, frames, target_time):
+        from_color = [float(i) for i in [*frames[:3], 1]]
+        to_color = [float(i) for i in [*frames[3:6], 1]]
+        from_rotation = [0.0]
+        to_rotation = [self.solve(float(frames[6]), 60.0, 360.0, True)]
+        frames = frames[7:]
+        curves = [self.solve(float(item), is_odd(c), 1.0, False)
+                  for c, item in enumerate(frames)]
+        val = Cubic(curves).get_value(target_time)
+        color = [v if v > 0 else 0 for v in interpolate(from_color, to_color, val)]
+        rotation = interpolate(from_rotation, to_rotation, val)
+        matrix = convert_rotation_to_matrix(rotation[0])
+        str_arr = [format(round(v), "x") for v in color[:-1]]
+        for value in matrix:
+            rounded = round(value, 2)
+            if rounded < 0:
+                rounded = -rounded
+            hv = float_to_hex(rounded)
+            str_arr.append(f"0{hv}".lower() if hv.startswith(".") else hv if hv else "0")
+        str_arr.extend(["0", "0"])
+        return re.sub(r"[.-]", "", "".join(str_arr))
+
+    def get_animation_key(self, key_bytes):
+        row_index = key_bytes[self.row_index] % 16
+        frame_time = reduce(lambda a, b: a * b,
+                            [key_bytes[i] % 16 for i in self.key_indices])
+        frame_row = self.get_2d_array(key_bytes)[row_index]
+        return self.animate(frame_row, float(frame_time) / 4096)
+
+    def generate_transaction_id(self, method: str, path: str, time_now=None) -> str:
+        time_now = time_now or math.floor((time.time() * 1000 - 1682924400 * 1000) / 1000)
+        time_now_bytes = [(time_now >> (i * 8)) & 0xFF for i in range(4)]
+        key_bytes = self.key_bytes or list(base64.b64decode(bytes(self.key, "utf-8")))
+        animation_key = self.animation_key or self.get_animation_key(key_bytes)
+        digest = hashlib.sha256(
+            f"{method}!{path}!{time_now}{self.DEFAULT_KEYWORD}{animation_key}".encode()
+        ).digest()
+        random_num = random.randint(0, 255)
+        arr = [*key_bytes, *time_now_bytes, *list(digest)[:16],
+               self.ADDITIONAL_RANDOM_NUMBER]
+        out = bytearray([random_num, *[b ^ random_num for b in arr]])
+        return base64_encode(out).strip("=")
+
+
+if __name__ == "__main__":
+    print("import this module; see common.py for usage")

xapiweb-1.5.0/xapiweb/client.py

@@ -0,0 +1,52 @@
+"""XClient: one object for the whole X web API (stdlib only)."""
+from .session import Session
+from .resources import (Tweets, Engagement, Timelines, Users, Follows, Moderation,
+                        Lists, DMs, Communities, Trends, Notifications, Settings, Media, Misc)
+
+
+class XClient:
+    """Unified client. Writes verify by re-reading; calls are paced (>=1s apart).
+
+    Usage:
+        from xapiweb import XClient
+        x = XClient.from_session_file("my_data.json")   # cookie + csrf_token
+        x.timelines.home()
+        x.tweets.post("hello", verify=True)
+    """
+
+    def __init__(self, cookie=None, csrf_token=None, session=None, **session_kw):
+        self.session = session or Session(cookie, csrf_token, **session_kw)
+        self._me_cache = None
+        self.tweets = Tweets(self)
+        self.engagement = Engagement(self)
+        self.timelines = Timelines(self)
+        self.users = Users(self)
+        self.follows = Follows(self)
+        self.moderation = Moderation(self)
+        self.lists = Lists(self)
+        self.dms = DMs(self)
+        self.communities = Communities(self)
+        self.trends = Trends(self)
+        self.notifications = Notifications(self)
+        self.settings = Settings(self)
+        self.media = Media(self)
+        self.misc = Misc(self)
+
+    @classmethod
+    def from_session_file(cls, path, **session_kw):
+        return cls(session=Session.from_session_file(path, **session_kw))
+
+    @property
+    def me_id(self):
+        """Session owner's user id (from session file refs, else fetched+cached)."""
+        if self.session.refs.get("self_id"):
+            return self.session.refs["self_id"]
+        return self.me()["id"]
+
+    def me(self):
+        """Cached {id, screen_name, name} of the session owner."""
+        return self.users.me()
+
+    def health(self):
+        """Cheap liveness probe (badge counts). 200 => session alive."""
+        return self.notifications.badge_counts()

xapiweb-1.5.0/xapiweb/errors.py

@@ -0,0 +1,114 @@
+"""Structured errors for xapiweb (mapped from the pack's error catalog, guide §9)."""
+
+
+class XError(Exception):
+    """Base error for all xapiweb failures."""
+
+
+class XHttpError(XError):
+    """HTTP-level failure."""
+
+    def __init__(self, url, status, body=""):
+        self.url = url
+        self.status = status
+        self.body = body or ""
+        super().__init__(f"HTTP {status} {url}: {self.body[:200]}")
+
+
+class XAuthError(XHttpError):
+    """401 — session dead (recapture cookies + ct0)."""
+
+
+class XRateLimitError(XHttpError):
+    """403/429 — throttle/challenge (already retried once; cool off)."""
+
+
+class XTxnError(XError):
+    """Bad/missing x-client-transaction-id masquerading as another error
+    (REST 404 code 34, CreateTweet 200 with empty tweet_results, CreateBookmark 404,
+    or 344 'daily limit' MISTEXT on a fresh account)."""
+
+
+class XValidationError(XHttpError):
+    """422 GRAPHQL_VALIDATION_FAILED — missing/wrong variable (see body path)."""
+
+
+class XMethodError(XHttpError):
+    """406 — mutation called via GET (use POST)."""
+
+
+class XApiError(XError):
+    """GraphQL data-level error (HTTP 200 with errors[])."""
+
+    def __init__(self, code, message, op=""):
+        self.code = code
+        self.message = message or ""
+        self.op = op
+        super().__init__(f"[{op}] code {code}: {self.message[:250]}" if op else f"code {code}: {self.message[:250]}")
+
+
+class XAutomationFlag(XApiError):
+    """226 — 'looks like it might be automated' (slow down, cool off)."""
+
+
+class XGateError(XApiError):
+    """37 — Authorization: not author / no phone / no Premium / no eligibility."""
+
+
+class XBadRequest(XApiError):
+    """214 — BadRequest: bad token / invalid target."""
+
+
+class XAlreadyError(XApiError):
+    """327 — already retweeted (unretweet first)."""
+
+
+class XDailyLimit(XApiError):
+    """344 — daily limit (often MISTEXT when txn is bad — fix txn first)."""
+
+
+class XVerifyError(XError):
+    """Verify-by-reread failed: the ack lied or state did not change."""
+
+
+def http_error(url, status, body):
+    """Map an HTTP failure to a structured exception (guide §9)."""
+    body = body or ""
+    compact = body.replace(" ", "")
+    if status == 401:
+        return XAuthError(url, status, body)
+    if status in (403, 429):
+        return XRateLimitError(url, status, body)
+    if status == 406:
+        return XMethodError(url, status, body)
+    if status == 422:
+        return XValidationError(url, status, body)
+    if status == 404 and '"code":34' in compact:
+        return XTxnError(
+            f"404 code 34 on {url}: almost certainly a bad/missing "
+            f"x-client-transaction-id (not a dead endpoint). Regenerate txn for "
+            f"the exact (method, path); probe account/settings (must 200)."
+        )
+    return XHttpError(url, status, body)
+
+
+def guard(resp, op=""):
+    """Raise on GraphQL data-level errors[]; return resp otherwise."""
+    data = resp.data
+    errs = data.get("errors") if isinstance(data, dict) else None
+    if not errs:
+        return resp
+    e0 = errs[0] if isinstance(errs, list) else errs
+    code = e0.get("code") if isinstance(e0, dict) else None
+    msg = (e0.get("message", "") if isinstance(e0, dict) else str(e0)) or ""
+    if code == 226:
+        raise XAutomationFlag(code, msg, op)
+    if code == 37:
+        raise XGateError(code, msg, op)
+    if code == 214:
+        raise XBadRequest(code, msg, op)
+    if code == 327:
+        raise XAlreadyError(code, msg, op)
+    if code == 344:
+        raise XDailyLimit(code, msg, op)
+    raise XApiError(code, msg, op)

xapiweb-1.5.0/xapiweb/qids.py

@@ -0,0 +1,126 @@
+"""Operation -> queryId table (all values verified live 2026-09-19)."""
+
+QIDS = {
+    # ledger reads (GET)
+    "Following": "-Mn4uN7C-vxXBwUKtSwS6A", "PinnedTimelines": "1C9qXYjxcujNpyJWE6tAeg",
+    "CreatorStudioTabBarItemQuery": "1KZj_GRTxmPaSrk8jIb1Yw",
+    "isEligibleForVoButtonUpsellQuery": "BuWF9hiwmUyFdGo3J4DqbA",
+    "BlueVerifiedFollowers": "DWeIe6l1rsZMqHPbbWXtig",
+    "FetchScheduledTweets": "H2elmT2R9DLhWoo0DZFNkA",
+    "useStoryTopicQuery": "I3V_Tt32aTZdw7cBdKUJbg",
+    "ProfileTeamRoster": "I5ALHyuvPb6h7soVmbcq9g",
+    "NflScoresSidebarFollow": "JR_EpH80gwgFyOBOreLBZw",    "UserByScreenName": "KybxDj9RrADIITXlGG8kpw",
+    "NotificationsTimeline": "MSUPE4KwuxyghDO60Bv5uQ",  # user-captured 2026-09-20
+    "FetchDraftTweets": "L9RqKWmAWxK6vGtR3Qdsxw",
+    "QuickPromoteEligibility": "LtpCXh66W-uXh7u7XSRA8Q",
+    "ProfileSeasonSchedule": "M946jrb9CchmjVYMukJ6RQ",
+    "UsersVerifiedAvatars": "O9O_O1iF0QffoOBjB2OGIQ",
+    "getAltTextPromptPreference": "PFIxTk8owMoZgiMccP0r4g",
+    "SidebarUserRecommendations": "XFGj2pdlasiM3FndUe1PrQ",
+    "UserOriginalsTimeline": "Yr8749ieoUptxRqQv766Fw",
+    "Followers": "fVGYs5W9kNUuoUrZwYZQpQ",  # POST only (GET 404s)
+    "ProfileSpotlightsQuery": "mzoqrVGwk-YTSGME1dRfXQ",
+    "ViewerBadgeCounts": "q4Npr1-FYRWyXsRzPckwEA",
+    "DataSaverMode": "xF6sXnKJfS2AOylzxRjf6A",
+    "ExploreSidebar": "zJF1HRGpRjCStcTNm5aekA",
+    # ledger writes (POST)
+    "HomeTimeline": "og4a4SdSF3WiQkkwaPCdPg",
+    "FavoriteTweet": "lI07N6Otwv1PhnEgXILM7A",
+    "CreateRetweet": "mbRO74GrOvSfRcJnlMapnQ",
+    "CreateTweet": "GYdIGqVWfZNho79bQ2XDoA",  # txn-id REQUIRED
+    "usePremiumPaywallOnLoadMutation": "F6gikc1Bwzry7oHMrdrYzg",
+    "PutClientEducationFlag": "IjQ-egg0uPkY11NyPMfRMQ",
+    # discovered in JS, verified live
+    "Viewer": "9t128XgFic52jPUEkJMf6w",
+    "TweetResultByRestId": "Xl0tsHf4AzflMRjbw9e70A",
+    "TweetDetail": "zoF7_t363wZyzylk-BLfZQ",
+    "UserTweets": "jeAA-59Y9FL7FmjgBNIVPw",
+    "UserRepliesTimeline": "xz348nziCm96wndJ1S0MUQ",
+    "UserMedia": "TwLiEVUhRjjjKVc98IT0TQ",
+    "Likes": "XHn_Tw60c6pi0n3DGhpwiA",
+    "UserRepostsTimeline": "CnNg1YiKG7bRgi-RoIfKsw",
+    "UserVideoTimeline": "8FjnVm2ZmIymF6l1Tw2fBQ",
+    "UserHighlightsTweets": "TtovDhtuqVtzzfZ9fpztlw",
+    "UserArticlesTweets": "ic9_Nc9wg4whcOEBiWAP4w",
+    "UserPhotoTimeline": "-7Kl-CfOGgXpmvSvNxuPpA",
+    "UserTweetsAndReplies": "wI-ubAWfScnG6odLK4XgCg",  # POST only
+    "UserSuperFollowTweets": "6SjR3fvrAJwMXjnYF-0KEQ",
+    "UserPromotedTweets": "K8KVrFEj0ec0WnOZOtTpaA",
+    "UserPromotableTweets": "bwNtu6M5zSf94E7TmbrRIA",
+    "UserByRestId": "IdmRdjYxIGI39Hdwkwo5cQ",
+    "UsersByRestIds": "BuQFwM7wpHl00cfHL-r0rA",  # POST only
+    "UsersByScreenNames": "8G9O4pAkWTXNv3XQuOGVrw",
+    "SearchTimeline": "auLkqtmHqYEpRvflfvLhyQ",  # POST only
+    "ExplorePage": "7JBlImZfRkZIptknshoqCA",
+    "SupportedLanguages": "fZ5uZVeledO5SAseKnmTUg",
+    "GetUserClaims": "aQ-b88K_Lp7dgHX53MqNQQ",
+    "UserPreferences": "xFxU-O8hEYe74ovNVU74jA",
+    "UserSessionsList": "vJ-XatpmQSG8bDch8-t9Jw",
+    "Upsells": "Sg3BvwapuCMIjLJ7LGPhMA",
+    "PinnableTimelines": "XUpSmUE_n6ez-U_SdC7G7g",
+    "MutedAccounts": "doSy_eEELN6ol2addK5OfA",
+    "BlockedAccountsAll": "VlsRzrlUBsLKHvQdoYdSGw",
+    "BlockedAccountsImported": "S05B7hxH_1XPxdMiKT-VlQ",
+    "ModeratedTimeline": "kO0Oq6PcLpvQacRyW3LIPw",
+    "ConnectTabTimeline": "2a5nvYPVhrgXZqTUg8O5ZA",
+    "BookmarkSearchTimeline": "rbwiGBFqb93lmG7mw_OYZQ",
+    "ListSearchTimeline": "i4096Pm5N66WDAdjumVLrQ",
+    "SimilarPosts": "pnl_SipPG1I4d2CBGCEgQw",
+    "TrendRelevantUsers": "Av5yDFt1dtyBu2vhvvTA1g",
+    "TrendHistory": "2e9kT9dZau_UsQy29Ssj8Q",
+    "FinanceSearchTags": "4VTsYZ3r4xYW9S0Rys5G0A",
+    "GetUsernameAvailabilityAndSuggestions": "1bMz-9lPrmIXrhFmXntTHw",  # POST
+    "ProfileUserPhoneState": "5kUWP8C1hcd6omvg6HXXTQ",
+    "SuperFollowers": "4A1krY2Xn7uTA4tGOM6Gzw",
+    "UserCreatorSubscriptions": "NteGelNq-3jzn3gbc7fyvA",
+    "UserCreatorSubscribers": "ZKWe719CjFmlxZM95aw_yQ",
+    "FollowersYouKnow": "hEiuVHcQAxCsfSE9aL2e_g",
+    "MediaTabVideoMixer": "fGRGW6Se0cRPDbyIK3wjTA",
+    "BakeryQuery": "pROR-yRiBVsEjJyHt3fvhg",
+    "GlobalCommunitiesPostSearchTimeline": "tbfwt3lMoSiVODtsBmEFGQ",
+    "GlobalCommunitiesLatestPostSearchTimeline": "tKfhQuBk1YpT2yhpMng0Gw",
+    "TVHomeMixer": "Mxc2_ki1khctdccHe5LN6A",
+    "PaymentsUsersTypeahead": "dlHFEO5q9vveDgITz9zELg",
+    # mutations, all verified live (pairs restore state)
+    "UnfavoriteTweet": "ZYKSe-w7KEslx3JhSIk5LA",
+    "DeleteRetweet": "ZyZigVsNiFO6v1dEks1eWg",  # source_tweet_id = ORIGINAL id
+    "CreateBookmark": "aoDbu3RHznuiSkQ9aNM67Q",  # txn-id REQUIRED
+    "DeleteBookmark": "Wlmlj2-xzyS1GN3a6cj-mQ",
+    "DownvoteTweet": "Iu4kUV4vd_iHMupiHPPrAQ",
+    "UndoDownvoteTweet": "yqhcbdyy59k-FCwOysvvGQ",
+    "DeleteTweet": "nxpZCY2K-I6QoFHAHeojFQ",
+    "PinTweet": "VIHsNu89pK-kW35JpHq7Xw",
+    "UnpinTweet": "BhKei844ypCyLYCg0nwigw",
+    "dmBlockUser": "IYw9u1KEhrS-t-BXsau4Uw",
+    "dmUnblockUser": "Krbs6Nak_o7liWQwfV1jOQ",
+    "AddContentDisclosure": "D1nwFlsu_qHsX92YzoRaaA",
+    "AuthenticatePeriscope": "r7VUmxbfqNkx7uwjgONSNw",
+    "CommunityMemberRelationshipTypeahead": "6YgvBKI7c3YZ9d7zKKojng",
+    "CommunityUserRelationshipTypeahead": "MOKE3VjNMJ7BVsWdNkv32g",
+    "ConversationControlChange": "57WYJNnWH0vM3Ip_gm8B2g",
+    "ConversationControlDelete": "OoMO_aSZ1ZXjegeamF9QmA",
+    "CreateHighlight": "7jEc7ECTTDcNaqsMhjTxXg",
+    "CreateNoteTweet": "u-Vsy3HZId2j10nbdqMI0A",
+    "DeleteContentDisclosure": "YeIV-eqGwEZXDtYaDsJz2Q",
+    "DeleteHighlight": "ea-VVDSLIEYNY2_2aPg3Uw",
+    "DisableVerifiedPhoneLabel": "g2m0pAOamawNtVIfjXNMJg",
+    "DmNsfwMediaFilterUpdate": "of_N6O33zfyD4qsFJMYFxA",
+    "EnableVerifiedPhoneLabel": "C3RJFfMsb_KcEytpKmRRkw",
+    "GenericTimelineById": "6KKcBTcCsVtXvAx4aFDzRQ",
+    "ModerateTweet": "pjFnHGVqCjTcZol0xcBJjw",
+    "PinTimeline": "ZMYcJPUQ0QIAyWekMdAuDw",
+    "ProfileFilter": "O6BaAhZzuUp7_TTTynMF2g",
+    "RemoveFollower": "QpNfg0kpPRfjROQ_9eOLXA",
+    "SharingAudiospacesListeningDataWithFollowersUpdate": "5h0kNbk3ii97rmfY6CdgAA",
+    "TweetResultsByRestIds": "mQnBPxNdkMLfhXINDDYUSg",
+    "UnmentionUserFromConversation": "xVW9j3OqoBRY9d6_2OONEg",
+    "UnmoderateTweet": "pVSyu6PA57TLvIE4nN2tsA",
+    "UnpinTimeline": "_uu6eZuimGwywEa4qtZxZA",
+    "UnpinTweet": "BhKei844ypCyLYCg0nwigw",
+    "UpdatePinnedTimelines": "AtN-0mKI3fXXmxzYYk1Wqw",
+    "UrtFixtures": "Jw90Znej2ooqJH0gx1voEA",
+    "UserBusinessProfileTeamTimeline": "v_oniRKLdCZ__sqG-6yTqQ",
+    "WriteDataSaverPreferences": "H03etWvZGz41YASxAU2YPg",
+    "timelinesFeedback": "vfVbgvTPTQ-dF_PQ5lD1WQ",
+    "updateAltTextPromptPreference": "aQKrduk_DA46XfOQDkcEng",
+}

xapiweb-1.5.0/xapiweb/resources/__init__.py

@@ -0,0 +1,20 @@
+"""All API resources (one class per area)."""
+from ._base import BaseResource
+from .tweets import Tweets
+from .engagement import Engagement
+from .timelines import Timelines
+from .users import Users
+from .follows import Follows
+from .moderation import Moderation
+from .lists import Lists
+from .dms import DMs
+from .communities import Communities
+from .trends import Trends
+from .notifications import Notifications
+from .settings import Settings
+from .media import Media
+from .misc import Misc
+
+__all__ = ["BaseResource", "Tweets", "Engagement", "Timelines", "Users", "Follows",
+           "Moderation", "Lists", "DMs", "Communities", "Trends", "Notifications",
+           "Settings", "Media", "Misc"]

xapiweb-1.5.0/xapiweb/resources/_base.py

@@ -0,0 +1,13 @@
+"""Shared base for all resources."""
+
+
+class BaseResource:
+    def __init__(self, client):
+        self._client = client
+
+    @property
+    def _s(self):
+        return self._client.session
+
+    def _me(self):
+        return self._client.me_id

xapiweb-1.5.0/xapiweb/resources/communities.py

@@ -0,0 +1,34 @@
+"""Communities: search, typeaheads, tweet moderation shapes."""
+from ._base import BaseResource
+
+
+class Communities(BaseResource):
+    def post_search(self, raw_query, count=5):
+        """Proven: test_communities_post_search.py"""
+        return self._s.gql_get("GlobalCommunitiesPostSearchTimeline",
+                               {"rawQuery": raw_query, "count": count})
+
+    def latest_search(self, raw_query, count=5):
+        """Proven: test_communities_latest_search.py"""
+        return self._s.gql_get("GlobalCommunitiesLatestPostSearchTimeline",
+                               {"rawQuery": raw_query, "count": count})
+
+    def member_typeahead(self, community_id, prefix="a"):
+        """Needs a REAL community id (bogus => CommunityUnavailable).
+        Proven: test_community_member_typeahead.py"""
+        return self._s.gql_post("CommunityMemberRelationshipTypeahead",
+                                {"communityId": str(community_id), "prefix": prefix})
+
+    def user_typeahead(self, community_id, prefix="a"):
+        """Proven: test_community_user_typeahead.py"""
+        return self._s.gql_post("CommunityUserRelationshipTypeahead",
+                                {"communityId": str(community_id), "prefix": prefix})
+
+    def moderate(self, tweet_id):
+        """Requires conversation authorship (code 37 otherwise — safe on others' tweets).
+        Proven: test_moderate_tweet_shape.py"""
+        return self._s.gql_post("ModerateTweet", {"tweetId": str(tweet_id)})
+
+    def unmoderate(self, tweet_id):
+        """Proven: test_unmoderate_tweet_shape.py"""
+        return self._s.gql_post("UnmoderateTweet", {"tweetId": str(tweet_id)})