Firepup650/bitbot-3.11-fork
2
0
Fork 0
Code Issues Pull requests Activity Actions

Refactor IRCLineHandler in to an object that uses .on("raw") events

Browse source
This commit is contained in:
jesopo 2018-08-29 12:20:25 +01:00
parent a4a12a70c4
commit fead75cd2f
3 changed files with 383 additions and 363 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
IRCBot.py
View file

@ -1,5 +1,7 @@
import os, select, sys, threading, time, traceback import os, select, sys, threading, time, traceback
import EventManager, IRCLogging, IRCServer, ModuleManager, Timer
import EventManager, IRCLineHandler, IRCLogging, IRCServer
import ModuleManager, Timer
class Bot(object): class Bot(object):
def __init__(self): def __init__(self):
@ -14,6 +16,7 @@ class Bot(object):
self.modules = ModuleManager.ModuleManager(self) self.modules = ModuleManager.ModuleManager(self)
self.events = EventManager.EventHook(self) self.events = EventManager.EventHook(self)
self.log = IRCLogging.Log(self) self.log = IRCLogging.Log(self)
self.line_handler = IRCLineHandler.LineHandler(self)
self.timers = [] self.timers = []
self.events.on("timer").on("reconnect").hook(self.reconnect) self.events.on("timer").on("reconnect").hook(self.reconnect)
self.events.on("boot").on("done").hook(self.setup_timers) self.events.on("boot").on("done").hook(self.setup_timers)

722
IRCLineHandler.py
View file

