twitter-openapi-python 0.0.43__py3-none-any.whl → 0.0.45__py3-none-any.whl

twitter_openapi_python/api/user_api.py

@@ -1,80 +1,80 @@
-from typing import Any, Callable, Optional, TypeVar
-
-import twitter_openapi_python_generated as twitter
-import twitter_openapi_python_generated.models as models
-from x_client_transaction import ClientTransaction
-
-from twitter_openapi_python.models import TwitterApiUtilsResponse, UserApiUtilsData
-from twitter_openapi_python.utils import (
-    build_response,
-    error_check,
-    get_kwargs,
-    user_or_null_converter,
-)
-
-T = TypeVar("T")
-ResponseType = TwitterApiUtilsResponse[UserApiUtilsData]
-ApiFnType = Callable[..., twitter.ApiResponse[T]]
-ParamType = dict[str, Any]
-
-
-class UserApiUtils:
-    api: twitter.UserApi
-    flag: ParamType
-
-    def __init__(self, api: twitter.UserApi, flag: ParamType, ct: ClientTransaction):
-        self.api = api
-        self.flag = flag
-        self.ct = ct
-
-    def request(
-        self,
-        apiFn: "ApiFnType[T]",
-        convertFn: Callable[[T], models.UserResults],
-        key: str,
-        param: ParamType,
-    ) -> ResponseType:
-        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
-        res = apiFn(**args)
-        result = convertFn(res.data)
-        if result.result is None:
-            raise Exception("No user")
-        user = user_or_null_converter(result.result)
-        if user is None:
-            raise Exception("No user")
-        data = UserApiUtilsData(
-            raw=result,
-            user=user,
-        )
-
-        return build_response(response=res, data=data)
-
-    def get_user_by_screen_name(
-        self,
-        screen_name: str,
-        extra_param: Optional[ParamType] = None,
-    ) -> ResponseType:
-        param: ParamType = {"screen_name": screen_name}
-        if extra_param is not None:
-            param.update(extra_param)
-        return self.request(
-            apiFn=self.api.get_user_by_screen_name_with_http_info,
-            convertFn=lambda e: error_check(e.data.user, e.errors),
-            key="UserByScreenName",
-            param=param,
-        )
-
-    def get_user_by_rest_id(
-        self,
-        user_id: str,
-        extra_param: Optional[ParamType] = None,
-    ) -> ResponseType:
-        param: ParamType = {"userId": user_id}
-        if extra_param is not None:
-            param.update(extra_param)
-        return self.request(
-            apiFn=self.api.get_user_by_rest_id_with_http_info,
-            convertFn=lambda e: error_check(e.data.user, e.errors),
-            key="UserByRestId",
-            param=param,
-        )
+from typing import Any, Callable, Optional, TypeVar
+
+import twitter_openapi_python_generated as twitter
+import twitter_openapi_python_generated.models as models
+from x_client_transaction import ClientTransaction
+
+from twitter_openapi_python.models import TwitterApiUtilsResponse, UserApiUtilsData
+from twitter_openapi_python.utils import (
+    build_response,
+    error_check,
+    get_kwargs,
+    user_or_null_converter,
+)
+
+T = TypeVar("T")
+ResponseType = TwitterApiUtilsResponse[UserApiUtilsData]
+ApiFnType = Callable[..., twitter.ApiResponse[T]]
+ParamType = dict[str, Any]
+
+
+class UserApiUtils:
+    api: twitter.UserApi
+    flag: ParamType
+
+    def __init__(self, api: twitter.UserApi, flag: ParamType, ct: ClientTransaction):
+        self.api = api
+        self.flag = flag
+        self.ct = ct
+
+    def request(
+        self,
+        apiFn: "ApiFnType[T]",
+        convertFn: Callable[[T], models.UserResults],
+        key: str,
+        param: ParamType,
+    ) -> ResponseType:
+        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
+        res = apiFn(**args)
+        result = convertFn(res.data)
+        if result.result is None:
+            raise Exception("No user")
+        user = user_or_null_converter(result.result)
+        if user is None:
+            raise Exception("No user")
+        data = UserApiUtilsData(
+            raw=result,
+            user=user,
+        )
+
+        return build_response(response=res, data=data)
+
+    def get_user_by_screen_name(
+        self,
+        screen_name: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"screen_name": screen_name}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_user_by_screen_name_with_http_info,
+            convertFn=lambda e: error_check(e.data.user, e.errors),
+            key="UserByScreenName",
+            param=param,
+        )
+
+    def get_user_by_rest_id(
+        self,
+        user_id: str,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"userId": user_id}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_user_by_rest_id_with_http_info,
+            convertFn=lambda e: error_check(e.data.user, e.errors),
+            key="UserByRestId",
+            param=param,
+        )

