leadguru-jobs 0.414.0__py3-none-any.whl → 0.415.0__py3-none-any.whl

lgt_jobs/lgt_common/discord_client/discord_client.py

@@ -1,62 +0,0 @@
-import loguru
-import requests
-from requests import Response
-from lgt_jobs.lgt_common.discord_client.methods import DiscordMethods
-
-
-class DiscordClient:
-    base_url = 'https://discord.com/api/'
-    discord_api_version = 'v9/'
-    token: str
-    headers: dict
-
-    def __init__(self, token: str = None):
-        self.token = token
-        self.headers = {"Authorization": self.token}
-
-    def login(self, login: str, password: str, captcha_key: str = None) -> dict:
-        payload = {
-            'login': login,
-            'password': password,
-            'captcha_key': captcha_key,
-            "undelete": False,
-            "login_source": "",
-            "gift_code_sku_id": None
-        }
-        response = requests.post(f"{self.base_url}{self.discord_api_version}{DiscordMethods.LOGIN.value}", json=payload)
-        if response.status_code == 400 or response.status_code == 200:
-            return response.json()
-        return {}
-
-    def get_servers(self) -> list | dict:
-        response = requests.get(f"{self.base_url}{DiscordMethods.USER_GUILDS.value}", headers=self.headers)
-        return self.__response(response).json()
-
-    def get_dms(self) -> list | dict:
-        response = requests.get(f"{self.base_url}{DiscordMethods.USER_DMS.value}", headers=self.headers)
-        return self.__response(response).json()
-
-    def get_current_user(self) -> dict:
-        response = requests.get(f"{self.base_url}{DiscordMethods.USER.value}", headers=self.headers)
-        if response.status_code != 200:
-            self.__log_error(response)
-        return response.json()
-
-    def get_channels(self, guild_id: str) -> list | dict:
-        response = requests.get(f"{self.base_url}{DiscordMethods.guild_channels(guild_id)}", headers=self.headers)
-        return self.__response(response).json()
-
-    def get_invite_link(self, channel_id: str) -> Response:
-        response = requests.post(f'{self.base_url}{self.discord_api_version}'
-                                 f'{DiscordMethods.channels_invites(channel_id)}', headers=self.headers)
-        return self.__response(response)
-
-    @staticmethod
-    def __log_error(response: Response):
-        loguru.logger.warning(f"[DiscordClient WARNING]: {response.url}, {response.status_code}, {response.content}")
-
-    @staticmethod
-    def __response(response: Response):
-        if response.status_code != 200:
-            DiscordClient.__log_error(response)
-        return response

lgt_jobs/lgt_common/discord_client/methods.py

@@ -1,16 +0,0 @@
-from enum import Enum
-
-
-class DiscordMethods(str, Enum):
-    USER_GUILDS = 'users/@me/guilds'
-    USER_DMS = 'users/@me/channels'
-    USER = 'users/@me'
-    LOGIN = 'auth/login'
-
-    @staticmethod
-    def guild_channels(guild_id: str):
-        return f'guilds/{guild_id}/channels'
-
-    @staticmethod
-    def channels_invites(channel_id: str):
-        return f'channels/{channel_id}/invites'

lgt_jobs/lgt_common/enums/slack_errors.py

@@ -1,6 +0,0 @@
-from enum import Enum
-
-
-class SlackErrors(str, Enum):
-    INVALID_AUTH = 'invalid_auth'
-    TWO_FACTOR_REQUIRED = 'two_factor_setup_required'

lgt_jobs/lgt_common/helpers.py

@@ -1,18 +0,0 @@
-import re
-
-
-def update_credentials(credentials, token, cookies):
-    credentials.token = token
-    credentials.cookies = cookies
-    credentials.invalid_creds = False
-    return credentials
-
-
-def get_formatted_bot_name(name):
-    bot_name = name
-    bot_name.replace(" ", "_") \
-        .replace(".", "dot_") \
-        .replace("#", "") \
-        .replace("+", "_plus")
-
-    return re.sub(r'[^A-Za-z0-9]', "", bot_name).lower()

lgt_jobs/lgt_common/lgt_logging.py

