tweepy-self 0.1.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

twitter/errors.py

@@ -0,0 +1,145 @@
+from curl_cffi import requests
+
+from .account import Account
+
+__all__ = [
+    "TwitterException",
+    "HTTPException",
+    "BadRequest",
+    "Unauthorized",
+    "Forbidden",
+    "NotFound",
+    "RateLimited",
+    "ServerError",
+    "BadAccount",
+    "BadToken",
+    "Locked",
+    "Suspended",
+]
+
+
+class TwitterException(Exception):
+    pass
+
+
+class BadAccount(TwitterException):
+    def __init__(
+            self,
+            account: Account,
+            custom_exception_message: str = None,
+    ):
+        self.account = account
+        exception_message = f"Bad Twitter account."
+        super().__init__(custom_exception_message or exception_message)
+
+
+class BadToken(BadAccount):
+    def __init__(self, account: Account):
+        exception_message = f"Bad Twitter account's auth_token."
+        super().__init__(account, custom_exception_message=exception_message)
+
+
+class Locked(BadAccount):
+    def __init__(self, account: Account):
+        exception_message = f"Twitter account is locked. Captcha required to unlock."
+        super().__init__(account, custom_exception_message=exception_message)
+
+
+class Suspended(BadAccount):
+    def __init__(self, account: Account):
+        exception_message = f"Twitter account is suspended."
+        super().__init__(account, custom_exception_message=exception_message)
+
+
+class HTTPException(TwitterException):
+    """Exception raised when an HTTP request fails.
+    """
+
+    def __init__(
+            self,
+            response: requests.Response,
+            data: dict | str,
+            custom_exception_message: str = None,
+    ):
+        self.response = response
+        self.api_errors: list[dict[str, int | str]] = []
+        self.api_codes: list[int] = []
+        self.api_messages: list[str] = []
+
+        # Если ответ — строка, то это html
+        if isinstance(data, str):
+            exception_message = f"{response.status_code}"
+            if response.status_code == 429:
+                exception_message = (f"{response.status_code} Rate limit exceeded."
+                                     f"\nSet twitter.Client(wait_on_rate_limit=True) to ignore this exception.")
+            super().__init__(exception_message)
+            return
+
+        errors = data.get("errors", [])
+
+        if "error" in data:
+            errors.append(data["error"])
+        else:
+            errors.append(data)
+
+        error_text = ""
+
+        for error in errors:
+            self.api_errors.append(error)
+
+            if isinstance(error, str):
+                self.api_messages.append(error)
+                error_text += '\n' + error
+                continue
+
+            if "code" in error:
+                self.api_codes.append(error["code"])
+            if "message" in error:
+                self.api_messages.append(error["message"])
+
+            if "code" in error and "message" in error:
+                error_text += f"\n{error['code']} - {error['message']}"
+            elif "message" in error:
+                error_text += '\n' + error["message"]
+
+        if not error_text and "detail" in data:
+            self.api_messages.append(data["detail"])
+            error_text = '\n' + data["detail"]
+        exception_message = f"{response.status_code} {error_text}"
+        super().__init__(custom_exception_message or exception_message)
+
+
+class BadRequest(HTTPException):
+    """Exception raised for a 400 HTTP status code.
+    """
+    pass
+
+
+class Unauthorized(HTTPException):
+    """Exception raised for a 401 HTTP status code.
+    """
+    pass
+
+
+class Forbidden(HTTPException):
+    """Exception raised for a 403 HTTP status code.
+    """
+    pass
+
+
+class NotFound(HTTPException):
+    """Exception raised for a 404 HTTP status code.
+    """
+    pass
+
+
+class RateLimited(HTTPException):
+    """Exception raised for a 429 HTTP status code.
+    """
+    pass
+
+
+class ServerError(HTTPException):
+    """Exception raised for a 5xx HTTP status code.
+    """
+    pass

twitter/models.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from .utils import to_datetime
+
+
+class UserData(BaseModel):
+    id: int
+    username: str
+    name: str
+    created_at: datetime
+    description: str
+    location: str
+    followers_count: int
+    friends_count: int
+    raw_data: dict
+
+    def __str__(self):
+        return f"({self.id}) @{self.username}"
+
+    @classmethod
+    def from_raw_user_data(cls, data: dict):
+        legacy = data["legacy"]
+        keys = ("name", "description", "location", "followers_count", "friends_count")
+        values = {key: legacy[key] for key in keys}
+        values.update({
+            "id": int(data["rest_id"]),
+            "username": legacy["screen_name"],
+            "created_at": to_datetime(legacy["created_at"]),
+            "raw_data": data,
+        })
+        return cls(**values)
+
+
+class Tweet(BaseModel):
+    user_id: int
+    id: int
+    created_at: datetime
+    full_text: str
+    lang: str
+    favorite_count: int
+    quote_count: int
+    reply_count: int
+    retweet_count: int
+    retweeted: bool
+    raw_data: dict
+
+    def __str__(self):
+        short_text = f"{self.full_text[:32]}..." if len(self.full_text) > 16 else self.full_text
+        return f"({self.id}) {short_text}"
+
+    @classmethod
+    def from_raw_data(cls, data: dict):
+        legacy = data['legacy']
+        keys = ("full_text", "lang", "favorite_count", "quote_count", "reply_count", "retweet_count", "retweeted")
+        values = {key: legacy[key] for key in keys}
+        values.update({
+            "user_id": int(legacy["user_id_str"]),
+            "id": int(legacy["id_str"]),
+            "created_at": to_datetime(legacy["created_at"]),
+            "raw_data": data
+        })
+        return cls(**values)

