tweetapi 1.2.0__tar.gz → 2.0.0__tar.gz

{tweetapi-1.2.0 → tweetapi-2.0.0}/.gitignore

@@ -10,3 +10,5 @@ venv/
 .env
 .env.*
 .pytest_cache/
+.claude/
+AGENTS.md

{tweetapi-1.2.0 → tweetapi-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tweetapi
-Version: 1.2.0
+Version: 2.0.0
 Summary: Official Python SDK for TweetAPI — Twitter/X Data API for developers and researchers
 Project-URL: Homepage, https://tweetapi.com?utm_source=pypi&utm_medium=readme&utm_campaign=python-sdk
 Project-URL: Documentation, https://tweetapi.com/docs?utm_source=pypi&utm_medium=readme&utm_campaign=python-sdk
@@ -191,7 +191,9 @@ next_page = client.user.get_followers(
 
 | Method | Description |
 |--------|-------------|
-| `client.auth.login(username=..., password=..., proxy=...)` | Log in, get auth tokens |
+| `client.auth.login(username=..., password=..., proxy=..., country=...)` | Log in, get auth tokens |
+
+`country` is the ISO 3166-1 alpha-2 code for the proxy's public egress IP (for example, `"US"`). It must match the IP used for the complete login attempt. Pass `two_factor_secret` when the account uses TOTP-based 2FA.
 
 ### X Chat (Encrypted DMs)
 

{tweetapi-1.2.0 → tweetapi-2.0.0}/README.md

@@ -161,7 +161,9 @@ next_page = client.user.get_followers(
 
 | Method | Description |
 |--------|-------------|
-| `client.auth.login(username=..., password=..., proxy=...)` | Log in, get auth tokens |
+| `client.auth.login(username=..., password=..., proxy=..., country=...)` | Log in, get auth tokens |
+
+`country` is the ISO 3166-1 alpha-2 code for the proxy's public egress IP (for example, `"US"`). It must match the IP used for the complete login attempt. Pass `two_factor_secret` when the account uses TOTP-based 2FA.
 
 ### X Chat (Encrypted DMs)
 

{tweetapi-1.2.0 → tweetapi-2.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tweetapi"
-version = "1.2.0"
+version = "2.0.0"
 description = "Official Python SDK for TweetAPI — Twitter/X Data API for developers and researchers"
 readme = "README.md"
 license = "MIT"
@@ -53,6 +53,13 @@ Issues = "https://github.com/tweetapi/python/issues"
 [tool.hatch.build.targets.wheel]
 packages = ["tweetapi"]
 
+[tool.hatch.build.targets.sdist]
+include = [
+    "/tweetapi",
+    "/README.md",
+    "/pyproject.toml",
+]
+
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 

{tweetapi-1.2.0 → tweetapi-2.0.0}/tweetapi/__init__.py

@@ -37,4 +37,4 @@ __all__ = [
     "paginate_pages",
 ]
 
-__version__ = "1.2.0"
+__version__ = "2.0.0"

{tweetapi-1.2.0 → tweetapi-2.0.0}/tweetapi/resources/auth.py

@@ -11,9 +11,10 @@ class AuthResource:
     def __init__(self, client: TweetAPI) -> None:
         self._client = client
 
-    def login(self, *, username: str, password: str, proxy: str, two_factor_secret: Optional[str] = None) -> LoginApiResponse:
-        """Log in to a Twitter account and get auth tokens."""
+    def login(self, *, username: str, password: str, proxy: str, country: str, two_factor_secret: Optional[str] = None) -> LoginApiResponse:
+        """Log in using the proxy egress country and get auth tokens."""
         return self._client._post("/tw-v2/auth/login", {
             "username": username, "password": password,
-            "proxy": proxy, "twoFactorSecret": two_factor_secret,
+            "proxy": proxy, "country": country,
+            "twoFactorSecret": two_factor_secret,
         })

tweetapi-1.2.0/.claude/settings.local.json

@@ -1,3 +0,0 @@
-{
-  "includeCoAuthoredBy": false
-}

tweetapi-1.2.0/AGENTS.md

@@ -1,92 +0,0 @@
-# TweetAPI Python SDK Agent Notes
-
-## Repository Context
-
-This repository is the official Python SDK for TweetAPI.
-
-- GitHub: https://github.com/tweetapi/python
-- PyPI package: https://pypi.org/project/tweetapi/
-- Import package: `tweetapi`
-- Distribution package: `tweetapi`
-
-This repo is not a deployed web service. Customer impact happens when changes are
-merged to the public GitHub repository and, separately, when a new package
-version is built and uploaded to PyPI.
-
-## Package And Release Model
-
-Package metadata lives in `pyproject.toml`. The package uses Hatchling:
-
-```toml
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-```
-
-When preparing a release:
-
-1. Update the version in `pyproject.toml`.
-2. Update `tweetapi/__init__.py` so `__version__` matches.
-3. Run tests and compile checks.
-4. Build distributions with `python -m build`.
-5. Inspect the generated `dist/` contents.
-6. Upload to PyPI only when explicitly requested by the maintainer.
-
-Do not publish to PyPI from an agent run unless the user explicitly asks for it.
-Do not reuse a version number that already exists on PyPI.
-
-## API Surface Policy
-
-Expose documented customer-facing routes only. The SDK should map Pythonic
-snake_case method parameters to the backend's camelCase JSON body and query
-parameters.
-
-Do not expose hidden, internal, or undocumented routes, including:
-
-- `/tw-v2/internal/*`
-- `/tw-v2/interaction/home-timeline`
-- `/tw-v2/interaction/following-timeline`
-- `/tw-v2/interaction/search`
-- `/tw-v2/interaction/tweet-details`
-- device follow notification routes
-
-Authenticated Twitter/X actions still require a customer-provided `auth_token`
-and, when required by the endpoint, `proxy`. The TweetAPI API key is passed by
-the client through the `X-API-Key` header.
-
-## Code Patterns
-
-- Resource classes live in `tweetapi/resources/`.
-- `TweetAPI` registers resources in `tweetapi/client.py`.
-- Lightweight JSON-compatible response and request shapes live in
-  `tweetapi/types.py` as `TypedDict` definitions and aliases.
-- Keep method names and arguments Pythonic (`snake_case`), but serialize request
-  payload keys exactly as the backend expects (`camelCase`).
-- `TweetAPI._get` and `TweetAPI._post` strip `None` values. Prefer passing
-  optional fields through those helpers instead of hand-filtering in resources.
-- Add tests with `responses` for new request paths and serialized bodies.
-
-## Verification
-
-Run these before considering changes ready:
-
-```bash
-pytest
-python -m compileall tweetapi
-```
-
-For release candidates that add mutating authenticated endpoints, add mocked
-request-body tests locally and consider a controlled live smoke test against a
-test Twitter/X account before publishing to PyPI.
-
-## Customer Safety
-
-Merging code to GitHub does not automatically update installed customer
-packages. Customers receive new SDK code only after a PyPI release and a local
-upgrade such as:
-
-```bash
-python -m pip install --upgrade tweetapi
-```
-
-Treat PyPI publishing as the production release step for this SDK.

tweetapi-1.2.0/examples/create_post.py

@@ -1,37 +0,0 @@
-from tweetapi import TweetAPI, AuthenticationError, TweetAPIError
-
-client = TweetAPI(api_key="YOUR_API_KEY")
-
-try:
-    # First, log in to get an auth token
-    login_result = client.auth.login(
-        username="your_twitter_username",
-        password="your_twitter_password",
-        proxy="hostname:port@username:password",
-    )
-
-    auth_token = login_result["data"]["cookies"]["auth_token"]
-    print(f'Logged in as @{login_result["data"]["user"]["username"]}')
-
-    # Create a tweet
-    post = client.post.create_post(
-        auth_token=auth_token,
-        text="Hello from TweetAPI! 🚀",
-        proxy="hostname:port@username:password",
-    )
-
-    print(f'Tweet created: {post["data"]["metadata"]["tweet_id"]}')
-    print(f'URL: {post["data"]["metadata"]["url"]}')
-
-    # Like the tweet we just created
-    client.interaction.favorite_post(
-        auth_token=auth_token,
-        tweet_id=post["data"]["id"],
-        proxy="hostname:port@username:password",
-    )
-    print("Liked the tweet!")
-
-except AuthenticationError:
-    print("Authentication failed. Check your credentials.")
-except TweetAPIError as e:
-    print(f"API error [{e.code}]: {e.message}")

tweetapi-1.2.0/examples/get_user.py

@@ -1,31 +0,0 @@
-from tweetapi import TweetAPI, NotFoundError, RateLimitError, TweetAPIError
-
-client = TweetAPI(api_key="YOUR_API_KEY")
-
-try:
-    # Get a single user by username
-    user = client.user.get_by_username(username="elonmusk")
-    data = user["data"]
-    print(f'{data["name"]} (@{data["username"]})')
-    print(f'Followers: {data["followerCount"]:,}')
-    print(f'Tweets: {data["tweetCount"]:,}')
-    print(f'Verified: {data["isBlueVerified"]}')
-
-    # Get first page of followers
-    followers = client.user.get_followers(user_id=data["id"])
-    print(f"\nFirst {len(followers['data'])} followers:")
-    for follower in followers["data"][:5]:
-        print(f'  - @{follower["username"]} ({follower["followerCount"]} followers)')
-
-    # Paginate to next page
-    next_cursor = followers["pagination"]["nextCursor"]
-    if next_cursor:
-        next_page = client.user.get_followers(user_id=data["id"], cursor=next_cursor)
-        print(f"\nNext page: {len(next_page['data'])} more followers")
-
-except NotFoundError:
-    print("User not found")
-except RateLimitError as e:
-    print(f"Rate limited. Retry in {e.retry_after} seconds")
-except TweetAPIError as e:
-    print(f"API error [{e.code}]: {e.message}")

tweetapi-1.2.0/examples/search_tweets.py

@@ -1,20 +0,0 @@
-from tweetapi import TweetAPI
-
-client = TweetAPI(api_key="YOUR_API_KEY")
-
-# Search for latest tweets about Bitcoin
-results = client.explore.search(query="bitcoin", type="Latest")
-
-print(f'Found {results["meta"]["resultCount"]} results in {results["meta"]["completedIn"]}ms\n')
-
-for item in results["data"]:
-    if "text" in item and "author" in item:
-        author = item["author"]
-        print(f'@{author["username"]}: {item["text"][:100]}')
-        print(f'  ♥ {item["likeCount"]}  🔁 {item["retweetCount"]}  💬 {item["replyCount"]}\n')
-
-# Paginate if more results exist
-next_cursor = results["pagination"]["nextCursor"]
-if next_cursor:
-    print(f'More results available. Use cursor to paginate:')
-    print(f'  cursor="{next_cursor}"')

tweetapi-1.2.0/tests/test_client.py

@@ -1,492 +0,0 @@
-import json
-
-import pytest
-import responses
-
-from tweetapi import (
-    TweetAPI,
-    TweetAPIError,
-    AuthenticationError,
-    ValidationError,
-    NotFoundError,
-    RateLimitError,
-    ServerError,
-    NetworkError,
-)
-
-BASE_URL = "https://api.tweetapi.com"
-
-
-def make_client(**kwargs) -> TweetAPI:
-    defaults = {"api_key": "test-api-key", "max_retries": 0}
-    defaults.update(kwargs)
-    return TweetAPI(**defaults)
-
-
-class TestClientInit:
-    def test_raises_on_empty_api_key(self):
-        with pytest.raises(ValueError, match="api_key is required"):
-            TweetAPI(api_key="")
-
-    def test_creates_with_valid_key(self):
-        client = TweetAPI(api_key="key")
-        assert client is not None
-
-    def test_all_resources_exist(self):
-        client = make_client()
-        for attr in ["user", "tweet", "post", "interaction", "list", "community",
-                      "profile", "space", "explore", "auth", "xchat", "dm"]:
-            assert hasattr(client, attr), f"Missing resource: {attr}"
-
-
-class TestGetRequests:
-    @responses.activate
-    def test_sends_api_key_header(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"data": {"id": "123", "username": "testuser", "name": "Test"}},
-            status=200,
-        )
-
-        client = make_client()
-        client.user.get_by_username(username="testuser")
-
-        assert len(responses.calls) == 1
-        assert responses.calls[0].request.headers["X-API-Key"] == "test-api-key"
-
-    @responses.activate
-    def test_sends_query_params(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"data": {"id": "123", "username": "elonmusk"}},
-            status=200,
-        )
-
-        client = make_client()
-        client.user.get_by_username(username="elonmusk")
-
-        assert "username=elonmusk" in responses.calls[0].request.url
-
-    @responses.activate
-    def test_omits_none_params(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/followers",
-            json={"data": [], "pagination": {"nextCursor": None, "prevCursor": None}},
-            status=200,
-        )
-
-        client = make_client()
-        client.user.get_followers(user_id="123")
-
-        assert "cursor" not in responses.calls[0].request.url
-        assert "userId=123" in responses.calls[0].request.url
-
-    @responses.activate
-    def test_parses_json_response(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"data": {"id": "123", "username": "elonmusk", "followerCount": 180000000}},
-            status=200,
-        )
-
-        client = make_client()
-        result = client.user.get_by_username(username="elonmusk")
-
-        assert result["data"]["username"] == "elonmusk"
-        assert result["data"]["followerCount"] == 180000000
-
-
-class TestPostRequests:
-    @responses.activate
-    def test_sends_json_body(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/interaction/like-post",
-            json={"data": {"id": "789", "action": "like", "timestamp": "2025-01-01", "success": True}},
-            status=200,
-        )
-
-        client = make_client()
-        client.interaction.favorite_post(auth_token="auth123", tweet_id="789", proxy="h:p@u:p")
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body["authToken"] == "auth123"
-        assert body["tweetId"] == "789"
-
-    @responses.activate
-    def test_strips_none_from_body(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/interaction/create-post",
-            json={"data": {"id": "1", "action": "create_tweet", "success": True}},
-            status=200,
-        )
-
-        client = make_client()
-        client.post.create_post(auth_token="auth", text="Hello", proxy="h:p@u:p")
-
-        body = json.loads(responses.calls[0].request.body)
-        assert "disableLinkPreview" not in body
-
-    @responses.activate
-    def test_create_post_serializes_reply_option(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/interaction/create-post",
-            json={"data": {"id": "1", "action": "create_tweet", "success": True}},
-            status=200,
-        )
-
-        client = make_client()
-        client.post.create_post(
-            auth_token="auth",
-            text="Hello",
-            proxy="h:p@u:p",
-            reply_option={"mode": "followers", "regions": ["US"]},
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body["replyOption"] == {"mode": "followers", "regions": ["US"]}
-
-    @responses.activate
-    def test_create_post_with_media_preserves_media_id(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/interaction/create-post-with-media",
-            json={"data": {"id": "1", "action": "create_tweet", "success": True}},
-            status=200,
-        )
-
-        client = make_client()
-        client.post.create_post_with_media(
-            auth_token="auth",
-            text="Hello",
-            media=[{"media_id": "1971008286821380096"}],
-            proxy="h:p@u:p",
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body["media"] == [{"media_id": "1971008286821380096"}]
-
-
-class TestListParity:
-    @responses.activate
-    def test_create_sends_camel_case_body(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/list/create",
-            json={"data": {"id": "list-1", "name": "Research"}},
-            status=200,
-        )
-
-        client = make_client()
-        client.list.create(
-            auth_token="auth",
-            name="Research",
-            description="Signals",
-            is_private=False,
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body == {
-            "authToken": "auth",
-            "name": "Research",
-            "description": "Signals",
-            "isPrivate": False,
-        }
-
-    @responses.activate
-    def test_add_member_sends_camel_case_body_and_strips_none(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/list/add-member",
-            json={"data": {"success": True}},
-            status=200,
-        )
-
-        client = make_client()
-        client.list.add_member(auth_token="auth", list_id="list-1", user_id="user-1")
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body == {
-            "authToken": "auth",
-            "listId": "list-1",
-            "userId": "user-1",
-        }
-        assert "proxy" not in body
-
-    @responses.activate
-    def test_remove_member_sends_camel_case_body(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/list/remove-member",
-            json={"data": {"success": True}},
-            status=200,
-        )
-
-        client = make_client()
-        client.list.remove_member(
-            auth_token="auth",
-            list_id="list-1",
-            user_id="user-1",
-            proxy="h:p@u:p",
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body == {
-            "authToken": "auth",
-            "listId": "list-1",
-            "userId": "user-1",
-            "proxy": "h:p@u:p",
-        }
-
-
-class TestProfileParity:
-    @responses.activate
-    def test_update_sends_body_and_strips_none(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/profile/update",
-            json={"data": {"id": "user-1", "name": "New Name"}},
-            status=200,
-        )
-
-        client = make_client()
-        client.profile.update(
-            auth_token="auth",
-            name="New Name",
-            bio=None,
-            location="Bangkok",
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body == {
-            "authToken": "auth",
-            "name": "New Name",
-            "location": "Bangkok",
-        }
-        assert "bio" not in body
-        assert "website" not in body
-        assert "proxy" not in body
-
-    @responses.activate
-    def test_avatar_sends_media_body(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/profile/avatar",
-            json={"data": {"id": "user-1", "avatar": "https://example.com/a.jpg"}},
-            status=200,
-        )
-
-        client = make_client()
-        client.profile.avatar(
-            auth_token="auth",
-            media={"url": "https://example.com/a.jpg"},
-            proxy="h:p@u:p",
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body == {
-            "authToken": "auth",
-            "media": {"url": "https://example.com/a.jpg"},
-            "proxy": "h:p@u:p",
-        }
-
-    @responses.activate
-    def test_banner_sends_media_body(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/profile/banner",
-            json={"data": {"id": "user-1", "banner": "https://example.com/b.jpg"}},
-            status=200,
-        )
-
-        client = make_client()
-        client.profile.banner(
-            auth_token="auth",
-            media={"data": "base64", "type": "image/png"},
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body == {
-            "authToken": "auth",
-            "media": {"data": "base64", "type": "image/png"},
-        }
-
-
-class TestCommunityParity:
-    @responses.activate
-    def test_create_quote_sends_path_and_body(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/interaction/create-community-quote",
-            json={"data": {"id": "tweet-1", "success": True}},
-            status=200,
-        )
-
-        client = make_client()
-        client.community.create_quote(
-            auth_token="auth",
-            text="Quote",
-            attachment_url="https://x.com/user/status/1",
-            community_id="community-1",
-            proxy="h:p@u:p",
-            disable_link_preview=True,
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body == {
-            "authToken": "auth",
-            "text": "Quote",
-            "attachmentUrl": "https://x.com/user/status/1",
-            "communityId": "community-1",
-            "proxy": "h:p@u:p",
-            "disableLinkPreview": True,
-        }
-
-    @responses.activate
-    def test_create_quote_with_media_sends_path_and_body(self):
-        responses.add(
-            responses.POST,
-            f"{BASE_URL}/tw-v2/interaction/create-community-quote-with-media",
-            json={"data": {"id": "tweet-1", "success": True}},
-            status=200,
-        )
-
-        client = make_client()
-        client.community.create_quote_with_media(
-            auth_token="auth",
-            text="Quote",
-            attachment_url="https://x.com/user/status/1",
-            community_id="community-1",
-            media=[{"media_id": "1971008286821380096"}],
-            proxy="h:p@u:p",
-        )
-
-        body = json.loads(responses.calls[0].request.body)
-        assert body == {
-            "authToken": "auth",
-            "text": "Quote",
-            "attachmentUrl": "https://x.com/user/status/1",
-            "communityId": "community-1",
-            "media": [{"media_id": "1971008286821380096"}],
-            "proxy": "h:p@u:p",
-        }
-
-
-class TestErrorHandling:
-    @responses.activate
-    def test_validation_error_on_400(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"error": {"code": "VALIDATION_ERROR", "message": "Required - username", "details": None}},
-            status=400,
-        )
-
-        client = make_client()
-        with pytest.raises(ValidationError) as exc_info:
-            client.user.get_by_username(username="")
-
-        assert exc_info.value.code == "VALIDATION_ERROR"
-        assert exc_info.value.status_code == 400
-
-    @responses.activate
-    def test_authentication_error_on_401(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"error": {"code": "UNAUTHORIZED", "message": "Invalid token", "details": None}},
-            status=401,
-        )
-
-        client = make_client()
-        with pytest.raises(AuthenticationError) as exc_info:
-            client.user.get_by_username(username="test")
-
-        assert exc_info.value.code == "UNAUTHORIZED"
-
-    @responses.activate
-    def test_not_found_error_on_404(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"error": {"code": "NOT_FOUND", "message": "User not found", "details": None}},
-            status=404,
-        )
-
-        client = make_client()
-        with pytest.raises(NotFoundError) as exc_info:
-            client.user.get_by_username(username="nonexistent")
-
-        assert exc_info.value.code == "NOT_FOUND"
-        assert exc_info.value.status_code == 404
-        assert exc_info.value.message == "User not found"
-
-    @responses.activate
-    def test_rate_limit_error_with_retry_after(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"error": {"code": "RATE_LIMIT", "message": "Rate limit exceeded", "details": {"retryAfter": 30}}},
-            status=429,
-        )
-
-        client = make_client()
-        with pytest.raises(RateLimitError) as exc_info:
-            client.user.get_by_username(username="test")
-
-        assert exc_info.value.retry_after == 30
-
-    @responses.activate
-    def test_server_error_on_500(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"error": {"code": "INTERNAL_SERVER_ERROR", "message": "Something went wrong", "details": None}},
-            status=500,
-        )
-
-        client = make_client()
-        with pytest.raises(ServerError):
-            client.user.get_by_username(username="test")
-
-    @responses.activate
-    def test_malformed_error_response(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            body="not json",
-            status=500,
-            content_type="text/plain",
-        )
-
-        client = make_client()
-        with pytest.raises(ServerError) as exc_info:
-            client.user.get_by_username(username="test")
-
-        assert exc_info.value.code == "UNKNOWN_ERROR"
-
-    @responses.activate
-    def test_preserves_api_error_code(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"error": {"code": "ACCOUNT_SUSPENDED", "message": "Account suspended", "details": None}},
-            status=403,
-        )
-
-        client = make_client()
-        with pytest.raises(TweetAPIError) as exc_info:
-            client.user.get_by_username(username="suspended")
-
-        assert exc_info.value.code == "ACCOUNT_SUSPENDED"
-
-    def test_network_error_on_connection_failure(self):
-        client = TweetAPI(api_key="key", base_url="http://localhost:1", max_retries=0)
-        with pytest.raises(NetworkError):
-            client.user.get_by_username(username="test")

tweetapi-1.2.0/tests/test_pagination.py

@@ -1,101 +0,0 @@
-"""Tests for auto-pagination helpers."""
-
-import pytest
-
-from tweetapi import paginate, paginate_pages
-
-
-def make_fetcher(pages):
-    """Create a fetcher that returns pre-built pages in sequence."""
-    call_count = [0]
-
-    def fetcher(cursor=None):
-        idx = call_count[0]
-        if idx >= len(pages):
-            raise RuntimeError(f"Unexpected call #{idx + 1}")
-        call_count[0] += 1
-        return pages[idx]
-
-    fetcher.call_count = call_count
-    return fetcher
-
-
-class TestPaginatePages:
-    def test_iterates_all_pages(self):
-        pages_data = [
-            {"data": [{"id": "1"}, {"id": "2"}], "pagination": {"nextCursor": "c2", "prevCursor": None}},
-            {"data": [{"id": "3"}], "pagination": {"nextCursor": "c3", "prevCursor": "c2"}},
-            {"data": [{"id": "4"}], "pagination": {"nextCursor": None, "prevCursor": "c3"}},
-        ]
-        fetcher = make_fetcher(pages_data)
-
-        result = list(paginate_pages(fetcher))
-        assert len(result) == 3
-        assert fetcher.call_count[0] == 3
-
-    def test_respects_max_pages(self):
-        pages_data = [
-            {"data": [{"id": "1"}], "pagination": {"nextCursor": "c2", "prevCursor": None}},
-            {"data": [{"id": "2"}], "pagination": {"nextCursor": "c3", "prevCursor": "c2"}},
-            {"data": [{"id": "3"}], "pagination": {"nextCursor": None, "prevCursor": "c3"}},
-        ]
-        fetcher = make_fetcher(pages_data)
-
-        result = list(paginate_pages(fetcher, max_pages=2))
-        assert len(result) == 2
-        assert fetcher.call_count[0] == 2
-
-    def test_single_page_no_next_cursor(self):
-        pages_data = [
-            {"data": [{"id": "1"}], "pagination": {"nextCursor": None, "prevCursor": None}},
-        ]
-        fetcher = make_fetcher(pages_data)
-
-        result = list(paginate_pages(fetcher))
-        assert len(result) == 1
-
-    def test_empty_data(self):
-        pages_data = [
-            {"data": [], "pagination": {"nextCursor": None, "prevCursor": None}},
-        ]
-        fetcher = make_fetcher(pages_data)
-
-        result = list(paginate_pages(fetcher))
-        assert len(result) == 1
-        assert result[0]["data"] == []
-
-    def test_error_propagation(self):
-        call_count = [0]
-
-        def fetcher(cursor=None):
-            idx = call_count[0]
-            call_count[0] += 1
-            if idx == 0:
-                return {"data": [{"id": "1"}], "pagination": {"nextCursor": "c2", "prevCursor": None}}
-            raise RuntimeError("API error")
-
-        with pytest.raises(RuntimeError, match="API error"):
-            list(paginate_pages(fetcher))
-
-
-class TestPaginate:
-    def test_yields_individual_items(self):
-        pages_data = [
-            {"data": [{"id": "1"}, {"id": "2"}], "pagination": {"nextCursor": "c2", "prevCursor": None}},
-            {"data": [{"id": "3"}], "pagination": {"nextCursor": None, "prevCursor": "c2"}},
-        ]
-        fetcher = make_fetcher(pages_data)
-
-        items = list(paginate(fetcher))
-        assert items == [{"id": "1"}, {"id": "2"}, {"id": "3"}]
-
-    def test_respects_max_pages(self):
-        pages_data = [
-            {"data": [{"id": "1"}], "pagination": {"nextCursor": "c2", "prevCursor": None}},
-            {"data": [{"id": "2"}], "pagination": {"nextCursor": None, "prevCursor": "c2"}},
-        ]
-        fetcher = make_fetcher(pages_data)
-
-        items = list(paginate(fetcher, max_pages=1))
-        assert items == [{"id": "1"}]
-        assert fetcher.call_count[0] == 1

tweetapi-1.2.0/tests/test_retry.py

@@ -1,148 +0,0 @@
-"""Tests for retry with exponential backoff."""
-
-from unittest.mock import patch
-
-import pytest
-import responses
-
-from tweetapi import (
-    TweetAPI,
-    RateLimitError,
-    ServerError,
-    NetworkError,
-    ValidationError,
-    AuthenticationError,
-    NotFoundError,
-)
-
-BASE_URL = "https://api.tweetapi.com"
-
-
-def make_client(**kwargs):
-    defaults = {"api_key": "test-key", "initial_retry_delay": 0.01, "max_retry_delay": 0.1}
-    defaults.update(kwargs)
-    return TweetAPI(**defaults)
-
-
-class TestRetryOnTransientErrors:
-    @responses.activate
-    def test_retries_on_500_and_succeeds(self):
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"error": {"code": "SERVER_ERROR", "message": "fail", "details": None}}, status=500)
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"data": {"id": "1", "username": "test"}}, status=200)
-
-        client = make_client(max_retries=3)
-        result = client.user.get_by_username(username="test")
-        assert result["data"]["id"] == "1"
-        assert len(responses.calls) == 2
-
-    @responses.activate
-    def test_retries_on_429_with_retry_after(self):
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"error": {"code": "RATE_LIMIT", "message": "rate limited",
-                                       "details": {"retryAfter": 1}}}, status=429)
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"data": {"id": "1"}}, status=200)
-
-        client = make_client(max_retries=1, max_retry_delay=2.0)
-        with patch("tweetapi.client.time.sleep") as mock_sleep:
-            result = client.user.get_by_username(username="test")
-            assert result["data"]["id"] == "1"
-            assert len(responses.calls) == 2
-            # Should have slept for the retryAfter duration (1 second)
-            mock_sleep.assert_called_once()
-            delay = mock_sleep.call_args[0][0]
-            assert 0.9 <= delay <= 2.0  # retryAfter=1, capped at max_retry_delay
-
-    @responses.activate
-    def test_exhausts_retries_and_raises(self):
-        for _ in range(4):
-            responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                          json={"error": {"code": "SERVER_ERROR", "message": "fail", "details": None}}, status=500)
-
-        client = make_client(max_retries=2)
-        with pytest.raises(ServerError):
-            client.user.get_by_username(username="test")
-        assert len(responses.calls) == 3  # 1 initial + 2 retries
-
-
-class TestNoRetryOnClientErrors:
-    @responses.activate
-    def test_no_retry_on_400(self):
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"error": {"code": "BAD_REQUEST", "message": "bad", "details": None}}, status=400)
-
-        client = make_client(max_retries=3)
-        with pytest.raises(ValidationError):
-            client.user.get_by_username(username="test")
-        assert len(responses.calls) == 1
-
-    @responses.activate
-    def test_no_retry_on_401(self):
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"error": {"code": "UNAUTHORIZED", "message": "bad key", "details": None}}, status=401)
-
-        client = make_client(max_retries=3)
-        with pytest.raises(AuthenticationError):
-            client.user.get_by_username(username="test")
-        assert len(responses.calls) == 1
-
-    @responses.activate
-    def test_no_retry_on_404(self):
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"error": {"code": "NOT_FOUND", "message": "nope", "details": None}}, status=404)
-
-        client = make_client(max_retries=3)
-        with pytest.raises(NotFoundError):
-            client.user.get_by_username(username="test")
-        assert len(responses.calls) == 1
-
-
-class TestRetryOnNetworkErrors:
-    @responses.activate
-    def test_retries_on_connection_error(self):
-        import requests as req
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      body=req.exceptions.ConnectionError("connection refused"))
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"data": {"id": "1"}}, status=200)
-
-        client = make_client(max_retries=1)
-        result = client.user.get_by_username(username="test")
-        assert result["data"]["id"] == "1"
-        assert len(responses.calls) == 2
-
-
-class TestRetryDisabled:
-    @responses.activate
-    def test_max_retries_zero(self):
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"error": {"code": "SERVER_ERROR", "message": "fail", "details": None}}, status=500)
-
-        client = make_client(max_retries=0)
-        with pytest.raises(ServerError):
-            client.user.get_by_username(username="test")
-        assert len(responses.calls) == 1
-
-
-class TestRateLimitInfo:
-    @responses.activate
-    def test_rate_limit_info_initially_none(self):
-        client = make_client()
-        assert client.rate_limit_info is None
-
-    @responses.activate
-    def test_rate_limit_info_populated_after_429(self):
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"error": {"code": "RATE_LIMIT", "message": "rate limited",
-                                       "details": {"retryAfter": 30}}}, status=429)
-        responses.add(responses.GET, f"{BASE_URL}/tw-v2/user/by-username",
-                      json={"data": {"id": "1"}}, status=200)
-
-        client = make_client(max_retries=1)
-        client.user.get_by_username(username="test")
-
-        assert client.rate_limit_info is not None
-        assert client.rate_limit_info["retry_after"] == 30
-        assert client.rate_limit_info["timestamp"] > 0

