PySPlusthon 0.5.3__py3-none-any.whl

PySPlusthon/client/attachments/upload_file.py

@@ -0,0 +1,82 @@
+from typing import Union, BinaryIO
+from io import BufferedIOBase, BytesIO, RawIOBase
+import mimetypes
+import os
+
+import PySPlusthon
+from ...objects import File
+try:
+    from PySPlusthon.proto import requests, structs, enums
+except ImportError:
+    pass
+
+
+class UploadFile:
+
+    async def upload_file(
+            self: "PySPlusthon.Client",
+            chat_id: str,
+            file: Union[bytes, BinaryIO],
+            send_type: "enums.SendType",
+            expected_size: int = None,
+            name: str = None,
+            mime_type: str = None,
+    ) -> File:
+        peer_id, peer_type = map(int, chat_id.split("|"))
+
+        is_file_like = isinstance(file, (BufferedIOBase, BytesIO, RawIOBase))
+
+        if not expected_size:
+            if isinstance(file, bytes):
+                expected_size = len(file)
+            elif is_file_like:
+                current = file.tell()
+                file.seek(0, 2)
+                expected_size = file.tell()
+                file.seek(current)
+
+        if not name:
+            if is_file_like:
+                raw_name = getattr(file, "name", None)
+                name = os.path.basename(raw_name) if raw_name else "upload"
+            else:
+                name = "upload"
+
+        send_type_map = {
+            enums.SEND_TYPE_PHOTO: "image",
+            enums.SEND_TYPE_VIDEO: "video",
+            enums.SEND_TYPE_GIF: "video",
+            enums.SEND_TYPE_AUDIO: "audio",
+            enums.SEND_TYPE_VOICE: "audio",
+            enums.SEND_TYPE_DOCUMENT: "document",
+        }
+        file_type = send_type_map.get(send_type, "application")
+
+        if not mime_type:
+            if name != "upload":
+                mime_type = mimetypes.guess_type(name)[0]
+
+        if not mime_type:
+            mime_type = f"{file_type}/octet-stream"
+
+        if is_file_like:
+            file.seek(0)
+            file = file.read()
+
+        result = await self.execute(requests.GetNasimFileUploadUrl(
+            expected_size=expected_size,
+            crc=0,
+            uid=peer_id,
+            name=name,
+            mime_type=mime_type,
+            ex_peer=structs.ExPeer(
+                type=peer_type,
+                id=peer_id,
+                access_hash=0
+            ),
+            send_type=structs.SendTypeValue(
+                type=send_type
+            )
+        ))
+        await self.http2_connection.upload_file(result.url, file, result.chunk_size)
+        return File(id=result.file_id, size=expected_size, name=name, mime_type=mime_type)

PySPlusthon/client/chats/__init__.py

@@ -0,0 +1,43 @@
+from .ban_chat_member import BanChatMember
+from .delete_chat_photo import DeleteChatPhoto
+from .get_chat import GetChat
+from .get_chat_administrators import GetChatAdministrators
+from .get_chat_history import GetChatHistory
+from .get_chat_members_count import GetChatMembersCount
+from .get_chat_member import GetChatMember
+from .get_chat_members import GetChatMembers
+from .join_chat import JoinChat
+from .leave_chat import LeaveChat
+from .pin_chat_message import PinChatMessage
+from .promote_chat_member import PromoteChatMember
+from .restrict_chat_member import RestrictChatMember
+from .set_chat_description import SetChatDescription
+from .set_chat_photo import SetChatPhoto
+from .set_chat_title import SetChatTitle
+from .unban_chat_member import UnbanChatMember
+from .unpin_all_chat_messages import UnpinAllChatMessages
+from .unpin_chat_message import UnpinChatMessage
+
+
+class Chats(
+    BanChatMember,
+    DeleteChatPhoto,
+    GetChat,
+    GetChatAdministrators,
+    GetChatHistory,
+    GetChatMembersCount,
+    GetChatMember,
+    GetChatMembers,
+    JoinChat,
+    LeaveChat,
+    PinChatMessage,
+    PromoteChatMember,
+    RestrictChatMember,
+    SetChatDescription,
+    SetChatTitle,
+    SetChatPhoto,
+    UnbanChatMember,
+    UnpinAllChatMessages,
+    UnpinChatMessage
+):
+    pass

PySPlusthon/client/chats/ban_chat_member.py

