def run(): logger.info('Bot is running...') bot = TelegramClient('bot', config.API_ID, config.API_HASH).start(bot_token=config.BOT_TOKEN) @bot.on(events.NewMessage) async def any_message_arrived_handler(event): chat = await event.get_chat() result = await bot( functions.messages.GetFullChatRequest(chat_id=chat.id)) description = result.full_chat.about if check_description_changed(description): new_topic = Topic(text=description) insert_new_topic(new_topic) logger.debug('Group "%s" had description changed to "%s"', chat.title, description) await bot.send_message( chat.id, f'Вова знову поміняв опис!\n**{description}**') @bot.on(events.NewMessage) async def poll_created_handler(event): poll = event.message.poll message_id = event.message.id await handle_polls(bot, event) if event.message.poll is not None: results = poll.results new_poll = Poll(message_id=message_id) insert_new_poll(new_poll) print('Total voters', results.total_voters) raise events.StopPropagation bot.run_until_disconnected()
def start_sync(): """Start tgcf live sync.""" # pylint: disable=import-outside-toplevel from telethon.sync import TelegramClient, functions, types client = TelegramClient(config.SESSION, config.API_ID, config.API_HASH) client.start(bot_token=config.BOT_TOKEN) is_bot = client.is_bot() for key, val in ALL_EVENTS.items(): if key.startswith("bot"): if not is_bot: continue if config.CONFIG.live.delete_sync is False and key == "deleted": continue client.add_event_handler(*val) logging.info(f"Added event handler for {key}") if is_bot and const.REGISTER_COMMANDS: client( functions.bots.SetBotCommandsRequest( commands=[ types.BotCommand(command=key, description=value) for key, value in const.COMMANDS.items() ] ) ) client.run_until_disconnected()
class Forwarder: def __init__(self, config): self.telegram = TelegramClient(StringSession(config.session), config.api_id, config.api_hash) self.message_pattern = config.message_pattern self.input_chat_usernames = config.input_chat_usernames self.output_chat_usernames = config.output_chat_usernames self.input_chats = [] self.output_chats = [] def start(self): self.__connect() self.__load_input_chats() self.__load_output_chats() self.__start_forwarding() def __connect(self): self.telegram.start() def __load_input_chats(self): dialogs = self.telegram.get_dialogs() for username in self.input_chat_usernames: dialog = next( filter(lambda e: e.entity.username == username, dialogs), None) if dialog: self.input_chats.append( InputChannel(dialog.entity.id, dialog.entity.access_hash)) else: raise RuntimeError(f"Input chat '{username}' was not found") def __load_output_chats(self): dialogs = self.telegram.get_dialogs() for username in self.output_chat_usernames: dialog = next( filter(lambda e: e.entity.username == username, dialogs), None) if dialog: self.output_chats.append( InputChannel(dialog.entity.id, dialog.entity.access_hash)) else: raise RuntimeError(f"Output chat '{username}' was not found") def __start_forwarding(self): @self.telegram.on( events.NewMessage(chats=self.input_chats, pattern=self.message_pattern)) async def handler(event): logger.info("Forwarding 1 message") for output_chat in self.output_chats: await self.telegram.forward_messages(output_chat, event.message) logger.info(f"Listening on {len(self.input_chats)} chats.") logger.info(f"Forwarding messages to {len(self.output_chats)} chats.") self.telegram.run_until_disconnected()
def script_work(): global client admin_client = TelegramClient(username, api_id, api_hash) admin_client.start(phone, password) with admin_client as client: admin_client.get_entity("ChatWarsBot") client.add_event_handler(stats_handler, event=events.NewMessage) print("telegram script launched") admin_client.run_until_disconnected()
def start(): client = TelegramClient('parser', config.api_id, config.api_hash) @client.on(events.NewMessage(chats=(config.chats_name))) async def normal_handler(event): # print(event.message.from_id) for key in config.keys: if key in event.message.to_dict()['message']: await client.forward_messages(config.source, event.message, event.message.from_id) client.start() client.run_until_disconnected()
def script_work(): global client global loop loop = asyncio.get_event_loop() admin_client = TelegramClient(username, api_id, api_hash) admin_client.start(phone, password) with admin_client as client: client = admin_client admin_client.get_entity("ChatWarsBot") start_updating() start_countdown() print("started timer") #timer = Timer(interval=5, function=update_guild_stats, args=[client, True]).start() admin_client.run_until_disconnected()
def start_bot(API_ID: int, API_HASH: str, name: str, token: str): os.makedirs(name, exist_ok=True) os.chdir(name) download_image(url=conf.config.watermark) client = TelegramClient(name, API_ID, API_HASH).start(bot_token=token) client( functions.bots.SetBotCommandsRequest(commands=[ types.BotCommand(command=key, description=value) for key, value in conf.COMMANDS.items() ])) for key, val in ALL_EVENTS.items(): print(f"Adding event {key}") client.add_event_handler(*val) print(f"Started bot {name}") client.run_until_disconnected()
class BotController: def __init__(self, session_name=SESSION_NAME): self.client = TelegramClient(session_name, API_KEY, API_HASH) def __enter__(self): self.client.__enter__() return self def __exit__(self, exc_type, exc_val, exc_tb): self.client.__exit__(exc_type, exc_val, exc_tb) def start(self): self.client.loop.run_until_complete(import_modules(self.client)) @self.client.on(NewMessage(outgoing=True)) async def message(event: NewMessage.Event): await handle_message(event.message) self.client.start() self.client.run_until_disconnected()
def script_work(): global client session_path = "./sessions/{}".format(username) if telethon_proxy is not None: proxy = (telethon_proxy["host"], telethon_proxy["port"], telethon_proxy["secret"]) admin_client = TelegramClient( session_path, api_id, api_hash, proxy=proxy, connection=connection.tcpmtproxy.ConnectionTcpMTProxyIntermediate) else: admin_client = TelegramClient(session_path, api_id, api_hash) # admin_client.start(phone, password) # # client = admin_client with admin_client as client: admin_client.get_entity("ChatWarsBot") client.add_event_handler(stats_handler, event=events.NewMessage) print("telegram script launched") admin_client.run_until_disconnected()
if (id != target_id) & (sender.bot == False): print(peer_id, "username", sender.username, message) if (type(target_entity) == InputPeerChannel): try: result = await client( InviteToChannelRequest(channel=target_id, users=[sender.id])) # print('Join success to channel', result) print('Join success to channel') except ChatAdminRequiredError as error: print('Add user channel group error', error) except UserPrivacyRestrictedError as error: print('Add user channel group error', error) except PeerFloodError as error: print('Add user channel group error', error) elif (type(target_entity) == InputPeerChat): try: result = await client( AddChatUserRequest(chat_id=target_id, user_id=sender.id, fwd_limit=10)) # print('Join success to chat', result) print('Join success to chat') except UserAlreadyParticipantError as error: print('User are already participated chat group', error) client.run_until_disconnected()
me = await bot.get_me() # "me" is an User object. You can pretty-print # any Telegram object with the "stringify" method: print(me.stringify()) if __name__ == '__main__': bot = TelegramClient('bot', api_id, api_hash).start(bot_token=bot_token) @bot.on(events.NewMessage) async def my_event_handler(event): chat = await event.get_chat() from telethon.tl.functions.channels import GetFullChannelRequest from telethon import functions, types # creating client here # ch = client.get_entity("@mychannel") entity = await bot.get_entity(chat.id) # ch_full = await bot(GetFullChannelRequest(channel=chat)) result = await bot(functions.messages.GetFullChatRequest( chat_id=chat.id )) print(result.stringify()) import pdb; pdb.set_trace() await event.reply(event.raw_text) # with bot: # bot.loop.run_until_complete(main(bot)) bot.run_until_disconnected()
class TelegramStrategy(strategy): """ """ strategyName = 'Telegram' channel = None orders = [] telegramClient = None message = None apiID = None apiSecret = None def __init__(self): self.importAPIKeys() self.telegramClient = TelegramClient('kcapbot', self.apiID, self.apiSecret) self.telegramClient.connect() logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') print("Telegram Account authorized:\nListening for Alerts\n\n") def listen(self): """ """ @self.telegramClient.on(events.NewMessage) async def my_event_handler(event): print(event.raw_text) parseMessage(self, event.raw_text) self.telegramClient.start() self.telegramClient.run_until_disconnected() def importAPIKeys(self): """ """ f = open('strategies/Telegram/TelegramCredentials.json', 'r') with open(f.name) as jsonFile: data = json.load(jsonFile) for keySet in data['API_Keys']: if keySet['keyID'] is not 'Fake': self.apiID = keySet['keyID'] self.apiSecret = keySet['privateKey'] else: print('PLEASE ADD TELEGRAM API KEYS TO Telegram/TelegramCredentials.json\n') def runStrategy(self, marketControllers): """ :param marketControllers: """ return self.orders def addOrder(self, order): """ :param order: """ self.orders.append(order)
def conect(): #config api_id = "1265435" api_hash = '17e1fd69156fa33ec73960a5806b4897' client = TelegramClient('sessiong_name', api_id, api_hash) #group_name = {'Các thánh than cà khịa','Chợ Bitcoin Hà Nội'} listCoin = {'ETH', ' B', 'BTC', 'U', 'USDT', 'BIT', 'E'} try: @client.on(events.NewMessage(chats=None)) async def handler(event): # Good try: chat = await event.get_chat() #print(chat) sender = await event.get_sender() print("GroupID:", str(chat.id), "Group_name: ", str(chat.title), "UserName: "******" --- Chat: ", str(event.raw_text)) list_record = list() list_chat = processMessage(event.raw_text, listCoin) print(list_chat) num_record = 0 for i in range(10): if ("Quanlity" + str(num_record)) in list_chat and ( "CoinType" + str(num_record)): recorddb = dict() recorddb['Groupid'] = chat.id recorddb['GroupName'] = chat.title recorddb['UserName'] = sender.username recorddb['UserID'] = sender.id recorddb['UserPhone'] = sender.phone recorddb['Chat'] = event.raw_text recorddb['action'] = list_chat['action'] recorddb['Quanlity'] = list_chat['Quanlity' + str(num_record)] recorddb['CoinType'] = list_chat['CoinType' + str(num_record)] list_record.append(recorddb) #### # send thist record to database >>> list_record ''' myclient = pymongo.MongoClient("mongodb://localhost:27017/") mydb = myclient["mydatabase"] mycol = mydb["customers"] ----recorddb is dict() type recorddb = {'Groupid': 1135988787, 'GroupName': 'Chợ Bitcoin Hà Nội', 'UserName': '******', 'UserID': 155296816, 'UserPhone': None, 'Chat': 'Bán 60 eth giá tốt', 'action': 'Sell', 'Quanlity': '60', 'CoinType': 'ETH'} x = mycol.insert_one(recorddb) ''' #### print("Recrod to database ", recorddb) num_record = num_record + 1 #sender = await ev81ent.get_sender() #print("send_information:", se nder) #print (str(processMessage(event.raw_text,listCoin))) print("-------------") #chat_id = event.chat_id except Exception as identifier: pass except Exception as identifier: pass #client.conversation() client.start() client.run_until_disconnected()
class Controller: albums = {} active_posting = True def __init__(self, session, api_id, api_hash, mode, proxy=None): """ Initializes the InteractiveTelegramClient. :param session: Name of the *.session file. :param api_id: Telegram's api_id acquired through my.telegram.org. :param api_hash: Telegram's api_hash. :param mode: development or production mode :param proxy: Optional proxy tuple/dictionary. """ if mode == "dev": self.client = TelegramClient( session, api_id, api_hash, proxy=proxy, connection=connection. ConnectionTcpMTProxyRandomizedIntermediate) elif mode == "prod": self.client = TelegramClient(session, api_id, api_hash) # Use the client in a `with` block. It calls `start/disconnect` automatically. self.database = Database() with self.client: self.client.add_event_handler( self.forward_album_legacy, events.NewMessage(from_users=('@Ordicyn', '@lazycat90210'), func=lambda e: e.grouped_id)) self.client.add_event_handler( self.forward_msg, events.NewMessage(from_users=('@Ordicyn', '@lazycat90210'), func=lambda e: e.grouped_id is None)) # Task to print alive-messages every 5 minutes loop.create_task(self.print_forever()) # Task to grab the most popular posts from channels (table "channels") every day at 08:00 GMT+3 loop.create_task(self.do_dump_schedule()) # Task to post 2 times in hour 3 random media from posts (table "posts") in period 09:00-23:00 GMT+3 loop.create_task(self.do_post_schedule()) self.client.run_until_disconnected() async def forward_album_legacy(self, event): logger.info('Recieved message with album') await event.mark_read() pair = (event.chat_id, event.grouped_id) if pair in self.albums: self.albums[pair].append(event.message) return self.albums[pair] = [event.message] await asyncio.sleep(0.3) messages = self.albums.pop(pair) logger.info('%s %s', 'Album contains photos:', str(len(messages))) await event.respond(f'Got {len(messages)} photos!') medias = [] for msg in messages: medias.append(msg.media) await self.client.send_file( chat, medias, caption='✅ [Сохранёнки](https://t.me/savedmemess)') async def forward_msg(self, event): await event.mark_read() logger.info('%s %s', "Event", str(event)) sender = await event.get_sender() logger.info('%s %s', "Recieved new message for forwarding from", str(sender.username)) msg = event.message logger.info('%s %s', "Message", str(msg)) if msg.media is not None and (isinstance(msg.media, MessageMediaPhoto) or isinstance(msg.media, MessageMediaDocument)): logger.info('Message contains media photo or video') media = msg.media await self.client.send_file( chat, media, caption='✅ [Сохранёнки](https://t.me/savedmemess)') else: logger.info("Message doesn't contain media photo or video") if msg.message.lower() == 'help': logger.info('Message is help request') with codecs.open('help.html', "r", encoding='utf-8') as help_file: help_msg = help_file.read() await event.respond(help_msg, parse_mode='html') elif msg.message.lower() == 'list': logger.info('Message is channels list request') try: channels = self.database.getAllChannels() response = "Now is listening following channels:\n" + "\n".join( map(str, channels)) logger.info(response) await event.respond(message=response, link_preview=False) except Exception as ex: error_msg = "Failed to get chanel list with exception: " + str( ex) logger.error(error_msg) elif msg.message.lower().startswith('add'): logger.info('Message is request to add channel to list') try: channel_url = msg.message.lower().split(' ')[1] channel_entity = await self.client.get_entity(channel_url) if self.database.getChannelByID(channel_entity.id) is None: channel = Channel(channel_entity.id, channel_entity.title, channel_url, True) self.database.addChannel(channel) success_msg = channel_entity.title + ' was added to database. Dumping will start at 8:00 GMT+3' logger.info(success_msg) await event.respond(success_msg) else: error_msg = 'Channel with ID ' + str( channel_entity.id) + ' already in database' logger.error(error_msg) await event.respond(error_msg) except Exception as ex: error_msg = "Failed to add channel to list with exception: " + str( ex) logger.error(error_msg) await event.respond(error_msg) elif msg.message.lower().startswith('delete'): logger.info('Message is request to delete channel from list') try: channel_id = msg.message.lower().split(' ')[1] if self.database.getChannelByID(channel_id) is not None: channel_entity = await self.client.get_input_entity( self.database.getChannelByID(channel_id).link) await self.client( LeaveChannelRequest(channel=channel_entity)) self.database.delChannelByID(channel_id) success_msg = channel_id + ', channel with this id was successfully deleted from the database.' \ 'Media from this channel was deleted too and bot leave channel' logger.info(success_msg) await event.respond(success_msg) else: error_msg = 'Channel with ID ' + str( channel_id) + ' not in database' logger.error(error_msg) await event.respond(error_msg) except Exception as ex: error_msg = "Failed to delete channel from list with exception: " + str( ex) logger.error(error_msg) await event.respond(error_msg) elif msg.message.lower() == 'dump': logger.info( 'Message is request dump messages from channel manually') try: await self.do_dump() success_msg = 'Request dump messages from channel manually was handled success' logger.info(success_msg) await event.respond(success_msg) except Exception as ex: error_msg = "Failed dump messages from channels " + str(ex) logger.error(error_msg) await event.respond(error_msg) elif msg.message.lower() == 'post': logger.info('Message is request to do 3 posts manually') try: await self.do_post() success_msg = 'Request to do 3 posts manually was handled success' logger.info(success_msg) await event.respond(success_msg) except Exception as ex: error_msg = "Failed to do 3 posts manually " + str(ex) logger.error(error_msg) await event.respond(error_msg) elif msg.message.lower() == 'start': logger.info('Message is request to start automatic posting') if self.active_posting is True: logger.info('Automatic posting is active already') await event.respond('Automatic posting is active already') else: self.active_posting = True logger.info('Automatic posting is set true') await event.respond('Automatic posting is set true') elif msg.message.lower() == 'stop': logger.info('Message is request to stop automatic posting') if self.active_posting is False: logger.info('Automatic posting is stop already') await event.respond('Automatic posting is stop already') else: self.active_posting = False logger.info('Automatic posting stopped') await event.respond('Automatic posting stopped') elif msg.message.lower() == 'stats': logger.info('Message is request to get bot statistic') try: logger.info('Get information about posts database') total, posted, not_posted = self.database.getPostsInfo() msg = 'Bot statistic:\nPost database contains posts: ' + str( total) + '\nPosted count: ' + str( posted) + '\nNot posted count: ' + str( not_posted ) + '\nInformation about last 10 revisions:\n' logger.info('Get information about last 10 revisions') revisions = self.database.getLast10Revisions() for revision in revisions: msg += 'Channel ID: ' + str(revision[0]) + ', channel name: ' + revision[1] + ', collected: ' \ + str(revision[2]) + ', time(GMT+3): ' \ + str( revision[3].astimezone(pytz.timezone("Europe/Moscow")).strftime("%Y-%m-%d %H:%M:%S")) + '\n' # print(revisions) logger.info(msg) await event.respond(msg) except Exception as ex: error_msg = "Failed to to get bot statistic " + str(ex) logger.error(error_msg) await event.respond(error_msg) else: logger.info('Command is unrecognized. Use help command') await event.respond('Command is unrecognized. Use help command' ) async def join_channel(self): channels = self.database.getAllChannels() for channel in channels: try: await self.client(JoinChannelRequest(channel.channel_id)) logger.info('%s %s', 'success join to the channel', channel.title) except Exception as ex: logger.error('%s %s %s', 'failed join to the channel', channel.title, str(ex)) async def do_dump_schedule(self): while True: logger.info("Get current time in UTC") current_time_utc = datetime.time(datetime.now(pytz.utc)) logger.info('%s %s', 'Now: ', str(current_time_utc)) dump_time_utc = time(hour=5, minute=0) if current_time_utc <= dump_time_utc: logger.info("Current time less than 08:00 GMT+3(05:00 UTC)") remaining = ( datetime.combine(datetime.date(datetime.now(pytz.utc)), dump_time_utc) - datetime.combine(datetime.date(datetime.now(pytz.utc)), current_time_utc)).total_seconds() else: logger.info("Current time greater than 08:00 GMT+3(05:00 UTC)") remaining = (datetime.combine( datetime.date(datetime.now(pytz.utc)) + timedelta(days=1), dump_time_utc) - datetime.combine( datetime.date(datetime.now(pytz.utc)), current_time_utc)).total_seconds() logger.info('%s %s', "Now go sleep for: ", str(remaining)) await asyncio.sleep(remaining) logger.info('Now 08:00 GMT+3. Dump process wake up!') try: await self.do_dump() except Exception as ex: error_msg = "Failed dump messages from channels " + str(ex) logger.error(error_msg) async def do_dump(self): logger.info('Task#1 - clear messages table') try: r = self.database.clearPosts() logger.info('%s %s', str(r), ' posts was cleared') except Exception as ex: error_msg = "Failed to clear messages table with exception: " + str( ex) logger.error(error_msg) logger.info('Task#2 - join to channels') try: await self.join_channel() except Exception as ex: error_msg = "Failed to join to channels with exception: " + str(ex) logger.error(error_msg) logger.info( 'Task#3 - Get last 200 messages from channels in date range' ' [current date-1 21:00; current date-2 21:00]') # Current date in UTC current_date = datetime.date(datetime.now(pytz.utc)) logger.info('%s %s', 'Current date in UTC ', str(current_date)) # 18:00 in UTC = 21:00 in GMT + 3 time_dump = time(hour=18, minute=0) # before datetime = current date-1 21:00 dt_before = datetime.combine(current_date - timedelta(days=1), time_dump).replace(tzinfo=pytz.UTC) logger.info('%s %s', 'before datetime = current date-1 21:00 ', str(dt_before)) # after datetime = current date-2 21:00 dt_after = datetime.combine(current_date - timedelta(days=2), time_dump).replace(tzinfo=pytz.UTC) logger.info('%s %s', 'after datetime = current date-2 21:00 ', str(dt_after)) # global posts list posts_list_global = [] try: logger.info('Get actual channel list') channels = self.database.getAllChannels() for channel in channels: logger.info('%s %s', 'Try to dump message from channel', channel.title) try: logger.info('This channel hasnt been dumped yet') logger.info('Init telethon request') channel_entity = await self.client.get_input_entity( channel.channel_id) posts_list = [] # Get first 100 messages logger.info('Get first 100 messages') posts = await self.client( GetHistoryRequest(peer=channel_entity, limit=100, offset_date=dt_before, offset_id=0, max_id=0, min_id=0, add_offset=0, hash=0)) logger.info('%s %s', 'Got messages: ', str(len(posts.messages))) posts_list.extend(posts.messages) offset_id = posts_list[99].id logger.info('%s %s', 'Offset message id: ', str(offset_id)) logger.info('Get another 100 messages') posts = await self.client( GetHistoryRequest(peer=channel_entity, limit=100, offset_date=dt_before, offset_id=offset_id, max_id=0, min_id=0, add_offset=0, hash=0)) logger.info('%s %s', 'Got messages: ', str(len(posts.messages))) posts_list.extend(posts.messages) logger.info('%s %s', 'Totally got messages: ', str(len(posts_list))) logger.info( 'Filter messages that not album with media photo or video and text without invite link and not reply' ) filtered_posts_list = list( filter( lambda msg: (dt_after <= msg.date and dt_before >= msg.date ) and (msg.grouped_id is None) and (msg.media is not None) and (msg.reply_markup is None) and (isinstance(msg.media, MessageMediaPhoto) or isinstance(msg.media, MessageMediaDocument)) and (not any(s in msg.message for s in ["https", ".shop", ".com", ".ru"])), posts_list)) logger.info('%s %s', 'After filtering messages list contain: ', str(len(filtered_posts_list))) # for x in filtered_posts_list: logger.info(str(x)) logger.info( 'Sort list by views and save 50% first more popular post to global' ) filtered_posts_list.sort(key=lambda msg: msg.views, reverse=True) # for x in filtered_posts_list[:int(len(filtered_posts_list)/2)]: logger.info(str(x)) posts_list_global.extend( filtered_posts_list[:int(len(filtered_posts_list) / 2)]) logger.info( '%s %s', 'Add revision record about channel for this date', channel.title) revision = Revision(channel.channel_id, datetime.now(pytz.utc), len(filtered_posts_list)) try: self.database.addRevision(revision) except Exception as ex: error_msg = "Failed to store revision to database with exception " + str( ex) logger.error(error_msg) except Exception as ex: error_msg = "Failed to dump message from channel " + channel.title + " : " + str( ex) logger.error(error_msg) except Exception as ex: error_msg = "Failed to get last 200 messages from channels in general: " + str( ex) logger.error(error_msg) logger.info('%s %s', 'Totally from all channels got messages: ', str(len(posts_list_global))) logger.info('Task#4 - Now we should cast class Message to Posts') logger.info('Now we should cast class Message to Post') # logger.info(posts_list_global[0]) filtered_posts_list_global_in_post = list( map( lambda msg: Post(msg.to_id.channel_id, msg.id, "", msg.date, False), posts_list_global)) # for x in filtered_posts_list_global_in_post: print(x) self.database.addPosts(filtered_posts_list_global_in_post) # for post in filtered_posts_list_global_in_post: # await self.client.send_file('test_channel_5', pickle.loads(post.media), # caption='✅ [Сохранёнки](https://t.me/savedmemess)') # await asyncio.sleep(5) # await asyncio.sleep(80) async def do_post_schedule(self): while True: logger.info( "Function post 2 times in hour 3 random media from database in period 09:00-23:00 GMT+3 " "or 06:00-20:00 UTC") logger.info("Get current time in UTC") current_time_utc = datetime.time(datetime.now(pytz.utc)) logger.info('%s %s', 'Now: ', str(current_time_utc)) after_time_utc = time(hour=6, minute=0) before_time_utc = time(hour=20, minute=0) if current_time_utc < after_time_utc: logger.info("Current time less than 09:00 GMT+3(06:00 UTC)") remaining = ( datetime.combine(datetime.date(datetime.now(pytz.utc)), after_time_utc) - datetime.combine(datetime.date(datetime.now(pytz.utc)), current_time_utc)).total_seconds() logger.info('%s %s', "Now go sleep for: ", str(remaining)) await asyncio.sleep(remaining) if current_time_utc > before_time_utc: logger.info("Current time greater than 23:00 GMT+3(20:00 UTC)") remaining = (datetime.combine( datetime.date(datetime.now(pytz.utc)) + timedelta(days=1), after_time_utc) - datetime.combine( datetime.date(datetime.now(pytz.utc)), current_time_utc)).total_seconds() logger.info('%s %s', "Now go sleep for: ", str(remaining)) await asyncio.sleep(remaining) else: if self.active_posting is True: logger.info('Automatic posting is active now') # self.database.printAllPosts() logger.info("Time to post!") await self.do_post() logger.info("Done! Now sleep for 29 minutes") await asyncio.sleep(1740) else: logger.info('Automatic posting is inactive now') logger.info("Now sleep for 30 minutes") await asyncio.sleep(1800) async def do_post(self): for i in range(0, 3): try: post = self.database.getRandomPost() logger.info("Select from database following random post:") logger.info(str(post)) logger.info("Trying to retrive message from channel:") channel_entity = await self.client.get_input_entity( post.channel_id) logger.info(str(channel_entity)) msg = await self.client( GetMessagesRequest(channel=channel_entity, id=[post.message_id])) logger.info(str(msg)) media = msg.messages[0].media await self.client.send_file( bot, media, caption='✅ [Сохранёнки](https://t.me/savedmemess)') logger.info("Post was send. Now mark it in database as marked") try: self.database.setPostPosted(post) except Exception as ex: error_msg = "Failed with exception: " + str(ex) logger.error(error_msg) except Exception as ex: error_msg = "Failed to post exception: " + str(ex) logger.error(error_msg) finally: await asyncio.sleep(5) async def print_forever(self): while True: logger.info("Await(alive) function") current_time_utc = datetime.time(datetime.now(pytz.utc)) logger.info('%s %s', 'Now: ', str(current_time_utc)) await asyncio.sleep(300)