tweetapi-1.2.0/tests/test_timeout.py

@@ -1,56 +0,0 @@
-"""Tests for split timeout configuration."""
-
-import responses
-
-from tweetapi import TweetAPI
-
-BASE_URL = "https://api.tweetapi.com"
-
-
-class TestTimeoutDefaults:
-    def test_default_timeout_is_tuple(self):
-        client = TweetAPI(api_key="key")
-        assert client._timeout == (10.0, 30.0)
-
-    def test_single_timeout_value(self):
-        client = TweetAPI(api_key="key", timeout=15)
-        assert client._timeout == 15
-
-    def test_tuple_timeout_value(self):
-        client = TweetAPI(api_key="key", timeout=(5, 20))
-        assert client._timeout == (5, 20)
-
-    def test_explicit_connect_and_read(self):
-        client = TweetAPI(api_key="key", connect_timeout=5.0, read_timeout=60.0)
-        assert client._timeout == (5.0, 60.0)
-
-    def test_only_connect_timeout(self):
-        client = TweetAPI(api_key="key", connect_timeout=3.0)
-        assert client._timeout == (3.0, 30.0)
-
-    def test_only_read_timeout(self):
-        client = TweetAPI(api_key="key", read_timeout=120.0)
-        assert client._timeout == (10.0, 120.0)
-
-    def test_timeout_overrides_connect_read(self):
-        """When timeout is explicitly set, connect_timeout/read_timeout are ignored."""
-        client = TweetAPI(api_key="key", timeout=25, connect_timeout=5, read_timeout=60)
-        assert client._timeout == 25
-
-
-class TestTimeoutPassedToRequests:
-    @responses.activate
-    def test_timeout_passed_in_request(self):
-        responses.add(
-            responses.GET,
-            f"{BASE_URL}/tw-v2/user/by-username",
-            json={"data": {"id": "1", "username": "test"}},
-            status=200,
-        )
-
-        client = TweetAPI(api_key="key", timeout=42)
-        client.user.get_by_username(username="test")
-
-        # The responses library records the request but doesn't expose the
-        # timeout kwarg. We verify configuration storage instead.
-        assert client._timeout == 42