@@ -0,0 +1,24 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class BanChatMember:
+
+    async def ban_chat_member(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            user_id: Union[int, str]
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            return await self.execute(requests.KickUser(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                user=structs.UserOutPeer(uid=user_id, access_hash=1),
+                rid=self.ws_connection.create_rid()
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        user_id = await self.resolve_peer_id(user_id)
+        return await self.auto_execute("banChatMember", locals())

PySPlusthon/client/chats/delete_chat_photo.py

@@ -0,0 +1,32 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class DeleteChatPhoto:
+
+    async def delete_chat_photo(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str]
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+
+            response = await self.execute(requests.LoadGroupAvatars(
+                peer=structs.GroupOutPeer(group_id=peer_id)
+            ))
+
+            avatars = response.avatars.avatars
+            if not avatars:
+                return
+            last_avatar = avatars[0]
+
+            return await self.execute(requests.RemoveGroupAvatar(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                rid=self.ws_connection.create_rid(),
+                avatar_id=last_avatar.id
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("deleteChatPhoto", locals())

PySPlusthon/client/chats/get_chat.py

@@ -0,0 +1,69 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import Chat
+
+
+class GetChat:
+
+    async def get_chat(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str]
+    ) -> Chat:
+        if self.is_userbot():
+            from ...proto import requests, structs
+            peer_id, peer_type = chat_id.split("|")
+
+            if not peer_id.isnumeric():
+                # "@username"
+                if peer_id.startswith("@"):
+                    peer_id = peer_id[1:]
+
+                # "+9*********" | "+09*********" | "+989*********"
+                elif peer_id.startswith("+"):
+                    peer_id =  peer_id[1:]
+
+                # "https://ble.ir/join/ABCDEEFGHI" | "https://ble.ir/username"
+                elif peer_id.startswith("https://ble.ir/"):
+                    peer_id = peer_id[15:]
+
+                # "ble.ir/join/ABCDEEFGHI" | "ble.ir/username"
+                elif peer_id.startswith("ble.ir/"):
+                    peer_id = peer_id[7:]
+
+                response = await self.execute(requests.SearchContacts(
+                    request=peer_id
+                ))
+
+                if response.user_peers:
+                    result = response.user_peers[0]
+                    peer_id = result.uid
+
+                elif response.group_peers:
+                    result = response.group_peers[0]
+                    peer_id = result.group_id
+
+                else:
+                    return
+
+            peer_id, peer_type = map(int, (peer_id, peer_type))
+
+            if peer_type in (1, 4):
+                users = await self.execute(requests.LoadUsers(
+                    user_peers=[structs.UserOutPeer(
+                        uid=peer_id,
+                        access_hash=1
+                    )]
+                ))
+                return users.users[0]
+
+            if peer_type in (2, 3, 5):
+                return await self.execute(requests.GetFullGroup(
+                    peer=structs.GroupOutPeer(
+                        group_id=peer_id,
+                        access_hash=1
+                    )
+                ))
+
+        else:
+            return await self.auto_execute("getChat", locals())

PySPlusthon/client/chats/get_chat_administrators.py

@@ -0,0 +1,18 @@
+from typing import Union, List
+
+import PySPlusthon
+from ...objects import ChatMember
+
+
+class GetChatAdministrators:
+
+    async def get_chat_administrators(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str]
+    ) -> List[ChatMember]:
+        if self.is_userbot():
+            result = await self.get_chat_members(chat_id)
+            return [member for member in result.members if member.is_admin.value]
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("getChatAdministrators", locals())

PySPlusthon/client/chats/get_chat_history.py

@@ -0,0 +1,39 @@
+from typing import Union, List
+from datetime import datetime
+
+import PySPlusthon
+from ...objects import Message, List as PySplusthonList
+try:
+    from PySPlusthon.proto import requests, structs, updates
+except ImportError:
+    pass
+
+
+class GetChatHistory:
+
+    async def get_chat_history(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            date: Union[datetime, int] = -1,
+            limit: int = 40
+    ) -> List[Message]:
+        peer_id, peer_type = map(int, chat_id.split("|"))
+        if isinstance(date, datetime):
+            date = date.timestamp() * 1000
+        peer = structs.Peer(type=peer_type, id=peer_id)
+        response = await self.execute(requests.LoadHistory(
+            peer=peer,
+            date=date,
+            load_mode=2,
+            limit=limit
+        ))
+        history = PySplusthonList()
+        for message_container in response.history:
+            message_container_fields = [field.name for field in message_container.DESCRIPTOR.fields]
+            message_fields = [field.name for field in updates.Message.DESCRIPTOR.fields]
+            fields = [field for field in message_container_fields if field in message_fields]
+            data = {field: getattr(message_container, field) for field in fields}
+            update_message = updates.Message(peer=peer, **data)
+            message = Message.from_protobuf(update_message)
+            history.append(message)
+        return history

PySPlusthon/client/chats/get_chat_member.py

@@ -0,0 +1,16 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import ChatMember
+
+
+class GetChatMember:
+
+    async def get_chat_member(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            user_id: Union[int, str]
+    ) -> ChatMember:
+        chat_id = await self.resolve_peer_id(chat_id)
+        user_id = await self.resolve_peer_id(user_id)
+        return await self.auto_execute("getChatMember", locals())

PySPlusthon/client/chats/get_chat_members.py

@@ -0,0 +1,29 @@
+import PySPlusthon
+try:
+    from PySPlusthon.proto import requests, structs, responses
+except ImportError:
+    pass
+
+
+class GetChatMembers:
+
+    async def get_chat_members(
+            self: "PySPlusthon.Client",
+            chat_id: str,
+            limit: int = 200,
+            next: bytes = None,
+            excepted_permissions: bool = False,
+            contacts: bool = False,
+            query: str = None
+    ) -> "responses.LoadMembers":
+        peer_id, peer_type = map(int, chat_id.split("|"))
+        return await self.execute(requests.LoadMembers(
+            group=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+            limit=limit,
+            next=next,
+            condition=structs.LoadMembersCondition(
+                excepted_permissions=excepted_permissions,
+                contacts=contacts,
+                query=query
+            )
+        ))

PySPlusthon/client/chats/get_chat_members_count.py

@@ -0,0 +1,21 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class GetChatMembersCount:
+
+    async def get_chat_members_count(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str]
+    ) -> int:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            response = await self.execute(requests.GetGroupMembersCount(
+                group=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+            ))
+            return response.members_count
+        
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("getChatMembersCount", locals())

PySPlusthon/client/chats/join_chat.py

@@ -0,0 +1,31 @@
+from typing import Union
+
+import PySPlusthon
+try:
+    from ...proto import requests, structs, responses
+except ImportError:
+    pass
+
+
+class JoinChat:
+    async def join_chat(
+            self: "PySPlusthon.Client",
+            chat_id: str
+    ) -> Union["responses.JoinGroup", "responses.JoinPublicGroup"]:
+        peer_id, peer_type = chat_id.split("|")
+
+        # 1234567890 | "1234567890"
+        if isinstance(peer_id, int) or (isinstance(peer_id, str) and peer_id.isnumeric()):
+            return await self.execute(requests.JoinPublicGroup(
+                peer=structs.Peer(
+                    type=int(peer_type),
+                    id=int(peer_id)
+                )
+            ))
+
+        # "https://ble.ir/join/ABCDEEFGHI" | "ble.ir/join/ABCDEEFGHI" 
+        token = peer_id.replace("https://", "").replace("ble.ir/join/", "")
+
+        return await self.execute(requests.JoinGroup(
+            token=token
+        ))

PySPlusthon/client/chats/leave_chat.py

@@ -0,0 +1,22 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class LeaveChat:
+
+    async def leave_chat(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str]
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            return await self.execute(requests.LeaveGroup(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                rid=self.ws_connection.create_rid(),
+                make_orphan=False
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("leaveChat", locals())

PySPlusthon/client/chats/pin_chat_message.py

@@ -0,0 +1,31 @@
+from typing import Union
+
+import PySPlusthon
+from ...objects import resolve_message_id
+
+
+class PinChatMessage:
+
+    async def pin_chat_message(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            message_id: Union[int, str]
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            message_id = resolve_message_id(message_id)
+            if peer_type in (1, 4):
+                return await self.execute(requests.PinMessages(
+                    peer=structs.Peer(type=peer_type, id=peer_id),
+                    message_id=structs.MessageId(date=message_id.date, rid=message_id.rid)
+                ))
+            elif peer_type in (2 ,3 ,5):
+                return await self.execute(requests.PinMessage(
+                    group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                    date=message_id.date,
+                    msg_rid=message_id.rid
+                ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("pinChatMessage", locals())

PySPlusthon/client/chats/promote_chat_member.py

@@ -0,0 +1,64 @@
+from typing import Union
+
+import PySPlusthon
+
+class PromoteChatMember:
+
+    async def promote_chat_member(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            user_id: Union[int, str],
+            can_edit_messages: bool = None,
+            can_delete_messages: bool = None,
+            can_manage_video_chats: bool = None,
+            can_restrict_members: bool = None,
+            can_promote_members: bool = None,
+            can_change_info: bool = None,
+            can_invite_users: bool = None,
+            can_pin_messages: bool = None,
+            can_send_messages: bool = None,
+            can_send_media_messages: bool = None,
+            can_send_media: bool = None,
+            can_send_gif_stickers: bool = None,
+            can_reply_to_story: bool = None,
+            can_forward_message_from: bool = None,
+            can_send_gift_packet: bool = None,
+            can_start_call: bool = None,
+            can_send_link_message: bool = None,
+            can_send_forwarded_message: bool = None,
+            can_kick_user: bool = None,
+            can_send_message: bool = None,
+            can_see_members: bool = None,
+            can_add_story: bool = None
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            return await self.execute(requests.SetMemberPermissions(
+                group=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                user=structs.UserOutPeer(uid=user_id, access_hash=1),
+                permissions=structs.Permissions(
+                    edit_message=can_edit_messages,
+                    delete_message=can_delete_messages,
+                    manage_call=can_manage_video_chats,
+                    change_info=can_change_info,
+                    invite_user=can_invite_users,
+                    pin_message=can_pin_messages,
+                    send_media=can_send_media,
+                    send_gif_stickers=can_send_gif_stickers,
+                    reply_to_story=can_reply_to_story,
+                    forward_message_from=can_forward_message_from,
+                    send_gift_packet=can_send_gift_packet,
+                    start_call=can_start_call,
+                    send_link_message=can_send_link_message,
+                    send_forwarded_message=can_send_forwarded_message,
+                    kick_user=can_kick_user,
+                    send_message=can_send_message,
+                    see_members=can_see_members,
+                    add_story=can_add_story
+                )
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        user_id = await self.resolve_peer_id(user_id)
+        return await self.auto_execute("promoteChatMember", locals())

PySPlusthon/client/chats/restrict_chat_member.py

@@ -0,0 +1,25 @@
+from typing import Union
+
+import PySPlusthon
+from PySPlusthon import objects
+
+
+class RestrictChatMember:
+
+    async def restrict_chat_member(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            user_id: Union[int, str],
+            permissions: "objects.ChatPermissions"
+    ) -> bool:
+        if self.is_userbot():
+            from ...proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            return await self.execute(requests.RemoveUserAdmin(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                user_peer=structs.UserOutPeer(uid=user_id, access_hash=1),
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        user_id = await self.resolve_peer_id(user_id)
+        return await self.auto_execute("restrictChatMember", locals())

PySPlusthon/client/chats/set_chat_description.py

@@ -0,0 +1,23 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class SetChatDescription:
+
+    async def set_chat_description(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            description: str
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            return await self.execute(requests.EditGroupAbout(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                rid=self.ws_connection.create_rid(),
+                about=description
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("setChatDescription", locals())

PySPlusthon/client/chats/set_chat_photo.py

@@ -0,0 +1,33 @@
+from typing import Union, BinaryIO
+
+import PySPlusthon
+from ...objects import InputMedia, resolve_media
+
+
+class SetChatPhoto:
+
+    async def set_chat_photo(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            photo: Union[str, bytes, BinaryIO, InputMedia]
+    ) -> bool:
+        photo = resolve_media(photo)
+
+        if self.is_userbot():
+            from ...proto import requests, structs, enums
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            file = await self.upload_file(f"{self.user.id}|1", photo, enums.SEND_TYPE_PHOTO)
+            return await self.execute(requests.EditGroupAvatar(
+                group_peer=structs.GroupOutPeer(
+                    group_id=peer_id,
+                    access_hash=1
+                ),
+                file_location=structs.FileLocation(
+                    file_id=file.id,
+                    access_hash=self.user.id
+                ),
+                rid=self.ws_connection.create_rid()
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("setChatPhoto", locals())

PySPlusthon/client/chats/set_chat_title.py

@@ -0,0 +1,23 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class SetChatTitle:
+
+    async def set_chat_title(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            title: str
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            return await self.execute(requests.EditGroupTitle(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                title=title,
+                rid=self.ws_connection.create_rid()
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        return await self.auto_execute("setChatTitle", locals())

PySPlusthon/client/chats/unban_chat_member.py

@@ -0,0 +1,24 @@
+from typing import Union
+
+import PySPlusthon
+
+
+class UnbanChatMember:
+
+    async def unban_chat_member(
+            self: "PySPlusthon.Client",
+            chat_id: Union[int, str],
+            user_id: Union[int, str],
+            only_if_banned: bool = True
+    ) -> bool:
+        if self.is_userbot():
+            from PySPlusthon.proto import requests, structs
+            peer_id, peer_type = map(int, chat_id.split("|"))
+            return await self.execute(requests.UnBanUser(
+                group_peer=structs.GroupOutPeer(group_id=peer_id, access_hash=1),
+                user=structs.UserOutPeer(uid=user_id, access_hash=1)
+            ))
+
+        chat_id = await self.resolve_peer_id(chat_id)
+        user_id = await self.resolve_peer_id(user_id)
+        return await self.auto_execute("unbanChatMember", locals())