RubigramClient 0.1.0__tar.gz

rubigramclient-0.1.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: RubigramClient
+Version: 0.1.0
+Summary: A Python library for connect to Rubika API
+Author-email: Javad RJ <Javad.Py1385@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+python -m twine upload -u token -p pypi-AgEIcHlwaS5vcmcCJDM3ZGM2OTFmLWJkNDQtNDRkNy1hOWQ5LWRmNGZlM2Y2NjkwNAACKlszLCI1YzNiYjZiYS01YWEzLTQwZjQtYmQyNC1kMTdiOTg0MjRjNWMiXQAABiCdw4uqs3lDpnGPuPeSZSfYSacF21-SYevphQLzU5G2vg dist/*

rubigramclient-0.1.0/README.md

@@ -0,0 +1 @@
+python -m twine upload -u token -p pypi-AgEIcHlwaS5vcmcCJDM3ZGM2OTFmLWJkNDQtNDRkNy1hOWQ5LWRmNGZlM2Y2NjkwNAACKlszLCI1YzNiYjZiYS01YWEzLTQwZjQtYmQyNC1kMTdiOTg0MjRjNWMiXQAABiCdw4uqs3lDpnGPuPeSZSfYSacF21-SYevphQLzU5G2vg dist/*

rubigramclient-0.1.0/RubigramClient.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: RubigramClient
+Version: 0.1.0
+Summary: A Python library for connect to Rubika API
+Author-email: Javad RJ <Javad.Py1385@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+python -m twine upload -u token -p pypi-AgEIcHlwaS5vcmcCJDM3ZGM2OTFmLWJkNDQtNDRkNy1hOWQ5LWRmNGZlM2Y2NjkwNAACKlszLCI1YzNiYjZiYS01YWEzLTQwZjQtYmQyNC1kMTdiOTg0MjRjNWMiXQAABiCdw4uqs3lDpnGPuPeSZSfYSacF21-SYevphQLzU5G2vg dist/*

rubigramclient-0.1.0/RubigramClient.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+RubigramClient.egg-info/PKG-INFO
+RubigramClient.egg-info/SOURCES.txt
+RubigramClient.egg-info/dependency_links.txt
+RubigramClient.egg-info/top_level.txt
+rubigram/__init__.py
+rubigram/client.py
+rubigram/filters.py
+rubigram/types.py

rubigramclient-0.1.0/RubigramClient.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

rubigramclient-0.1.0/RubigramClient.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+rubigram

rubigramclient-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "RubigramClient"
+version = "0.1.0"
+description = "A Python library for connect to Rubika API"
+readme = "README.md"
+authors = [
+    { name = "Javad RJ", email = "Javad.Py1385@gmail.com" }
+]
+license = { file = "LICENSE" }
+requires-python = ">=3.7"
+
+[tool.setuptools.packages.find]
+where = ["."]

rubigramclient-0.1.0/rubigram/__init__.py

@@ -0,0 +1,3 @@
+from .client import Client
+from . import filters
+from . import types

rubigramclient-0.1.0/rubigram/client.py

@@ -0,0 +1,317 @@
+from rubigram.types import Message, InlineMessage, MessageId, Chat, Bot
+from aiohttp import ClientSession, FormData, web
+from typing import Literal
+import aiofiles
+
+
+class Client:
+    def __init__(self, token: str, webhook_url: str = "0.0.0.0", port: int = 5000):
+        self.token = token
+        self.webhook = webhook_url
+        self.port = port
+        self.messages_handler = []
+        self.api = "https://botapi.rubika.ir/v3"
+    
+    async def request(self, method: str, data: dict):
+        async with ClientSession() as session:
+            async with session.post(f"{self.api}/{self.token}/{method}", json=data) as response:
+                return await response.json()
+    
+    def on_message(self, *filters):
+        def decorator(func):
+            async def wrapped(client, update):
+                if all(f(update) for f in filters):
+                    await func(client, update)
+            self.messages_handler.append(wrapped)
+            return func
+        return decorator
+    
+    async def update(self, data: dict):
+        update_object = Message(self, data["update"]) if data.get("update") else InlineMessage(data["inline_message"])
+        for handler in self.messages_handler:
+            await handler(self, update_object)
+            
+    
+    async def get_me(self) -> "Bot":
+        response = await self.request("getMe", {})
+        return Bot(response["data"]["bot"])
+    
+    
+    async def get_chat(self, chat_id: str) -> "Chat":
+        response = await self.request("getChat", {"chat_id": chat_id})
+        return Chat(response["data"])
+
+    
+    async def get_updates(self, limit: int = 1, offset_id: str = None):
+        response = await self.request("getUpdates", {"limit": limit, "offset_id": offset_id})
+        return response
+    
+    
+    async def set_command(self, commands: list):
+        response = await self.request("setCommands", {"bot_commands": commands})
+        return response
+    
+    
+    async def update_bot_endpoint(
+        self,
+        url: str,
+        type: Literal["ReceiveUpdate", "ReceiveInlineMessage", "ReceiveQuery", "GetSelectionItem", "SearchSelectionItems"]
+    ):
+        response = await self.request("updateBotEndpoints", {"url": url, "type": type})
+        return response
+    
+    
+    async def send_message(
+        self,
+        chat_id: str,
+        text: str,
+        chat_keypad = None, # مشخص کردن تایپ
+        inline_keypad = None, # مشخص کردن تایپ
+        chat_keypad_type: Literal["New", "Remove"] = None,
+        disable_notification: bool = None,
+        reply_to_message_id = None
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "text": text,
+            "chat_keypad": chat_keypad,
+            "inline_keypad": inline_keypad,
+            "chat_keypad_type": chat_keypad_type,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id
+        }
+        response = await self.request("sendMessage", data)
+        return MessageId(response["data"])
+
+    
+    async def send_poll(
+        self,
+        chat_id: str,
+        question: str,
+        options: list[str],
+        chat_keypad = None, # مشخص کردن تایپ
+        inline_keypad = None, # مشخص کردن تایپ
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal[None, "New", "Remove"] = None
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "question": question,
+            "options": options,
+            "chat_keypad": chat_keypad,
+            "inline_keypad": inline_keypad,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        response = await self.request("sendPoll", data)
+        return MessageId(response["data"])
+    
+    
+    async def send_location(
+        self,
+        chat_id: str,
+        latitude: str,
+        longitude: str,
+        chat_keypad = None, # مشخص کردن تایپ
+        inline_keypad = None, # مشخص کردن تایپ
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal[None, "New", "Remove"] = None
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "latitude": latitude,
+            "longitude": longitude,
+            "chat_keypad": chat_keypad,
+            "inline_keypad": inline_keypad,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        response = await self.request("sendLocation", data)
+        return MessageId(response["data"])
+    
+    
+    async def send_contact(
+        self,
+        chat_id: str,
+        first_name: str,
+        last_name: str,
+        phone_number: str,
+        chat_keypad = None, # مشخص کردن تایپ
+        inline_keypad  = None, # مشخص کردن تایپ
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal[None, "New", "Remove"] = None
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "first_name": first_name,
+            "last_name": last_name,
+            "phone_number": phone_number,
+            "chat_keypad": chat_keypad,
+            "inline_keypad": inline_keypad,
+            "disable_notification": disable_notification,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        response = await self.request("sendContact", data)
+        return MessageId(response["data"])
+    
+    
+    async def send_sticker(
+        self,
+        chat_id: str,
+        sticker_id: str,
+        chat_keypad = None, # مشخص کردن تایپ
+        inline_keypad = None, # مشخص کردن تایپ
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal[None, "New", "Remove"] = None,
+    ) -> "MessageId":
+        data = {
+            "chat_id": chat_id,
+            "sticker_id": sticker_id,
+            "chat_keypad": chat_keypad,
+            "disable_notification": disable_notification,
+            "inline_keypad": inline_keypad,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type
+        }
+        response = await self.request("sendSticker", data)
+        return MessageId(response["data"])
+    
+    
+    async def forward_message(
+        self,
+        from_chat_id: str,
+        message_id: str,
+        to_chat_id: str,
+        disable_notification: bool = False
+    ) -> "MessageId":
+        data = {
+            "from_chat_id": from_chat_id,
+            "message_id": message_id,
+            "to_chat_id": to_chat_id,
+            "disable_notification": disable_notification
+        }
+        response = await self.request("forwardMessage", data)
+        return MessageId(response["data"])
+    
+    
+    async def edit_message_text(
+        self,
+        chat_id: str,
+        message_id: str,
+        text: str
+    ) -> None:
+        data = {"chat_id": chat_id, "message_id": message_id, "text": text}
+        await self.request("editMessageText", data)
+    
+    
+    async def edit_message_keypad(
+        self,
+        chat_id: str,
+        message_id: str,
+        inline_keypad # مشخص کردن تایپ
+        ) -> None:
+        data = {"chat_id": chat_id, "message_id": message_id, "inline_keypad": inline_keypad}
+        await self.request("editMessageKeypad", data)
+        
+        
+    async def edit_chat_keypad(
+        self,
+        chat_id: str,
+        chat_keypad # مشخص کردن تایپ
+    ) -> None:
+        data = {"chat_id": chat_id, "chat_keypad_type": "New", "chat_keypad": chat_keypad}
+        await self.request("editChatKeypad", data)
+    
+    
+    async def remove_chat_keypad(
+        self,
+        chat_id: str
+    ) -> None:
+        data = {"chat_id": chat_id, "chat_keypad_type": "Remove"}
+        await self.request("editChatKeypad", data)
+        
+    
+    async def delete_message(
+        self,
+        chat_id: str,
+        message_id: str
+        ) -> None:
+        data = {"chat_id": chat_id, "message_id": message_id}
+        await self.request("deleteMessage", data)
+    
+    
+    async def get_file(self, file_id: str) -> str:
+        response = await self.request("getFile", {"file_id": file_id})
+        return response["data"]["download_url"]
+
+    
+    async def request_send_file(self, type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"]) -> str:
+        response = await self.request("requestSendFile", {"type": type})
+        return response["data"]["upload_url"]
+
+    
+    async def upload_file(self, path: str, file_name: str, type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"]) -> str:
+        upload_url = await self.request_send_file(type)
+        form = FormData()
+        form.add_field("file", open(path, "rb"), filename=file_name, content_type="application/octet-stream")
+        async with ClientSession() as session:
+            async with session.post(upload_url, data=form) as response:
+                result = await response.json()
+                return result["data"]["file_id"]
+    
+    
+    async def send_file(
+        self,
+        chat_id: str,
+        path: str,
+        file_name: str,
+        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File",
+        chat_keypad = None,
+        inline_keypad = None,
+        disable_notification: bool = False,
+        reply_to_message_id: str = None,
+        chat_keypad_type: Literal["New", "Remove"] = None,
+    ) -> str:
+        file_id = await self.upload_file(path, file_name, type)
+        data = {
+            "chat_id": chat_id,
+            "file_id": file_id,
+            "chat_keypad": chat_keypad,
+            "disable_notification": disable_notification,
+            "inline_keypad": inline_keypad,
+            "reply_to_message_id": reply_to_message_id,
+            "chat_keypad_type": chat_keypad_type,
+        }
+        response = await self.request("sendFile", data)
+        return MessageId(response["data"])
+
+    
+    async def download_file(self, file_id: str, file_name: str):
+        download_url = await self.get_file(file_id)
+        async with ClientSession() as session:
+            async with session.get(download_url) as response:
+                if response.status == 200:
+                    async with aiofiles.open(file_name, "wb") as file:
+                        await file.write(await response.read())
+                    return {"status": "OK", "file": file_name}
+                raise Exception(f"Download Error | status_code : {response.status}")
+    
+    
+    def run(self):
+        routes = web.RouteTableDef()
+        @routes.post("/receiveUpdate")
+        @routes.post("/receiveInlineMessage")
+        async def webhook(request):
+            data = await request.json()
+            await self.update(data)
+            return web.json_response({"status": "ok"})
+        app = web.Application()
+        app.add_routes(routes)
+        web.run_app(app, host=self.webhook, port=self.port)

rubigramclient-0.1.0/rubigram/filters.py

@@ -0,0 +1,50 @@
+from rubigram.types import Message
+from typing import Union
+
+
+class filter:
+    @staticmethod
+    def text():
+        def inner(update: Message):
+            return update.new_message.text
+        return inner
+
+    @staticmethod
+    def private():
+        def inner(update: Message):
+            return update.new_message.sender_type == "User"
+        return inner
+    
+    @staticmethod
+    def command(cmd: Union[str, list[str]]):
+        def inner(update: Message):
+            if not update.new_message.text:
+                return False
+            if not update.new_message.text.startswith("/"):
+                return False
+            return update.new_message.text.lstrip("/").split()[0] == cmd
+        return inner
+    
+    @staticmethod
+    def text_filter(text: str):
+        def inner(update: Message):
+            return update.new_message.text == text if update.new_message.text else False
+        return inner
+    
+    @staticmethod
+    def chat(chat_id: str):
+        def inner(update: Message):
+            return update.chat_id == chat_id
+        return inner
+    
+    @staticmethod
+    def file():
+        def inner(update: Message):
+            return update.new_message.file
+        return inner
+    
+    @staticmethod
+    def button(id: str):
+        def inner(update: Message):
+            return update.new_message.aux_data.button_id == id if update.new_message.aux_data else False
+        return inner

rubigramclient-0.1.0/rubigram/types.py

@@ -0,0 +1,235 @@
+import rubigram
+from typing import Literal
+from json import dumps
+
+
+
+class ForwardFrom:
+    def __init__(self, data: dict):
+        self.type_from: str = data["type_from"]
+        self.message_id: str = data["message_id"]
+        self.from_sender_id: str = data.get("from_sender_id")
+        self.from_chat_id: str = data.get("from_chat_id")
+    
+    def _dict(self):
+        return {
+            "type_from": self.type_from,
+            "message_id": self.message_id,
+            "from_sender_id": self.from_sender_id,
+            "from_chat_id": self.from_chat_id
+        }
+
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+        
+        
+class File:
+    def __init__(self, data: dict):
+        self.file_id: str = data["file_id"]
+        self.file_name: str = data.get("file_name")
+        self.size: int = data.get("size")
+    
+    def _dict(self):
+        return {"file_id": self.file_id, "file_name": self.file_name, "size": self.size}
+        
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+    
+    
+class Location:
+    def __init__(self, data: dict):
+        self.longitude: int = data["longitude"]
+        self.latitude: int = data["latitude"]
+    
+    def _dict(self):
+        return {"longitude": self.longitude, "latitude": self.latitude}
+    
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+
+
+class AuxData:
+    def __init__(self, data: dict):
+        self.start_id = data.get("start_id")
+        self.button_id: str = data.get("button_id")
+    
+    def _dict(self):
+        return {"start_id": self.start_id, "button_id": self.button_id}
+    
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+        
+        
+class MessageId:
+    def __init__(self, data: dict):
+        self.message_id = data["message_id"]
+    
+    def _dict(self):
+        return {"message_id": self.message_id}
+    
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+
+
+class UpdateMessage:
+    def __init__(self, data: dict):
+        self.message_id: str = data["message_id"]
+        self.text: str = data["text"]
+        self.time: str = data["time"]
+        self.is_edited: bool = data["is_edited"]
+        self.sender_type: str = data["sender_type"]
+        self.sender_id: str = data["sender_id"]
+        
+    def _dict(self):
+        return {
+            "message_id": self.message_id,
+            "text": self.text,
+            "time": self.time,
+            "is_edited": self.is_edited,
+            "sender_type": self.sender_type,
+            "sender_id": self.sender_id
+        }
+        
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+
+
+class NewMessage:
+    def __init__(self, data: dict):
+        self.message_id: str = data["message_id"]
+        self.time: str = data["time"]
+        self.is_edited: bool = data["is_edited"]
+        self.sender_type: str = data["sender_type"]
+        self.sender_id: str = data["sender_id"]
+        self.text: str = data.get("text")
+        self.forwarded_from: ForwardFrom = ForwardFrom(data["forwarded_from"]) if data.get("forwarded_from") else None
+        self.file: File = File(data["file"]) if data.get("file") else None
+        self.location: Location = Location(data["location"]) if data.get("location") else None
+        self.aux_data: AuxData = AuxData(data["aux_data"]) if data.get("aux_data") else None
+
+    def _dict(self):
+        return {
+            "message_id": self.message_id,
+            "time": self.time,
+            "is_edited": self.is_edited,
+            "sender_type": self.sender_type,
+            "sender_id": self.sender_id,
+            "text": self.text,
+            "forwarded_from": self.forwarded_from._dict() if self.forwarded_from else None,
+            "file": self.file._dict() if self.file else None,
+            "location": self.location._dict() if self.location else None,
+            "aux_data": self.aux_data._dict() if self.aux_data else None
+        }
+        
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+    
+
+class InlineMessage:
+    def __init__(self, data: dict):
+        self.message_id: str = data["message_id"]
+        self.chat_id: str = data["chat_id"]
+        self.sender_id: str = data["sender_id"]
+        self.text: str = data["text"]
+        self.aux_data: AuxData = AuxData(data["aux_data"])
+        self.location: Location = Location(data["location"]) if data.get("location") else None
+    
+    def _dict(self):
+        return {
+            "message_id": self.message_id,
+            "chat_id": self.chat_id,
+            "sender_id": self.sender_id,
+            "text": self.text,
+            "aux_data": self.aux_data._dict() if self.aux_data else None,
+            "location":self.location._dict() if self.location else None
+        }
+        
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+
+
+class Bot:
+    def __init__(self, data: dict):
+        self.bot_id: str = data["bot_id"]
+        self.bot_title: str = data["bot_title"]
+        self.username: str = data["username"]
+        self.start_message: str = data["start_message"]
+        self.share_url: str = data["share_url"]
+        self.description: str = data["description"]
+        self.avatar: File = File(data["avatar"]) if data.get("avatar") else None
+
+    def _dict(self):
+        return {
+            "bot_id": self.bot_id,
+            "bot_title": self.bot_title,
+            "username": self.username,
+            "start_message": self.start_message,
+            "share_url": self.share_url,
+            "description": self.description,
+            "avatar": self.avatar._dict() if self.avatar else None
+        }
+    
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+
+
+class Chat:
+    def __init__(self, data: dict):
+        self.chat_id: str = data["chat_id"]
+        self.chat_type: str = data["chat_type"]
+        self.user_id: str = data.get("user_id")
+        self.first_name: str = data.get("first_name")
+        self.last_name: str = data.get("last_name")
+        self.title: str = data.get("title")
+        self.username: str = data.get("username")
+    
+    def _dict(self):
+        return {
+            "chat_id": self.chat_id,
+            "chat_type": self.chat_type,
+            "user_id": self.user_id,
+            "first_name": self.first_name,
+            "last_name": self.last_name,
+            "title" : self.title,
+            "username": self.username
+        }
+        
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+    
+
+class Message:
+    def __init__(self, client: "rubigram.Client", data: dict):
+        # Message Update Type : ["NewMessage", "UpdatedMessage", "RemovedMessage", "StartedBot", "StoppedBot"و "UpdatedPayment"]
+        self.client = client
+        self.type: str = data["type"]
+        self.chat_id: str = data["chat_id"]
+        self.new_message: NewMessage = NewMessage(data.get("new_message")) if data.get("new_message") else None
+        self.removed_message_id: int = data.get("removed_message_id")
+        self.updated_message: UpdateMessage = UpdateMessage(data.get("updated_message")) if data.get("updated_message") else None
+    
+    def _dict(self):
+        return {
+            "type": self.type,
+            "chat_id": self.chat_id,
+            "new_message": self.new_message._dict() if self.new_message else None,
+            "removed_message_id" : self.removed_message_id,
+            "updated_message": self.updated_message._dict() if self.updated_message else None
+        }
+        
+    def __str__(self):
+        return dumps(self._dict(), indent=4, ensure_ascii=False)
+
+    async def reply_text(self, text: str):
+        return await self.client.send_message(self.chat_id, text, reply_to_message_id=self.new_message.message_id)
+    
+    async def reply_file(
+        self,
+        path: str,
+        file_name: str,
+        type: Literal["File", "Image", "Voice", "Music", "Gif", "Video"] = "File"
+    ):
+        return await self.client.send_file(self.chat_id, path, file_name, type)
+
+    async def download(self, file_name: str):
+        return await self.client.download_file(self.new_message.file.file_id, file_name)

rubigramclient-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+