twitter/utils/__init__.py

@@ -0,0 +1,36 @@
+from .file import (
+    copy_file,
+    load_lines,
+    load_json,
+    load_toml,
+    write_lines,
+    write_json,
+    to_json,
+)
+from .html import (
+    parse_unlock_html,
+    parse_oauth_html,
+)
+from .other import (
+    remove_at_sign,
+    tweet_url,
+    to_datetime,
+    hidden_value,
+)
+
+
+__all__ = [
+    "copy_file",
+    "load_lines",
+    "load_json",
+    "load_toml",
+    "write_lines",
+    "write_json",
+    "to_json",
+    "parse_unlock_html",
+    "parse_oauth_html",
+    "remove_at_sign",
+    "tweet_url",
+    "to_datetime",
+    "hidden_value",
+]

twitter/utils/file.py

@@ -0,0 +1,41 @@
+import json
+import shutil
+import tomllib
+from pathlib import Path
+from typing import Iterable
+
+
+def copy_file(source_path: Path | str, destination_path: Path | str):
+    destination_path = Path(destination_path)
+    if destination_path.exists():
+        return
+    shutil.copy2(str(source_path), str(destination_path))
+
+
+def load_toml(filepath: Path | str) -> dict:
+    with open(filepath, "rb") as file:
+        return tomllib.load(file)
+
+
+def load_lines(filepath: Path | str) -> list[str]:
+    with open(filepath, "r") as file:
+        return [line.strip() for line in file.readlines() if line != "\n"]
+
+
+def write_lines(filepath: Path | str, lines: Iterable[str]):
+    with open(filepath, "w") as file:
+        file.write("\n".join(lines))
+
+
+def load_json(filepath: Path | str) -> dict:
+    with open(filepath, "r") as file:
+        return json.load(file)
+
+
+def write_json(filepath: Path | str, data):
+    with open(filepath, "w") as file:
+        json.dump(data, file, indent=4)
+
+
+def to_json(obj) -> str:
+    return json.dumps(obj, separators=(',', ':'), ensure_ascii=True)

twitter/utils/html.py

@@ -0,0 +1,29 @@
+from bs4 import BeautifulSoup
+
+
+def parse_oauth_html(html: str) -> tuple[str | None, str | None, str | None]:
+    """
+    :return: authenticity_token, redirect_url, redirect_after_login_url
+    """
+    soup = BeautifulSoup(html, "lxml")
+    authenticity_token_element = soup.find("input", {"name": "authenticity_token"})
+    authenticity_token = authenticity_token_element.get("value") if authenticity_token_element else None
+    redirect_url_element = soup.find("a", text="click here to continue")
+    redirect_url = redirect_url_element.get("href") if redirect_url_element else None
+    redirect_after_login_element = soup.find("input", {"name": "redirect_after_login"})
+    redirect_after_login_url = redirect_after_login_element.get("value") if redirect_after_login_element else None
+    return authenticity_token, redirect_url, redirect_after_login_url
+
+
+def parse_unlock_html(html: str) -> tuple[str | None, str | None, bool]:
+    """
+    :return: authenticity_token, assignment_token, needs_unlock
+    """
+    soup = BeautifulSoup(html, "lxml")
+    authenticity_token_element = soup.find("input", {"name": "authenticity_token"})
+    authenticity_token = authenticity_token_element.get("value") if authenticity_token_element else None
+    assignment_token_element = soup.find("input", {"name": "assignment_token"})
+    assignment_token = assignment_token_element.get("value") if assignment_token_element else None
+    verification_string = soup.find('input', id='verification_string')
+    needs_unlock = bool(verification_string)
+    return authenticity_token, assignment_token, needs_unlock

twitter/utils/other.py

@@ -0,0 +1,24 @@
+from datetime import datetime
+
+
+def remove_at_sign(username: str) -> str:
+    if username.startswith("@"):
+        return username[1:]
+    return username
+
+
+def tweet_url(username: str, tweet_id: int) -> str:
+    """
+    :return: Tweet URL
+    """
+    return f"https://x.com/{username}/status/{tweet_id}"
+
+
+def to_datetime(twitter_datetime: str):
+    return datetime.strptime(twitter_datetime, '%a %b %d %H:%M:%S +0000 %Y')
+
+
+def hidden_value(value: str) -> str:
+    start = value[:3]
+    end = value[-3:]
+    return f"{start}**{end}"

tweepy_self-0.1.0.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: tweepy-self
-Version: 0.1.0
-Summary: Twitter (selfbot) for Python!
-Author: Alen
-Author-email: alen.kimov@gmail.com
-Requires-Python: >=3.11,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Description-Content-Type: text/markdown
-
-# Tweepy-self
-
-https://github.com/alenkimov/better_automation

tweepy_self-0.1.0.dist-info/RECORD

@@ -1,4 +0,0 @@
-tweepy-self/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tweepy_self-0.1.0.dist-info/METADATA,sha256=lHOX3W_jeCYq7b1s3xGCi4d__V2v3yc9N2IUtvNzJLk,424
-tweepy_self-0.1.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-tweepy_self-0.1.0.dist-info/RECORD,,