telegram-api-client-python 1.0.0__py3-none-any.whl

telegram-api-client-python/tools/receiving.py

@@ -0,0 +1,80 @@
+from typing import TYPE_CHECKING
+
+from ..response import Response
+
+if TYPE_CHECKING:
+    from ..API import GreenApi
+
+
+class Receiving:
+    def __init__(self, api: "GreenApi"):
+        self.api = api
+
+    def receiveNotification(self) -> Response:
+        """
+        The method is aimed for receiving one incoming notification
+        from the notifications queue.
+
+        https://green-api.com/telegram/docs/api/receiving/technology-http-api/ReceiveNotification/
+        """
+
+        return self.api.request(
+            "GET", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "receiveNotification/{{apiTokenInstance}}"
+            )
+        )
+
+    async def receiveNotificationAsync(self) -> Response:
+        return await self.api.requestAsync(
+            "GET", "{{host}}/waInstance{{idInstance}}/receiveNotification/{{apiTokenInstance}}"
+        )
+
+    def deleteNotification(self, receiptId: int) -> Response:
+        """
+        The method is aimed for deleting an incoming notification from
+        the notification queue.
+
+        https://green-api.com/telegram/docs/api/receiving/technology-http-api/DeleteNotification/
+        """
+
+        url = (
+            "{{host}}/waInstance{{idInstance}}/"
+            "deleteNotification/{{apiTokenInstance}}"
+        )
+
+        return self.api.request("DELETE", f"{url}/{receiptId}")
+
+    async def deleteNotificationAsync(self, receiptId: int) -> Response:
+        return await self.api.requestAsync(
+            "DELETE", 
+            "{{host}}/waInstance{{idInstance}}/deleteNotification/{{apiTokenInstance}}/",
+            receiptId
+        )
+
+    def downloadFile(self, chatId: str, idMessage: str) -> Response:
+        """
+        The method is aimed for downloading incoming and outgoing files.
+
+        https://green-api.com/telegram/docs/api/receiving/files/DownloadFile/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "downloadFile/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def downloadFileAsync(self, chatId: str, idMessage: str) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/downloadFile/{{apiTokenInstance}}",
+            request_body
+        )

telegram-api-client-python/tools/sending.py

@@ -0,0 +1,301 @@
+import mimetypes
+import pathlib
+from typing import Dict, List, Optional, TYPE_CHECKING, Union
+
+import aiofiles
+
+from ..response import Response
+
+if TYPE_CHECKING:
+    from ..API import GreenApi
+
+
+class Sending:
+    def __init__(self, api: "GreenApi"):
+        self.api = api
+
+    def sendMessage(
+            self,
+            chatId: str,
+            message: str,
+    ) -> Response:
+        """
+        The method is aimed for sending a text message to a personal or
+        a group chat.
+
+        https://green-api.com/telegram/docs/api/sending/SendMessage/
+        """
+
+        request_body = self.__handle_parameters(locals())
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "sendMessage/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def sendMessageAsync(
+            self,
+            chatId: str,
+            message: str,
+    ) -> Response:
+        request_body = self.__handle_parameters(locals())
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/sendMessage/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def sendFileByUpload(
+            self,
+            chatId: str,
+            path: str,
+            fileName: Optional[str] = None,
+            caption: Optional[str] = None,
+    ) -> Response:
+        """
+        The method is aimed for sending a file uploaded by form
+        (form-data).
+
+        https://green-api.com/telegram/docs/api/sending/SendFileByUpload/
+        """
+
+        request_body = self.__handle_parameters(locals())
+
+        file_name = pathlib.Path(path).name
+        content_type = mimetypes.guess_type(file_name)[0]
+
+        files = {"file": (file_name, open(path, "rb"), content_type)}
+
+        request_body.pop("path")
+
+        return self.api.request(
+            "POST", (
+                "{{media}}/waInstance{{idInstance}}/"
+                "sendFileByUpload/{{apiTokenInstance}}"
+            ), request_body, files
+        )
+
+    async def sendFileByUploadAsync(
+            self,
+            chatId: str,
+            path: str,
+            fileName: Optional[str] = None,
+            caption: Optional[str] = None,
+    ) -> Response:
+        request_body = self.__handle_parameters(locals())
+
+        file_name = pathlib.Path(path).name
+        content_type = mimetypes.guess_type(file_name)[0]
+
+        async with aiofiles.open(path, "rb") as file:
+            file_data = await file.read()
+            files = {"file": (file_name, file_data, content_type)}
+
+        request_body.pop("path")
+
+        return await self.api.requestAsync(
+            "POST", 
+            "{{media}}/waInstance{{idInstance}}/sendFileByUpload/{{apiTokenInstance}}",
+            request_body, 
+            files=files
+        )
+
+    def sendFileByUrl(
+            self,
+            chatId: str,
+            urlFile: str,
+            fileName: str,
+            caption: Optional[str] = None,
+    ) -> Response:
+        """
+        The method is aimed for sending a file uploaded by URL.
+
+        https://green-api.com/telegram/docs/api/sending/SendFileByUrl/
+        """
+
+        request_body = self.__handle_parameters(locals())
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "sendFileByUrl/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def sendFileByUrlAsync(
+            self,
+            chatId: str,
+            urlFile: str,
+            fileName: str,
+            caption: Optional[str] = None,
+    ) -> Response:
+        request_body = self.__handle_parameters(locals())
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/sendFileByUrl/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def uploadFile(self, path: str) -> Response:
+        """
+        The method is designed to upload a file to the cloud storage,
+        which can be sent using the sendFileByUrl method.
+
+        https://green-api.com/telegram/docs/api/sending/UploadFile/
+        """
+
+        file_name = pathlib.Path(path).name
+        content_type = mimetypes.guess_type(file_name)[0]
+
+        with open(path, "rb") as file:
+            return self.api.raw_request(
+                method="POST",
+                url=(
+                    f"{self.api.media}/waInstance{self.api.idInstance}/"
+                    f"uploadFile/{self.api.apiTokenInstance}"
+                ),
+                data=file.read(),
+                headers={"Content-Type": content_type,
+                         "GA-Filename": file_name}
+            )
+
+    async def uploadFileAsync(self, path: str) -> Response:
+        file_name = pathlib.Path(path).name
+        content_type = mimetypes.guess_type(file_name)[0]
+
+        async with aiofiles.open(path, "rb") as file:
+            return await self.api.raw_request_async(
+                method="POST",
+                url=(
+                    f"{self.api.media}/waInstance{self.api.idInstance}/"
+                    f"uploadFile/{self.api.apiTokenInstance}"
+                ),
+                data=file.read(),
+                headers={"Content-Type": content_type,
+                         "GA-Filename": file_name}
+            )
+
+    def sendLocation(
+            self,
+            chatId: str,
+            latitude: float,
+            longitude: float,
+    ) -> Response:
+        """
+        The method is aimed for sending location message.
+
+        https://green-api.com/telegram/docs/api/sending/SendLocation/
+        """
+
+        request_body = self.__handle_parameters(locals())
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "sendLocation/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def sendLocationAsync(
+            self,
+            chatId: str,
+            latitude: float,
+            longitude: float,
+    ) -> Response:
+        request_body = self.__handle_parameters(locals())
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/sendLocation/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def sendContact(
+            self,
+            chatId: str,
+            contact: Dict[str, Union[int, str]],
+    ) -> Response:
+        """
+        The method is aimed for sending a contact message.
+
+        https://green-api.com/telegram/docs/api/sending/SendContact/
+        """
+
+        request_body = self.__handle_parameters(locals())
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "sendContact/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def sendContactAsync(
+            self,
+            chatId: str,
+            contact: Dict[str, Union[int, str]],
+    ) -> Response:
+        request_body = self.__handle_parameters(locals())
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/sendContact/{{apiTokenInstance}}",
+            request_body
+        )
+
+
+    def sendPoll(
+            self,
+            chatId: str,
+            message: str,
+            options: List[Dict[str, str]],
+            multipleAnswers: Optional[bool] = None,
+            isAnonymous: Optional[bool] = None
+    ) -> Response:
+        """
+        This method is intended for sending messages with a poll to a
+        private or group chat.
+
+        https://green-api.com/telegram/docs/api/sending/SendPoll/
+        """
+
+        request_body = self.__handle_parameters(locals())
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "sendPoll/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def sendPollAsync(
+            self,
+            chatId: str,
+            message: str,
+            options: List[Dict[str, str]],
+            multipleAnswers: Optional[bool] = None,
+            isAnonymous: Optional[bool] = None
+    ) -> Response:
+        request_body = self.__handle_parameters(locals())
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/sendPoll/{{apiTokenInstance}}",
+            request_body
+        )
+
+
+    @classmethod
+    def __handle_parameters(cls, parameters: dict) -> dict:
+        handled_parameters = parameters.copy()
+        handled_parameters.pop("self")
+
+        for key, value in parameters.items():
+            if value is None:
+                handled_parameters.pop(key)
+
+        return handled_parameters

telegram-api-client-python/tools/serviceMethods.py

@@ -0,0 +1,264 @@
+from typing import Optional, TYPE_CHECKING
+
+from ..response import Response
+
+if TYPE_CHECKING:
+    from ..API import GreenApi
+
+class ServiceMethods:
+    def __init__(self, api: "GreenApi"):
+        self.api = api
+
+    def checkAccount(self, phoneNumber: int) -> Response:
+        """
+        The method checks Account account availability on a phone
+        number.
+
+        https://green-api.com/telegram/docs/api/service/CheckAccount/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "checkAccount/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def checkAccountAsync(self, phoneNumber: int) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/checkAccount/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def getAvatar(self, chatId: str) -> Response:
+        """
+        The method returns a user or a group chat avatar.
+
+        https://green-api.com/telegram/docs/api/service/GetAvatar/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "getAvatar/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def getAvatarAsync(self, chatId: str) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/getAvatar/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def getContacts(self) -> Response:
+        """
+        The method is aimed for getting a list of the current account
+        contacts.
+
+        https://green-api.com/telegram/docs/api/service/GetContacts/
+        """
+
+        return self.api.request(
+            "GET", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "getContacts/{{apiTokenInstance}}"
+            )
+        )
+
+    async def getContactsAsync(self) -> Response:
+        return await self.api.requestAsync(
+            "GET", "{{host}}/waInstance{{idInstance}}/getContacts/{{apiTokenInstance}}"
+        )
+
+    def getContactInfo(self, chatId: str) -> Response:
+        """
+        The method is aimed for getting information on a contact.
+
+        https://green-api.com/telegram/docs/api/service/GetContactInfo/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "getContactInfo/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def getContactInfoAsync(self, chatId: str) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/getContactInfo/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def deleteMessage(self, chatId: str, idMessage: str, onlySenderDelete: Optional[bool] = None) -> Response:
+        """
+        The method deletes a message from a chat.
+
+        https://green-api.com/telegram/docs/api/service/deleteMessage/
+        """
+
+        request_body = locals()
+        if onlySenderDelete is None:
+            request_body.pop("onlySenderDelete")
+        request_body.pop("self")
+        print(request_body)
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "deleteMessage/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def deleteMessageAsync(self, chatId: str, idMessage: str, onlySenderDelete: Optional[bool] = None) -> Response:
+        request_body = locals()
+        if onlySenderDelete is None:
+            request_body.pop("onlySenderDelete")
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/deleteMessage/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def editMessage(self, chatId: str, idMessage: str, message: str) -> Response:
+        """
+        The method edits a message in chat.
+
+        https://green-api.com/telegram/docs/api/service/editMessage/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "editMessage/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def editMessageAsync(self, chatId: str, idMessage: str, message: str) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/editMessage/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def archiveChat(self, chatId: str) -> Response:
+        """
+        The method archives a chat.
+
+        https://green-api.com/telegram/docs/api/service/archiveChat/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "archiveChat/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def archiveChatAsync(self, chatId: str) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/archiveChat/{{apiTokenInstance}}",
+            request_body
+        )
+
+    def unarchiveChat(self, chatId: str) -> Response:
+        """
+        The method unarchives a chat.
+
+        https://green-api.com/telegram/docs/api/service/unarchiveChat/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "unarchiveChat/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def unarchiveChatAsync(self, chatId: str) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/unarchiveChat/{{apiTokenInstance}}",
+            request_body
+        )
+    
+    def sendTyping(
+            self, chatId: str, typingTime: Optional[int] = None, typingType: Optional[str] = None,
+    ) -> Response:
+        """
+        The method is used to send a notification about typing or recording audio in a chat.
+
+        https://green-api.com/telegram/docs/api/service/SendTyping/
+        """
+
+        request_body = locals()
+        if typingTime is None:
+            request_body.pop("typingTime")
+        if typingType is None:
+            request_body.pop("typingType")
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "sendTyping/{{apiTokenInstance}}"
+            ), request_body
+        )
+
+    async def sendTypingAsync(
+            self, chatId: str, typingTime: Optional[int] = None, typingType: Optional[str] = None,
+    ) -> Response:
+        request_body = locals()
+        if typingTime is None:
+            request_body.pop("typingTime")
+        if typingType is None:
+            request_body.pop("typingType")
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/sendTyping/{{apiTokenInstance}}",
+            request_body
+        )