@ -6,381 +6,413 @@ RE_CHANMODES = re.compile(
r"\bCHANMODES=(\w*),(\w*),(\w*),(\w*)(?:\b|$)") r"\bCHANMODES=(\w*),(\w*),(\w*),(\w*)(?:\b|$)")
RE_CHANTYPES = re.compile(r"\bCHANTYPES=(\W+)(?:\b|$)") RE_CHANTYPES = re.compile(r"\bCHANTYPES=(\W+)(?:\b|$)")
handlers = {} class LineHandler(object):
descriptions = {} def __init__(self, bot):
default_events = {} self.bot = bot
current_description = None bot.events.on("raw").on("PING").hook(self.ping)
current_default_event = False
handle_lock = threading.Lock()
bot = None
class LineData: bot.events.on("raw").on("001").hook(self.handle_001,
def __init__(self, line, line_split, prefix, command, args, is_final, server): default_event=True)
self.line, self.prefix = line, prefix bot.events.on("raw").on("005").hook(self.handle_005)
self.command, self.args = command, args bot.events.on("raw").on("311").hook(self.handle_311,
self.is_final = is_final, default_event=True)
self.server, self.line_split = server, line_split bot.events.on("raw").on("332").hook(self.handle_332,
default_event=True)
bot.events.on("raw").on("333").hook(self.handle_333,
default_event=True)
bot.events.on("raw").on("353").hook(self.handle_353,
default_event=True)
bot.events.on("raw").on("366").hook(self.handle_366,
default_event=True)
bot.events.on("raw").on("421").hook(self.handle_421,
default_event=True)
bot.events.on("raw").on("352").hook(self.handle_352,
default_event=True)
bot.events.on("raw").on("324").hook(self.handle_324,
default_event=True)
bot.events.on("raw").on("329").hook(self.handle_329,
default_event=True)
bot.events.on("raw").on("433").hook(self.handle_433,
default_event=True)
bot.events.on("raw").on("477").hook(self.handle_477,
default_event=True)
def map(self): bot.events.on("raw").on("JOIN").hook(self.join)
return { bot.events.on("raw").on("PART").hook(self.quit)
"line": self.line, "line_split": self.line_split, bot.events.on("raw").on("QUIT").hook(self.quit)
"prefix": self.prefix, "command": self.command, bot.events.on("raw").on("NICK").hook(self.nick)
"args": self.args, "is_final": self.is_final, bot.events.on("raw").on("MODE").hook(self.mode)
"server": self.server, bot.events.on("raw").on("KICK").hook(self.kick)
} bot.events.on("raw").on("INVITE").hook(self.invite)
bot.events.on("raw").on("PRIVMSG").hook(self.privmsg)
bot.events.on("raw").on("NOTICE").hook(self.notice)
def handler(f=None, description=None, default_event=False): bot.events.on("raw").on("CAP").hook(self.cap)
global current_description, current_default_event bot.events.on("raw").on("authenticate").hook(self.authenticate)
if not f:
current_description = description
current_default_event = default_event
return handler
name = f.__name__.split("handle_")[1].upper()
handlers[name] = f
descriptions[name] = current_description def handle(self, server, line):
default_events[name] = current_default_event original_line = line
current_description, current_default_event = None, False prefix = None
command = None
def handle(line, prefix, command, args, is_final, _bot, server): if line[0] == ":":
global bot prefix, command, line = line[1:].split(" ", 2)
line_split = line.split(" ")
data = LineData(line, line_split, prefix, command, args, is_final, server)
handler_function = None
if command in handlers:
handler_function = handlers[command]
if default_events.get(command, False) or not command in handlers:
if command.isdigit():
_bot.events.on("received").on("numeric").on(
command).call(number=command, **data.map())
else: else:
_bot.events.on("received").on(command).call(**data.map()) command, line = line.split(" ", 1)
if handler_function:
with handle_lock:
bot = _bot
handler_function(data)
@handler(description="received a ping from the server") arbitrary = None
def handle_PING(data): if ":" in line:
nonce = data.args[0] line, arbitrary = line.split(":", 1)
data.server.send_pong(nonce) if line.endswith(" "):
bot.events.on("received").on("ping").call(nonce=nonce, server=data.server) line = line[:-1]
@handler(description="received a pong from the server") args = line.split(" ")
def handle_PONG(data):
nonce = data.args[1]
bot.events.on("recevied").on("pong").call(nonce=nonce, server=data.server)
@handler(description="the first line sent to a registered client", default_event=True) hooks = self.bot.events.on("raw").on(command).get_hooks()
def handle_001(data): default_event = False
server = data.server for hook in hooks:
server.name = Utils.remove_colon(data.prefix) if hook.kwargs.get("default_event", False):
server.set_own_nickname(data.args[0]) default_event = True
server.send_whois(server.nickname) break
@handler(description="the extra supported things line") #server, prefix, command, args, arbitrary
def handle_005(data): self.bot.events.on("raw").on(command).call(server=server,
server = data.server prefix=prefix, args=args, arbitrary=arbitrary)
isupport_line = " ".join(data.args[1:]) if default_event:
if "NAMESX" in data.line: if command.isdigit():
server.send("PROTOCTL NAMESX") self.bot.events.on("received").on("numeric").on(command
match = re.search(RE_PREFIXES, isupport_line) ).call(line=line, line_split=line.split(" "),
if match: number=command, server=server)
server.mode_prefixes.clear() else:
modes = match.group(1) self.bot.events.on("received").on(command).call(
prefixes = match.group(2) line=line, line_split=line.split(" "), command=command,
for i, prefix in enumerate(prefixes): server=server)
if i < len(modes):
server.mode_prefixes[prefix] = modes[i]
match = re.search(RE_CHANMODES, isupport_line)
if match:
server.channel_modes = list(match.group(4))
match = re.search(RE_CHANTYPES, isupport_line)
if match:
server.channel_types = list(match.group(1))
bot.events.on("received").on("numeric").on("005").call(
isupport=isupport_line, number="005", server=data.server)
@handler(description="whois respose (nickname, username, realname, hostname)", default_event=True) def ping(self, event):
def handle_311(data): nonce = event["arbitrary"]
server = data.server event["server"].send_pong(nonce)
nickname = data.args[1]
if server.is_own_nickname(nickname):
target = server
else:
target = server.get_user(nickname)
target.username = data.args[2]
target.hostname = data.args[3]
target.realname = data.args[-1]
@handler(description="on-join channel topic line", default_event=True) def handle_001(self, event):
def handle_332(data): event["server"].name = Utils.remove_colon(event["prefix"])
channel = data.server.get_channel(data.args[1]) event["server"].set_own_nickname(event["args"][0])
topic = data.args[2] event["server"].send_whois(event["server"].nickname)
channel.set_topic(topic)
@handler(description="on-join channel topic set by/at", default_event=True) def handle_005(self, event):
def handle_333(data): isupport_line = " ".join(event["args"][1:])
channel = data.server.get_channel(data.args[1]) if "NAMESX" in isupport_line:
topic_setter_hostmask = data.args[2] event["server"].send("PROTOCTL NAMESX")
nickname, username, hostname = Utils.seperate_hostmask( match = re.search(RE_PREFIXES, isupport_line)
topic_setter_hostmask) if match:
topic_time = int(data.args[3]) if data.args[3].isdigit() else None event["server"].mode_prefixes.clear()
channel.set_topic_setter(nickname, username, hostname) modes = match.group(1)
channel.set_topic_time(topic_time) prefixes = match.group(2)
for i, prefix in enumerate(prefixes):
if i < len(modes):
event["server"].mode_prefixes[prefix] = modes[i]
match = re.search(RE_CHANMODES, isupport_line)
if match:
event["server"].channel_modes = list(match.group(4))
match = re.search(RE_CHANTYPES, isupport_line)
if match:
event["server"].channel_types = list(match.group(1))
self.bot.events.on("received").on("numeric").on("005").call(
isupport=isupport_line, server=event["server"])
@handler(description="on-join user list with status symbols", default_event=True) # whois respose (nickname, username, realname, hostname)
def handle_353(data): def handle_311(self, event):
server = data.server nickname = event["args"][1]
channel = server.get_channel(data.args[2]) if event["server"].is_own_nickname(nickname):
nicknames = data.args[3].split() target = event["server"]
for nickname in nicknames: else:
if nickname.strip(): target = event["server"].get_user(nickname)
modes = set([]) target.username = event["args"][2]
while nickname[0] in server.mode_prefixes: target.hostname = event["args"][3]
modes.add(server.mode_prefixes[nickname[0]]) target.realname = event["arbitrary"]
nickname = nickname[1:]
user = server.get_user(nickname) # on-join channel topic line
user.join_channel(channel) def handle_332(self, event):
event["server"].get_channel(event["args"][1]).set_topic(
event["arbitrary"])
# on-join channel topic set by/at
def handle_333(self, event):
channel = event["server"].get_channel(event["args"][1])
topic_setter_hostmask = event["args"][2]
nickname, username, hostname = Utils.seperate_hostmask(
topic_setter_hostmask)
topic_time = int(event["args"][3]) if event["args"][3].isdigit(
) else None
channel.set_topic_setter(nickname, username, hostname)
channel.set_topic_time(topic_time)
# on-join user list with status symbols
def handle_353(self, event):
channel = event["server"].get_channel(event["args"][2])
nicknames = event["arbitrary"].split()
for nickname in nicknames:
if nickname.strip():
modes = set([])
while nickname[0] in event["server"].mode_prefixes:
modes.add(event["server"].mode_prefixes[nickname[0]])
nickname = nickname[1:]
user = event["server"].get_user(nickname)
user.join_channel(channel)
channel.add_user(user)
for mode in modes:
channel.add_mode(mode, nickname)
# on-join user list has finished
def handle_366(self, event):
event["server"].send_who(event["args"][1])
# on user joining channel
def join(self, event):
nickname, username, hostname = Utils.seperate_hostmask(
event["prefix"])
channel = event["server"].get_channel(
event["arbitrary"] or event["args"][0])
if not event["server"].is_own_nickname(nickname):
user = event["server"].get_user(nickname)
if not event["server"].has_user(nickname):
user.username = username
user.hostname = hostname
channel.add_user(user) channel.add_user(user)
for mode in modes: user.join_channel(channel)
channel.add_mode(mode, nickname) self.bot.events.on("received").on("join").call(channel=channel,
@handler(description="on-join user list has finished", default_event=True) user=user, server=event["server"])
def handle_366(data): else:
data.server.send_who(data.args[1]) if channel.name in event["server"].attempted_join:
del event["server"].attempted_join[channel.name]
self.bot.events.on("self").on("join").call(channel=channel,
server=event["server"])
channel.send_mode()
@handler(description="on user joining channel") # on user parting channel
def handle_JOIN(data): def part(self, event):
server = data.server nickname, username, hostname = Utils.seperate_hostmask(
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) event["prefix"])
channel = server.get_channel(Utils.remove_colon(data.args[0])) channel = event["server"].get_channel(event["args"][0])
if not server.is_own_nickname(nickname): reason = event["arbitrary"] or ""
user = server.get_user(nickname)
if not server.has_user(nickname):
user.username = username
user.hostname = hostname
channel.add_user(user)
user.join_channel(channel)
bot.events.on("received").on("join").call(channel=channel,
user=user, server=data.server)
else:
if channel.name in server.attempted_join:
del server.attempted_join[channel.name]
bot.events.on("self").on("join").call(channel=channel,
server=data.server)
channel.send_mode()
@handler(description="on user parting channel") if not event["server"].is_own_nickname(nickname):
def handle_PART(data): user = event["server"].get_user(nickname)
server = data.server self.bot.events.on("received").on("part").call(channel=channel,
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) reason=reason, user=user, server=event["server"])
channel = server.get_channel(data.args[0]) channel.remove_user(user)
reason = data.args[1] if len(data.args)>1 else "" user.part_channel(channel)
if not server.is_own_nickname(nickname): if not len(user.channels):
user = server.get_user(nickname) event["server"].remove_user(user)
bot.events.on("received").on("part").call(channel=channel, else:
reason=reason, user=user, server=data.server) event["server"].remove_channel(channel)
channel.remove_user(user) self.bot.events.on("self").on("part").call(channel=channel,
user.part_channel(channel) reason=reason, server=event["server"])
if not len(user.channels):
server.remove_user(user)
else:
server.remove_channel(channel)
bot.events.on("self").on("part").call(channel=channel,
reason=reason, server=data.server)
@handler(description="unknown command sent by us, oops!", default_event=True) # unknown command sent by us, oops!
def handle_421(data): def handle_421(self, event):
print("warning: unknown command '%s'." % data.args[1]) print("warning: unknown command '%s'." % event["args"][1])
@handler(description="a user has disconnected!") # a user has disconnected!
def handle_QUIT(data): def quit(self, event):
server = data.server nickname, username, hostname = Utils.seperate_hostmask(
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) event["prefix"])
reason = data.args[0] if len(data.args) else None reason = event["arbitrary"] or ""
if not server.is_own_nickname(nickname):
user = server.get_user(nickname)
server.remove_user(user)
bot.events.on("received").on("quit").call(reason=reason,
user=user, server=data.server)
else:
server.disconnect()
@handler(description="The server is telling us about its capabilities!") if not event["server"].is_own_nickname(nickname):
def handle_CAP(data): user = event["server"].get_user(nickname)
capability_list = [] event["server"].remove_user(user)
if len(data.args) > 2: self.bot.events.on("received").on("quit").call(reason=reason,
capability_list = data.args[2].split() user=user, server=event["server"])
bot.events.on("received").on("cap").call(subcommand=data.args[1], else:
capabilities=capability_list, server=data.server) event["server"].disconnect()
@handler(description="The server is asking for authentication") # the server is telling us about its capabilities!
def handle_AUTHENTICATE(data): def cap(self, event):
bot.events.on("received").on("authenticate").call(message=data.args[0], capability_list = []
server=data.server) if len(event["args"]) > 2:
capability_list = event["args"][2].split()
self.bot.events.on("received").on("cap").call(
subcommand=event["args"][1], capabilities=capability_list,
server=event["server"])
@handler(description="someone has changed their nickname") # the server is asking for authentication
def handle_NICK(data): def authenticate(self, event):
server = data.server self.bot.events.on("received").on("authenticate").call(
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) message=event["args"][0], server=event["server"])
new_nickname = data.args[0]
if not server.is_own_nickname(nickname):
user = server.get_user(nickname)
old_nickname = user.nickname
user.set_nickname(new_nickname)
server.change_user_nickname(old_nickname, new_nickname)
bot.events.on("received").on("nick").call(new_nickname=new_nickname,
old_nickname=old_nickname, user=user, server=data.server)
else:
old_nickname = server.nickname
server.set_own_nickname(new_nickname)
bot.events.on("self").on("nick").call(server=server,
new_nickname=new_nickname, old_nickname=old_nickname)
@handler(description="something's mode has changed") # someone has changed their nickname
def handle_MODE(data): def nick(self, event):
server = data.server nickname, username, hostname = Utils.seperate_hostmask(
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) event["prefix"])
target = data.args[0] new_nickname = event["arbitrary"]
is_channel = target[0] in server.channel_types if not event["server"].is_own_nickname(nickname):
if is_channel: user = event["server"].get_user(nickname)
channel = server.get_channel(target) old_nickname = user.nickname
remove = False user.set_nickname(new_nickname)
args = data.args[2:] event["server"].change_user_nickname(old_nickname, new_nickname)
modes = data.args[1] self.bot.events.on("received").on("nick").call(
for i, char in enumerate(modes): new_nickname=new_nickname, old_nickname=old_nickname,
if char == "+": user=user, server=event["server"])
remove = False else:
elif char == "-": old_nickname = event["server"].nickname
remove = True event["server"].set_own_nickname(new_nickname)
else: self.bot.events.on("self").on("nick").call(
if char in server.channel_modes: server=event["server"], new_nickname=new_nickname,
if remove: old_nickname=old_nickname)
channel.remove_mode(char)
else: # something's mode has changed
channel.add_mode(char) def mode(self, event):
elif char in server.mode_prefixes.values() and len(args): nickname, username, hostname = Utils.seperate_hostmask(
nickname = args.pop(0) event["prefix"])
if remove: target = event["args"][0]
channel.remove_mode(char, nickname) is_channel = target[0] in event["server"].channel_types
else: if is_channel:
channel.add_mode(char, nickname) channel = event["server"].get_channel(target)
elif len(args): remove = False
args.pop(0) args = event["args"][2:]
bot.events.on("received").on("mode").call(modes=modes, modes = event["args"][1]
mode_args=args, channel=channel, server=data.server) for i, char in enumerate(modes):
elif server.is_own_nickname(target): if char == "+":
modes = Utils.remove_colon(data.args[1]) remove = False
remove = False elif char == "-":
for i, char in enumerate(modes): remove = True
if char == "+":
remove = False
elif char == "-":
remove = True
else:
if remove:
server.remove_own_mode(char)
else: else:
server.add_own_mode(char) if char in event["server"].channel_modes:
bot.events.on("self").on("mode").call(modes=modes, server=data.server) if remove:
channel.remove_mode(char)
else:
channel.add_mode(char)
elif char in event["server"].mode_prefixes.values(
) and len(args):
nickname = args.pop(0)
if remove:
channel.remove_mode(char, nickname)
else:
channel.add_mode(char, nickname)
elif len(args):
args.pop(0)
self.bot.events.on("received").on("mode").call(modes=modes,
mode_args=args, channel=channel, server=event["server"])
elif event["server"].is_own_nickname(target):
modes = event["arbitrary"]
remove = False
for i, char in enumerate(modes):
if char == "+":
remove = False
elif char == "-":
remove = True
else:
if remove:
event["server"].remove_own_mode(char)
else:
event["server"].add_own_mode(char)
self.bot.events.on("self").on("mode").call(modes=modes,
server=event["server"])
@handler(description="I've been invited somewhere") # I've been invited somewhere
def handle_INVITE(data): def invite(self, event):
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) nickname, username, hostname = Utils.seperate_hostmask(
target_channel = Utils.remove_colon(data.args[1]) event["prefix"])
user = data.server.get_user(nickname) target_channel = event["arbitrary"]
bot.events.on("received").on("invite").call( user = event["server"].get_user(nickname)
user=user, target_channel=target_channel, server=data.server) self.bot.events.on("received").on("invite").call(
user=user, target_channel=target_channel,
server=event["server"])
@handler(description="we've received a message") # we've received a message
def handle_PRIVMSG(data): def privmsg(self, event):
server = data.server nickname, username, hostname = Utils.seperate_hostmask(
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) event["prefix"])
user = server.get_user(nickname) user = event["server"].get_user(nickname)
message = "" if len(data.args) < 2 else data.args[1] message = event["arbitrary"] or ""
message_split = message.split(" ") message_split = message.split(" ")
target = data.args[0] target = event["args"][0]
action = message.startswith("\01ACTION ") and message.endswith("\01") action = message.startswith("\01ACTION ") and message.endswith("\01")
if action: if action:
message = message.replace("\01ACTION ", "", 1)[:-1] message = message.replace("\01ACTION ", "", 1)[:-1]
if target[0] in server.channel_types: if target[0] in event["server"].channel_types:
channel = server.get_channel(data.args[0]) channel = event["server"].get_channel(event["args"][0])
bot.events.on("received").on("message").on("channel").call( self.bot.events.on("received").on("message").on("channel").call(
user=user, message=message, message_split=message_split, user=user, message=message, message_split=message_split,
channel=channel, action=action, server=data.server) channel=channel, action=action, server=event["server"])
channel.buffer.add_line(user.nickname, message, action) channel.buffer.add_line(user.nickname, message, action)
elif server.is_own_nickname(target): elif event["server"].is_own_nickname(target):
bot.events.on("received").on("message").on("private").call( self.bot.events.on("received").on("message").on("private").call(
user=user, message=message, message_split=message_split, user=user, message=message, message_split=message_split,
action=action, server=data.server) action=action, server=event["server"])
user.buffer.add_line(user.nickname, message, action) user.buffer.add_line(user.nickname, message, action)
@handler(description="we've received a notice") # we've received a notice
def handle_NOTICE(data): def notice(self, event):
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) nickname, username, hostname = Utils.seperate_hostmask(
message = "" if len(data.args) < 2 else data.args[1] event["prefix"])
message_split = message.split(" ") message = event["arbitrary"] or ""
target = data.args[0] message_split = message.split(" ")
if nickname == data.server.name or target == "*": target = event["args"][0]
bot.events.on("received.server-notice").call( if nickname == event["server"].name or target == "*":
message=message, message_split=message_split, self.bot.events.on("received.server-notice").call(
server=data.server)
else:
user = data.server.get_user(nickname)
if target[0] in data.server.channel_types:
channel = data.server.get_channel(target)
bot.events.on("received.notice.channel").call(
message=message, message_split=message_split, message=message, message_split=message_split,
user=user, server=data.server, channel=channel) server=event["server"])
elif data.server.is_own_nickname(target): else:
bot.events.on("received.notice.private").call( user = event["server"].get_user(nickname)
message=message, message_split=message_split, if target[0] in event["server"].channel_types:
user=user, server=data.server) channel = event["server"].get_channel(target)
self.bot.events.on("received.notice.channel").call(
message=message, message_split=message_split,
user=user, server=event["server"], channel=channel)
elif event["server"].is_own_nickname(target):
self.bot.events.on("received.notice.private").call(
message=message, message_split=message_split,
user=user, server=event["server"])
@handler(description="response to a WHO command for user information", default_event=True) # response to a WHO command for user information
def handle_352(data): def handle_352(self, event):
user = data.server.get_user(data.args[5]) user = event["server"].get_user(event["args"][5])
user.username = data.args[2] user.username = event["args"][2]
user.hostname = data.args[3] user.hostname = event["args"][3]
@handler(description="response to an empty mode command", default_event=True) # response to an empty mode command
def handle_324(data): def handle_324(self, event):
channel = data.server.get_channel(data.args[1]) channel = event["server"].get_channel(event["args"][1])
modes = data.args[2] modes = event["args"][2]
if modes[0] == "+" and modes[1:]: if modes[0] == "+" and modes[1:]:
for mode in modes[1:]: for mode in modes[1:]:
if mode in data.server.channel_modes: if mode in event["server"].channel_modes:
channel.add_mode(mode) channel.add_mode(mode)
@handler(description="channel creation unix timestamp", default_event=True) # channel creation unix timestamp
def handle_329(data): def handle_329(self, event):
channel = data.server.get_channel(data.args[1]) channel = event["server"].get_channel(event["args"][1])
channel.creation_timestamp = int(data.args[2]) channel.creation_timestamp = int(event["args"][2])
@handler(description="nickname already in use", default_event=True) # nickname already in use
def handle_433(data): def handle_433(self, event):
pass pass
@handler(description="we need a registered nickname for this channel", default_event=True) # we need a registered nickname for this channel
def handle_477(data): def handle_477(self, event):
if data.args[1].lower() in data.server.attempted_join: if event["args"][1].lower() in event["server"].attempted_join:
bot.add_timer("rejoin", 5, channel_name=data.args[1], self.bot.add_timer("rejoin", 5,
key=data.server.attempted_join[data.args[1].lower()], channel_name=event["args"][1],
server_id=data.server.id) key=event["server"].attempted_join[event["args"][1].lower()],
server_id=event["server"].id)
@handler(description="someone's been kicked from a channel") # someone's been kicked from a channel
def handle_KICK(data): def kick(self, event):
nickname, username, hostname = Utils.seperate_hostmask(data.prefix) nickname, username, hostname = Utils.seperate_hostmask(
user = data.server.get_user(nickname) event["prefix"])
target = data.args[1] user = event["server"].get_user(nickname)
channel = data.server.get_channel(data.args[0]) target = event["args"][1]
reason = data.args[2] channel = event["server"].get_channel(event["args"][0])
reason = event["arbitrary"] or ""
if not data.server.is_own_nickname(target): if not event["server"].is_own_nickname(target):
target_user = data.server.get_user(target) target_user = event["server"].get_user(target)
bot.events.on("received").on("kick").call(channel=channel, self.bot.events.on("received").on("kick").call(channel=channel,
reason=reason, target_user=target_user, user=user, reason=reason, target_user=target_user, user=user,
server=data.server) server=event["server"])
else: else:
bot.events.on("self").on("kick").call(channel=channel, self.bot.events.on("self").on("kick").call(channel=channel,
reason=reason, user=user, server=data.server) reason=reason, user=user, server=event["server"])

19
IRCServer.py
View file

@ -1,5 +1,5 @@
import collections, socket, ssl, sys, time import collections, socket, ssl, sys, time
import IRCChannel, IRCLineHandler, IRCUser import IRCChannel, IRCUser
OUR_TLS_PROTOCOL = ssl.PROTOCOL_SSLv23 OUR_TLS_PROTOCOL = ssl.PROTOCOL_SSLv23
THROTTLE_LINES = 4 THROTTLE_LINES = 4
@ -168,22 +168,7 @@ class Server(object):
def parse_line(self, line): def parse_line(self, line):
if not line: if not line:
return return
original_line = line self.bot.line_handler.handle(self, line)
prefix, final = None, None
if line[0] == ":":
prefix, line = line[1:].split(" ", 1)
command, line = (line.split(" ", 1) + [""])[:2]
if line[0] == ":":
final, line = line[1:], ""
elif " :" in line:
line, final = line.split(" :", 1)
args_split = line.split(" ") if line else []
if final:
args_split.append(final)
IRCLineHandler.handle(original_line, prefix, command, args_split, final!=None, self.bot, self)
self.check_users() self.check_users()
def check_users(self): def check_users(self):
for user in self.new_users: for user in self.new_users: