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

telegram-api-client-python/API.py

@@ -0,0 +1,323 @@
+import json
+import logging
+from typing import Any, NoReturn, Optional
+
+import aiohttp
+from requests import Response, Session
+from requests.adapters import HTTPAdapter, Retry
+
+from .response import Response as GreenAPIResponse
+from .tools import (
+    account,
+    groups,
+    journals,
+    marking,
+    queues,
+    receiving,
+    sending,
+    serviceMethods,
+    webhooks,
+    partner
+)
+
+
+class GreenApi:
+    host: str
+    media: str
+    idInstance: str
+    apiTokenInstance: str
+
+    def __init__(
+            self,
+            idInstance: str,
+            apiTokenInstance: str,
+            debug_mode: bool = False,
+            raise_errors: bool = False,
+            host: str = "https://4100.api.green-api.com",
+            media: str = "https://4100.api.green-api.com",
+            host_timeout: float = 180, # sec per retry
+            media_timeout: float = 10800, # sec per retry
+    ):
+        self.host = host
+        self.media = media
+        self.debug_mode = debug_mode
+        self.raise_errors = raise_errors
+
+        # Change default values in init() if required
+        self.host_timeout = host_timeout
+        self.media_timeout = media_timeout
+
+        self.idInstance = idInstance
+        self.apiTokenInstance = apiTokenInstance
+
+        self.session = Session()
+        self.__prepare_session()
+
+        self.account = account.Account(self)
+        self.groups = groups.Groups(self)
+        self.journals = journals.Journals(self)
+        self.marking = marking.Marking(self)
+        self.queues = queues.Queues(self)
+        self.receiving = receiving.Receiving(self)
+        self.sending = sending.Sending(self)
+        self.serviceMethods = serviceMethods.ServiceMethods(self)
+        self.webhooks = webhooks.Webhooks(self)
+
+        self.logger = logging.getLogger("telegram-api-client-python")
+        self.__prepare_logger()
+
+    def request(
+            self,
+            method: str,
+            url: str,
+            payload: Optional[dict] = None,
+            files: Optional[dict] = None
+    ) -> GreenAPIResponse:
+        url = url.replace("{{host}}", self.host)
+        url = url.replace("{{media}}", self.media)
+        url = url.replace("{{idInstance}}", self.idInstance)
+        url = url.replace("{{apiTokenInstance}}", self.apiTokenInstance)
+
+        headers = {
+            'User-Agent': 'GREEN-API_SDK_PY/1.0'
+        }
+
+        try:
+            if not files:
+                response = self.session.request(
+                    method=method, url=url, json=payload, timeout=self.host_timeout, headers=headers
+                )
+            else:
+                response = self.session.request(
+                    method=method, url=url, data=payload, files=files, timeout=self.media_timeout, headers=headers
+                )
+        except Exception as error:
+            error_message = f"Request was failed with error: {error}."
+
+            if self.raise_errors:
+                raise GreenAPIError(error_message)
+            self.logger.log(logging.CRITICAL, error_message)
+
+            return GreenAPIResponse(None, error_message)
+
+        self.__handle_response(response)
+
+        return GreenAPIResponse(response.status_code, response.text)
+
+    async def requestAsync(
+            self,
+            method: str,
+            url: str,
+            payload: Optional[dict] = None,
+            files: Optional[dict] = None
+    ) -> GreenAPIResponse:
+        url = url.replace("{{host}}", self.host)
+        url = url.replace("{{media}}", self.media)
+        url = url.replace("{{idInstance}}", self.idInstance)
+        url = url.replace("{{apiTokenInstance}}", self.apiTokenInstance)
+
+        headers = {
+            'User-Agent': 'GREEN-API_SDK_PY/1.0'
+        }
+
+        try:
+            timeout = aiohttp.ClientTimeout(total=self.host_timeout if not files else self.media_timeout)
+            
+            async with aiohttp.ClientSession(timeout=timeout, headers=headers) as session:
+                if not files:
+                    async with session.request(method=method, url=url, json=payload) as response:
+                        text = await response.text()
+                        status_code = response.status
+                else:
+                    data = aiohttp.FormData()
+                    for key, value in (payload or {}).items():
+                        if isinstance(value, (dict, list)):
+                            data.add_field(key, json.dumps(value), content_type='application/json')
+                        else:
+                            data.add_field(key, str(value))
+                    
+                    for field_name, file_data in files.items():
+                        filename, file_obj, content_type = file_data
+                        data.add_field(field_name, file_obj, filename=filename, content_type=content_type)
+                    
+                    async with session.request(method=method, url=url, data=data) as response:
+                        text = await response.text()
+                        status_code = response.status
+
+        except Exception as error:
+            error_message = f"Async request was failed with error: {error}."
+
+            if self.raise_errors:
+                raise GreenAPIError(error_message)
+            self.logger.log(logging.CRITICAL, error_message)
+
+            return GreenAPIResponse(None, error_message)
+
+        self.__handle_response_async(status_code, text)
+        return GreenAPIResponse(status_code, text)
+
+    def raw_request(self, **arguments: Any) -> GreenAPIResponse:
+        try:
+            response = self.session.request(**arguments)
+        except Exception as error:
+            error_message = f"Request was failed with error: {error}."
+
+            if self.raise_errors:
+                raise GreenAPIError(error_message)
+            self.logger.log(logging.CRITICAL, error_message)
+
+            return GreenAPIResponse(None, error_message)
+
+        self.__handle_response(response)
+
+        return GreenAPIResponse(response.status_code, response.text)
+
+    async def raw_request_async(self, **arguments: Any) -> GreenAPIResponse:
+        try:
+            timeout = aiohttp.ClientTimeout(total=arguments.pop('timeout', self.host_timeout))
+            headers = arguments.pop('headers', {})
+            headers['User-Agent'] = 'GREEN-API_SDK_PY/1.0'
+            
+            async with aiohttp.ClientSession(timeout=timeout, headers=headers) as session:
+                async with session.request(**arguments) as response:
+                    text = await response.text()
+                    status_code = response.status
+
+        except Exception as error:
+            error_message = f"Async raw request was failed with error: {error}."
+
+            if self.raise_errors:
+                raise GreenAPIError(error_message)
+            self.logger.log(logging.CRITICAL, error_message)
+
+            return GreenAPIResponse(None, error_message)
+
+        self.__handle_response_async(status_code, text)
+        return GreenAPIResponse(status_code, text)
+
+    def __handle_response(self, response: Response) -> Optional[NoReturn]:
+        status_code = response.status_code
+        if status_code != 200 or self.debug_mode:
+            try:
+                data = json.dumps(
+                    json.loads(response.text), ensure_ascii=False, indent=4
+                )
+            except json.JSONDecodeError:
+                data = response.text
+
+            if status_code != 200:
+                error_message = (
+                    f"Request was failed with status code: {status_code}."
+                    f" Data: {data}"
+                )
+
+                if self.raise_errors:
+                    raise GreenAPIError(error_message)
+                self.logger.log(logging.ERROR, error_message)
+
+                return None
+
+            self.logger.log(
+                logging.DEBUG, f"Request was successful with data: {data}"
+            )
+
+    def __handle_response_async(self, status_code: int, text: str) -> Optional[NoReturn]:
+        if status_code != 200 or self.debug_mode:
+            try:
+                data = json.dumps(
+                    json.loads(text), ensure_ascii=False, indent=4
+                )
+            except json.JSONDecodeError:
+                data = text
+
+            if status_code != 200:
+                error_message = (
+                    f"Async request was failed with status code: {status_code}."
+                    f" Data: {data}"
+                )
+
+                if self.raise_errors:
+                    raise GreenAPIError(error_message)
+                self.logger.log(logging.ERROR, error_message)
+
+                return None
+
+            self.logger.log(
+                logging.DEBUG, f"Async request was successful with data: {data}"
+            )
+
+    def __prepare_logger(self) -> None:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter(
+            (
+                "%(asctime)s:%(name)s:"
+                "%(levelname)s:%(message)s"
+            ), datefmt="%Y-%m-%d %H:%M:%S"
+        ))
+
+        self.logger.addHandler(handler)
+
+        if not self.debug_mode:
+            self.logger.setLevel(logging.INFO)
+        else:
+            self.logger.setLevel(logging.DEBUG)
+
+    def __prepare_session(self) -> None:
+        self.session.headers["Connection"] = "close"
+
+        retry = Retry(
+            total=3,
+            backoff_factor=1.0,
+            allowed_methods=None,
+            status_forcelist=[429]
+        )
+
+        self.session.mount("http://", HTTPAdapter(max_retries=retry))
+        self.session.mount("https://", HTTPAdapter(max_retries=retry))
+
+class GreenAPI(GreenApi):
+    pass
+
+
+class GreenAPIError(Exception):
+    pass
+
+class GreenApiPartner(GreenApi):
+    def __init__(
+            self,
+            partnerToken: str,
+            email: str = None,
+            host: str = "https://api.green-api.com"
+    ):
+
+        super().__init__(
+            idInstance="",
+            apiTokenInstance="",
+            host=host
+        )
+        
+        self.partnerToken = partnerToken
+        self.email = email
+        self.partner = partner.Partner(self)
+
+    def request(
+            self,
+            method: str,
+            url: str,
+            payload: Optional[dict] = None,
+            files: Optional[dict] = None
+    ) -> GreenAPIResponse:
+
+        url = url.replace("{{partnerToken}}", self.partnerToken)
+
+        return super().request(method, url, payload, files)
+
+    async def requestAsync(
+            self,
+            method: str,
+            url: str,
+            payload: Optional[dict] = None,
+            files: Optional[dict] = None
+    ) -> GreenAPIResponse:
+        url = url.replace("{{partnerToken}}", self.partnerToken)
+        return await super().requestAsync(method, url, payload, files)

