class BoilerBot: def __init__(self): self._bot = Bot(conf.bot_token, proxy=conf.tele_proxy) self.session = self._bot.session self.loop = self._bot.loop self.init_handlers() def init_handlers(self): self._bot.add_command(r'/ch', get_chat_id) self._bot.add_command(r'/save_ch', save_chat_id)
class ParseBot(object): bot = None states = None oops_handler = None def __init__(self): self.states = {} def init(self): self.bot = Bot(api_token=config.TELEGRAM_TOKEN) from bot.conversation import init_dialogs init_dialogs(self) self.bot.default(self.get_default_handler()) yield_data.add_observer('pbot', self.data_receive_observer) async def data_receive_observer(self, tg_id, data): log.debug("DATA RECEIVED: to {}, data: {}", tg_id, data) chat = self.bot.private(tg_id) return chat.send_text('Look what I found!\n{}'.format(data)) def add_state_handler(self, state, hlr): self.states[state] = hlr def add_default_state_handler(self, hlr): self.oops_handler = hlr def add_callback(self, regexp, fn): return self.bot.add_callback(regexp, fn) def add_command(self, regexp, fn): return self.bot.add_command(regexp, fn) def add_inline(self, regexp, fn): return self.bot.add_inline(regexp, fn) def get_default_handler(self): @with_user_data async def def_handler(chat, message, user_data): state = user_data.get('state') if state: handler = self.states.get(state) if handler: return await handler(chat, message, user_data) if self.oops_handler: return await self.oops_handler(chat, message, user_data) return await chat.send_text('Oops! Something went wrong, for now we can start again and see how it goes') return def_handler def run(self, webhook=config.WEBHOOK_URL): if webhook: self.bot.run_webhook(webhook) else: self.bot.run(config.DEBUG)
class CamBot: def __init__(self, agent: 'gphotos.GooglePhotosManager', manager: vkmanager.VKManager): self._bot = Bot(conf.bot_token, proxy=conf.tele_proxy) self.session = self._bot.session self.loop = self._bot.loop self.menu_markup = Menu() self.init_handlers() self.agent = agent self.vk_manager = manager def init_handlers(self): self._bot.add_command(r'/mov (.+) (.+)', self.mov) self._bot.add_command(r'/push_vk (.+) (.+)', self.push_vk) self._bot.add_command(r'/check (.+) (.+)', self.check_album) self._bot.add_command(r'/full_check (.+)', self.full_check) self._bot.add_command(r'/clear (.+)', self.clear_command) self._bot.add_command(r'/reg', reg) self._bot.add_command(r'/ch', self.reg_channel) self._bot.add_command(r'/photo_reg', self.reg_photo_channel) self._bot.add_command(r'/menu', self.menu) self._bot.add_command(r'/all', self.img_all_cams) self._bot.add_command(r'/stats (.+)', self.stats_command) self._bot.add_command(r'/stats', self.stats_command) self._bot.add_command(r'/lstats (.+)', self.lstats_command) self._bot.add_command(r'/lstats', self.lstats_command) self._bot.add_command(r'/dbdata', self.db_data) self._bot.add_command(r'/daily', self.daily_movie_group_command) self._bot.add_command(r'/push_on', self.push_vk_on) self._bot.add_command(r'/push_off', self.push_vk_off) self._bot.add_callback(r'regular (.+)', regular) self._bot.add_callback(r'today (.+)', today) self._bot.add_callback(r'weekly (.+)', weekly) self._bot.add_callback(r'select (.+)', self.select) self._bot.add_callback(r'back', self.back) self._bot.add_callback(r'img (.+)', self.img_callback) self._bot.add_callback(r'choose_cam (.+)', self.choose_cam_callback) self._bot.add_callback(r'choose_photo_cam (.+)', self.choose_photo_cam_callback) self._bot.add_callback(r'sync (.+)', self.sync_gphotos) self._bot.add_callback(r'gsnc (.+)', self.run_sync_gphotos) self._bot.add_callback(r'remove (.+)', self.remove_folder) self._bot.add_callback(r'post (.+) (.+)', self.post_photo) self._bot.add_callback(r'clear_cb (.+)', self.clear_callback) self._bot.add_callback(r'check_cb (.+)', self.full_check_callback) self._bot.callback(unhandled_callbacks) def stop(self): self._bot.stop() @ThreadSwitcherWithDB.optimized async def daily_stats(self): await self.stats_request(pendulum.yesterday(), self.notify_admins) @ThreadSwitcherWithDB.optimized async def daily_movie(self, cam: Cam): day = datetime.datetime.now() - datetime.timedelta(days=1) day = day.strftime('%d_%m_%Y') loop = asyncio.get_event_loop() with concurrent.futures.ThreadPoolExecutor() as pool: try: clip = await loop.run_in_executor(pool, lambda: make_movie(cam, day)) except FileNotFoundError as exc: logger.exception(exc) await self.notify_admins( f'File {exc.filename} not found for daily movie {cam.name}: {day}' ) return except Exception as exc: logger.exception(exc) await self.notify_admins( f'Error during making daily movie for {cam.name}: {day}') return if cam.update_channel: async with db_in_thread(): channels = db.query(Channel).filter( Channel.cam == cam.name).all() for channel in channels: await send_video(Chat(self._bot, channel.chat_id), clip) await self.notify_admins(f'Daily movie for {cam.name}: {day} ready!') for chat in await self.admin_chats(): await send_video(Chat(self._bot, chat.chat_id), clip) async def push_vk(self, chat, match): cam = await get_cam(match.group(1), chat) if not cam: return day = match.group(2) path = Path(conf.root_dir ) / 'data' / cam.name / 'regular' / 'clips' / f'{day}.mp4' if not path.exists(): await chat.send_text('Movie file does not exist!') return try: await self.vk_manager.new_post(cam.name, str(path), day.replace('_', ' '), day.replace('_', '/')) except vkmanager.VKManagerError as exc: logger.exception('Error during pushing video to vk') await chat.send_text(exc.detail) except Exception: logger.exception('Unhandled exception during pushing video to vk') await chat.send_text('Unhandled error!') await chat.send_text('Movie successfully published') async def mov(self, chat, match): """ Make movie for specified cam and day. Example: /mov favcam 25_04_2019 :param chat: :param match: :return: """ cam = await get_cam(match.group(1), chat) if not cam: return day = match.group(2) loop = asyncio.get_event_loop() with concurrent.futures.ThreadPoolExecutor() as pool: try: clip = await loop.run_in_executor(pool, lambda: make_movie(cam, day)) except Exception: logger.exception('Error during movie request') await self.notify_admins( f'Error during movie request {day} {cam.name}') return await self.notify_admins(f'Video ready. Uploading..') with open(clip.path, 'rb') as clip: await chat.send_video(clip) async def daily_movie_group(self): for cam in sorted(conf.cameras_list, key=lambda k: k.offset): if cam.render_daily: await self.daily_movie(cam) await self.daily_stats() async def daily_photo_group(self): for cam in conf.cameras_list: image = await CamHandler(cam, self._bot.session).get_img(regular=False) if not image: await self.notify_admins( f'Error during image request for {cam.name}') continue path = image.original_path if cam.resize else image.path await self._post_photo(cam, path) async def daily_movie_group_command(self, chat, match): logger.info('Forced daily movie group command') await self.daily_movie_group() async def push_vk_on(self, chat: Chat, match): loop = asyncio.get_event_loop() cmd = f'systemctl --user start {conf.vk_service}'.split() try: await loop.run_in_executor(None, lambda: subprocess_call(cmd)) except Exception: msg = 'Error during starting vk push service' logger.exception(msg) await chat.send_text(msg) return await chat.send_text('vk push service started') async def push_vk_off(self, chat: Chat, match): loop = asyncio.get_event_loop() cmd = f'systemctl --user stop {conf.vk_service}'.split() try: await loop.run_in_executor(None, lambda: subprocess_call(cmd)) except Exception: msg = 'Error during stopping vk push service' logger.exception(msg) await chat.send_text(msg) return await chat.send_text('vk push service stopped') async def img_all_cams(self, chat: Chat, match): for cam in conf.cameras_list: await self.img_handler(chat, cam) async def img_handler(self, chat: Chat, cam): image = await CamHandler(cam, self._bot.session).get_img(regular=False) if not image: await chat.send_text(f'Error during image request for {cam.name}') return path = image.original_path if cam.resize else image.path markup = Markup([[ InlineKeyboardButton(text='post', callback_data=f'post {cam.name} {path.name}') ]]) with open(path, 'rb') as image: await chat.send_photo(image, reply_markup=markup.to_json()) async def img_callback(self, chat, cq, match): await cq.answer() cam = await get_cam(match.group(1), chat) if not cam: return await self.img_handler(chat, cam) @ThreadSwitcherWithDB.optimized async def reg_channel(self, chat: Chat, match): async with db_in_thread(): channel = db.query(Channel).filter( Channel.chat_id == chat.id).one_or_none() if channel: await self.notify_admins(f'Channel {chat.id} already registered!') return await chat.send_text('Choose cam for channel', reply_markup=CamerasChannel().options.to_json()) @ThreadSwitcherWithDB.optimized async def reg_photo_channel(self, chat: Chat, match): async with db_in_thread(): channel = db.query(PhotoChannel).filter( PhotoChannel.chat_id == chat.id).one_or_none() if channel: await self.notify_admins(f'Channel {chat.id} already registered!') return await chat.send_text( 'Choose cam for photo channel', reply_markup=CamerasChannel('choose_photo_cam').options.to_json()) @ThreadSwitcherWithDB.optimized async def choose_cam_callback(self, chat, cq, match): cam = match.group(1) async with db_in_thread(): channel = Channel(chat_id=chat.id, cam=cam) db.add(channel) db.commit() await cq.answer(text=f'Added channel for {cam}') await self.notify_admins(text=f'Added channel {chat.id} for {cam}') @ThreadSwitcherWithDB.optimized async def choose_photo_cam_callback(self, chat, cq, match): cam = match.group(1) async with db_in_thread(): channel = PhotoChannel(chat_id=chat.id, cam=cam) db.add(channel) db.commit() await cq.answer(text=f'Added photo channel for {cam}') await self.notify_admins( text=f'Added photo channel {chat.id} for {cam}') async def post_photo(self, chat, cq, match): cam = match.group(1) photo = match.group(2) cam = conf.cameras[cam] path = Path(conf.root_dir) / 'data' / cam.name / 'imgs' if cam.resize: path /= 'original' path = path / '_'.join(photo.split('_')[:3]) / photo await self._post_photo(cam, path) await cq.answer() @ThreadSwitcherWithDB.optimized async def _post_photo(self, cam: Cam, photo: Path): async with db_in_thread(): channels = db.query(PhotoChannel).filter( PhotoChannel.cam == cam.name).all() for channel in channels: chat = Chat(self._bot, channel.chat_id) with open(photo, 'rb') as ph: await chat.send_photo(ph) @ThreadSwitcherWithDB.optimized async def notify_admins(self, text, **options): async with db_in_thread(): admins = db.query(Admin).all() for admin in admins: await self._bot.send_message(admin.chat_id, text, **options) @ThreadSwitcherWithDB.optimized async def admin_chats(self): async with db_in_thread(): return db.query(Admin).all() async def menu(self, chat, match): await chat.send_text('Menu', reply_markup=self.menu_markup.main_menu.to_json()) async def select(self, chat: Chat, cq, match): await cq.answer() cam = match.group(1) await chat.edit_text(cq.src['message']['message_id'], f'Camera: {cam}', markup=dataclasses.asdict( self.menu_markup.cam_options[cam].markup)) async def back(self, chat, cq, match): await cq.answer() await chat.edit_text(cq.src['message']['message_id'], 'Menu', markup=dataclasses.asdict( self.menu_markup.main_menu)) async def sync_gphotos(self, chat, cq, match): await cq.answer() cam = match.group(1) await chat.edit_text(cq.src['message']['message_id'], f'Choose folder for {cam}', markup=dataclasses.asdict( SyncFolders(cam).folders)) async def run_sync_gphotos(self, chat, cq, match): _folder = match.group(1) folder = Path(conf.root_dir) / 'data' / _folder logger.debug(f'GOING TO SYNC FOLDER {folder}') await cq.answer(text=f'GOING TO SYNC FOLDER {folder}') await self.notify_admins(f'Started sync {folder}') try: await GooglePhotosManager().batch_upload(Path(folder)) except Exception: logger.exception('Sync error!') await self.notify_admins(f'Error with {folder}!') return await self.notify_admins(f'{folder} successfully uploaded!') markup = Markup([[ InlineKeyboardButton(text=f'{_folder}', callback_data=f'remove {_folder}') ]]) await chat.send_text(f'Remove folder {folder.name}', reply_markup=markup.to_json()) async def remove_folder(self, chat, cq, match): await cq.answer(text='Removing folder..') folder = match.group(1) folder = Path(conf.root_dir) / 'data' / folder shutil.rmtree(folder) await chat.send_text('Successfully removed!') async def stats_command(self, chat: Chat, match): try: day = pendulum.from_format(match.group(1), 'DD_MM_YYYY') except IndexError: day = pendulum.today() await self.stats_request(day, chat.send_text) async def lstats_command(self, chat: Chat, match): try: day = pendulum.from_format(match.group(1), 'DD_MM_YYYY') except IndexError: day = pendulum.today() await self.stats_request(day, chat.send_text) @ThreadSwitcherWithDB.optimized async def db_data(self, chat: Chat, match): async with db_in_thread(): md_data = db_data() await chat.send_text('\n'.join(md_data), parse_mode='Markdown') async def stats_request(self, day: pendulum.DateTime, send_command): logger.info(f'Getting stats info for {day}') try: markdown_result = await self.local_stats_handler(day) except Exception: logger.exception('Error during stats request') await send_command('Error during request stats') return day = day.format('DD_MM_YYYY') markup = Markup([[ InlineKeyboardButton(text='check', callback_data=f'check_cb {day}') ], [ InlineKeyboardButton(text='clear', callback_data=f'clear_cb {day}') ]]) await send_command('\n'.join(markdown_result), parse_mode='Markdown', reply_markup=markup.to_json()) async def stats_handler(self, day=None): loop = asyncio.get_event_loop() result = await loop.run_in_executor(None, lambda: stats(day)) album_stats = await self.agent.album_stats(day) markdown_result = [f'#stats *{day.format("DD/MM/YYYY")}*'] for d in result['cameras']: stat = result['cameras'][d] count, size = stat['count'], convert_size(stat['size']) if count: avg = convert_size(stat['size'] / count) else: avg = 0 media_count = album_stats[d] markdown_result.append( f'*{d}*: {count} - {media_count} - {size} - {avg} ') total = convert_size(result['total']) markdown_result.append(f'*total*: {total}') free = convert_size(result['free']) markdown_result.append(f'*free*: {free}') return markdown_result async def local_stats_handler(self, day=None): loop = asyncio.get_event_loop() result = await loop.run_in_executor(None, lambda: stats(day)) markdown_result = [f'#stats *{day.format("DD/MM/YYYY")}*'] for d in result['cameras']: stat = result['cameras'][d] count, size = stat['count'], convert_size(stat['size']) if count: avg = convert_size(stat['size'] / count) else: avg = 0 markdown_result.append(f'*{d}*: {count} - {size} - {avg} ') total = convert_size(result['total']) markdown_result.append(f'*total*: {total}') free = convert_size(result['free']) markdown_result.append(f'*free*: {free}') return markdown_result async def check_album(self, chat, match): cam = await get_cam(match.group(1), chat) if not cam: return day = match.group(2) await self.agent.check_album(cam, day) async def full_check_handler(self, chat, day): logger.info(f'Going to full check for {day}') for cam in conf.cameras_list: try: await self.agent.check_album(cam, day) except Exception: logger.exception( f'Error during check and sync {cam.name} -- {day}') await chat.send_text(f'Error {cam.name} — {day}') continue await chat.send_text(f'Finished with {cam.name} — {day}') msg = f'Finished full check for {day}' logger.info(msg) await chat.send_text(msg) async def full_check(self, chat, match): day = match.group(1) await self.full_check_handler(chat, day) async def full_check_callback(self, chat, cq, match): day = match.group(1) await cq.answer(text=f'Running full check for {day}') await self.full_check_handler(chat, day) async def clear_handler(self, chat, day): logger.info(f'Going to clear for {day}') loop = asyncio.get_event_loop() for cam in conf.cameras_list: try: await loop.run_in_executor(None, lambda: clear_cam_storage(day, cam)) except Exception: logger.exception(f'Error during clear {cam.name} -- {day}') await chat.send_text(f'Error {cam.name} — {day}') continue await chat.send_text(f'Finished with {cam.name} — {day}') logger.info(f'Finished clear for {day}') async def clear_command(self, chat, match): day = match.group(1) await self.clear_handler(chat, day) async def clear_callback(self, chat, cq, match): day = match.group(1) await cq.answer(text=f'Cleaning for {day}') await self.clear_handler(chat, day)
def main(): """Main app""" logger = init_logger() # Loading settings try: setting = { "token": os.environ["FWD_TOKEN"], "keys_path": os.environ["FWD_KEYS_PATH"], "salt": int(os.environ["FWD_SALT"]), "webhook_url": os.environ["FWD_WEBHOOK_URL"], "listen_addr": os.environ.get("FWD_LISTEN_ADDR", "127.0.0.1"), "listen_port": int(os.environ.get("FWD_LISTEN_PORT", 8080)), } except KeyError as err: logger.critical("Setting %s not found. Exit!", err) sys.exit(1) except ValueError: logger.critical( "Invalid setting value. Check `FWD_SALT` or `FWD_LISTEN_PORT`. Exit!" ) sys.exit(1) # Init token module base_dir = os.path.realpath(setting["keys_path"]) if not os.path.isdir(base_dir): logger.critical("Invalid directory in `FWD_KEYS_PATH`: %s", base_dir) sys.exit(1) token = Token(pub_key_path=os.path.join(base_dir, "fwd_pub.pem"), priv_key_path=os.path.join(base_dir, "fwd_priv.pem"), salt=setting["salt"]) # Init bot module parsed_url = urlparse(setting["webhook_url"]) bot = Bot(api_token=setting["token"]) bot_handlers = BotHandlers( token=token, base_api_url="{p.scheme}://{p.netloc}".format(p=parsed_url)) bot.add_command("token", bot_handlers.token_handler) bot.add_command("ping", bot_handlers.ping_handler) bot.add_command("help", bot_handlers.help_handler) try: logger.info("Register webhook...") bot.set_webhook(setting["webhook_url"]) logger.info("Register webhook... OK!") except BotApiError as err: logger.error("Register webhook... ERROR!") logger.critical("Unable to register webhook: %s", err) sys.exit(2) # Init web app app = web.Application() app["bot"] = bot app.on_cleanup.append(bot_shutdown) web_handlers = RestHandlers(token=token, bot=bot) app.add_routes([ web.post("/in", web_handlers.incomming_message), web.get("/v1/message", web_handlers.send_message), web.post("/v1/message", web_handlers.send_message), web.put("/v1/message", web_handlers.update_message), web.delete("/v1/message", web_handlers.delete_message), ]) web.run_app(app, host=setting["listen_addr"], port=setting["listen_port"], access_log=logger) logger.info("Web application closed. Exit!")
class Telegram(Service): chats = {} class TelegramChat(Chat): def __init__(self, service, name, channel): super().__init__(service, name) self.id = "{0}/{1}/{2}".format(service.id, channel.server.name, channel.name) self.channel = channel # async def join(self): # self.service.conn.send("JOIN {}".format(self.name)) # async def send(self, message): #self.service.conn.send("PRIVMSG {0} :{1}".format(self.name, message)) await self.service.conn.send_message(self.channel, message) async def receive(self, message): # Build context text = message.content author = message.author name = author.name if author.id == self.service.conn.user.id: logger.debug("{0}: Message is from us - ignoring.".format( self.service.id)) else: for bridge in self.bridges: await bridge.receive(text, self, name) def __init__(self, bot, id, name, enabled, token): super().__init__() self.bot = bot self.id = id self.name = name self.enabled = enabled self.token = token self.logger.info("Initialising Slack bot {0}".format(id)) def create(self): # Create Slack connection self.conn = Bot(api_token=self.token) # Event registration #self.conn.event(self.on_ready) #self.conn.event(self.on_message) self.conn.add_command(r'.*', self.on_message) def start(self): if self.enabled: self.create() return self.conn.loop() else: logger.info("{0} is currently disabled".format(self.id)) return async def create_chat(self, channel, discord_channel): logger.debug("{0} creating chat for {1}".format( self.id, channel['name'])) chat = self.DiscordChat(self, channel['name'], discord_channel) if 'bridges' not in channel: bridges = [None] else: bridges = channel['bridges'] # Get/create bridges for bridge_name in bridges: bridge = self.bot.get_bridge(bridge_name) bridge.add(chat) chat.bridges.append(bridge) self.chats[chat.channel.id] = chat #await chat.join() #await chat.send("Hello {}!".format(chat.name)) # async def on_join(self, conn, message): # nick = message.prefix.nick # channel = message.parameters[0] # logger.debug("{0}: {1} joined {2}".format(self.id, nick, channel)) # # if nick == self.nick: # # This is us # logger.debug("{0}: We've joined {1}".format(self.id, channel)) # self.chats[channel].joined = True # # async def log(self, conn, message): # logger.debug("{0}: {1}".format(self.id, message)) # async def on_message(self, chat, match): user = chat.sender message = chat.message chat_details = message['chat'] logger.debug( "{0}: message received: [{1} ({2}, {3})] {4} (@{5}) {6}".format( self.id, chat_details['title'], chat.id, chat.type, user['first_name'], user['username'], message['text'])) #channel = message.channel.id #if channel in self.chats: # await self.chats[channel].receive(message) #else: # logger.debug("{0}: Ignoring message in unconfigured channel.".format(self.id)) async def quit(self): logger.debug("{0}: Quitting...".format(self.id)) self.conn.stop() logger.debug("{0}: Disconnected!".format(self.id))