xselfbot 4.0.0__tar.gz

xselfbot-4.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 d60
+
+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.

xselfbot-4.0.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: xselfbot
+Version: 4.0.0
+Summary: X client for python — posting, reading, search and streaming, no API key.
+Home-page: https://github.com/Tky567/xselfbot
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx[socks]
+Requires-Dist: filetype
+Requires-Dist: beautifulsoup4
+Requires-Dist: pyotp
+Requires-Dist: lxml
+Requires-Dist: webvtt-py
+Requires-Dist: m3u8
+Requires-Dist: Js2Py-3.13
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# XSelfBot
+
+X client for Python. Posts, reads, searches and streams over a cookie session, with no
+API key.
+
+```
+pip install git+https://github.com/Tky567/xselfbot.git@main
+```
+
+```
+pip install xselfbot
+```
+
+Requires Python 3.10+.
+
+## Session
+
+The cookie session is the supported path. Export the cookies of a signed-in browser
+session (any Netscape-format jar works) and hand them to the client:
+
+```python
+import asyncio
+from xselfbot import Client
+
+client = Client('en-US')
+client.load_cookies('cookies.json')
+
+async def main():
+    print(await client.identity())
+    # {'user_id': '…', 'screen_name': '…', 'name': '…', 'avatar': '…'}
+
+asyncio.run(main())
+```
+
+`login()` by password is still in the tree, but it is the path that gets accounts
+flagged. See [ToProtectYourAccount.md](ToProtectYourAccount.md) and
+[ratelimits.md](ratelimits.md).
+
+## Post
+
+```python
+media_ids = [await client.upload_media('media1.jpg')]
+await client.create_tweet('Example', media_ids=media_ids)
+```
+
+Content disclosure, the way the web composer sends it:
+
+```python
+await client.create_tweet('Rendered overnight', made_with_ai=True)
+await client.create_tweet('Partner drop', paid_partnership=True)
+
+await client.add_content_disclosure(tweet_id, made_with_ai=True)
+await client.delete_content_disclosure(tweet_id)
+```
+
+Read it back — the label is only serialised when the read query asks for it, which the
+default feature sets do:
+
+```python
+from xselfbot import applied_disclosures
+
+tweet = await client.get_tweet_by_id(tweet_id)
+applied_disclosures(tweet)      # {'paid_partnership': False, 'made_with_ai': True}
+```
+
+## Read
+
+```python
+tweets = await client.search_tweet('python', 'Latest')
+for tweet in tweets:
+    print(tweet.user.name, tweet.text, tweet.created_at)
+
+tweets = await client.get_user_tweets('123456', 'Tweets')
+trends = await client.get_trends('trending')
+```
+
+## Message and stream
+
+```python
+await client.send_dm('123456789', 'Hello')
+
+from xselfbot.streaming import Topic
+```
+
+## Layout
+
+| path | what |
+|---|---|
+| `xselfbot/client/(client|gql|v11).py` | session, GraphQL and v1.1 transport |
+| `xselfbot/tweet.py`, `user.py`, `message.py` | entities |
+| `xselfbot/content_disclosure.py` | the Paid partnership / Made with AI labels |
+| `xselfbot/x_client_transaction/` | `X-Client-Transaction-Id` builder, with a fallback |
+| `xselfbot/guest/` | logged-out client |
+| `docs/` | Sphinx sources |
+| `tests/` | offline checks, no network |
+
+## Tests
+
+```
+python -m pytest tests -q
+```
+
+## Credit
+
+This library began as a fork of the [Twikit](https://github.com/d60/twikit) project, and the shape of the client —
+the entity model, the GraphQL endpoint table, the captcha hook — is that project's work.
+Credit for the original design belongs to its author; what is here is the same library
+carried through the 2026 x.com build and renamed so the two can be told apart.
+
+## Licence
+
+MIT. See [LICENSE](LICENSE).

xselfbot-4.0.0/README.md

@@ -0,0 +1,112 @@
+# XSelfBot
+
+X client for Python. Posts, reads, searches and streams over a cookie session, with no
+API key.
+
+```
+pip install git+https://github.com/Tky567/xselfbot.git@main
+```
+
+```
+pip install xselfbot
+```
+
+Requires Python 3.10+.
+
+## Session
+
+The cookie session is the supported path. Export the cookies of a signed-in browser
+session (any Netscape-format jar works) and hand them to the client:
+
+```python
+import asyncio
+from xselfbot import Client
+
+client = Client('en-US')
+client.load_cookies('cookies.json')
+
+async def main():
+    print(await client.identity())
+    # {'user_id': '…', 'screen_name': '…', 'name': '…', 'avatar': '…'}
+
+asyncio.run(main())
+```
+
+`login()` by password is still in the tree, but it is the path that gets accounts
+flagged. See [ToProtectYourAccount.md](ToProtectYourAccount.md) and
+[ratelimits.md](ratelimits.md).
+
+## Post
+
+```python
+media_ids = [await client.upload_media('media1.jpg')]
+await client.create_tweet('Example', media_ids=media_ids)
+```
+
+Content disclosure, the way the web composer sends it:
+
+```python
+await client.create_tweet('Rendered overnight', made_with_ai=True)
+await client.create_tweet('Partner drop', paid_partnership=True)
+
+await client.add_content_disclosure(tweet_id, made_with_ai=True)
+await client.delete_content_disclosure(tweet_id)
+```
+
+Read it back — the label is only serialised when the read query asks for it, which the
+default feature sets do:
+
+```python
+from xselfbot import applied_disclosures
+
+tweet = await client.get_tweet_by_id(tweet_id)
+applied_disclosures(tweet)      # {'paid_partnership': False, 'made_with_ai': True}
+```
+
+## Read
+
+```python
+tweets = await client.search_tweet('python', 'Latest')
+for tweet in tweets:
+    print(tweet.user.name, tweet.text, tweet.created_at)
+
+tweets = await client.get_user_tweets('123456', 'Tweets')
+trends = await client.get_trends('trending')
+```
+
+## Message and stream
+
+```python
+await client.send_dm('123456789', 'Hello')
+
+from xselfbot.streaming import Topic
+```
+
+## Layout
+
+| path | what |
+|---|---|
+| `xselfbot/client/(client|gql|v11).py` | session, GraphQL and v1.1 transport |
+| `xselfbot/tweet.py`, `user.py`, `message.py` | entities |
+| `xselfbot/content_disclosure.py` | the Paid partnership / Made with AI labels |
+| `xselfbot/x_client_transaction/` | `X-Client-Transaction-Id` builder, with a fallback |
+| `xselfbot/guest/` | logged-out client |
+| `docs/` | Sphinx sources |
+| `tests/` | offline checks, no network |
+
+## Tests
+
+```
+python -m pytest tests -q
+```
+
+## Credit
+
+This library began as a fork of the [Twikit](https://github.com/d60/twikit) project, and the shape of the client —
+the entity model, the GraphQL endpoint table, the captcha hook — is that project's work.
+Credit for the original design belongs to its author; what is here is the same library
+carried through the 2026 x.com build and renamed so the two can be told apart.
+
+## Licence
+
+MIT. See [LICENSE](LICENSE).

xselfbot-4.0.0/setup.cfg

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

xselfbot-4.0.0/setup.py

@@ -0,0 +1,33 @@
+import re
+
+from setuptools import setup
+
+with open('README.md', encoding='utf-8') as f:
+    long_description = f.read()
+
+with open('./xselfbot/__init__.py') as f:
+    version = re.findall(r"__version__ = '(.+)'", f.read())[0]
+
+
+setup(
+    name='xselfbot',
+    version=version,
+    install_requires=[
+        'httpx[socks]',
+        'filetype',
+        'beautifulsoup4',
+        'pyotp',
+        'lxml',
+        'webvtt-py',
+        'm3u8',
+        'Js2Py-3.13'
+    ],
+    python_requires='>=3.10',
+    description='X client for python — posting, reading, search and streaming, no API key.',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    license='MIT',
+    url='https://github.com/Tky567/xselfbot',
+    package_data={'xselfbot': ['py.typed']}
+)
+

xselfbot-4.0.0/tests/test_fork.py

@@ -0,0 +1,356 @@
+"""Offline checks for the 2026 fork. No network, no cookies.
+
+    python -m pytest tests -q
+"""
+
+import asyncio
+import json
+
+from xselfbot import Client, Tweet
+from xselfbot.client.gql import GQLClient
+from xselfbot.content_disclosure import applied_disclosures, build_content_disclosure
+
+
+# ---------------------------------------------------------------- disclosure
+
+
+def test_build_disclosure_none():
+    assert build_content_disclosure() is None
+    assert build_content_disclosure(False, False) is None
+
+
+def test_build_disclosure_ai():
+    assert build_content_disclosure(made_with_ai=True) == {
+        'ai_generated_disclosure': {
+            'has_ai_generated_media': True,
+            'ai_generated_detection_source': 'UserDeclared',
+        }
+    }
+
+
+def test_build_disclosure_paid():
+    assert build_content_disclosure(paid_partnership=True) == {
+        'advertising_disclosure': {'is_paid_promotion': True}
+    }
+
+
+def test_build_disclosure_both_sources():
+    assert build_content_disclosure(True, True) == {
+        'advertising_disclosure': {'is_paid_promotion': True},
+        'ai_generated_disclosure': {
+            'has_ai_generated_media': True,
+            'ai_generated_detection_source': 'UserDeclared',
+        },
+    }
+    c2pa = build_content_disclosure(made_with_ai=True, ai_detection_source='C2paClient')
+    assert c2pa['ai_generated_disclosure']['ai_generated_detection_source'] == 'C2paClient'
+
+
+def test_applied_disclosures():
+    assert applied_disclosures({}) == {'paid_partnership': False, 'made_with_ai': False}
+    assert applied_disclosures({
+        'content_disclosure': {'ai_generated_disclosure': {'has_ai_generated_media': True}}
+    }) == {'paid_partnership': False, 'made_with_ai': True}
+
+
+# ---------------------------------------------------------------- client
+
+
+def test_cookie_jar_dedupes_by_name():
+    client = Client('en-US')
+    client.set_cookies({'auth_token': 'a', 'ct0': 'b', 'twid': 'u%3D1'})
+    client.set_cookies({'twid': 'u%3D2'})
+    cookies = client.get_cookies()
+    assert cookies['twid'] == 'u%3D2'
+    assert set(cookies) == {'auth_token', 'ct0', 'twid'}
+
+
+def test_user_id_from_twid_cookie():
+    client = Client('en-US')
+    client.set_cookies({'twid': 'u%3D1938595739770470400'})
+    assert client._user_id_from_cookies() == '1938595739770470400'
+    client.set_cookies({'twid': 'not-a-user-id'})
+    assert client._user_id_from_cookies() is None
+
+
+def test_identity_from_home_page():
+    client = Client('en-US')
+    html = (
+        '<html><script>{"users":{"entities":{"1938595739770470400":{'
+        '"name":"Tky","screen_name":"Tky567","id_str":"1938595739770470400",'
+        '"profile_image_url_https":"https://pbs.twimg.com/a_normal.png"}}}}</script></html>'
+    )
+    from bs4 import BeautifulSoup
+    client.client_transaction.home_page_response = BeautifulSoup(html, 'lxml')
+    client.set_cookies({'twid': 'u%3D1938595739770470400'})
+    identity = client.identity()
+    assert identity == {
+        'user_id': '1938595739770470400',
+        'name': 'Tky',
+        'screen_name': 'Tky567',
+        'avatar': 'https://pbs.twimg.com/a_normal.png',
+    }
+
+
+def test_trimmed_user_payload_builds():
+    """The user object embedded in CreateTweet results has no entities block."""
+    from xselfbot.user import User
+    user = User(None, {
+        'rest_id': '1',
+        'core': {'name': 'Tky', 'screen_name': 'Tky567', 'created_at': 'x'},
+        'avatar': {'image_url': 'https://pbs.twimg.com/b.png'},
+    })
+    assert user.screen_name == 'Tky567'
+    assert user.description_urls == []
+    assert user.followers_count == 0
+
+
+# ---------------------------------------------------------------- create_tweet
+
+
+class RecordingGQL(GQLClient):
+    """Real GQLClient with the transport replaced, so payload building is exercised."""
+
+    def __init__(self, base, response):
+        super().__init__(base)
+        self.calls = []
+        self.response = response
+
+    async def gql_post(self, url, variables, features=None, **kwargs):
+        self.calls.append({'url': url, 'variables': variables, 'features': features})
+        return self.response, None
+
+    async def gql_get(self, url, params=None, headers=None, **kwargs):
+        self.calls.append({'url': url, 'params': params})
+        return self.response, None
+
+
+TWEET_RESPONSE = {
+    'data': {
+        'create_tweet': {
+            'tweet_results': {
+                'result': {
+                    'rest_id': '2121671135263920528',
+                    'legacy': {'full_text': 'hello'},
+                    'content_disclosure': {
+                        'ai_generated_disclosure': {
+                            'has_ai_generated_media': True,
+                            'ai_generated_detection_source': 'UserDeclared',
+                        }
+                    },
+                }
+            }
+        }
+    }
+}
+
+
+def test_create_tweet_sends_disclosure():
+    client = Client('en-US')
+    client.gql = RecordingGQL(client, TWEET_RESPONSE)
+    tweet = asyncio.run(client.create_tweet('hello', made_with_ai=True))
+    call = client.gql.calls[0]
+    assert call['url'].endswith('/CreateTweet')
+    assert 'l4hk8uVGvR-a8kzQ4nOhPA' in call['url']
+    assert call['variables']['content_disclosure'] == {
+        'ai_generated_disclosure': {
+            'has_ai_generated_media': True,
+            'ai_generated_detection_source': 'UserDeclared',
+        }
+    }
+    assert call['features']['content_disclosure_indicator_enabled'] is True
+    assert isinstance(tweet, Tweet)
+    assert tweet.id == '2121671135263920528'
+
+
+def test_create_tweet_without_disclosure_omits_field():
+    client = Client('en-US')
+    client.gql = RecordingGQL(client, TWEET_RESPONSE)
+    asyncio.run(client.create_tweet('hello'))
+    assert 'content_disclosure' not in client.gql.calls[0]['variables']
+    assert client.gql.calls[0]['variables']['semantic_annotation_options'] == {
+        'source': 'UniversalLink'
+    }
+
+
+def test_add_and_delete_disclosure():
+    client = Client('en-US')
+    client.gql = RecordingGQL(client, {})
+    asyncio.run(client.add_content_disclosure('42', True, True))
+    assert client.gql.calls[0]['variables'] == {
+        'tweet_id': '42',
+        'advertising_disclosure': {'is_paid_promotion': True},
+        'ai_generated_disclosure': {
+            'has_ai_generated_media': True,
+            'ai_generated_detection_source': 'UserDeclared',
+        },
+    }
+    asyncio.run(client.delete_content_disclosure('42'))
+    assert client.gql.calls[1]['variables'] == {'tweet_id': '42'}
+
+
+def test_add_disclosure_requires_a_label():
+    client = Client('en-US')
+    client.gql = RecordingGQL(client, {})
+    try:
+        asyncio.run(client.add_content_disclosure('42'))
+    except ValueError as exc:
+        assert 'Nothing to disclose' in str(exc)
+    else:
+        raise AssertionError('expected ValueError')
+
+
+# ---------------------------------------------------------------- transaction
+
+
+def test_transaction_falls_back_without_bundle():
+    from xselfbot.x_client_transaction.transaction import ClientTransaction
+    tx = ClientTransaction()
+    tx.available = False
+    assert tx.generate_transaction_id('POST', '/i/api/graphql/x/CreateTweet') == '0' * 32
+
+
+def test_transaction_keeps_real_path_when_available():
+    from xselfbot.x_client_transaction.transaction import ClientTransaction
+    tx = ClientTransaction()
+    assert tx.available is False  # not initialised yet
+    assert tx.generate_transaction_id('GET', '/x') == '0' * 32
+
+
+# ---------------------------------------------------------------- timeline cursors
+#
+# 2026-11: x.com moved the cursor value off `content.itemContent` and onto the holder
+# itself. Both shapes are read; anything else is a crash on a healthy response.
+
+
+def test_cursor_value_old_shape():
+    from xselfbot.utils import timeline_cursor_value
+    entry = {'entryId': 'cursor-bottom-1',
+             'content': {'itemContent': {'value': 'OLD'}}}
+    assert timeline_cursor_value(entry) == 'OLD'
+
+
+def test_cursor_value_current_shape():
+    from xselfbot.utils import timeline_cursor_value
+    entry = {'entryId': 'cursor-bottom-1',
+             'content': {'__typename': 'TimelineTimelineCursor',
+                         'cursorType': 'Bottom', 'value': 'CUR'}}
+    assert timeline_cursor_value(entry) == 'CUR'
+
+
+def test_cursor_value_module_item():
+    from xselfbot.utils import timeline_cursor_value
+    item = {'entryId': 'cursor-showmore-1', 'item': {'cursorType': 'ShowMore', 'value': 'S'}}
+    assert timeline_cursor_value(item) == 'S'
+    assert timeline_cursor_value({'entryId': 'x', 'content': {}}) is None
+    assert timeline_cursor_value(None) is None
+
+
+TWEET_NODE = {
+    '__typename': 'Tweet',
+    'rest_id': '123',
+    'core': {'user_results': {'result': {
+        '__typename': 'User', 'rest_id': '9',
+        'core': {'name': 'A', 'screen_name': 'a'}}}},
+    'legacy': {'full_text': 'hi', 'created_at': 'x', 'lang': 'en',
+               'is_quote_status': False},
+}
+
+
+def detail_response(cursor_content):
+    return {'data': {'threaded_conversation_with_injections_v2': {'instructions': [
+        {'type': 'TimelineClearCache'},
+        {'type': 'TimelineAddEntries', 'entries': [
+            {'entryId': 'tweet-123',
+             'content': {'entryType': 'TimelineTimelineItem',
+                         'itemContent': {'itemType': 'TimelineTweet',
+                                         'tweet_results': {'result': TWEET_NODE}}}},
+            {'entryId': 'cursor-bottom-1', 'content': cursor_content},
+        ]},
+    ]}}}
+
+
+def test_get_tweet_by_id_reads_bottom_cursor():
+    client = Client('en-US')
+    client.gql = RecordingGQL(client, detail_response({
+        '__typename': 'TimelineTimelineCursor', 'cursorType': 'Bottom', 'value': 'NEXT',
+    }))
+    tweet = asyncio.run(client.get_tweet_by_id('123'))
+    assert tweet.id == '123'
+    assert tweet.replies.next_cursor == 'NEXT'
+    assert tweet.replies.next is not None
+
+
+def test_get_tweet_by_id_reads_wrapped_cursor():
+    client = Client('en-US')
+    client.gql = RecordingGQL(client, detail_response({'itemContent': {'value': 'OLD'}}))
+    tweet = asyncio.run(client.get_tweet_by_id('123'))
+    assert tweet.replies.next_cursor == 'OLD'
+
+
+# ---------------------------------------------------------------- read-side labels
+
+
+def test_read_features_carry_disclosure_flags():
+    from xselfbot.constants import (
+        FEATURES, TWEET_RESULT_BY_REST_ID_FEATURES, TWEET_RESULTS_BY_REST_IDS_FEATURES
+    )
+    for features in (FEATURES, TWEET_RESULT_BY_REST_ID_FEATURES,
+                     TWEET_RESULTS_BY_REST_IDS_FEATURES):
+        assert features['content_disclosure_indicator_enabled'] is True
+        assert features['content_disclosure_ai_generated_indicator_enabled'] is True
+
+
+def test_applied_disclosures_accepts_a_tweet():
+    from xselfbot.content_disclosure import applied_disclosures
+
+    class Node:
+        _data = {'content_disclosure': {
+            'ai_generated_disclosure': {'has_ai_generated_media': True}}}
+
+    assert applied_disclosures(Node()) == {'paid_partnership': False, 'made_with_ai': True}
+    assert applied_disclosures(None) == {'paid_partnership': False, 'made_with_ai': False}
+    assert applied_disclosures({'content_disclosure': {}}) == {
+        'paid_partnership': False, 'made_with_ai': False}
+
+
+# ---------------------------------------------------------------- degraded identity
+
+
+def test_user_falls_back_marked_partial():
+    from xselfbot.errors import TwitterException
+
+    class RefusingClient(Client):
+        async def get_user_by_id(self, user_id):
+            raise TwitterException('403 from UserByRestId')
+
+        def identity(self):
+            return {'user_id': '1', 'screen_name': 'a', 'name': 'A',
+                    'avatar': 'https://pbs.twimg.com/a_normal.png'}
+
+    client = RefusingClient('en-US')
+    client.set_cookies({'twid': 'u%3D1'})
+    user = asyncio.run(client.user())
+    assert user.screen_name == 'a'
+    assert user.partial is True
+    assert user.followers_count == 0
+
+
+def test_user_from_payload_is_not_partial():
+    from xselfbot.user import User
+    assert User(None, {'rest_id': '1', 'core': {'screen_name': 'a'}}).partial is False
+
+
+def test_create_tweet_raises_when_result_is_not_a_tweet():
+    """A create call that returns a tombstone must not hand back None."""
+    from xselfbot.errors import CouldNotTweet
+
+    client = Client('en-US')
+    client.gql = RecordingGQL(client, {'data': {'create_tweet': {'tweet_results': {
+        'result': {'__typename': 'TweetTombstone'}}}}})
+    try:
+        asyncio.run(client.create_tweet('hello'))
+    except CouldNotTweet as exc:
+        assert 'TweetTombstone' in str(exc)
+    else:
+        raise AssertionError('expected CouldNotTweet')