telegram-api-client-python/response.py

@@ -0,0 +1,18 @@
+from json import loads
+from typing import Optional
+
+
+class Response:
+    code: Optional[int]
+    data: Optional[dict] = None
+    error: Optional[str] = None
+
+    def __init__(self, code: Optional[int], text: str):
+        self.code = code
+        if self.code == 200:
+            try:
+                self.data = loads(text)
+            except Exception:
+                self.data = "[]"
+        else:
+            self.error = text

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

@@ -0,0 +1,261 @@
+from pathlib import Path
+from typing import Dict, TYPE_CHECKING, Optional, Union
+
+import aiofiles
+
+from ..response import Response
+
+if TYPE_CHECKING:
+    from ..API import GreenApi
+
+
+class Account:
+    def __init__(self, api: "GreenApi"):
+        self.api = api
+
+    def getSettings(self) -> Response:
+        """
+        The method is aimed for getting the current account settings.
+
+        https://green-api.com/telegram/docs/api/account/GetSettings/
+        """
+
+        return self.api.request(
+            "GET", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "getSettings/{{apiTokenInstance}}"
+            )
+        )
+
+    async def getSettingsAsync(self) -> Response:
+        return await self.api.requestAsync(
+            "GET", "{{host}}/waInstance{{idInstance}}/getSettings/{{apiTokenInstance}}"
+        )
+
+    def getAccountSettings(self) -> Response:
+        """
+        The method is aimed to get information about the Account
+        account.
+
+        https://green-api.com/telegram/docs/api/account/getAccountSettings/
+        """
+
+        return self.api.request(
+            "GET", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "getAccountSettings/{{apiTokenInstance}}"
+            )
+        )
+
+    async def getAccountSettingsAsync(self) -> Response:
+        return await self.api.requestAsync(
+            "GET", "{{host}}/waInstance{{idInstance}}/getAccountSettings/{{apiTokenInstance}}"
+        )
+
+    def setSettings(self, requestBody: Dict[str, Union[int, str]]) -> Response:
+        """
+        The method is aimed for setting account settings.
+
+        https://green-api.com/telegram/docs/api/account/SetSettings/
+        """
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "setSettings/{{apiTokenInstance}}"
+            ), requestBody
+        )
+
+    async def setSettingsAsync(self, requestBody: Dict[str, Union[int, str]]) -> Response:
+        return await self.api.requestAsync(
+            "POST",
+            "{{host}}/waInstance{{idInstance}}/setSettings/{{apiTokenInstance}}",
+            requestBody
+        )
+
+
+    def getStateInstance(self) -> Response:
+        """
+        The method is aimed for getting the account state.
+
+        https://green-api.com/telegram/docs/api/account/GetStateInstance/
+        """
+
+        return self.api.request(
+            "GET", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "getStateInstance/{{apiTokenInstance}}"
+            )
+        )
+
+    async def getStateInstanceAsync(self) -> Response:
+        return await self.api.requestAsync(
+            "GET", "{{host}}/waInstance{{idInstance}}/getStateInstance/{{apiTokenInstance}}"
+        )
+    
+    def reboot(self) -> Response:
+        """
+        The method is aimed for rebooting an account.
+
+        https://green-api.com/telegram/docs/api/account/Reboot/
+        """
+
+        return self.api.request(
+            "GET", (
+                "{{host}}/waInstance{{idInstance}}/reboot/{{apiTokenInstance}}"
+            )
+        )
+
+    async def rebootAsync(self) -> Response:
+        return await self.api.requestAsync(
+            "GET", "{{host}}/waInstance{{idInstance}}/reboot/{{apiTokenInstance}}"
+        )
+
+    def logout(self) -> Response:
+        """
+        The method is aimed for logging out an account.
+
+        https://green-api.com/telegram/docs/api/account/Logout/
+        """
+
+        return self.api.request(
+            "GET", (
+                "{{host}}/waInstance{{idInstance}}/logout/{{apiTokenInstance}}"
+            )
+        )
+
+    async def logoutAsync(self) -> Response:
+        return await self.api.requestAsync(
+            "GET", "{{host}}/waInstance{{idInstance}}/logout/{{apiTokenInstance}}"
+        )
+
+    def qr(self) -> Response:
+        """
+        The method is aimed for getting QR code.
+
+        https://green-api.com/telegram/docs/api/account/QR/
+        """
+
+        return self.api.request(
+            "GET", "{{host}}/waInstance{{idInstance}}/qr/{{apiTokenInstance}}"
+        )
+
+    async def qrAsync(self) -> Response:
+        return await self.api.requestAsync(
+            "GET", "{{host}}/waInstance{{idInstance}}/qr/{{apiTokenInstance}}"
+        )
+
+    def setProfilePicture(self, path: str) -> Response:
+        """
+        The method is aimed for setting an account picture.
+
+        https://green-api.com/telegram/docs/api/account/SetProfilePicture/
+        """
+
+        file_name = Path(path).name
+        files = {"file": (file_name, open(path, "rb"), "image/jpeg")}
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "setProfilePicture/{{apiTokenInstance}}"
+            ), files=files
+        )
+
+    async def setProfilePictureAsync(self, path: str) -> Response:
+        file_name = Path(path).name
+        async with aiofiles.open(path, "rb") as file:
+            file_data = await file.read()
+            files = {"file": (file_name, file_data, "image/jpeg")}
+
+        return await self.api.requestAsync(
+            "POST", 
+            "{{host}}/waInstance{{idInstance}}/setProfilePicture/{{apiTokenInstance}}",
+            files=files
+        )
+
+
+    def startAuthorization(self, phoneNumber: int) -> Response:
+        """
+        The method is designed to receive code for instance authorization.
+
+        https://green-api.com/telegram/docs/api/account/StartAuthorization/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "startAuthorization/{{apiTokenInstance}}"
+            ), request_body
+        )
+    
+    async def startAuthorizationAsync(self, phoneNumber: int) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST", 
+            "{{host}}/waInstance{{idInstance}}/startAuthorization/{{apiTokenInstance}}",
+            request_body
+        )
+    
+    def sendAuthorizationCode(self, code: str,  password: Optional[str] = None) -> Response:
+        """
+        The method is designed to receive code for instance authorization.
+
+        https://green-api.com/telegram/docs/api/account/SendAuthorizationCode/
+        """
+
+        request_body = locals()
+        if password is None:
+            request_body.pop("password")
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "sendAuthorizationCode/{{apiTokenInstance}}"
+            ), request_body
+        )
+    
+    async def sendAuthorizationCodeAsync(self, code: str,  password: Optional[str] = None) -> Response:
+        request_body = locals()
+        if password is None:
+            request_body.pop("password")
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST", 
+            "{{host}}/waInstance{{idInstance}}/sendAuthorizationCode/{{apiTokenInstance}}",
+            request_body
+        )
+    
+    def sendAuthorizationPassword(self, password: str) -> Response:
+        """
+        The method is designed to receive code for instance authorization.
+
+        https://green-api.com/telegram/docs/api/account/SendAuthorizationPassword/
+        """
+
+        request_body = locals()
+        request_body.pop("self")
+
+        return self.api.request(
+            "POST", (
+                "{{host}}/waInstance{{idInstance}}/"
+                "sendAuthorizationPassword/{{apiTokenInstance}}"
+            ), request_body
+        )
+    
+    async def sendAuthorizationPasswordAsync(self, password: str) -> Response:
+        request_body = locals()
+        request_body.pop("self")
+
+        return await self.api.requestAsync(
+            "POST", 
+            "{{host}}/waInstance{{idInstance}}/sendAuthorizationPassword/{{apiTokenInstance}}",
+            request_body
+        )