tweepy-self 1.10.0b6__py3-none-any.whl → 1.10.0b8__py3-none-any.whl

{tweepy_self-1.10.0b6.dist-info → tweepy_self-1.10.0b8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tweepy-self
-Version: 1.10.0b6
+Version: 1.10.0b8
 Summary: Twitter (selfbot) for Python!
 Home-page: https://github.com/alenkimov/tweepy-self
 Author: Alen

{tweepy_self-1.10.0b6.dist-info → tweepy_self-1.10.0b8.dist-info}/RECORD

@@ -10,14 +10,14 @@ twitter/account.py,sha256=joAB5Zw-Le5E3kOZ-1nb4DPGlTqWYv2Vs6gJ3cwu7is,3175
 twitter/base/__init__.py,sha256=Q2ko0HeOS5tiBnDVKxxaZYetwRR3YXJ67ujL3oThGd4,141
 twitter/base/client.py,sha256=J_iL4ZGfwTbZ2gpjtFCbBxNgt7weJ55EeMGzYsLtjf4,500
 twitter/base/session.py,sha256=JFPS-9Qae1iY3NfNcywxvWWmRDijaU_Rjs3WaQ00iFA,2071
-twitter/client.py,sha256=zcW31OYf4Y9NvfgH2V5rnmdHXSa6tRFdxVuKvy_JyEw,70579
+twitter/client.py,sha256=3eCld11wiZPOKF561RlTcJ_Re-lupvGSPz7MPKrJl1k,75103
 twitter/enums.py,sha256=-OH6Ibxarq5qt4E2AhkProVawcEyIf5YG_h_G5xiV9Y,270
 twitter/errors.py,sha256=oNa0Neos80ZK4-0FBzqgxXonH564qFnoN-kavHalfR4,5274
-twitter/models.py,sha256=7yObMPUUEwJEbraHzFwmUKd91UhR2-zyfJTm4xIqrSQ,4834
+twitter/models.py,sha256=CrGb3dvA0U4PfPTkUtuprPKXpqkLpM8AR_-De4D3efM,5677
 twitter/utils/__init__.py,sha256=usxpfcRQ7zxTTgZ-i425tT7hIz73Pwh9FDj4t6O3dYg,663
 twitter/utils/file.py,sha256=Sz2KEF9DnL04aOP1XabuMYMMF4VR8dJ_KWMEVvQ666Y,1120
 twitter/utils/html.py,sha256=nrOJw0vUKfBaHgFaQSQIdXfvfZ8mdu84MU_s46kJTJ4,2087
 twitter/utils/other.py,sha256=9RIYF2AMdmNKIwClG3jBP7zlvxZPEgYfuHaIiOhURzM,1061
-tweepy_self-1.10.0b6.dist-info/METADATA,sha256=9RkGszuiywuEgKLozQNVo_usGEgJ3ismzwnsVGqZkc4,13153
-tweepy_self-1.10.0b6.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-tweepy_self-1.10.0b6.dist-info/RECORD,,
+tweepy_self-1.10.0b8.dist-info/METADATA,sha256=gghI1xBSOt1w8QajiIFg6H93LAydql3haQ3tk0YghoU,13153
+tweepy_self-1.10.0b8.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+tweepy_self-1.10.0b8.dist-info/RECORD,,

twitter/client.py

@@ -30,7 +30,7 @@ from .errors import (
 from .utils import to_json
 from .base import BaseHTTPClient
 from .account import Account, AccountStatus
-from .models import User, Tweet, Media
+from .models import User, Tweet, Media, Subtask
 from .utils import (
     parse_oauth_html,
     parse_unlock_html,
@@ -190,7 +190,6 @@ class Client(BaseHTTPClient):
                     raise Locked(exc, self.account)
                 raise exc
 
-            self.account.status = AccountStatus.GOOD
             return response, data
 
         if response.status_code == 400:
@@ -1184,6 +1183,7 @@ class Client(BaseHTTPClient):
         url = "https://twitter.com/i/api/1.1/account/update_profile.json"
         try:
             await self.request("POST", url, auto_unlock=False, auto_relogin=False)
+            self.account.status = AccountStatus.GOOD
         except BadAccount:
             pass
 
@@ -1377,7 +1377,8 @@ class Client(BaseHTTPClient):
             solution = await FunCaptcha(**funcaptcha).aio_captcha_handler()
             if solution.errorId:
                 logger.warning(
-                    f"{self.account} Failed to solve funcaptcha:"
+                    f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                    f"Failed to solve funcaptcha:"
                     f"\n\tUnlock attempt: {attempt}/{self.max_unlock_attempts}"
                     f"\n\tError ID: {solution.errorId}"
                     f"\n\tError code: {solution.errorCode}"
@@ -1422,18 +1423,51 @@ class Client(BaseHTTPClient):
 
         await self.establish_status()
 
-    async def _task(self, **kwargs):
+    async def update_backup_code(self):
+        url = "https://api.twitter.com/1.1/account/backup_code.json"
+        response, response_json = await self.request("GET", url)
+        self.account.backup_code = response_json["codes"][0]
+
+    async def _send_raw_subtask(self, **request_kwargs) -> tuple[str, list[Subtask]]:
         """
-        :return: flow_token, subtasks
+        :return: flow_token and subtasks
         """
         url = "https://api.twitter.com/1.1/onboarding/task.json"
-        response, response_json = await self.request("POST", url, **kwargs)
-        return response_json["flow_token"], response_json["subtasks"]
+        response, data = await self.request("POST", url, **request_kwargs)
+        subtasks = [
+            Subtask.from_raw_data(subtask_data) for subtask_data in data["subtasks"]
+        ]
+        log_message = (
+            f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+            f" Requested subtasks:"
+        )
+        for subtask in subtasks:
+            log_message += f"\n\t{subtask.id}"
+            if subtask.primary_text:
+                log_message += f"\n\tPrimary text: {subtask.primary_text}"
+            if subtask.secondary_text:
+                log_message += f"\n\tSecondary text: {subtask.secondary_text}"
+            if subtask.detail_text:
+                log_message += f"\n\tDetail text: {subtask.detail_text}"
+        logger.debug(log_message)
+        return data["flow_token"], subtasks
 
-    async def _request_login_tasks(self):
-        """
-        :return: flow_token, subtask_ids
-        """
+    async def _complete_subtask(
+        self,
+        flow_token: str,
+        inputs: list[dict],
+        **request_kwargs,
+    ) -> tuple[str, list[Subtask]]:
+        payload = request_kwargs["json"] = request_kwargs.get("json") or {}
+        payload.update(
+            {
+                "flow_token": flow_token,
+                "subtask_inputs": inputs,
+            }
+        )
+        return await self._send_raw_subtask(**request_kwargs)
+
+    async def _request_login_tasks(self) -> tuple[str, list[Subtask]]:
         params = {
             "flow_name": "login",
         }
@@ -1488,30 +1522,14 @@ class Client(BaseHTTPClient):
                 "web_modal": 1,
             },
         }
-        return await self._task(params=params, json=payload, auth=False)
+        return await self._send_raw_subtask(params=params, json=payload, auth=False)
 
-    async def _send_task(self, flow_token: str, subtask_inputs: list[dict], **kwargs):
-        payload = kwargs["json"] = kwargs.get("json") or {}
-        payload.update(
-            {
-                "flow_token": flow_token,
-                "subtask_inputs": subtask_inputs,
-            }
-        )
-        return await self._task(**kwargs)
-
-    async def _finish_task(self, flow_token):
-        payload = {
-            "flow_token": flow_token,
-            "subtask_inputs": [],
-        }
-        return await self._task(json=payload)
-
-    async def _login_enter_user_identifier(self, flow_token):
-        subtask_inputs = [
+    async def _login_enter_user_identifier(self, flow_token: str):
+        inputs = [
             {
                 "subtask_id": "LoginEnterUserIdentifierSSO",
                 "settings_list": {
+                    "link": "next_link",
                     "setting_responses": [
                         {
                             "key": "user_identifier",
@@ -1523,49 +1541,70 @@ class Client(BaseHTTPClient):
                             },
                         }
                     ],
-                    "link": "next_link",
                 },
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs, auth=False)
+        return await self._complete_subtask(flow_token, inputs, auth=False)
 
-    async def _login_enter_password(self, flow_token):
-        subtask_inputs = [
+    async def _login_enter_password(self, flow_token: str):
+        inputs = [
             {
                 "subtask_id": "LoginEnterPassword",
                 "enter_password": {
-                    "password": self.account.password,
                     "link": "next_link",
+                    "password": self.account.password,
                 },
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs, auth=False)
+        return await self._complete_subtask(flow_token, inputs, auth=False)
 
     async def _account_duplication_check(self, flow_token):
-        subtask_inputs = [
+        inputs = [
             {
                 "subtask_id": "AccountDuplicationCheck",
                 "check_logged_in_account": {"link": "AccountDuplicationCheck_false"},
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs, auth=False)
-
-    async def _login_two_factor_auth_challenge(self, flow_token):
-        if not self.account.totp_secret:
-            raise TwitterException(
-                f"Failed to login. Task id: LoginTwoFactorAuthChallenge"
-            )
+        return await self._complete_subtask(flow_token, inputs, auth=False)
 
-        subtask_inputs = [
+    async def _login_two_factor_auth_challenge(self, flow_token, value: str):
+        inputs = [
             {
                 "subtask_id": "LoginTwoFactorAuthChallenge",
                 "enter_text": {
-                    "text": self.account.get_totp_code(),
                     "link": "next_link",
+                    "text": value,
                 },
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs, auth=False)
+        return await self._complete_subtask(flow_token, inputs, auth=False)
+
+    async def _login_two_factor_auth_choose_method(
+        self, flow_token: str, choices: Iterable[int] = (0,)
+    ):
+        inputs = [
+            {
+                "subtask_id": "LoginTwoFactorAuthChooseMethod",
+                "choice_selection": {
+                    "link": "next_link",
+                    "selected_choices": [str(choice) for choice in choices],
+                },
+            }
+        ]
+        return await self._complete_subtask(flow_token, inputs, auth=False)
+
+    async def _login_acid(
+        self,
+        flow_token: str,
+        value: str,
+    ):
+        inputs = [
+            {
+                "subtask_id": "LoginAcid",
+                "enter_text": {"text": value, "link": "next_link"},
+            }
+        ]
+        return await self._complete_subtask(flow_token, inputs, auth=False)
 
     async def _viewer(self):
         url, query_id = self._action_to_url("Viewer")
@@ -1582,9 +1621,9 @@ class Client(BaseHTTPClient):
         }
         variables = {"withCommunitiesMemberships": True}
         params = {
-            "features": to_json(features),
-            "fieldToggles": to_json(field_toggles),
-            "variables": to_json(variables),
+            "features": features,
+            "fieldToggles": field_toggles,
+            "variables": variables,
         }
         return await self.request("GET", url, params=params)
 
@@ -1601,38 +1640,92 @@ class Client(BaseHTTPClient):
         guest_token = re.search(r"gt\s?=\s?\d+", response.text)[0].split("=")[1]
         return guest_token
 
-    async def _login(self):
+    async def _login(self) -> bool:
+        update_backup_code = False
+
         guest_token = await self._request_guest_token()
         self._session.headers["X-Guest-Token"] = guest_token
 
-        # Можно не устанавливать, так как твиттер сам вернет этот токен
-        # self._session.cookies["gt"] = guest_token
-
         flow_token, subtasks = await self._request_login_tasks()
         for _ in range(2):
             flow_token, subtasks = await self._login_enter_user_identifier(flow_token)
 
-        subtask_ids = [subtask["subtask_id"] for subtask in subtasks]
-
+        subtask_ids = {subtask.id for subtask in subtasks}
         if "LoginEnterAlternateIdentifierSubtask" in subtask_ids:
             if not self.account.username:
-                raise ValueError("No username to relogin")
+                raise TwitterException("Failed to login: no username to relogin")
 
         flow_token, subtasks = await self._login_enter_password(flow_token)
         flow_token, subtasks = await self._account_duplication_check(flow_token)
 
-        subtask_ids = [subtask["subtask_id"] for subtask in subtasks]
-
-        # TODO IMAP Обработчик
+        subtask_ids = {subtask.id for subtask in subtasks}
         if "LoginAcid" in subtask_ids:
-            raise TwitterException(f"Failed to login: email verification!")
+            if not self.account.email:
+                raise TwitterException(
+                    f"Failed to login. Task id: LoginAcid. No email!"
+                )
+
+            try:
+                # fmt: off
+                flow_token, subtasks = await self._login_acid(flow_token, self.account.email)
+                # fmt: on
+            except HTTPException as exc:
+                if 399 in exc.api_codes:
+                    logger.warning(
+                        f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                        f" Bad email!"
+                    )
+                    raise TwitterException(
+                        f"Failed to login. Task id: LoginAcid. Bad email!"
+                    )
+                else:
+                    raise
 
         if "LoginTwoFactorAuthChallenge" in subtask_ids:
-            flow_token, subtasks = await self._login_two_factor_auth_challenge(
-                flow_token
-            )
+            if not self.account.totp_secret:
+                raise TwitterException(
+                    f"Failed to login. Task id: LoginTwoFactorAuthChallenge. No totp_secret!"
+                )
 
-        await self._finish_task(flow_token)
+            try:
+                # fmt: off
+                flow_token, subtasks = await self._login_two_factor_auth_challenge(flow_token, self.account.get_totp_code())
+                # fmt: on
+            except HTTPException as exc:
+                if 399 in exc.api_codes:
+                    logger.warning(
+                        f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                        f" Bad TOTP secret!"
+                    )
+                    if not self.account.backup_code:
+                        raise TwitterException(
+                            f"Failed to login. Task id: LoginTwoFactorAuthChallenge. No backup code!"
+                        )
+
+                    # Enter backup code
+                    # fmt: off
+                    flow_token, subtasks = await self._login_two_factor_auth_choose_method(flow_token)
+                    try:
+                        flow_token, subtasks = await self._login_two_factor_auth_challenge(flow_token, self.account.backup_code)
+                    except HTTPException as exc:
+                        if 399 in exc.api_codes:
+                            logger.warning(
+                                f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                                f" Bad backup code!"
+                            )
+                            raise TwitterException(
+                                f"Failed to login. Task id: LoginTwoFactorAuthChallenge. Bad backup_code!"
+                            )
+                        else:
+                            raise
+
+                    update_backup_code = True
+                    # fmt: on
+                else:
+                    raise
+
+        await self._complete_subtask(flow_token, [])
+        return update_backup_code
 
     async def relogin(self):
         """
@@ -1647,8 +1740,17 @@ class Client(BaseHTTPClient):
         if not self.account.password:
             raise ValueError("No password")
 
-        await self._login()
+        update_backup_code = await self._login()
         await self._viewer()
+
+        if update_backup_code:
+            await self.update_backup_code()
+            logger.warning(
+                f"(auth_token={self.account.hidden_auth_token}, id={self.account.id}, username={self.account.username})"
+                f" Requested new backup code!"
+            )
+            # TODO Также обновлять totp_secret
+
         await self.establish_status()
 
     async def login(self):
@@ -1665,13 +1767,13 @@ class Client(BaseHTTPClient):
 
         url = f"https://twitter.com/i/api/1.1/strato/column/User/{self.account.id}/account-security/twoFactorAuthSettings2"
         response, data = await self.request("GET", url)
-        return "Totp" in [
-            method_data["twoFactorType"] for method_data in data["methods"]
-        ]
+        # fmt: off
+        return "Totp" in [method_data["twoFactorType"] for method_data in data["methods"]]
+        # fmt: on
 
-    async def _request_2fa_tasks(self):
+    async def _request_2fa_tasks(self) -> tuple[str, list[Subtask]]:
         """
-        :return: flow_token, subtask_ids
+        :return: flow_token, tasks
         """
         query = {
             "flow_name": "two-factor-auth-app-enrollment",
@@ -1727,34 +1829,37 @@ class Client(BaseHTTPClient):
                 "web_modal": 1,
             },
         }
-        return await self._task(params=query, json=payload)
+        return await self._send_raw_subtask(params=query, json=payload)
 
-    async def _two_factor_enrollment_verify_password_subtask(self, flow_token: str):
-        subtask_inputs = [
+    async def _two_factor_enrollment_verify_password_subtask(
+        self, flow_token: str
+    ) -> tuple[str, list[Subtask]]:
+        inputs = [
             {
                 "subtask_id": "TwoFactorEnrollmentVerifyPasswordSubtask",
                 "enter_password": {
-                    "password": self.account.password,
                     "link": "next_link",
+                    "password": self.account.password,
                 },
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs)
+        return await self._complete_subtask(flow_token, inputs)
 
     async def _two_factor_enrollment_authentication_app_begin_subtask(
         self, flow_token: str
-    ):
-        subtask_inputs = [
+    ) -> tuple[str, list[Subtask]]:
+        inputs = [
             {
                 "subtask_id": "TwoFactorEnrollmentAuthenticationAppBeginSubtask",
                 "action_list": {"link": "next_link"},
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs)
+        return await self._complete_subtask(flow_token, inputs)
 
     async def _two_factor_enrollment_authentication_app_plain_code_subtask(
-        self, flow_token: str
-    ):
+        self,
+        flow_token: str,
+    ) -> tuple[str, list[Subtask]]:
         subtask_inputs = [
             {
                 "subtask_id": "TwoFactorEnrollmentAuthenticationAppPlainCodeSubtask",
@@ -1763,12 +1868,12 @@ class Client(BaseHTTPClient):
             {
                 "subtask_id": "TwoFactorEnrollmentAuthenticationAppEnterCodeSubtask",
                 "enter_text": {
-                    "text": self.account.get_totp_code(),
                     "link": "next_link",
+                    "text": self.account.get_totp_code(),
                 },
             },
         ]
-        return await self._send_task(flow_token, subtask_inputs)
+        return await self._complete_subtask(flow_token, subtask_inputs)
 
     async def _finish_2fa_task(self, flow_token: str):
         subtask_inputs = [
@@ -1777,52 +1882,38 @@ class Client(BaseHTTPClient):
                 "cta": {"link": "finish_link"},
             }
         ]
-        return await self._send_task(flow_token, subtask_inputs)
+        await self._complete_subtask(flow_token, subtask_inputs)
 
     async def _enable_totp(self):
+        # fmt: off
         flow_token, subtasks = await self._request_2fa_tasks()
-        flow_token, subtasks = (
-            await self._two_factor_enrollment_verify_password_subtask(flow_token)
-        )
-        flow_token, subtasks = (
-            await self._two_factor_enrollment_authentication_app_begin_subtask(
-                flow_token
-            )
+        flow_token, subtasks = await self._two_factor_enrollment_verify_password_subtask(
+            flow_token
         )
+        flow_token, subtasks = (await self._two_factor_enrollment_authentication_app_begin_subtask(flow_token))
 
         for subtask in subtasks:
-            if (
-                subtask["subtask_id"]
-                == "TwoFactorEnrollmentAuthenticationAppPlainCodeSubtask"
-            ):
-                self.account.totp_secret = subtask["show_code"]["code"]
+            if subtask.id == "TwoFactorEnrollmentAuthenticationAppPlainCodeSubtask":
+                self.account.totp_secret = subtask.raw_data["show_code"]["code"]
                 break
 
-        flow_token, subtasks = (
-            await self._two_factor_enrollment_authentication_app_plain_code_subtask(
-                flow_token
-            )
-        )
+        flow_token, subtasks = await self._two_factor_enrollment_authentication_app_plain_code_subtask(flow_token)
 
         for subtask in subtasks:
-            if (
-                subtask["subtask_id"]
-                == "TwoFactorEnrollmentAuthenticationAppCompleteSubtask"
-            ):
-                result = re.search(
-                    r"\n[a-z0-9]{12}\n", subtask["cta"]["secondary_text"]["text"]
-                )
+            if subtask.id == "TwoFactorEnrollmentAuthenticationAppCompleteSubtask":
+                result = re.search(r"\n[a-z0-9]{12}\n", subtask.raw_data["cta"]["secondary_text"]["text"])
                 backup_code = result[0].strip() if result else None
                 self.account.backup_code = backup_code
                 break
 
+        # fmt: on
         await self._finish_2fa_task(flow_token)
 
     async def enable_totp(self):
-        if not self.account.password:
-            raise ValueError("Password is required for this action")
-
         if await self.totp_is_enabled():
             return
 
+        if not self.account.password:
+            raise ValueError("Password required to enable TOTP")
+
         await self._enable_totp()

twitter/models.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Any
 from datetime import datetime, timedelta
 
 from pydantic import BaseModel, Field, field_validator
@@ -153,3 +153,24 @@ class Tweet(BaseModel):
             "raw_data": data,
         }
         return cls(**values)
+
+
+class Subtask(BaseModel):
+    id: str
+    primary_text: Optional[str] = None
+    secondary_text: Optional[str] = None
+    detail_text: Optional[str] = None
+    raw_data: dict
+
+    @classmethod
+    def from_raw_data(cls, data: dict) -> "Subtask":
+        task = {"id": data["subtask_id"]}
+        if enter_text := data.get("enter_text"):
+            if header := enter_text.get("header"):
+                if primary_text := header.get("primary_text"):
+                    task["primary_text"] = primary_text["text"]
+                if secondary_text := header.get("secondary_text"):
+                    task["secondary_text"] = secondary_text["text"]
+                if detail_text := header.get("detail_text"):
+                    task["detail_text"] = detail_text["text"]
+        return cls(**task, raw_data=data)