twitter_openapi_python/api/user_list_api.py

@@ -1,171 +1,171 @@
-from typing import Any, Callable, List, Optional, TypeVar
-
-import twitter_openapi_python_generated as twitter
-import twitter_openapi_python_generated.models as models
-from x_client_transaction import ClientTransaction
-
-from twitter_openapi_python.models import (
-    ApiUtilsRaw,
-    TimelineApiUtilsResponse,
-    TwitterApiUtilsResponse,
-    UserApiUtilsData,
-)
-from twitter_openapi_python.utils import (
-    build_response,
-    entries_cursor,
-    error_check,
-    get_kwargs,
-    instruction_to_entry,
-    user_entries_converter,
-    user_result_converter,
-)
-
-T = TypeVar("T")
-ResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[UserApiUtilsData]]
-ApiFnType = Callable[..., twitter.ApiResponse[T]]
-ParamType = dict[str, Any]
-
-
-class UserListApiUtils:
-    api: twitter.UserListApi
-    flag: ParamType
-
-    def __init__(self, api: twitter.UserListApi, flag: ParamType, ct: ClientTransaction):
-        self.api = api
-        self.flag = flag
-        self.ct = ct
-
-    def request(
-        self,
-        apiFn: "ApiFnType[T]",
-        convertFn: Callable[[T], List[models.InstructionUnion]],
-        key: str,
-        param: ParamType,
-    ) -> ResponseType:
-        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
-        res = apiFn(**args)
-        instruction = convertFn(res.data)
-        entry = instruction_to_entry(instruction)
-        user_list = user_entries_converter(entry)
-        user = user_result_converter(user_list)
-
-        raw = ApiUtilsRaw(
-            instruction=instruction,
-            entry=entry,
-        )
-        data = TimelineApiUtilsResponse[UserApiUtilsData](
-            raw=raw,
-            cursor=entries_cursor(entry),
-            data=user,
-        )
-
-        return build_response(response=res, data=data)
-
-    def get_followers(
-        self,
-        user_id: str,
-        cursor: Optional[str] = None,
-        count: Optional[int] = None,
-        extra_param: Optional[ParamType] = None,
-    ) -> ResponseType:
-        param: ParamType = {"userId": user_id}
-        if cursor is not None:
-            param["cursor"] = cursor
-        if count is not None:
-            param["count"] = count
-        if extra_param is not None:
-            param.update(extra_param)
-        return self.request(
-            apiFn=self.api.get_followers_with_http_info,
-            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
-            key="Followers",
-            param=param,
-        )
-
-    def get_following(
-        self,
-        user_id: str,
-        cursor: Optional[str] = None,
-        count: Optional[int] = None,
-        extra_param: Optional[ParamType] = None,
-    ) -> ResponseType:
-        param: ParamType = {"userId": user_id}
-        if cursor is not None:
-            param["cursor"] = cursor
-        if count is not None:
-            param["count"] = count
-        if extra_param is not None:
-            param.update(extra_param)
-        return self.request(
-            apiFn=self.api.get_following_with_http_info,
-            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
-            key="Following",
-            param=param,
-        )
-
-    def get_followers_you_know(
-        self,
-        user_id: str,
-        cursor: Optional[str] = None,
-        count: Optional[int] = None,
-        extra_param: Optional[ParamType] = None,
-    ) -> ResponseType:
-        param: ParamType = {"userId": user_id}
-        if cursor is not None:
-            param["cursor"] = cursor
-        if count is not None:
-            param["count"] = count
-        if extra_param is not None:
-            param.update(extra_param)
-        return self.request(
-            apiFn=self.api.get_followers_you_know_with_http_info,
-            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
-            key="FollowersYouKnow",
-            param=param,
-        )
-
-    def get_favoriters(
-        self,
-        tweet_id: str,
-        cursor: Optional[str] = None,
-        count: Optional[int] = None,
-        extra_param: Optional[ParamType] = None,
-    ) -> ResponseType:
-        param: ParamType = {"tweetId": tweet_id}
-        if cursor is not None:
-            param["cursor"] = cursor
-        if count is not None:
-            param["count"] = count
-        if extra_param is not None:
-            param.update(extra_param)
-        return self.request(
-            apiFn=self.api.get_favoriters_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.favoriters_timeline, e.errors).timeline, e.errors
-            ).instructions,
-            key="Favoriters",
-            param=param,
-        )
-
-    def get_retweeters(
-        self,
-        tweet_id: str,
-        cursor: Optional[str] = None,
-        count: Optional[int] = None,
-        extra_param: Optional[ParamType] = None,
-    ) -> ResponseType:
-        param: ParamType = {"tweetId": tweet_id}
-        if cursor is not None:
-            param["cursor"] = cursor
-        if count is not None:
-            param["count"] = count
-        if extra_param is not None:
-            param.update(extra_param)
-        return self.request(
-            apiFn=self.api.get_retweeters_with_http_info,
-            convertFn=lambda e: error_check(
-                error_check(e.data.retweeters_timeline, e.errors).timeline, e.errors
-            ).instructions,
-            key="Retweeters",
-            param=param,
-        )
+from typing import Any, Callable, List, Optional, TypeVar
+
+import twitter_openapi_python_generated as twitter
+import twitter_openapi_python_generated.models as models
+from x_client_transaction import ClientTransaction
+
+from twitter_openapi_python.models import (
+    ApiUtilsRaw,
+    TimelineApiUtilsResponse,
+    TwitterApiUtilsResponse,
+    UserApiUtilsData,
+)
+from twitter_openapi_python.utils import (
+    build_response,
+    entries_cursor,
+    error_check,
+    get_kwargs,
+    instruction_to_entry,
+    user_entries_converter,
+    user_result_converter,
+)
+
+T = TypeVar("T")
+ResponseType = TwitterApiUtilsResponse[TimelineApiUtilsResponse[UserApiUtilsData]]
+ApiFnType = Callable[..., twitter.ApiResponse[T]]
+ParamType = dict[str, Any]
+
+
+class UserListApiUtils:
+    api: twitter.UserListApi
+    flag: ParamType
+
+    def __init__(self, api: twitter.UserListApi, flag: ParamType, ct: ClientTransaction):
+        self.api = api
+        self.flag = flag
+        self.ct = ct
+
+    def request(
+        self,
+        apiFn: "ApiFnType[T]",
+        convertFn: Callable[[T], List[models.InstructionUnion]],
+        key: str,
+        param: ParamType,
+    ) -> ResponseType:
+        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
+        res = apiFn(**args)
+        instruction = convertFn(res.data)
+        entry = instruction_to_entry(instruction)
+        user_list = user_entries_converter(entry)
+        user = user_result_converter(user_list)
+
+        raw = ApiUtilsRaw(
+            instruction=instruction,
+            entry=entry,
+        )
+        data = TimelineApiUtilsResponse[UserApiUtilsData](
+            raw=raw,
+            cursor=entries_cursor(entry),
+            data=user,
+        )
+
+        return build_response(response=res, data=data)
+
+    def get_followers(
+        self,
+        user_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"userId": user_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_followers_with_http_info,
+            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
+            key="Followers",
+            param=param,
+        )
+
+    def get_following(
+        self,
+        user_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"userId": user_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_following_with_http_info,
+            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
+            key="Following",
+            param=param,
+        )
+
+    def get_followers_you_know(
+        self,
+        user_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"userId": user_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_followers_you_know_with_http_info,
+            convertFn=lambda e: error_check(e.data.user, e.errors).result.timeline.timeline.instructions,
+            key="FollowersYouKnow",
+            param=param,
+        )
+
+    def get_favoriters(
+        self,
+        tweet_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"tweetId": tweet_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_favoriters_with_http_info,
+            convertFn=lambda e: error_check(
+                error_check(e.data.favoriters_timeline, e.errors).timeline, e.errors
+            ).instructions,
+            key="Favoriters",
+            param=param,
+        )
+
+    def get_retweeters(
+        self,
+        tweet_id: str,
+        cursor: Optional[str] = None,
+        count: Optional[int] = None,
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"tweetId": tweet_id}
+        if cursor is not None:
+            param["cursor"] = cursor
+        if count is not None:
+            param["count"] = count
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_retweeters_with_http_info,
+            convertFn=lambda e: error_check(
+                error_check(e.data.retweeters_timeline, e.errors).timeline, e.errors
+            ).instructions,
+            key="Retweeters",
+            param=param,
+        )

