def __init__(self, *,
hostname="localhost", port=6667, ssl=False,
nickname=None, username=None, realname=None, password=None,
channels=[]):
"""
Initialize the actual IRC client and register callback methods.
"""
self.logger.info("Creating Protocol instance.")
self.nickname = nickname
self.password = password
self.username = username
self.realname = realname
self.channels = channels
self.logger.debug("Registering callback methods.")
self.irc = bottom.Client(hostname, port, ssl=ssl)
self.event_handler("PING")(self.keepalive)
self.event_handler("CLIENT_CONNECT")(self.register)
self.event_handler("CLIENT_DISCONNECT")(self.reconnect)
self.event_handler("RPL_WELCOME")(self.join)
self.fake_ping = functools.partial(
self.irc.trigger, "PING", message="keepalive")
def __init__(self, parent, config):
self.config = config
self.irc = bottom.Client(host=config['host'].get(),
port=config['port'].get(),
ssl=config['ssl'].get())
@self.irc.on('CLIENT_CONNECT')
async def connect(**kwargs):
self.irc.send('NICK', nick=config['nick'].get())
self.irc.send('USER',
user=config['username'].get(),
realname='https://devse.wiki/')
done, pending = await asyncio.wait(
[self.irc.wait('RPL_ENDOFMOTD'),
self.irc.wait('ERR_NOMOTD')],
return_when=asyncio.FIRST_COMPLETED)
for future in pending:
future.cancel()
# FIXME: maybe a cleaner way to do this with confuse (maybe I'll just drop confuse)
try:
self.irc.send('PRIVMSG',
target="nickserv",
message=f"IDENTIFY {config['nickserv'].get()}")
except BaseException:
pass
self.irc.send('JOIN', channel=config['channel'].get())
@self.irc.on('privmsg')
async def irc_message(nick, target, message, **kwargs):
if nick == config['nick'].get():
return
if target == config['nick'].get():
if message == '\001VERSION\001':
def gnuify(x):
return 'GNU/Linux' if x == 'Linux' else x
self.irc.send(
'NOTICE',
target=nick,
message=
f"\001VERSION devse-chan on {gnuify(platform.system())}\001"
)
elif message == '\001SOURCE\001':
self.irc.send(
'NOTICE',
target=nick,
message=
'\001SOURCE https://github.com/d0p1s4m4/devse-chan\001'
)
elif target != config['channel'].get():
return
await parent.to_discord(nick, message)
@self.irc.on('PING')
async def irc_ping(message, **kwargs):
self.irc.send('PONG', message=message)
def __init__(self, nick, channels, noiselevel=5):
self.nick = nick
self.channels = channels
self.noiselevel = noiselevel
self.client = bottom.Client(host=host, port=port, ssl=ssl)
self.client.on('CLIENT_CONNECT', self.handle_connect)
self.client.on('PING', self.keepalive)
self.client.on('PRIVMSG', self.message)
self.client.on('RPL_WELCOME', self.loop)
self.silence = False
def __init__(self, xanmel, config):
self.connected = False
self.joined = False
self.reconnect_interval = 0
super(IRCModule, self).__init__(xanmel, config)
self.client = bottom.Client(host=config['host'],
port=config['port'],
ssl=config['ssl'],
loop=self.loop)
self.message_queue = asyncio.Queue(maxsize=config.get('flood_max_queue_size', 1024))
self.msg_lock = asyncio.Lock()
self.challenge_reply = None
def __init__(self, discordChannel, host, port, ircChannel, nickname,
discordBot):
self.discordChannel = discordChannel
self.host = host
self.port = port
self.ircChannel = ircChannel
self.nickname = nickname
self.discordBot = discordBot
self.ircclient = bottom.Client(host=host, port=port, ssl=False)
self.ircclient.on('CLIENT_CONNECT', self.connect)
self.ircclient.on('PING', self.keepalive)
self.ircclient.on('PRIVMSG', self.on_message)
self.loop = asyncio.get_event_loop()
self.task = self.loop.create_task(self.ircclient.connect())
async def connect_irc(apps, serviceid, auth_token):
print("Connecting to IRC...")
conn = bottom.Client("localhost", 6667, ssl=False, loop=loop)
await conn.connect()
conn.send("NICK", nick="matrix")
conn.send("USER", user="******", realname="apps")
# Temp join for testing
conn.send('JOIN', channel=room)
# Tempt send for testing
conn.send('PRIVMSG', target=room, message="Hello")
return conn, serviceid
async def run(self):
self.client = bottom.Client(host=self.ircserver,
port=self.ircport,
ssl=self.ssl)
self.client.on('CLIENT_CONNECT', self.handle_connect)
self.client.on('CLIENT_DISCONNECT', self.handle_disconnect)
self.client.on('RPL_WELCOME', self.handle_welcome)
self.client.on('RPL_MYINFO', self.handle_myinfo)
self.client.on('PING', self.handle_ping)
self.client.on('PRIVMSG', self.handle_privmsg)
self.client.on('JOIN', self.handle_join)
self.client.on('PART', self.handle_part)
self.client.on('KICK', self.handle_kick)
self.client.on('QUIT', self.handle_quit)
self.client.on('NICK', self.handle_nick)
self.client.on('RPL_NAMREPLY', self.handle_namreply)
await self.client.connect()
import bottom, asyncio, logging, random
from tbot.twitch_bot.unpack import rfc2812_handler
from tbot import config
'''
Used for sending messages to channels so we can log
the bots own messages on the main connection.
'''
bot_sender = bottom.Client('a', 0)
bot_sender.pong_check_callback = None
bot_sender.ping_callback = None
bot_sender.raw_handlers = [rfc2812_handler(bot_sender)]
def setup(bot):
bot_sender.host = config['twitch']['irc_host']
bot_sender.port = config['twitch']['irc_port']
bot_sender.ssl = config['twitch']['irc_use_ssl']
@bot_sender.on('CLIENT_CONNECT')
async def connect(**kwargs):
if bot_sender.pong_check_callback:
bot_sender.pong_check_callback.cancel()
if bot_sender.ping_callback:
bot_sender.ping_callback.cancel()
bot_sender.ping_callback = asyncio.ensure_future(send_ping(10))
if config['twitch']['chat_token']:
bot_sender.send('PASS',
password='******'.format(
config['twitch']['chat_token']))
import spoilerbot.srl as srl
import spoilerbot.sg as sg
# our special asyncio version of pyz3r
import pyz3r_asyncio
config = cfg.get_config()
# discord bot using discord.py rewrite
discordbot = commands.Bot(command_prefix=config['cmd_prefix'], )
discordbot.load_extension("spoilerbot.verifiers")
discordbot.load_extension("spoilerbot.eggs")
discordbot.load_extension("spoilerbot.admin")
# irc bot using bottom, an very, very low level async irc client
ircbot = bottom.Client(host='irc.speedrunslive.com', port=6667, ssl=False)
#setup logging configuration
logger = logging.getLogger('discord')
logger.setLevel(logging.INFO)
handler = handlers.TimedRotatingFileHandler(filename='logs/discord.log',
encoding='utf-8',
when='D',
interval=1,
backupCount=30)
handler.setFormatter(
logging.Formatter('%(asctime)s:%(levelname)s:%(name)s: %(message)s'))
logger.addHandler(handler)
#do some stuff when we connect to discord
import asyncio
from time import gmtime, strftime, time
import bottom
from utils import log_msg, get_settings
host, port, nick, password, channel = get_settings()
bot = bottom.Client(host=host, port=port, ssl=False)
loop = asyncio.get_event_loop()
loop.set_debug(True)
@bot.on('CLIENT_CONNECT')
async def connect(**kwargs):
print("Connected.")
bot.send('PASS', password=password)
bot.send('NICK', nick=nick)
bot.send('USER', user=nick, realname=nick)
# wait till server motd
done, pending = await asyncio.wait(
[bot.wait("RPL_ENDOFMOTD"),
bot.wait("ERR_NOMOTD")],
return_when=asyncio.FIRST_COMPLETED)
for future in pending:
future.cancel()
print("joining %s" % channel)
import asyncio
import bottom
import json
import re
import websockets
from helpers import config, ripple_api, convertmods, naoapi, generate
from irc import Dispatcher, connector, cooldown
bot_ripple = bottom.Client(host=config.ripple()["irc_ip"],
port=config.ripple()["irc_port"],
ssl=False)
bot_twitch = bottom.Client(host=config.twitch()["irc_ip"],
port=config.twitch()["irc_port"],
ssl=False)
def load_memes():
arr = []
players = naoapi.get_list()["data"]
for player in players:
arr.append(player["user_id"])
return arr
async def ripple_websocket():
await bot_ripple.wait("client_connect")
async with websockets.connect("wss://api.ripple.moe/api/v1/ws",
timeout=1) as websocket:
await websocket.send('{"type": "subscribe_scores", "data": []}')
import asyncio
from time import gmtime, strftime, time
import bottom
from handlers import command, action
from singletons.config import Config
config = Config()
bot = bottom.Client(host=config['irc']['host'],
port=int(config['irc']['port']),
ssl=False)
loop = asyncio.get_event_loop()
loop.set_debug(True) # TODO: remove this?
NICK = config['irc']['nick']
CHANNELS = [
"#%s" % x for x in config['irc']['channels'].replace(" ", "").split(",")
]
message_send_lock = asyncio.Lock()
bot.last_message = 0
async def keepalive():
"""
Every five seconds, checks if it's been two minutes since the last time we got a message.
If it has, the bot will reconnect.
b.get_api()
break
except phue.PhueRegistrationException:
if not press_message_displayed:
print('Press the button on the Hue Bridge to allow access')
press_message_displayed = True
time.sleep(1)
except:
raise
print('Connected to the Hue Bridge')
return b
bot = bottom.Client(
host='irc.chat.twitch.tv',
port=6697,
ssl=True,
)
bot.raw_handlers = [rfc2812_handler(bot)]
@bot.on('CLIENT_CONNECT')
async def connect(**kwargs):
bot.send('PASS', password='******')
bot.send('NICK', nick='justinfan32429')
done, pending = await asyncio.wait(
[bot.wait("RPL_ENDOFMOTD"),
bot.wait("ERR_NOMOTD")],
loop=bot.loop,
return_when=asyncio.FIRST_COMPLETED
)
import bottom
from dispatcher import Dispatcher, connector, cooldown
host = 'chat.freenode.net'
port = 6697
ssl = True
NICK = "russel-test"
CHANNEL = ["#pigbenis", "#fuccboi"]
PASSWORD = None
loop = asyncio.get_event_loop()
loop.set_debug(True)
# create the irc client
bot = bottom.Client(host=host, port=port, ssl=ssl, loop=loop)
async def autoupdate_or_some_shit():
await bot.wait("client_connect")
while not bot.protocol.closed:
# bot.send("privmsg", target=CHANNEL, message="sent this test message")
await asyncio.sleep(3, loop=bot.loop)
# this is the command dispatcher
class IrcBot(Dispatcher):
# nick, message and channel are always supplied
# command and args come from the regex named capture groups
# (in this case: r'^!(?P<command>.*?)\s(?P<args>.*)')
@cooldown(5)
import bottom, asyncio, logging, random, aiohttp
from datetime import datetime
from logitch.unpack import rfc2812_handler
from logitch import config, db
bot = bottom.Client('a', 0)
@bot.on('CLIENT_CONNECT')
async def connect(**kwargs):
if not bot.http_session:
bot.http_session = aiohttp.ClientSession()
if not bot.db:
bot.db = await db.Db().connect(bot.loop)
if bot.pong_check_callback:
bot.pong_check_callback.cancel()
logging.info('IRC Connecting to {}:{}'.format(config['irc']['host'],
config['irc']['port']))
if config['token']:
bot.send('PASS', password='******'.format(config['token']))
bot.send('NICK', nick=config['user'])
bot.send('USER', user=config['user'], realname=config['user'])
# Don't try to join channels until the server has
# sent the MOTD, or signaled that there's no MOTD.
done, pending = await asyncio.wait(
[bot.wait("RPL_ENDOFMOTD"),
bot.wait("ERR_NOMOTD")],
loop=bot.loop,
return_when=asyncio.FIRST_COMPLETED)
def irc_transform(func):
irc_transforms.append(func)
return func
# Functions that do message modification before sending to Discord
# Take message, author, irc client, discord server
discord_transforms = []
def discord_transform(func):
discord_transforms.append(func)
return func
irc_client = irc_client = bottom.Client(
host=get_config("mainserver.irc.irc.address"),
port=get_config("mainserver.irc.irc.port"),
loop=asyncio.get_event_loop(),
ssl=True
)
logger = logging.getLogger(__name__)
messagelogger = logging.getLogger("IRC")
MENTION_RE = re.compile(r"<@!?(\d+)>")
IRC_MENTION_RE = re.compile(r"@([^@]+?)@")
IGNORED_NAMES = {"travis-ci", "vg-bot", "py-ctcp"}
async def unload(loop=None):
logger.info("Dropping IRC connection.")
await irc_client.disconnect()
@irc_client.on("client_connect")
import bottom
import win32com
import win32com.client
speaker = win32com.client.Dispatch('SAPI.SpVoice')
host = '192.168.137.3'
port = 6667
ssl = False
NICK = "talkbot"
CHANNEL = "#system"
bot = bottom.Client(host=host, port=port, ssl=ssl)
@bot.on('CLIENT_CONNECT')
def connect(**kwargs):
print("Connected")
bot.send('NICK', nick=NICK)
bot.send('USER', user=NICK,
realname='iamthetalkingrobot')
bot.send('JOIN', channel=CHANNEL)
@bot.on("client_disconnect")
async def reconnect(**kwargs):
# Trigger an event that may cascade to a client_connect.
# Don't continue until a client_connect occurs, which may be never.
print("lost connection")
@bot.on('PING')
async def start_wrapper(self):
print("Attempting to connect to IRC...")
# Create bottom IRC client
self._bottom = bottom.Client(host=self._config["irc_server"],
port=self._config["irc_port"],
ssl=False)
# Basic IRC handlers
@self._bottom.on('NOTICE')
def irc_notice(message, **kwargs):
print(message)
@self._bottom.on('PING')
def keepalive(message, **kwargs):
self._bottom.send('PONG', message=message)
# Connect and then send username
await self._bottom.connect()
self._bottom.send('PASS', password=self._config["irc_password"])
self._bottom.send('NICK', nick=self._config["irc_nick"])
self._bottom.send('USER', user=self._config["irc_nick"],
realname=self._config["irc_nick"])
print("Waiting for IRC MOTD...")
# Wait on MOTD
done, pending = await asyncio.wait(
[self._bottom.wait("RPL_ENDOFMOTD"),
self._bottom.wait("ERR_NOMOTD")],
loop=self._loop,
return_when=asyncio.FIRST_COMPLETED
)
# Cancel whichever waiter's event didn't come in.
for future in pending:
future.cancel()
print("Joining channel...")
self._bottom.send('JOIN', channel=self._config["irc_channel"])
# Register message handler
@self._bottom.on('PRIVMSG')
async def privmsg(nick, target, message, **kwargs):
# User must be authorized
if nick not in self._config["users"]:
# Not a command, send to MC
self.mc_send(nick, message)
return
fragments = message.strip().split(maxsplit=2)
if len(fragments) != 3:
# Not a command, send to MC
self.mc_send(nick, message)
return
# Command must start with "!<nick>" or "!!<nick>"
if ((fragments[0] != ("!" + self._config["irc_nick"])) and
(fragments[0] != ("!!" + self._config["irc_nick"]))):
# Forward to minecraft, not a command
self.mc_send(nick, message)
return
is_special_cmd = fragments[0][:2] == "!!"
# Actual command
real_command = fragments[2]
if real_command == "nonce":
nonce_text = binascii.hexlify(self._nonce).decode('ascii')
self._bottom.send('PRIVMSG', message=nonce_text, target=nick)
return
# Sigcheck command
if self._config["enable_sig_verify"]:
# Signature must be this length
if len(fragments[1]) != 86:
print("Signature invalid!")
return
vk_enc = self._config["users"][nick]
vk = ed25519.VerifyingKey(vk_enc, encoding='base64')
bytes_to_sign = b'\x00' if not is_special_cmd else b'\x01'
bytes_to_sign += self._nonce
bytes_to_sign += real_command.encode('utf-8')
try:
vk.verify(fragments[1], bytes_to_sign, encoding='base64')
except ed25519.BadSignatureError:
print("Signature invalid!")
return
self.new_nonce()
if not is_special_cmd:
# Command to forward to server
if self._subprocess:
real_command = (real_command + "\n").encode('utf-8')
self._subprocess.stdin.write(real_command)
else:
# Command for us
if real_command == "kill":
self.subprocess_kill()
elif real_command == "launch":
if self._subprocess:
return
self._loop.create_task(self.subprocess_create())
elif real_command == "status":
if not self._subprocess:
message = "Server not running"
else:
message = "Server running, PID {}".format(
self._subprocess.pid)
self.irc_send(message)
elif real_command == "all-shutdown":
print("Shutting down!")
if self._backup_task:
self._backup_task.cancel()
self._backup_task = None
if self._subprocess:
self._subprocess.stdin.write(b"stop\n")
await self._subprocess.wait()
self._bottom.send('QUIT', message=":( :( :( ")
self._loop.stop()
return
elif real_command[:7] == "taillog":
lines = 10
try:
lines = int(real_command[8:])
except ValueError:
pass
with open("logs/latest.log", "r") as f:
# FIXME: Ugly
lines = f.readlines()[-lines:]
for line in lines:
self.irc_send(line)
else:
# Bad command
message = "Unrecognized command: " + real_command
self.irc_send(message)
@self._bottom.on('JOIN')
def irc_join(nick, user, host, **kwargs):
if not self._config["enable_irc_bridge"]:
return
if not self._subprocess:
return
if nick == self._config["irc_nick"]:
# Ourselves
return
message = "{} has joined IRC ({}!{}@{})".format(
nick, nick, user, host)
if self._config["use_tellraw"]:
json_msg = json.dumps(["* " + message])
formatted_message = "/tellraw @a " + json_msg
else:
formatted_message = "/say " + message
formatted_message = (formatted_message + "\n").encode('utf-8')
self._subprocess.stdin.write(formatted_message)
@self._bottom.on('PART')
def irc_part(nick, user, host, message, **kwargs):
if not self._config["enable_irc_bridge"]:
return
if not self._subprocess:
return
if nick == self._config["irc_nick"]:
# Ourselves
return
part_message = message
message = "{} has left IRC".format(nick, nick, user)
if part_message:
message += " (" + part_message + ")"
print(message)
if self._config["use_tellraw"]:
json_msg = json.dumps(["* " + message])
formatted_message = "/tellraw @a " + json_msg
else:
formatted_message = "/say " + message
formatted_message = (formatted_message + "\n").encode('utf-8')
self._subprocess.stdin.write(formatted_message)
print(formatted_message)
print("IRC ready!")
# Launch subprocess
self._loop.create_task(self.subprocess_create())
