def __init__(self,
master,
worker_name,
bot_name,
server,
access_token,
port=6667,
proxy=None):
self.master = master
self.worker_name = worker_name
self.command = "!" + self.master.bot_name
self.started = False
if proxy is not None:
logging.info('[%s] Proxy set: %s:%s', self.worker_name,
proxy["address"], proxy["port"])
socks.set_default_proxy(socks.HTTP, proxy["address"],
proxy["port"])
socket.socket = socks.socksocket
SingleServerIRCBot.__init__(self, [(server, port, access_token)],
bot_name, bot_name)
# Channels set up
self.channels = IRCDict()
self.channel_join_queue = Queue.Queue()
self.channel_list = []
# Messages set up
self.user_message_queue = Queue.Queue()
logging.info('[%s] Chat worker bot initialized.', self.worker_name)
def __init__(self, channel, nick, server, port=6667, clen=9, db=None, nspw=None):
"""Arguments are straightforward. Exception: if 'db' is not None, it signifies
desire to use an LMDB database as backing storage instead of memory; its
value should be a string containing the name of the database directory.
"""
SingleServerIRCBot.__init__(self, [(server, port)], nick, nick)
if channel:
self.clist = [channel]
else:
self.clist = []
self.clen = clen
self.nspw = nspw
self.chains = {}
self.mlen = 480
if db is not None:
self.env = lmdb.open(db, map_size=4294967296, max_dbs=4096)
with self.env.begin() as txn:
c = txn.cursor()
for i in c.iternext(values=False):
db = self.env.open_db(name=i)
i = i.decode()
self.chains[i] = markov.MarkovGenerator(self.clen, (self.env, db))
else:
self.env = None
def __init__(self, master, worker_name, bot_name, server, access_token, port=6667, proxy=None):
self.master = master
self.worker_name = worker_name
self.command = "!"+self.master.bot_name
self.started = False
self.is_connected = False
if proxy is not None:
logging.info('[%s] Proxy set: %s:%s', self.worker_name, proxy["address"], proxy["port"])
socks.set_default_proxy(socks.HTTP, proxy["address"], proxy["port"])
socket.socket = socks.socksocket
SingleServerIRCBot.__init__(self, [(server, port, access_token)], bot_name, bot_name)
# keep ip for logging
self.proxy_name = socket.gethostbyname(socket.getfqdn())
# Channels set up
self.channels = IRCDict()
self.channel_join_queue = Queue.Queue()
self.channel_list = []
# Messages set up
self.user_message_queue = Queue.Queue()
self.log('Chat worker bot initialized.')
def __init__(self,
chans,
nickname,
nickname_pass,
server,
port=6667,
ssl=False,
ipv6=True,
ident_passwd=None):
print('Connecting to IRC server %s...' % server)
self.chans = chans
self.nickname = nickname
kwargs = {}
if ssl:
import ssl
ssl_factory = irc.connection.Factory(ipv6=True,
wrapper=ssl.wrap_socket)
kwargs['connect_factory'] = ssl_factory
SingleServerIRCBot.__init__(self, [(server, port)], nickname_pass,
'IRC echo bot', **kwargs)
if ident_passwd is not None:
ib3_auth.SASL.__init__(self, [(server, port)], nickname_pass,
'IRC echo bot', ident_passwd, **kwargs)
def __init__(self, channel, server, port=6667, password=None, name="beardbot", noadmin=False):
SingleServerIRCBot.__init__(self, [(server, port, password)], name, "The Beardy-Based Botulator")
# The channel the bot is a member of
self.channel = channel
# The last place a message was recieved from (used by "reply")
self.last_message_sender = self.channel
# If bot should have no administrators
self.noadmin = noadmin
# The loaded modules
self.modules = {}
# list of nicks to ignore
self.ignore = []
# Try to load previously loaded modules
try:
old_modules = pickle.load(open(self.channel + "_modules.db", "r"))
for module in old_modules:
try:
self.load_module(module)
except Exception, e:
traceback.print_exc(file=sys.stdout)
except:
# Otherwise just start the admin
try:
self.load_module("admin")
except Exception, e:
print e
def __init__(self, settings, connect_factory, debug):
self.cfg = settings
self.debug = debug
self.start_time = time.time()
self.channel_list = []
if debug:
self.nickname = 'testbot'
self.realname = 'testbot'
self.channel_list.append(Channel(self.cfg['channel_list'][0], self.nickname, self.cfg['quotes_dir']))
else:
self.nickname = self.cfg['nickname']
self.realname = self.cfg['realname']
for channel in self.cfg['channel_list'][1:]:
self.channel_list.append(Channel(channel, self.nickname, self.cfg['quotes_dir']))
self.ignore_list = []
self.faq_timeout = self.cfg['faq_timeout']
self.last_faq = FAQ_Command.get_latest_faq()
SingleServerIRCBot.__init__(
self,
server_list=[(self.cfg['server'], self.cfg['port'])],
nickname=self.nickname,
realname=self.realname,
connect_factory=connect_factory
)
self.connection.privmsg = self.privmsg
def __init__(self, username, client_id, token, chan, settings):
self.reset_color = attr("reset")
print(
fg("#00ff00") +
"Thanks for using the chatbot! Use Ctrl+C to exit safely." +
self.reset_color)
self.init_logger()
self.client_id = client_id
self.token = token
self.channel = '#' + chan
self.dice_games = []
self.settings = settings
self.database = SQLiteConnector()
self.commands = {
"debug": DebugCommand,
"join": JoinCommand,
"slots": SlotsGame
}
# Initialize the thread cleaner
t_cleaner = ThreadCleaner(self)
t_cleaner.start()
# Create IRC bot connection
server = 'irc.chat.twitch.tv'
port = self.settings["bot_settings"]["port"]
self.logger.info(f'Connecting to {server} on port {port}')
SingleServerIRCBot.__init__(self, [(server, port, token)], username,
username)
def _dispatcher(self, c, e):
et = e.type
if et not in self._events_not_logged():
s = e.source
t = e.target
log.debug(u'{}, {}, {} -- {}'.format(et, s, t, e.arguments))
SingleServerIRCBot._dispatcher(self, c, e)
def run(self):
spec = ServerSpec(self.server)
SingleServerIRCBot.__init__(self, [spec], self.nick, self.realname)
self._connect()
self.lightCheck = 0 # Check only every N loops
self.timestamp = datetime.datetime.now()
self.updateStatus()
feed_read_counter=99
while(self.running):
self.checkLights()
feed_read_counter +=1
if (self.vaasa and feed_read_counter==100):
feed_read_counter = 0
self.read_feed()
self.updateStatus()
try:
self.reactor.process_once(0.2)
except UnicodeDecodeError:
pass
# print 'Somebody said something in non-utf8'
# traceback.print_exc(file=sys.stdout)
except irc.client.ServerNotConnectedError:
print 'Not connected. Can not do anything atm.'
time.sleep(0.5)
def __init__(self, host, port, nickname, password, channel):
logger.debug('TCIBot.__init__ (VERSION = %r)', self.VERSION)
SingleServerIRCBot.__init__(self, [(host, port, password)], nickname,
nickname)
self.channel = channel
self.viewers = []
self.es = Elasticsearch("http://{}:{}".format(
settings.ELK_HOST, settings.ELK_SEARCH_PORT))
def _dispatcher(self, c, e):
eventtype = e.type
source = e.source
if source is not None:
source = str(source)
else:
source = ''
SingleServerIRCBot._dispatcher(self, c, e)
def __init__(self, config, port=6667):
self.config = config
self.nick = config['network']['nick']
self.userpass=config['network']['nickserv']
miscinfo = ServerSpec(config['network']['server'],
port,
config['network']['nickserv'])
SingleServerIRCBot.__init__(self, [miscinfo], self.nick, self.nick)
def __init__(self):
port = config_data['irc_port']
nickname = config_data['irc_nickname']
server = config_data['irc_server']
print "connecting to %s as %s on port %s" % (server, nickname, port)
server_list = [(server, port)]
realname = config_data['irc_realname']
SingleServerIRCBot.__init__(self, server_list, nickname, realname)
self.chans = []
def __init__(self, server='localhost'):
self.channel = CONFIG['irc']['default_channel']
SingleServerIRCBot.__init__(
self, [(CONFIG['irc']['host'], int(CONFIG['irc']['port']))],
CONFIG['irc']['nick'], CONFIG['irc']['nick'])
xmlrpc_host = CONFIG['skype']['xmlrpc_host']
xmlrpc_port = CONFIG['skype']['xmlrpc_port']
self.skype = xmlrpclib.ServerProxy('http://%s:%s' %
(xmlrpc_host, xmlrpc_port))
def die(self, *args, **kwargs):
# Store a list of loaded modules before going down
pickle.dump(self.modules.keys(), open(self.channel + "_modules.db", "w"))
# Kill all the modules
for module in self.modules.values():
module.die()
# Disconnect and quit
SingleServerIRCBot.die(self, *args, **kwargs)
def __init__(self):
""" This initializes the bot with Config values. """
server, channel = Config().UpdateServer.split("#")
host, port = server.split(":")
SingleServerIRCBot.__init__(self, [(host,int(port))], self.makeUserName(), "OlympusIRCUpdater" )
self.channel = "#" + channel
self.connection.buffer_class.errors = 'replace'
self.ping_interval = 60
print "Connecting to the update server. This might take some time..."
print "-------------------------------------------------------------"
def __init__(self, nick, address, port, channels, task, download_dir=u"."):
SingleServerIRCBot.__init__(self, [(address, port)], nick, nick)
self.__recv_bytes = 0
self.task = task
self.filepath = u""
self.download_dir = download_dir
self.chans = channels
self.file = None
self.dcc = None
def __init__(self, channel, key, nickname, server, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
WHGame.__init__(self)
print "Initializing"
self.channel = channel
self.key = key
self.load_assets()
self.load_plugins("round")
self.load_plugins("modifier")
assert(self.rounds)
print "Initialization complete"
def __init__(self, channels, nickname, server, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
# self.connection.add_global_handler('pubmsg', self.on_pubmsg)
self.connection.add_global_handler('join', self.on_join)
self.connection.add_global_handler('welcome', self.on_welcome)
self.mainchannel = channels[0]
self.joined = dict()
for channel in channels:
self.joined[channel] = Event()
self.weboob = None
def __init__(self,
nickname,
server,
port=6667,
allowed_nicks=[],
command=Command):
self.allowed_nicks = allowed_nicks
self.command = command
logger.info(f"Connecting to {server}:{port} with nickname {nickname}")
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
def __init__(self, channel, key, nickname, server, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
WHGame.__init__(self)
print "Initializing"
self.channel = channel
self.key = key
self.load_assets()
self.load_plugins("round")
self.load_plugins("modifier")
assert (self.rounds)
print "Initialization complete"
def __init__(self, channels, nickname, server, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
# self.connection.add_global_handler('pubmsg', self.on_pubmsg)
self.connection.add_global_handler('join', self.on_join)
self.connection.add_global_handler('welcome', self.on_welcome)
self.mainchannel = channels[0]
self.joined = dict()
for channel in channels:
self.joined[channel] = Event()
self.weboob = None
def __init__(self, chans, nickname, server, port=6667, ssl=False):
print('Connecting to IRC server %s...' % server)
if ssl:
import ssl
ssl_factory = irc.connection.Factory(wrapper=ssl.wrap_socket)
SingleServerIRCBot.__init__(self, [(server, port)], nickname, 'IRC echo bot',
connect_factory=ssl_factory)
else:
SingleServerIRCBot.__init__(self, [(server, port)], nickname, 'IRC echo bot')
self.chans = chans
def __init__(self, channels, nickname, nickpass, server, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
self.initial_channels = channels
self.nickpass = nickpass
# magic_key is used for admin commands. E.g., "magic_key say
# test" in a query with the bot triggers the admin command
# "say".
self.magic_key = ''.join([random.choice(string.ascii_letters) for x in range(8)]) + ' '
self.print_magic_key()
self.current_topic = ''
self._timers = []
self._connect()
def __init__(self):
'''
Constructor
'''
self._channels = []
self.username = Setting.get(Setting.key == 'TwitchUsername').value
pw = Setting.get(Setting.key == 'TwitchAuth').value
spec = ServerSpec(Constants.TWITCH_HOST, Constants.TWITCH_PORT, pw)
SingleServerIRCBot.__init__(self, [spec], self.username, self.username)
run_thread = Thread(target=self.start)
run_thread.start()
def __init__(self, server_list, nickname, realname, bavard=True):
'''Doc de SingleServerIRCBot
- irc_list -- A list of ServerSpec objects or tuples of
parameters suitable for constructing ServerSpec
objects. Defines the list of servers the bot will
use (in order).
- nickname -- The bot's nickname.
- realname -- The bot's realname.
'''
SingleServerIRCBot.__init__(self, server_list, nickname, realname)
self.wiki_out = ''
self.bavard = bavard
self.address = ""
def __init__(self): ''' Constructor ''' self._channels = [] self.username = Setting.get(Setting.key=='TwitchUsername').value pw = Setting.get(Setting.key=='TwitchAuth').value spec = ServerSpec(Constants.TWITCH_HOST, Constants.TWITCH_PORT, pw) SingleServerIRCBot.__init__(self, [spec], self.username, self.username) run_thread = Thread(target=self.start) run_thread.start()
def __init__(self, server, channels, nick, nick_pass, port, topic, hist_path):
log.debug("new bot started at %s:%d@#%s as %s", server, port, channels, nick)
SingleServerIRCBot.__init__(self, server_list=[(server, port)], nickname=nick, realname="Mumford J. Hanabot")
self.nick_pass = nick_pass
self.nick_name = nick
self.topic = topic
# this should be in the config file so that different network
# rate limiting polices can be specified. These defaults
# are tuned to freenode.
self.connection.set_rate_limit(2)
game_history.hist_file = hist_path
# force channels to start with #
self.home_channels = [c if c[0] == "#" else "#%s" % c for c in channels]
log.debug("Home channels: %s" % self.home_channels)
# valid bot commands
self.command_dict = {
"Game Management": ["new", "delete", "join", "start", "stop", "leave", "part", "option", "watch"],
"Hand Management": ["move", "swap", "sort"],
"Game Action": ["play", "hint", "discard"],
"Information": [
"help",
"rules",
"turn",
"turns",
"game",
"hints",
"games",
"hands",
"table",
"discardpile",
"version",
"last",
],
}
self.commands = list()
for cmds in self.command_dict.values():
self.commands += cmds
self.commands_admin = ["die"]
# these commands can execute without an active game.
# otherwise the command handlers can assume an active game.
self.no_game_commands = ["new", "join", "help", "rules", "game", "games", "part", "version", "last"]
# games is a dict indexed by channel name, value is the Game object.
self.games = dict()
def __init__(self, conf, tui, all_joined):
SingleServerIRCBot.__init__(self, [(conf.server, conf.port)],
conf.nickname, conf.realname)
self.conf = conf
self.tui = tui
tui.bot = self
self.handler = MessageHandler(conf, self)
self.pollers = []
self.all_joined = all_joined
self.joined = []
for (user, project) in self.conf.issues:
p = IssuePoller(conf, self, user, project)
self.pollers.append(p)
self.tui.msg(u'Poller built for ' + user + '/' + project)
def __init__(self):
config = ConfigParser.SafeConfigParser()
config.read("./config.ini")
self.interpreter = basinterp.BasicInterpreter({})
self.user_list = []
src_dir = os.path.join(os.path.dirname(__file__), unicode(config.get("basic", "src_dir")))
self.interpreter.set_src_dir(src_dir) # default
server = unicode(config.get("irc", "server"))
port = int(config.get("irc", "port"))
nick = unicode(config.get("irc", "nick"))
SingleServerIRCBot.__init__(self, [(server, port)], nick, nick)
self.channel = unicode(config.get("irc", "channel"))
def __init__(self, channels, nickname, server, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
# self.connection.add_global_handler('pubmsg', self.on_pubmsg)
self.connection.add_global_handler('join', self.on_join)
self.connection.add_global_handler('welcome', self.on_welcome)
self.connection.buffer_class.errors = 'replace'
self.mainchannel = channels[0]
self.joined = dict()
for channel in channels:
self.joined[channel] = Event()
self.weboob = None
self.storage = None
self.tasks_queue = []
def __init__(self):
config = ConfigParser.SafeConfigParser()
config.read("./config.ini")
self.interpreter = basinterp.BasicInterpreter({})
self.user_list = []
src_dir = os.path.join(os.path.dirname(__file__),
unicode(config.get("basic", "src_dir")))
self.interpreter.set_src_dir(src_dir) # default
server = unicode(config.get("irc", "server"))
port = int(config.get("irc", "port"))
nick = unicode(config.get("irc", "nick"))
SingleServerIRCBot.__init__(self, [(server, port)], nick, nick)
self.channel = unicode(config.get("irc", "channel"))
def __init__(self, channels, nickname, server, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
# self.connection.add_global_handler('pubmsg', self.on_pubmsg)
self.connection.add_global_handler('join', self.on_join)
self.connection.add_global_handler('welcome', self.on_welcome)
self.connection.buffer_class.errors = 'replace'
self.mainchannel = channels[0]
self.joined = dict()
for channel in channels:
self.joined[channel] = Event()
self.weboob = None
self.storage = None
self.tasks_queue = []
def __init__(self, server_spec, nickname, realname, channels, ssl=False,
shutdown_predicate=None):
log('Connecting to IRC server {0.host}:{0.port:d} ...', server_spec)
connect_params = {}
if ssl:
ssl_factory = Factory(wrapper=ssl_wrap_socket)
connect_params['connect_factory'] = ssl_factory
SingleServerIRCBot.__init__(self, [server_spec], nickname,
realname, **connect_params)
# Note: `self.channels` already exists in super class.
self.channels_to_join = channels
self.shutdown_predicate = shutdown_predicate
def __init__(self, server_list, channel, nickname, realname, bavard=True):
"""Doc de SingleServerIRCBot
- irc_list -- A list of ServerSpec objects or tuples of
parameters suitable for constructing ServerSpec
objects. Defines the list of servers the bot will
use (in order).
- channel -- "#wikipedia-fr"
- nickname -- The bot's nickname.
- realname -- The bot's realname.
"""
SingleServerIRCBot.__init__(self, server_list, nickname, realname)
self.channel = channel
self.wiki_out = ''
self.bavard = bavard
self.address = ""
def __init__(self, config):
SingleServerIRCBot.__init__(self,
[serverOfConfig(config)],
config.settings[Configuration.IRC_UNAME],
config.settings[Configuration.IRC_UNAME])
self.config = config
self.channel = config.settings[Configuration.IRC_CHAN]
self.droplet = None
self.manager = None
if self.config.settings[Configuration.DO_API_KEY]:
try:
key = self.config.settings[Configuration.DO_API_KEY]
if key:
self.manager = digitalocean.Manager(token=key.strip())
except:
print "Couldn't setup a digital ocean manager. Key is bogus?"
self._config_commands()
def __init__(self, botconfig):
"""Setup everything.
| Setup the handler.
| Setup the server.
| Connect to the server.
"""
atexit.register(self.do_shutdown)
self.handler = handler.BotHandler(botconfig)
self.config = botconfig
serverinfo = ServerSpec(botconfig['core']['host'], int(botconfig['core']['ircport']), botconfig['auth']['nickpass'])
nick = botconfig['core']['nick']
SingleServerIRCBot.__init__(self, [serverinfo], nick, nick)
# properly log quits.
self.connection.add_global_handler("quit", self.handle_quit, -21)
# fix unicode problems
self.connection.buffer_class.errors = 'replace'
def __init__(self, site, channel, nickname, server, port=6667, **kwargs):
"""Initializer."""
pywikibot.Bot.__init__(self, **kwargs)
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
self.channel = channel
self.site = site
self.other_ns = re.compile(
'\x0314\\[\\[\x0307(%s)'
% '|'.join(item.custom_name for item in site.namespaces.values()
if item != 0))
self.api_url = (
self.site.apipath()
+ '?action=query&meta=siteinfo&siprop=statistics&format=xml')
self.api_found = re.compile(r'articles="(.*?)"')
self.re_edit = re.compile(
r'^C14\[\[^C07(?P<page>.+?)^C14\]\]^C4 (?P<flags>.*?)^C10 ^C02'
r'(?P<url>.+?)^C ^C5\*^C ^C03(?P<user>.+?)^C ^C5\*^C \(?^B?'
r'(?P<bytes>[+-]?\d+?)^B?\) ^C10(?P<summary>.*)^C'
.replace('^B', '\002').replace('^C', '\003').replace('^U', '\037'))
def __init__(self, site, channel, nickname, server, port=6667, **kwargs):
"""Initializer."""
pywikibot.Bot.__init__(self, **kwargs)
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
self.channel = channel
self.site = site
self.other_ns = re.compile(
'\x0314\\[\\[\x0307(%s)' %
'|'.join(item.custom_name
for item in site.namespaces.values() if item != 0))
self.api_url = (
self.site.apipath() +
'?action=query&meta=siteinfo&siprop=statistics&format=xml')
self.api_found = re.compile(r'articles="(.*?)"')
self.re_edit = re.compile(
r'^C14\[\[^C07(?P<page>.+?)^C14\]\]^C4 (?P<flags>.*?)^C10 ^C02'
r'(?P<url>.+?)^C ^C5\*^C ^C03(?P<user>.+?)^C ^C5\*^C \(?^B?'
r'(?P<bytes>[+-]?\d+?)^B?\) ^C10(?P<summary>.*)^C'.replace(
'^B', '\002').replace('^C', '\003').replace('^U', '\037'))
def __init__(self, botconfig):
"""Setup everything.
| Setup the handler.
| Setup the server.
| Connect to the server.
"""
atexit.register(self.do_shutdown)
self.handler = handler.BotHandler(botconfig)
self.config = botconfig
serverinfo = ServerSpec(botconfig['core']['host'], int(botconfig['core']['ircport']), botconfig['auth']['serverpass'])
nick = botconfig['core']['nick']
if botconfig['core'].getboolean('ssl'):
SingleServerIRCBot.__init__(self, [serverinfo], nick, nick, connect_factory=Factory(wrapper=ssl.wrap_socket))
else:
SingleServerIRCBot.__init__(self, [serverinfo], nick, nick)
# properly log quits.
self.connection.add_global_handler("quit", self.handle_quit, -21)
# fix unicode problems
self.connection.buffer_class.errors = 'replace'
def onStart(self):
# For handelig async stuff
self.waitEvents = {}
SingleServerIRCBot.__init__(self, [(server, port)], nickname, realname)
self.allChannels = channels
self.channel = channels[0] # first chan is default chan
log.info('all configured channels: %s' % self.allChannels)
log.info('configured main channel: %s' % self.channel)
self.secrets = secrets
self.help_hash = {'help':('This menu',{}),
}
self.queue = OutputManager(self.connection, .9)
self.queue.start()
try:
self.start()
except KeyboardInterrupt:
self.connection.quit("Ctrl-C at console")
print "Quit IRC."
except Exception, e:
self.connection.quit("%s: %s" % (e.__class__.__name__, e.args))
def __init__(self, config): #, channel, nickname, password, server, port=6667, debug=False):
self.log("Bot initialized.")
self.config = config
self.DEBUG = config.debug
SingleServerIRCBot.__init__(self, [(config.server, config.port)], config.name, config.name)
self.channel = config.channel
self.nick = config.name
self.nickpassword = config.password
self.connection.add_global_handler("join", getattr(self, "inform_webusers"), 42)
for i in ["kick", "join", "quit", "part", "topic", "endofnames", "notopic"]:
self.connection.add_global_handler(i, getattr(self, "dump_users"), 42)
# We need to distinguish between private and public messages
self.connection.add_global_handler("pubmsg", getattr(self, "publicMessage"), 42)
self.connection.add_global_handler("privmsg", getattr(self, "privateMessage"), 42)
self.connection.add_global_handler("privnotice", getattr(self, "privateMessage"), 42)
self.connection.add_global_handler("notice", getattr(self, "privateMessage"), 42)
# List of active modules
self.activeModules = []
def __init__(self, botconfig):
"""Setup everything.
| Setup the handler.
| Setup the server.
| Connect to the server.
"""
atexit.register(self.do_shutdown)
self.handler = handler.BotHandler(botconfig)
self.handler.workers = workers.Workers(self.handler)
self.config = botconfig
serverinfo = ServerSpec(botconfig['core']['host'], int(botconfig['core']['ircport']), botconfig['auth']['serverpass'])
nick = botconfig['core']['nick']
if botconfig['core'].getboolean('ssl'):
SingleServerIRCBot.__init__(self, [serverinfo], nick, nick, connect_factory=Factory(wrapper=ssl.wrap_socket))
else:
SingleServerIRCBot.__init__(self, [serverinfo], nick, nick)
# properly log quits.
self.connection.add_global_handler("quit", self.handle_quit, -21)
# fix unicode problems
self.connection.buffer_class.errors = 'replace'
def on_ctcp(self, c, e):
xbmc.log(e.arguments)
args = parse_args(e,
(u"protocol", u"opt", u"filename", u"ip", u"port"))
if not args or args[0:2] not in ([u"XDCC", u"SEND"], [u"DCC", u"SEND"
]):
return SingleServerIRCBot.on_ctcp(self, c, e)
self.filepath = os.path.join(self.download_dir, args[2])
self.file = open(self.filepath, u"ab")
self.dcc = self.dcc_connect(*args[3:5] + [u"raw"])
print u"\ndownload started"
def __init__(self, server, channel, nick='hanabot', nick_pass=None, port=6667, topic=None):
log.debug('new bot started at %s:%d@#%s as %s', server, port,
channel, nick)
SingleServerIRCBot.__init__(
self,
server_list=[(server, port)],
nickname=nick,
realname='Mumford J. Hanabot')
self.nick_pass = nick_pass
self.nick_name = nick
self.topic = topic
# force channel to start with #
self.initial_channel = channel if channel[0] == '#' else '#%s' % channel
# valid bot commands
self.command_dict = {
'Game Management': ['new', 'delete', 'join', 'start', 'leave', 'part'],
'Hand Management': ['move', 'swap', 'sort'],
'Game Action': ['play', 'hint', 'discard'],
'Information': ['help', 'rules', 'turn', 'turns', 'game',
'games', 'hands', 'table', 'discardpile']
}
self.commands = list()
for cmds in self.command_dict.values():
self.commands += cmds
self.commands_admin = ['die']
# these commands can execute without an active game.
# otherwise the command handlers can assume an active game.
self.no_game_commands = ['new', 'help', 'rules', 'game', 'games', 'part']
# games is a dict indexed by channel name, value is the Game object.
self.games = dict()
def run(self):
spec = ServerSpec(self.server)
SingleServerIRCBot.__init__(self, [spec], self.nick, self.realname)
self._connect()
self.lightCheck = 0 # Check only every N loops
self.timestamp = datetime.datetime.now()
self.updateStatus()
feed_read_counter=99
mqttclient = paho.Client()
mqttclient.on_subscribe = on_subscribe
mqttclient.on_message = on_message
try:
mqttclient.connect("tunkki9", 1883)
except:
print "mqtt not connected"
mqttclient.loop_start()
mqttclient.subscribe("door/#", qos=1)
while(self.running):
self.checkLights()
self.mqtt_door()
# feed_read_counter +=1
# if (self.vaasa and feed_read_counter==100):
# feed_read_counter = 0
# self.read_feed()
# self.updateStatus()
try:
self.reactor.process_once(0.2)
except UnicodeDecodeError:
pass
# print 'Somebody said something in non-utf8'
# traceback.print_exc(file=sys.stdout)
except irc.client.ServerNotConnectedError:
print 'Not connected. Can not do anything atm.'
time.sleep(0.5)
def on_pubmsg(self, c, e):
cmd = e.arguments[0].split()[0]
if cmd[0] == "!":
cmd = cmd[1:].upper()
if commands.has_key(cmd):
commands[cmd].index(self, c, e)
else:
cmd=e.arguments[0]
if cmd=='!kuole':
self.running = False
SingleServerIRCBot.die(self, 'By your command')
if (cmd=='!ovi') or (cmd=='!door'):
self.sayDoorStatus()
if (cmd=='!valot') or (cmd=='!lights'):
self.say('lights are ' + ('on' if self.lightStatus else 'off'))
if (cmd=='!checksum') or (cmd=='!checksum'):
self.say('pixelvar: ' + str(self.camera.checkSum()))
if (cmd=='!printer') or (cmd=='!tulostin'):
ping_response = subprocess.Popen(["/bin/ping", "-c1", "-w2", self.printer_ip], stdout=subprocess.PIPE).stdout.read()
if ('rtt' in ping_response):
self.say('printer is online')
else:
self.say('printer is offline')
print('p: ' + str(ping_response))
if cmd=='!shot':
self.camera.takeShotCommand()
c.privmsg(self.channel, self.shoturl + ('' if self.lightStatus else ' (pretty dark, eh)'))
if cmd=='!gitpull':
os.system('/home/pi/pajabot/scripts/gitpull.sh')
c.privmsg(self.channel, 'Pulled from git, restarting..')
self.restart_program()
if cmd=='!update':
self.updateStatus()
c.privmsg(self.channel, 'Done')
def __init__(self):
self.path, self.file = os.path.split(_abspath)
self.brain = Brain(u'{}/brain.sqlite'.format(self.path))
config_json = u'{}/config.json'.format(self.path)
rps_json = u'{}/rps.json'.format(self.path)
keys_json = u'{}/keys.json'.format(self.path)
self.config = dbaccess.Config(config_json, rps_json, keys_json)
# Load plugins
for plug_name in self.config.get(u'plugins', list())[:]:
public, private = self.handle_load([u'!load', plug_name])
for m in private:
log.info(m)
self.mb = util.CollectionOfNamedLists(u'{}/mb.json'.format(self.path))
self.tf = util.TitleFetcher()
args = sys.argv[1:]
for arg in args:
if arg.startswith(u'--set-'):
key, value = arg[6:].split(u'=', 1)
print u'Setting \'{}\' to \'{}\'.'.format(key, value)
self.config.set(key, value)
# Set up ignore if the ignore list is non-empty.
ignore = self.config.get(u'msg:ignore', u'')
self.reignore = None
if ignore:
self.reignore = re.compile(ignore, re.IGNORECASE)
server = self.config.get(u'irc:server')
nick = self.config.get(u'irc:nick')
name = self.config.get(u'irc:name')
SingleServerIRCBot.__init__(self, [(server, 6667)], nick, name)
self.connection.buffer_class.errors = u'replace'
def __init__(self, auth, roles, service, channel=None, running=lambda:True):
self.running = running
self.service = None
Interface.__init__(self, service)
self.HOST = "irc.chat.twitch.tv"
self.PORT = 6667
if not channel.startswith("#"):
channel = f"#{channel}"
self.CHANNEL = channel
self.CLIENT_ID = auth["client_id"]
self.TOKEN = auth["token"]
self.USERNAME = auth["username"]
self.ROLES = roles
url = f"https://api.twitch.tv/kraken/users?login={self.USERNAME}"
headers = {"Client-ID": self.CLIENT_ID, "Accept": "application/vnd.twitchtv.v5+json"}
resp = get(url, headers=headers).json()
self.channel_id = resp["users"][0]["_id"]
SingleServerIRCBot.__init__(self, [(self.HOST, self.PORT, f"oauth:{self.TOKEN}")],
self.USERNAME, self.USERNAME, recon=No_Reconnect())
def on_pubmsg(self, c, e):
cmd = e.arguments[0].split()[0]
if cmd[0] == "!":
cmd = cmd[1:].upper()
if commands.has_key(cmd):
commands[cmd].index(self, c, e)
else:
cmd=e.arguments[0]
if cmd=='!kuole':
self.running = False
SingleServerIRCBot.die(self, 'By your command')
if (cmd=='!ovi') or (cmd=='!door'):
self.sayDoorStatus()
if (cmd=='!valot') or (cmd=='!lights'):
self.say('lights are ' + ('on' if self.lightStatus else 'off'))
if (cmd=='!checksum') or (cmd=='!checksum'):
self.say('pixelvar: ' + str(self.camera.checkSum()))
if (cmd=='!printer') or (cmd=='!tulostin'):
self.sayPrinterStatus()
# if (cmd=='!printteri'):
# commands['PRINTTERI'].index(self, c,e)
if cmd=='!shot':
self.camera.takeShotCommand()
c.privmsg(self.channel, self.shoturl + ('' if self.lightStatus else ' (pretty dark, eh)'))
if cmd=='!gitpull':
os.system('/home/ovi/pajabot/scripts/gitpull.sh')
c.privmsg(self.channel, 'Pulled from git, restarting..')
self.restart_program()
if cmd=='!update':
self.updateStatus()
c.privmsg(self.channel, 'Done')
def __init__(self, channel, nick, server, nspw=None, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nick, nick)
self.channel = channel
self.nspw = nspw
def __init__(self, mindfile, blfile, logfile, agefile, real_id, real,
ident, birthday, friend):
SingleServerIRCBot.__init__(self, [(ident.server, ident.port)],
ident.nickname, ident.realname)
self.mindfile = mindfile
self.blfile = blfile
self.logfile = logfile
self.agefile = agefile
# load mind
try:
self.mind = pickle.load(open(mindfile, 'rb'))
except IOError:
print("No markov file (" + mindfile +
") found; making a blank one")
self.mind = Markov(2)
# words that will highlight some nicks, in the form of a dictionary
# from words to the nicks they hilight.
try:
self.blacklist = pickle.load(open(self.blfile, "rb"))
except FileNotFoundError:
self.blacklist = []
class State(dict):
def __getitem__(self, key):
if key not in self:
super(State, self).__setitem__(key, random.getstate())
return super(State, self).__getitem__(key)
# the handle generator
self.handlegen = Markov(2)
for line in open("nicks", "r"):
line = line[:-1] # strip newl
n = []
for c in line:
n.append(MarkovElem(c))
#n = map(MarkovElem, line)
n[0].tags["pos"] = "BEGIN"
n[-1].tags["pos"] = "END"
self.handlegen.learn(n)
try:
self.states = pickle.load(open("rstate", "rb"))
except FileNotFoundError:
self.states = State()
self.waiting_for_friend = queue.Queue() # channels to send lurkers to
self.nick = ident.nickname
self.password = ident.password
self.channel = ident.channel # active channels
self.cafe = ident.cafe
self.rstate = random.getstate() # random state
self.real_id = real_id # whether self.real is a user or a nick
self.real = real # real user she imitates (i.e. avery)
#self.save_counter = 0 # write to disk every 100 talks
self.friend = friend
self.birthday = birthday
def __init__(self, channel, nickname, server, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)], nickname, nickname)
self.channel = channel
def __init__(self, queue, server=IRC_SERVER, port=IRC_PORT, nick=IRC_NICK):
SingleServerIRCBot.__init__(self, [(server, port)], nick, nick)
self.queue = queue
def __init__(self, server, channel, nick, real, port=6667):
SingleServerIRCBot.__init__(self, [(server, port)],
nick, real)
self.channel = channel
def _load_irc_connection(self):
print(f'Connecting to {self.server} on port {str(self.port)}...')
SingleServerIRCBot.__init__(
self, [(self.server, self.port, 'oauth:' + self.token)],
self.username, self.username)
def __init__(self, plugin, channels):
IRCBot.__init__(self, [(plugin.server, plugin.port)], plugin.nick,
plugin.nick)
self.initial_channels = channels
self.plugin = plugin
self.ratelimit = RateLimit()
def handle_connect(self, serverinfo, nick, botconfig):
ipv6 = botconfig.getboolean('ipv6')
if botconfig.getboolean('ssl'):
SingleServerIRCBot.__init__(self, [serverinfo], nick, nick, connect_factory=Factory(wrapper=ssl.wrap_socket, ipv6=ipv6))
else:
SingleServerIRCBot.__init__(self, [serverinfo], nick, nick, connect_factory=Factory(ipv6=ipv6))