@@ -1,15 +0,0 @@
-import sys
-from loguru import logger as log
-
-log.remove()
-log.add(sys.stdout, format="{time} {name} {level} {message}", level="INFO",
-        filter=lambda record: record['level'] == 'INFO')
-log.add(sys.stderr, format="{time} {name} {level} {message}", level="WARNING",
-        filter=lambda record: record['level'] == 'WARNING')
-log.add(sys.stderr, format="{time} {name} {level} {message}", level="ERROR",
-        filter=lambda record: record['level'] in ['ERROR', 'FATAL', 'CRITICAL'])
-
-
-log.info('Logger has been configured') 
-
-log = log

lgt_jobs/lgt_common/pubsub/command.py

@@ -1,14 +0,0 @@
-import enum
-from typing import Optional
-from pydantic import BaseModel, Extra
-
-
-class TelegramCommandType(enum.Enum):
-    AUTH_VERIFICATION_CODE = 1
-    HARD_RESET = 1
-
-
-class TelegramCommand(BaseModel, extra=Extra.ignore):
-    bot_id: str
-    type: int
-    data: Optional[str]

lgt_jobs/lgt_common/pubsub/messages.py

@@ -1,37 +0,0 @@
-import os
-import time
-from google.cloud import pubsub_v1
-from loguru import logger
-
-project_id = os.environ.get('PUBSUB_PROJECT_ID')
-
-
-def publish_message2_pubsub(topic_name, message_json):
-    def callback(message_future):
-        try:
-            pubsub_result = message_future.result()
-            # When timeout is unspecified, the exception method waits indefinitely.
-            if message_future.exception(timeout=60):
-                logger.error(f'Publishing message on {topic_name} threw an Exception {message_future.exception()}.')
-            else:
-                logger.info('lgt-metric:lgt-slack-aggregator:pub-sub:message-sent')
-                logger.info(pubsub_result)
-        except Exception:
-            logger.error(f'Error has happening during getting result of future message')
-
-    attempt = 0
-    while True:
-        try:
-            publisher = pubsub_v1.PublisherClient()
-            topic_path = publisher.topic_path(project_id, topic_name)
-            logger.info(f'Json: {message_json}')
-            message = publisher.publish(topic_path, data=bytes(message_json, "utf8"))
-            message.add_done_callback(callback)
-            result = message.result()
-            logger.info(f'Message has been sent {result}')
-            return
-        except:
-            attempt = attempt + 1
-            if attempt >= 3:
-                raise
-            time.sleep(3)

lgt_jobs/lgt_common/pubsub/pubsubfactory.py

@@ -1,51 +0,0 @@
-from google.cloud import pubsub_v1
-from google.api_core.exceptions import GoogleAPICallError
-from google.auth.transport.grpc import *
-
-
-class PubSubFactory:
-
-    def __init__(self, project_id):
-        self.project_id = project_id
-        self.publisher = pubsub_v1.PublisherClient()
-        self.subscriber = pubsub_v1.SubscriberClient()
-
-    def get_topic_path(self, topic_name):
-        return self.publisher.api.topic_path(self.project_id, f'{topic_name}')
-
-    def get_subscription_path(self, subscriber_name, topic_name):
-        return self.subscriber.api.subscription_path(self.project_id, f'{topic_name}_{subscriber_name}')
-
-    def create_topic_if_doesnt_exist(self, topic_name) -> pubsub_v1.types.pubsub_gapic_types.Topic:
-        topic_path = self.get_topic_path(topic_name)
-        try:
-            return self.publisher.api.get_topic(topic=topic_path)
-        except GoogleAPICallError as ex:
-            if ex.grpc_status_code == grpc.StatusCode.NOT_FOUND:
-                return self.publisher.api.create_topic(name=topic_path)
-            else:
-                raise
-
-    def delete_topic(self, topic_name: str):
-        topic_path = self.get_topic_path(topic_name)
-        self.publisher.api.delete_topic(topic=topic_path)
-
-    def delete_subscriber(self, subscriber_name: str, topic_name: str):
-        subscription_path = self.get_subscription_path(subscriber_name, topic_name)
-        self.subscriber.api.delete_subscription(subscription=subscription_path)
-
-    def create_subscription_if_doesnt_exist(self, subscriber_name, topic_name,
-                                            ack_deadline_seconds=60) -> pubsub_v1.types.pubsub_gapic_types.Subscription:
-        subscription_path = self.get_subscription_path(subscriber_name, topic_name)
-        self.create_topic_if_doesnt_exist(topic_name)
-
-        try:
-            return self.subscriber.api.get_subscription(subscription=subscription_path)
-        except GoogleAPICallError as ex:
-            if ex.grpc_status_code == grpc.StatusCode.NOT_FOUND:
-                return self.subscriber.api.create_subscription(name=subscription_path,
-                                                               topic=self.get_topic_path(topic_name),
-                                                               push_config=None,
-                                                               ack_deadline_seconds=ack_deadline_seconds)
-            else:
-                raise

lgt_jobs/lgt_common/slack_client/methods.py

@@ -1,46 +0,0 @@
-class SlackMethods:
-    profile_set = 'users.profile.set'
-    profile_get = 'users.profile.get'
-    profile_set_photo = 'users.setPhoto'
-    set_sections = 'users.profile.setSections'
-    users_list = 'users.list'
-    users_info = 'users.info'
-    users_get_presence = 'users.getPresence'
-    list_users = "users.list"
-
-    conversations_join = 'conversations.join'
-    conversations_leave = 'conversations.leave'
-    conversations_list = 'conversations.list'
-    conversations_open = 'conversations.open'
-    conversations_history = 'conversations.history'
-    conversations_replies = 'conversations.replies'
-    conversations_info = 'conversations.info'
-
-    chat_delete = 'chat.delete'
-    chat_update = 'chat.update'
-    chat_post_message = 'chat.postMessage'
-    chat_schedule_message = "chat.scheduleMessage"
-    chat_attachments = "chat.unfurlLink"
-
-    rtm_connect = 'rtm.connect'
-
-    reactions_get = 'reactions.get'
-    create_shared_invite = 'users.admin.createSharedInvite'
-    send_invite_by_email = 'users.admin.inviteBulk'
-    alternative_invite_by_email = 'users.inviteRequests.create'
-
-    upload_file = 'files.upload'
-    download_file = 'files.download'
-    delete_file = 'files.delete'
-    share_files = 'files.share'
-
-    check_email = 'signup.checkEmail'
-    confirm_email = 'signup.confirmEmail'
-
-    confirm_code = 'signin.confirmCode'
-    find_workspaces = 'signin.findWorkspaces'
-
-    auth_test = 'auth.test'
-
-    team_profile_get = 'team.profile.get'
-    team_info = 'team.info'

lgt_jobs/lgt_common/slack_client/slack_client.py