twitter_openapi_python/api/users_api.py

@@ -1,56 +1,56 @@
-from typing import Any, Callable, Optional, TypeVar
-
-import twitter_openapi_python_generated as twitter
-import twitter_openapi_python_generated.models as models
-from x_client_transaction import ClientTransaction
-
-from twitter_openapi_python.models import TwitterApiUtilsResponse, UserApiUtilsData
-from twitter_openapi_python.utils import (
-    build_response,
-    error_check,
-    get_kwargs,
-    user_result_converter,
-)
-
-T = TypeVar("T")
-ResponseType = TwitterApiUtilsResponse[list[UserApiUtilsData]]
-ApiFnType = Callable[..., twitter.ApiResponse[T]]
-ParamType = dict[str, Any]
-
-
-class UsersApiUtils:
-    api: twitter.UsersApi
-    flag: ParamType
-
-    def __init__(self, api: twitter.UsersApi, flag: ParamType, ct: ClientTransaction):
-        self.api = api
-        self.flag = flag
-        self.ct = ct
-
-    def request(
-        self,
-        apiFn: "ApiFnType[T]",
-        convertFn: Callable[[T], list[models.UserResults]],
-        key: str,
-        param: ParamType,
-    ) -> ResponseType:
-        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
-        res = apiFn(**args)
-        user_result = convertFn(res.data)
-        user = user_result_converter(user_result)
-        return build_response(response=res, data=user)
-
-    def get_users_by_rest_ids(
-        self,
-        user_ids: list[str],
-        extra_param: Optional[ParamType] = None,
-    ) -> ResponseType:
-        param: ParamType = {"userIds": user_ids}
-        if extra_param is not None:
-            param.update(extra_param)
-        return self.request(
-            apiFn=self.api.get_users_by_rest_ids_with_http_info,
-            convertFn=lambda e: error_check(e.data.users, e.errors),
-            key="UsersByRestIds",
-            param=param,
-        )
+from typing import Any, Callable, Optional, TypeVar
+
+import twitter_openapi_python_generated as twitter
+import twitter_openapi_python_generated.models as models
+from x_client_transaction import ClientTransaction
+
+from twitter_openapi_python.models import TwitterApiUtilsResponse, UserApiUtilsData
+from twitter_openapi_python.utils import (
+    build_response,
+    error_check,
+    get_kwargs,
+    user_result_converter,
+)
+
+T = TypeVar("T")
+ResponseType = TwitterApiUtilsResponse[list[UserApiUtilsData]]
+ApiFnType = Callable[..., twitter.ApiResponse[T]]
+ParamType = dict[str, Any]
+
+
+class UsersApiUtils:
+    api: twitter.UsersApi
+    flag: ParamType
+
+    def __init__(self, api: twitter.UsersApi, flag: ParamType, ct: ClientTransaction):
+        self.api = api
+        self.flag = flag
+        self.ct = ct
+
+    def request(
+        self,
+        apiFn: "ApiFnType[T]",
+        convertFn: Callable[[T], list[models.UserResults]],
+        key: str,
+        param: ParamType,
+    ) -> ResponseType:
+        args = get_kwargs(flag=self.flag[key], additional=param, ct=self.ct)
+        res = apiFn(**args)
+        user_result = convertFn(res.data)
+        user = user_result_converter(user_result)
+        return build_response(response=res, data=user)
+
+    def get_users_by_rest_ids(
+        self,
+        user_ids: list[str],
+        extra_param: Optional[ParamType] = None,
+    ) -> ResponseType:
+        param: ParamType = {"userIds": user_ids}
+        if extra_param is not None:
+            param.update(extra_param)
+        return self.request(
+            apiFn=self.api.get_users_by_rest_ids_with_http_info,
+            convertFn=lambda e: error_check(e.data.users, e.errors),
+            key="UsersByRestIds",
+            param=param,
+        )