def register_user(message): reply_message = 'Welcome ' + \ str(message.from_user.first_name) + ' to F1 predictions!' try: cursor.execute("SELECT * FROM users WHERE username=?", (message.from_user.username, )) user = cursor.fetchall() except mariadb.Error as e: logger.error( f'Error SELECTING FROM users WHERE username... MariaDB output: {e}' ) if not user: try: cursor.execute( "INSERT IGNORE INTO users (username,user_id,points) VALUES (?, ?, ?)", (message.from_user.username, message.from_user.id, 0)) conn.commit() except mariadb.Error as e: logger.error(f'Error INSERTING username... MariaDB output: {e}') bot.reply_to(message, reply_message) logger.info('User created in database') return True bot.reply_to(message, "Wait, are you registered? I think so...")
def handle_exception(e): exc_type, exc_obj, exc_tb = sys.exc_info() fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1] logger.error(e) logger.debug("{} {} {}".format(exc_type, fname, exc_tb.tb_lineno)) logger.debug(traceback.format_exc()) logger.critical( "Provider does not have method correctly implemented cannot continue" ) tt = threading.Thread(target=thread_shutdown, args=()) tt.start() # (schedule_shutdown, args=(), id='shutdown')
async def execute(self, ctx, *, query): conn = await self.bot.connpool.acquire() try: await conn.execute(f"""{query}""") await ctx.message.add_reaction('\U00002705') logger.info(f"Successfully executed query: '{query}' on PG DB") except Exception as e: await ctx.message.add_reaction('\U0000274c') logger.error( f"Failed execute of query: '{query}' on PG DB - Error: {e}") finally: await self.bot.connpool.release(conn)
async def reload(self, ctx, cog: str): """Reload a cog""" try: self.bot.unload_extension(cog) except Exception as e: logger.error( f"Attempted to unload cog: {cog} which was never loaded on start up. Bypassing and attempting " f"to complete function.") self.bot.load_extension(cog) logger.info(f"Successfully reloaded extension: {cog}") await ctx.send(f"`{cog}` successfully reloaded.")
async def load(self, ctx, ext): """Load an Extension. """ print(f'{ctx.author.name} loading {ext}') try: check = path(f'extensions/{ext}.py') if not check.exists() or ext == 'AdminCommands': return await ctx.send(f'{ext} is not a valid extension.') self.bot.load_extension(f'extensions.{ext}') logger.warning(f'{ext} Loaded by {ctx.author.name}') print(f'{ext} Loaded') return await ctx.send(f'{ext} Loaded') except Exception as e: logger.error(f'Error loading {ext}. Error: {e}') logger.error(traceback.print_exc()) return print(e)
def get_list(message): try: cursor.execute("SELECT * FROM users") users_fetched = cursor.fetchall() except mariadb.Error as e: logger.error(f'Error SELECTING FROM users... MariaDB output: {e}') users = [] for user in users_fetched: users.append(User(user[0], user[1], user[2])) ordered_users = sorted(users, key=lambda x: x.points, reverse=True) table = create_standings_table(ordered_users) bot.send_message(message.chat.id, f'<pre>{table}</pre>', parse_mode=ParseMode.HTML)
def start_bot( logger, args ): """Create TahmatassuBot Arguments: logger {Logger} -- logger args {dict} -- Command line arguments """ try: config = ConfigParser() config.read(args.config) tahmatassu = TahmaTassuBot(token=config['DEFAULT']['token'], tahmatassu_base_url=config['DEFAULT']['tahmatassuapi'], bot_name=config['DEFAULT']['botname']) tahmatassu.run() except Exception as error: logger.error(error) logger.exception("message")
async def reload(self, ctx, ext): """ Reload an extension. """ print(f'{ctx.author.name} reloading {ext}') try: check = path(f'extensions/{ext}.py') if not check.exists(): return await ctx.send(f'{ext} is not a valid extension') self.bot.unload_extension(f'extensions.{ext}') print(f'{ext} Unloaded') self.bot.load_extension(f'extensions.{ext}') print(f'{ext} Loaded') logger.warning(f'{ext} Reloaded by {ctx.author.name}') return await ctx.send(f'{ext} Reloaded') except Exception as e: logger.error(f'Error reloading {ext}. Error: {e}') logger.error(traceback.print_exc()) print(e)
def update(self): self._unknown_options = [] try: tmp_data = read_json_file(self._file) except json.decoder.JSONDecodeError: logger.error("runtime file error reading") return if tmp_data is None: self.dump() return for key, value, in tmp_data.items(): if key.startswith('_'): continue if hasattr(self, key): setattr(self, key, value) else: self._unknown_options.append(key) if len(self._unknown_options) > 0: logger.debug("Unknown options were passed in [{}]".format(','.join( self._unknown_options)))
async def on_command_error(self, ctx, error): """Activates when an exception arises""" if hasattr(ctx.command, 'on_error'): return logger.debug("Exception found but handled by command's own error handler.") error = getattr(error, 'original', error) if isinstance(error, commands.CommandNotFound): return logger.error(f"{str(ctx.author.id)} called the bot's prefix but no corresponding command located.") if isinstance(error, commands.MissingRequiredArgument): logger.error(f"{str(ctx.author.id)} invoked the command '{ctx.command.name}' but missed required " f"arguments.") return await ctx.error(f"Required arguments missed. {self.bot.command_prefix}help <command> for indepth usage.") elif isinstance(error, commands.CheckFailure): logger.debug(f"{str(ctx.author.id)} invoked the command '{ctx.command.name}' but didn't meet the checks.") return await ctx.error("You do not meet the relevant checks inorder to invoke this command.") else: logger.error(f"Exception '{type(error).__name__}' raised in command when {ctx.author.id} invoked " f"'{ctx.command}' {error}")
async def on_ready(self): self.connpool = await postgresconn() for cog in cogs: try: self.load_extension(cog) logger.info(f'Successfully loaded extension: {cog}') except Exception as e: logger.error(f'Failed to load extension: {cog}\n{e}') self.load_extension('jishaku') logger.info(f'Client Logged in at {datetime.now()}') await self.change_presence(activity=discord.Game( name=f"Shard {str(self.shard_count)} | " f"{str(len(self.guilds))} Guilds")) conn = await self.connpool.acquire() message_count = await conn.fetch( '''SELECT messages_handled FROM bot_stats WHERE user_id=579399080799633448''' ) self.message_count = int(message_count[0][0]) await self.connpool.release(conn)
async def send_photo(bot: Bot, repo: Repo, user_id: int, photo, caption: str, disable_notification: bool = False): """ Безопасная рассылка :param repo: :param bot: :param caption: :param photo: :param user_id: :param disable_notification: :return: """ try: await bot.send_photo(chat_id=user_id, photo=photo, caption=caption, disable_notification=disable_notification) except exceptions.BotBlocked: logger.error( f"Пользователь [ID:{user_id}]: Бот заблокирован пользователем") await repo.delete_customer(user_id) except exceptions.ChatNotFound: logger.error(f"Пользователь [ID:{user_id}]: Неверный ID пользователя") except exceptions.RetryAfter as e: logger.error( f"Пользователь [ID:{user_id}]: Достигнут лимит рассылки. Засыпаю на {e.timeout} секунд." ) await asyncio.sleep(e.timeout) return await send_photo(user_id=user_id, photo=photo, caption=caption) # Recursive call except exceptions.UserDeactivated: logger.error( f"Пользователь [ID:{user_id}]: Аккаунт деактивирован/удалён") except exceptions.TelegramAPIError: logger.exception(f"Пользователь [ID:{user_id}]: Провалено") except exceptions.BotKicked: logger.exception( f"Бот был удален из группы. Удаляю [ID:{user_id}] из базы") await repo.delete_customer(user_id) else: logger.info(f"Пользователь [ID:{user_id}]: Успешно")
def connect(organization: Organization) -> Organization: try: client_id = current_app.config.get('BOT_CLIENT_ID') client_secret = current_app.config.get('BOT_CLIENT_SECRET') identity = authenticate(organization.organization_uid, client_id, client_secret) organization.token = identity.token organization.domain = identity.domain organization.token_expires_at = identity.expires db.session.add(organization) db.session.flush() except ApiError as api_error: logger.error('Received error response from API: %s' % api_error.message) # Any 4xx errors at this stage means our error if 400 <= api_error.status < 500: message = ('Unable to connect organization due to internal ' ' error. Please contact bot developer.') raise exceptions.InternalServerError( payload={'detail': message}) from api_error else: raise exceptions.BadRequest(message='API Error', payload={'detail': api_error.message }) from api_error except exc.IntegrityError as integrity_error: logger.error(integrity_error) db.session.rollback() raise exceptions.OrganizationConnect( message='Already connected', payload={'detail': 'Requested organization already connected.'}) except (exc.SQLAlchemyError, RequestException) as internal_error: logger.error(internal_error) db.session.rollback() raise exceptions.InternalServerError( payload={'detail': 'Unable to connect organization.'}) else: db.session.commit() logger.info('Organization %s successfully connected' % organization.organization_uid) return organization
def error(bot, update, error): logger.error('Update "%s" caused error "%s"' % (update, error))
def runtime_error(message): logger.error("Runtime error: {}".format(message))
async def initialize_iterator(self): ts = int(time.time() * 1000) try: async with websockets.connect(ws) as client: # Logging in websocket server if self._name: await client.send( json.dumps({ 'op': 'login', 'args': { 'key': self._key, 'subaccount': self._name, 'sign': hmac.new(self._secret.encode(), f'{ts}websocket_login'.encode(), 'sha256').hexdigest(), 'time': ts } }).encode()) else: await client.send( json.dumps({ 'op': 'login', 'args': { 'key': self._key, 'sign': hmac.new(self._secret.encode(), f'{ts}websocket_login'.encode(), 'sha256').hexdigest(), 'time': ts } }).encode()) # Subscribing for data listening if isinstance(self._currency, list): for currency in self._currency: await client.send( json.dumps({ 'op': 'subscribe', 'channel': 'ticker', 'market': currency })) else: # Subscribing for data listening await client.send( json.dumps({ 'op': 'subscribe', 'channel': 'ticker', 'market': self._currency })) # If we didnt subscribe for a stream, than there is a problem resp = json.loads(await client.recv()) if not resp.get('type') == 'subscribed': print(resp) logger.error('Didnt subscribe') return # Listening to the stream of data while True: yield json.loads(await client.recv()) except Exception as e: logger.error(e, repr(e))