@@ -1,392 +0,0 @@
-import requests
-import aiohttp
-import asyncio
-import websockets
-import json
-import io
-from urllib import parse
-from requests import Response
-from websockets.client import WebSocketClientProtocol
-from .methods import SlackMethods
-
-
-class SlackClient:
-    base_url = 'https://slack.com/api/'
-    token: str
-    cookies: dict
-    socket: WebSocketClientProtocol
-    headers: dict
-
-    def __init__(self, token: str, cookies):
-        self.token = token
-        self.headers = {"Authorization": f"Bearer {self.token}"}
-        if isinstance(cookies, list):
-            self.cookies = {cookie['name']: cookie['value'] for cookie in cookies}
-        else:
-            self.cookies = cookies
-
-    def join_channels(self, channels):
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        tasks = asyncio.gather(*[self.join_channel_async(channel) for channel in channels])
-        results = loop.run_until_complete(tasks)
-        loop.close()
-        return results
-
-    def leave_channels(self, channels):
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        tasks = asyncio.gather(*[self.leave_channel_async(channel) for channel in channels])
-        results = loop.run_until_complete(tasks)
-        loop.close()
-        return results
-
-    async def join_channel_async(self, channel):
-        async with aiohttp.ClientSession() as session:
-            url = f'{self.base_url}{SlackMethods.conversations_join}?{self.__channel_payload(channel)}'
-            async with session.post(url=url, cookies=self.cookies) as response:
-                return await response.json()
-
-    async def leave_channel_async(self, channel):
-        async with aiohttp.ClientSession() as session:
-            url = f'{self.base_url}{SlackMethods.conversations_leave}?{self.__channel_payload(channel)}'
-            async with session.post(url=url, cookies=self.cookies) as response:
-                return await response.json()
-
-    def upload_file(self, file, file_name):
-        payload = {"content": file, "filename": file_name}
-        return requests.post(f"{self.base_url}{SlackMethods.upload_file}", data=payload,
-                             headers=self.headers, cookies=self.cookies).json()
-
-    def download_file(self, file_url) -> Response:
-        return requests.get(file_url, headers=self.headers, cookies=self.cookies)
-
-    def delete_file(self, file_id: str):
-        payload = {"file": file_id}
-        return requests.post(f"{self.base_url}{SlackMethods.delete_file}", data=payload,
-                             headers=self.headers, cookies=self.cookies).json()
-
-    def share_files(self, files_ids: list, channel: str, text: str = None) -> dict:
-        payload = {
-            "files": ','.join(files_ids),
-            "channel": channel,
-        }
-        if text:
-            payload["blocks"] = json.dumps([{"type": "rich_text", "elements": [
-                {"type": "rich_text_section", "elements": [{"type": "text", "text": text}]}]}])
-
-        return requests.post(f"{self.base_url}{SlackMethods.share_files}", data=payload,
-                             headers=self.headers, cookies=self.cookies).json()
-
-    def get_profile(self, user_id: str = None):
-        url = f'{self.base_url}{SlackMethods.profile_get}'
-        payload = {}
-        if user_id:
-            payload['user'] = user_id
-        return requests.post(url=url, cookies=self.cookies, headers=self.headers, json=payload).json()
-
-    def get_team_profile(self):
-        url = f'{self.base_url}{SlackMethods.team_profile_get}'
-        return requests.post(url=url, cookies=self.cookies, headers=self.headers).json()
-
-    def get_team_info(self):
-        url = f'{self.base_url}{SlackMethods.team_info}'
-        return requests.get(url=url, cookies=self.cookies, headers=self.headers).json()
-
-    def update_profile(self, profile):
-        url = f'{self.base_url}{SlackMethods.profile_set}'
-        return requests.post(url=url, headers=self.headers, cookies=self.cookies, json={'profile': profile}).json()
-
-    def update_section(self, user_id: str, section_id: str, element_id: str, text: str):
-        url = f'{self.base_url}{SlackMethods.set_sections}'
-        payload = {
-            'token': self.token,
-            'user': user_id,
-            'section': section_id,
-            'elements': json.dumps([{"element_id": element_id, "text": {"text": text}}]),
-        }
-        return requests.post(url=url, headers=self.headers, cookies=self.cookies, data=payload).json()
-
-    def update_profile_photo(self, photo_url):
-        url = f'{self.base_url}{SlackMethods.profile_set_photo}'
-        with requests.get(photo_url) as img_resp:
-            if img_resp.status_code != 200:
-                raise Exception(f"Invalid url: {photo_url}")
-            image = io.BytesIO(img_resp.content)
-
-            files = {"image": image}
-            headers = {"Authorization": f"Bearer {self.token}"}
-
-            return requests.post(url=url, files=files, headers=headers, cookies=self.cookies, verify=False).json()
-
-    def get_conversations_list(self):
-        payload = {'types': ','.join(["public_channel", "private_channel"])}
-        base_url = f'{self.base_url}{SlackMethods.conversations_list}?limit=1000'
-        page = requests.post(url=base_url, cookies=self.cookies, data=payload, headers=self.headers).json()
-        result = page.copy()
-        if page["ok"]:
-            while page.get("response_metadata", {}).get("next_cursor"):
-                url = base_url + f'&cursor={page.get("response_metadata", {}).get("next_cursor")}'
-                page = requests.post(url=url, cookies=self.cookies, data=payload, headers=self.headers).json()
-                if page['ok']:
-                    result['channels'].extend(page['channels'])
-            result["channels"] = [ch for ch in result["channels"]
-                                  if ch.get('is_channel')
-                                  and not ch.get('is_archived')
-                                  and not ch.get('is_frozen')]
-
-        return result
-
-    def get_im_list(self):
-        url = f'{self.base_url}{SlackMethods.conversations_list}?{self.__conversation_list_payload(["im"])}'
-        return requests.get(url=url, cookies=self.cookies).json()
-
-    def im_open(self, user: str):
-        url = f'{self.base_url}{SlackMethods.conversations_open}?{self.__im_open_payload(user)}'
-        return requests.post(url=url, cookies=self.cookies).json()
-
-    def delete_message(self, channel: str, ts: str):
-        url = f'{self.base_url}{SlackMethods.chat_delete}?{self.__delete_message_payload(channel, ts)}'
-        return requests.post(url=url, cookies=self.cookies).json()
-
-    def conversations_info(self, channel: str):
-        url = f'{self.base_url}{SlackMethods.conversations_info}?{self.__conversation_info_payload(channel)}'
-        return requests.post(url=url, cookies=self.cookies).json()
-
-    def update_message(self, channel: str, ts: str, text: str, file_ids: str):
-        url = f'{self.base_url}{SlackMethods.chat_update}?{self.__update_message_payload(channel, ts, text, file_ids)}'
-        return requests.post(url=url, cookies=self.cookies).json()
-
-    def conversations_history(self, channel: str, ts: str = None):
-        url = f'{self.base_url}{SlackMethods.conversations_history}?{self.__channel_payload(channel, ts)}'
-        return requests.get(url=url, cookies=self.cookies).json()
-
-    def conversations_replies(self, channel: str, ts: str):
-        url = f'{self.base_url}{SlackMethods.conversations_replies}?{self.__ts_payload(channel, ts)}'
-        return requests.get(url=url, cookies=self.cookies).json()
-
-    def get_presense(self, user: str = None):
-        url = f'{self.base_url}{SlackMethods.users_get_presence}?{self.__presense_payload(user)}'
-        return requests.get(url=url, cookies=self.cookies).json()
-
-    def post_message(self, channel: str, text: str):
-        import uuid
-        payload = {
-            'channel': channel,
-            'text': text,
-            'client_msg_id': str(uuid.uuid4())
-        }
-        url = f'{self.base_url}{SlackMethods.chat_post_message}'
-        return requests.post(url=url, cookies=self.cookies, headers=self.headers, data=payload).json()
-
-    def post_message_schedule(self, channel: str, text: str, post_at: int):
-        url = (f'{self.base_url}{SlackMethods.chat_schedule_message}?'
-               f'{self.__post_scheduled_message_payload(channel, text, post_at)}')
-        return requests.post(url=url, cookies=self.cookies).json()
-
-    def users_list(self, cursor=None, limit: int = 1000):
-        url = f'{self.base_url}{SlackMethods.users_list}?{self.__token_payload()}'
-        if cursor:
-            url += f'&cursor={cursor}'
-
-        if limit:
-            url += f'&limit={limit}'
-
-        return requests.get(url=url, cookies=self.cookies).json()
-
-    def user_info(self, user: str):
-        url = f'{self.base_url}{SlackMethods.users_info}?{self.__user_info_payload(user)}'
-        return requests.get(url=url, cookies=self.cookies).json()
-
-    def get_reactions(self, channel: str, ts: str):
-        url = f'{self.base_url}{SlackMethods.reactions_get}?{self.__get_reactions_payload(channel, ts)}'
-        return requests.get(url=url, cookies=self.cookies).json()
-
-    def get_attachments(self, channel: str, msg_id: str, url: str):
-        payload = {
-            'token': self.token,
-            'channel': channel,
-            'client_msg_id': msg_id,
-            'url': url
-        }
-        url = f'{self.base_url}{SlackMethods.chat_attachments}'
-        response = requests.post(url=url, cookies=self.cookies, data=payload)
-        if response.status_code != 200:
-            return
-        return response.json().get('attachments')
-
-    def check_email(self, email: str, user_agent: str) -> bool:
-        payload = {'email': email}
-        headers = {'User-Agent': user_agent}
-        response = requests.post(f"{self.base_url}/{SlackMethods.check_email}", params=payload, headers=headers)
-        if response.status_code != 200:
-            return False
-        return response.json()['ok']
-
-    def confirm_email(self, email: str, user_agent: str, locale: str = 'en-US') -> bool:
-        payload = {'email': email, 'locale': locale}
-        headers = {'User-Agent': user_agent}
-        response = requests.post(f"{self.base_url}/{SlackMethods.confirm_email}", params=payload, headers=headers)
-        if response.status_code != 200:
-            return False
-        return response.json()['ok']
-
-    def confirm_code(self, email: str, code: str, user_agent: str) -> requests.Response:
-        payload = {'email': email, 'code': code}
-        headers = {'User-Agent': user_agent}
-        return requests.post(f"{self.base_url}/{SlackMethods.confirm_code}", params=payload, headers=headers)
-
-    def find_workspaces(self, user_agent: str) -> requests.Response:
-        headers = {'User-Agent': user_agent}
-        response = requests.post(f"{self.base_url}/{SlackMethods.find_workspaces}",
-                                 cookies=self.cookies, headers=headers)
-        return response
-
-    def create_shared_invite(self):
-        expiration = '36000'
-        max_signups = '100'
-        payload = {
-            'expiration': expiration,
-            'max_signups': max_signups
-        }
-        headers = {"Authorization": f"Bearer {self.token}"}
-        response = requests.post(f"{self.base_url}/{SlackMethods.create_shared_invite}", headers=headers,
-                                 cookies=self.cookies, params=payload)
-        return response
-
-    def send_slack_invite_to_workspace(self, email):
-        payload = {"invites": [{'email': email, "type": "regular", "mode": "manual"}]}
-        headers = {"Authorization": f"Bearer {self.token}"}
-        response = requests.post(f"{self.base_url}/{SlackMethods.send_invite_by_email}", headers=headers,
-                                 cookies=self.cookies, json=payload)
-        if not response.json()['ok']:
-            payload = {"requests": payload["invites"]}
-            response = requests.post(f"{self.base_url}/{SlackMethods.alternative_invite_by_email}", headers=headers,
-                                     cookies=self.cookies, json=payload)
-        return response
-
-    def test_auth(self):
-        headers = {"Authorization": f"Bearer {self.token}"}
-        return requests.post(f"{self.base_url}/{SlackMethods.auth_test}", headers=headers,
-                             cookies=self.cookies)
-
-    def rtm_connect(self, callback):
-        loop = asyncio.new_event_loop()
-        loop.run_until_complete(self.__consumer(callback))
-        loop.run_forever()
-
-    async def __consumer(self, callback):
-        url = f'{self.base_url}{SlackMethods.rtm_connect}?{self.__token_payload()}'
-        response = requests.get(url=url, cookies=self.cookies).json()
-        web_socket_url = response['url']
-        async with websockets.connect(uri=web_socket_url) as websocket:
-            self.socket = websocket
-            async for message in websocket:
-                await callback(json.loads(message))
-
-    def __token_payload(self):
-        return parse.urlencode({'token': self.token})
-
-    def __user_info_payload(self, user):
-        payload = {
-            'token': self.token,
-            'user': user
-        }
-        return parse.urlencode(payload)
-
-    def __post_scheduled_message_payload(self, channel, text, post_at):
-        payload = {
-            'token': self.token,
-            'channel': channel,
-            'text': text,
-            'post_at': post_at
-        }
-        return parse.urlencode(payload)
-
-    def __update_message_payload(self, channel, ts, text, file_ids):
-        payload = {
-            'parse': 'none',
-            'token': self.token,
-            'channel': channel,
-            'ts': ts,
-            'text': text,
-            'file_ids': file_ids
-        }
-        return parse.urlencode(payload)
-
-    def __conversation_info_payload(self, channel):
-        payload = {
-            'token': self.token,
-            'channel': channel,
-            'include_num_members': "true"
-        }
-        return parse.urlencode(payload)
-
-    def __delete_message_payload(self, channel, ts):
-        payload = {
-            'token': self.token,
-            'channel': channel,
-            'ts': ts
-        }
-        return parse.urlencode(payload)
-
-    def __conversation_list_payload(self, types: list):
-        payload = {
-            'token': self.token,
-            'types': ','.join(types)
-        }
-        return parse.urlencode(payload)
-
-    def __im_open_payload(self, user: str):
-        payload = {
-            'token': self.token,
-            'users': user,
-            'types': 'im'
-        }
-        return parse.urlencode(payload)
-
-    def __update_profile_payload(self, profile):
-        payload = {
-            'token': self.token,
-            'profile': profile
-        }
-        return parse.urlencode(payload)
-
-    def __channel_payload(self, channel, ts=None):
-        payload = {
-            'token': self.token,
-            'channel': channel
-        }
-
-        if ts:
-            payload["ts"] = ts
-            payload["limit"] = 1
-            payload["inclusive"] = True
-
-        return parse.urlencode(payload)
-
-    def __presense_payload(self, user: str = None):
-        payload = {
-            'token': self.token,
-        }
-
-        if user:
-            payload["user"] = user
-        return parse.urlencode(payload)
-
-    def __ts_payload(self, channel: str, ts: str):
-        payload = {
-            'token': self.token,
-            'channel': channel,
-            'ts': ts
-        }
-        return parse.urlencode(payload)
-
-    def __get_reactions_payload(self, channel, ts):
-        payload = {
-            'token': self.token,
-            'full': True,
-            'channel': channel,
-            'timestamp': ts
-        }
-        return parse.urlencode(payload)