def disco_main(run=False): """ Creates an argument parser and parses a standard set of command line arguments, creating a new :class:`Client`. Returns ------- :class:`Client` A new Client from the provided command line arguments """ from disco.client import Client, ClientConfig from disco.bot import Bot, BotConfig from disco.util.logging import setup_logging # Parse out all our command line arguments args = parser.parse_args() # Create the base configuration object if args.config: config = ClientConfig.from_file(args.config) else: if os.path.exists('config.json'): config = ClientConfig.from_file('config.json') elif os.path.exists('config.yaml'): config = ClientConfig.from_file('config.yaml') else: config = ClientConfig() for arg_key, config_key in six.iteritems(CONFIG_OVERRIDE_MAPPING): if getattr(args, arg_key) is not None: setattr(config, config_key, getattr(args, arg_key)) # Setup the auto-sharder if args.shard_auto: from disco.gateway.sharder import AutoSharder AutoSharder(config).run() return # Setup logging based on the configured level setup_logging(level=getattr(logging, config.log_level.upper())) # Build out client object client = Client(config) # If applicable, build the bot and load plugins bot = None if args.run_bot or hasattr(config, 'bot'): bot_config = BotConfig(config.bot) if hasattr(config, 'bot') else BotConfig() if not hasattr(bot_config, 'plugins'): bot_config.plugins = args.plugin else: bot_config.plugins += args.plugin bot = Bot(client, bot_config) if run: (bot or client).run_forever() return bot or client
def get_client(): from disco.client import ClientConfig, Client from rowboat.config import token config = ClientConfig() config.token = token return Client(config)
def __init__(self, **kwargs): self.db = redis.from_url(kwargs.get('redis_url'), decode_responses=True) discord_config = ClientConfig() discord_config.token = kwargs.get('discord_token') discord_client = Client(discord_config) self.api = discord_client.api self.log = logging.getLogger(self.__class__.__name__).info
def disco_main(run=False): """ Creates an argument parser and parses a standard set of command line arguments, creating a new :class:`Client`. Returns ------- :class:`Client` A new Client from the provided command line arguments """ args = parser.parse_args() from disco.client import Client, ClientConfig from disco.bot import Bot, BotConfig from disco.util.token import is_valid_token from disco.util.logging import setup_logging if os.path.exists(args.config): config = ClientConfig.from_file(args.config) else: config = ClientConfig() for k, v in six.iteritems(vars(args)): if hasattr(config, k) and v is not None: setattr(config, k, v) if not is_valid_token(config.token): print('Invalid token passed') return if args.shard_auto: from disco.gateway.sharder import AutoSharder AutoSharder(config).run() return if hasattr(config, 'logging_format'): setup_logging(level=logging.INFO, format=config.logging_format) else: setup_logging(level=logging.INFO) client = Client(config) bot = None if args.run_bot or hasattr(config, 'bot'): bot_config = BotConfig(config.bot) if hasattr(config, 'bot') else BotConfig() if not hasattr(bot_config, 'plugins'): bot_config.plugins = args.plugin else: bot_config.plugins += args.plugin bot = Bot(client, bot_config) if run: (bot or client).run_forever() return (bot or client)
def __init__(self, token, channel_id): """Creates a new message in the given `channel_id`.""" super(DiscordIO, self).__init__() config = ClientConfig() config.token = token client = Client(config) self.text = self.__class__.__name__ try: self.message = client.api.channels_messages_create(channel_id, self.text) except Exception as e: tqdm_auto.write(str(e))
def _on_rpc_request(self, op, data): log.info('RPC REQUEST: %s', op) if op == 'INIT' and not self.client: config = ClientConfig() config.token = data['token'] config.state = { 'sync_guild_members': False, 'track_messages': False } self.client = Client(config) self.state = self.client.state self._bind_events() elif op == 'DISPATCH': self._on_dispatch(*data)
def __init__(self, *args, **kwargs): self.broker_url = config.BROKER_URL or DEFAULT_BROKER_URL self.redis_url = config.REDIS_URL or DEFAULT_BROKER_URL self.log = logging.getLogger('worker').info self.redis = redis.from_url(self.redis_url, decode_responses=True) self.log('Connected to redis database') discord_config = ClientConfig() discord_config.token = config.MEE6_TOKEN discord_client = Client(discord_config) self.api = discord_client.api self.listeners = [] self.plugins = []
def start_disco(self): setup_logging(level=logging.DEBUG) self.config = ClientConfig.from_file("./secrets/discord.json") self.client = Client(self.config) self.bot_config = BotConfig(self.config.bot) self.bot = Bot(self.client, self.bot_config) self.bot.main_process_recv = self.main_process_recv return self.bot.client.run()
def run_bot(): from gevent import monkey monkey.patch_all() #patch_MessageTable() parser = argparse.ArgumentParser() parser.add_argument('--token', help="discord api auth token", default=None) parser.add_argument('--log-level', help='log level', default="INFO") if not os.path.exists(CONFIG_FILE): print("%s missing, pls fix" % CONFIG_FILE) exit() config = ClientConfig.from_file(CONFIG_FILE) args = parser.parse_args() if args.log_level: setup_logging(level=getattr(logging, args.log_level.upper())) if args.token is not None: config.token = args.token if not is_valid_token(config.token): print("the token '%s' isn't valid" % config.token) exit() client = Client(config) bot_config = BotConfig(config.bot) # get plugin files # todo: support multilevel nested plugins _, _, filenames = next(os.walk("plugins"), (None, None, [])) filenames.remove("__init__.py") # convert plugins from ayylmao.py to plugins.ayylmao filenames = ["plugins.%s" % os.path.splitext(p)[0] for p in filenames] # remove disabled plugins from plugin array filenames = [p for p in filenames if p not in config.disabled_plugins] bot_config.plugins = filenames if len(bot_config.plugins) > 0: print("discovered plugins:") for p in bot_config.plugins: print(" - %s" % p) else: print("no plugins found") bot = Bot(client, bot_config) bot.run_forever()
def __init__(self, *args, **kwargs): self.broker_url = kwargs.get('broker_url', 'redis://localhost') self.redis_url = kwargs.get('redis_url', 'redis://localhost') self.log = logging.getLogger('worker').info self.redis = redis.from_url(self.redis_url, decode_responses=True) self.log('Connected to redis database') discord_config = ClientConfig() discord_config.token = kwargs.get('discord_token') discord_client = Client(discord_config) self.api = discord_client.api self.listeners = [] self.plugins = []
def __init__(self): setup_logging(level=logging.WARNING) self.client_config = ClientConfig() self.client_config.token = app.config['DISCORD_BOT_TOKEN'] self.client = Client(self.client_config) self.bot = Bot(self.client) self.bot.add_plugin(RwrsBotDiscoPlugin)
def load(self, config=None, state=None): super().load(config=config, state=state) conf = ClientConfig() conf.token = self.config.get('token') conf.max_reconnects = 0 self.client = Client(conf) self.client.parent = self self.client.agent = self.agent self.bot = None bot_config = BotConfig() bot_config.commands_require_mention = False bot_config.commands_prefix = self.config.get('command_prefix', '.') bot_config.levels = self.config.get('access', {}) bot_config.commands_level_getter = self.level_getter self.bot = Bot(self.client, bot_config) for unique_id, pconf in self.config.get('plugins').items(): if pconf is None: pconf = {} pconf.setdefault("_autoload", True) pconf.setdefault("_module", unique_id) if not pconf["_autoload"]: continue self.bot.add_plugin_module(pconf["_module"], pconf) #TODO: replace for _, plugin in self.bot.plugins.items(): plugin.parent = self self.bot.agent = self.agent self.bot.parent = self self.me = self.client.api.users_me_get()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if 'token' not in self.serverdata: raise ProtocolError("No API token defined under server settings") self.client_config = ClientConfig({'token': self.serverdata['token']}) self.client = Client(self.client_config) self.bot_config = BotConfig() self.bot = Bot(self.client, self.bot_config) self.bot_plugin = DiscordBotPlugin(self, self.bot, self.bot_config) self.bot.add_plugin(self.bot_plugin) #setup_logging(level='DEBUG') self._children = {} self.message_queue = queue.Queue()
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if 'token' not in self.serverdata: raise ProtocolError("No API token defined under server settings") client_config = ClientConfig({'token': self.serverdata['token'], 'max_reconnects': 0}) self.client = Client(client_config) bot_config = BotConfig() self.bot = Bot(self.client, bot_config) self.bot_plugin = DiscordBotPlugin(self, self.bot, bot_config) self.bot.add_plugin(self.bot_plugin) self._children = {} self.message_queue = queue.Queue() self.webhooks = {} self._message_thread = None
def createBot(self): # Create the base configuration object config = ClientConfig.from_file( '/home/nathan/PYTHON/WORKING-USE-THIS!!!/src-3.0/config/discordconfig.json' ) # Setup logging based on the configured level setup_logging(level=getattr(logging, config.log_level.upper())) # Build our client object self.client = Client(config) # If applicable, build the bot and load plugins bot_config = BotConfig(config.bot) self.bot = Bot(self.client, bot_config) #self.bot.add_plugin(TutPlugin, config) # This is how we would add plugins, TugPlugin would be a class self.apiClient = self.bot.client.api self.startMainBotLoop() (self.bot or self.client).run_forever()
def disco_main(): """ Creates an argument parser and parses a standard set of command line arguments, creating a new :class:`Client`. Returns ------- :class:`Client` A new Client from the provided command line arguments """ args = parser.parse_args() config = ClientConfig.from_file('config.yaml') config.token = credentials['discord_login']['beta'] if args.log_level: config.log_level = args.log_level setup_logging(level=getattr(logging, config.log_level.upper())) bot_config = BotConfig(config.bot) bot = ConnectBot(Client(config), bot_config) bot.run_forever()
def disco_main(run=False): """ Creates an argument parser and parses a standard set of command line arguments, creating a new :class:`Client`. Returns ------- :class:`Client` A new Client from the provided command line arguments """ from gevent import monkey monkey.patch_all() from disco.client import Client, ClientConfig from disco.bot import Bot, BotConfig from disco.util.token import is_valid_token from disco.util.logging import setup_logging config = ClientConfig.from_file('config.yaml') if not is_valid_token(config.token): print('Invalid token passed') return setup_logging(level='WARN') client = Client(config) bot_config = BotConfig(config.bot) bot = Bot(client, bot_config) from db import ChartingDao bot.db = ChartingDao() bot.run_forever() return bot
def setup_config(args): if os.path.exists(args.config): config = ClientConfig.from_file(args.config) else: config = ClientConfig() return config
from gevent.monkey import patch_all; patch_all() import logging from os import environ from disco.bot import Bot, BotConfig from disco.client import Client, ClientConfig from disco.util.logging import setup_logging setup_logging(level=logging.INFO) config = ClientConfig.from_file("config.json") config.token = environ['token'] client = Client(config) bot_config = BotConfig(config.bot) bot = Bot(client, bot_config) if __name__ == '__main__': bot.run_forever()
def disco_main(run=False): """ Creates an argument parser and parses a standard set of command line arguments, creating a new :class:`Client`. Returns ------- :class:`Client` A new Client from the provided command line arguments """ args = parser.parse_args() from disco.client import Client, ClientConfig from disco.bot import Bot, BotConfig from disco.util.token import is_valid_token from disco.util.logging import setup_logging if os.path.exists(args.config): config = ClientConfig.from_file(args.config) else: config = ClientConfig() config.manhole_enable = args.manhole if args.manhole_bind: config.manhole_bind = args.manhole_bind for k, v in six.iteritems(vars(args)): if hasattr(config, k) and v is not None: setattr(config, k, v) if not is_valid_token(config.token): print('Invalid token passed') return if args.shard_auto: from disco.gateway.sharder import AutoSharder AutoSharder(config).run() return # TODO: make configurable setup_logging(level=getattr(logging, args.log_level.upper())) client = Client(config) bot = None if args.run_bot or hasattr(config, 'bot'): bot_config = BotConfig(config.bot) if hasattr(config, 'bot') else BotConfig() if not hasattr(bot_config, 'plugins'): bot_config.plugins = args.plugin else: bot_config.plugins += args.plugin if args.http_bind: bot_config.http_enabled = True host, port = args.http_bind.split(':', 1) bot_config.http_host = host bot_config.http_port = int(port) bot = Bot(client, bot_config) if run: (bot or client).run_forever() return (bot or client)
def get_client(): from disco.client import ClientConfig, Client config = ClientConfig() config.token = bot_config.token return Client(config)
from disco.bot import Plugin from disco.client import ClientConfig, Client, APIClient from disco.types.channel import MessageIterator from disco.types.permissions import Permissions from datetime import datetime from util.encoders import MessageEncoder from util.toCSV import toCSVLine with open('./config.json') as file: #Pull config variables from file data = json.load(file) AUTH_TOKEN = data['token'] DEBUG = data['debug'] mConfig = ClientConfig() mConfig.token = AUTH_TOKEN mClient = Client(mConfig) class ArchivePlugin(Plugin): @Plugin.command('ping') def command_ping(self, event): event.msg.reply('Pong!') @Plugin.command('archive', parser=True) @Plugin.parser.add_argument('--JSON', help="Archive in JSON format", action="store_true", default=False) @Plugin.parser.add_argument('--CSV',
def setUp(self): self.client = Client(ClientConfig({'config': 'TEST_TOKEN'})) self.bot = MockBot(self.client)
def disco_main(run=False): """ Creates an argument parser and parses a standard set of command line arguments, creating a new :class:`Client`. Returns ------- :class:`Client` A new Client from the provided command line arguments """ from disco.client import Client, ClientConfig from disco.bot import Bot, BotConfig from disco.util.logging import setup_logging, LOG_FORMAT from bot.base import bot args = bot.local.disco # Create the base configuration object if args.config: config = ClientConfig.from_file(args.config) else: config = ClientConfig(args.to_dict()) for arg_key, config_key in six.iteritems(CONFIG_OVERRIDE_MAPPING): if getattr(args, arg_key) is not None: setattr(config, config_key, getattr(args, arg_key)) # Setup the auto-sharder if args.shard_auto: from disco.gateway.sharder import AutoSharder AutoSharder(config).run() return # Setup logging based on the configured level if not os.path.exists("logs"): os.makedirs("logs") file_handler = logging.FileHandler("logs/bot.log") file_handler.setFormatter(logging.Formatter(LOG_FORMAT)) file_handler.setLevel(config.log_level.upper()) stream_handler = logging.StreamHandler() setup_logging( handlers=(file_handler, stream_handler), level=getattr(logging, config.log_level.upper()), ) # Build out client object client = Client(config) # If applicable, build the bot and load plugins bot = None if args.run_bot or hasattr(config, 'bot'): bot_config = BotConfig(config.bot.to_dict()) if hasattr( config, 'bot') else BotConfig() if not hasattr(bot_config, 'plugins'): bot_config.plugins = args.plugin else: bot_config.plugins += args.plugin bot = Bot(client, bot_config) if run: (bot or client).run_forever() return (bot or client)