diff options
| -rw-r--r-- | modules/commands/__init__.py | 13 | ||||
| -rw-r--r-- | modules/commands/outs.py | 18 | ||||
| -rw-r--r-- | modules/ircv3_multiline.py | 3 | ||||
| -rw-r--r-- | modules/relay.py | 13 | ||||
| -rw-r--r-- | modules/signals.py | 4 | ||||
| -rw-r--r-- | src/IRCServer.py | 68 | ||||
| -rw-r--r-- | src/utils/irc/__init__.py | 1 | ||||
| -rw-r--r-- | src/utils/irc/protocol.py | 90 |
8 files changed, 66 insertions, 144 deletions
diff --git a/modules/commands/__init__.py b/modules/commands/__init__.py index 9b104325..8cf56aa4 100644 --- a/modules/commands/__init__.py +++ b/modules/commands/__init__.py @@ -2,7 +2,7 @@ #--depends-on permissions import re, string, traceback, typing -from src import EventManager, ModuleManager, utils +from src import EventManager, IRCLine, ModuleManager, utils from . import outs COMMAND_METHOD = "command-method" @@ -172,6 +172,9 @@ class Module(ModuleManager.BaseModule): if not is_success: raise utils.EventError(message) + def _tagmsg(self, target, tags): + return IRCLine.ParsedLine("TAGMSG", [target], tags=tags) + def command(self, server, target, target_str, is_channel, user, command, args_split, tags, hook, **kwargs): message_tags = server.has_capability(MESSAGE_TAGS_CAP) @@ -188,8 +191,8 @@ class Module(ModuleManager.BaseModule): send_tags["+draft/reply"] = msgid if expect_output: - server.send(utils.irc.protocol.tagmsg(target_str, - {"+draft/typing": "active"}), immediate=True) + line = self._tagmsg(target_str, {"+draft/typing": "active"}) + server.send(line, immediate=True) stdout = outs.StdOut(server, module_name, target, target_str, send_tags) stderr = outs.StdErr(server, module_name, target, target_str, send_tags) @@ -238,8 +241,8 @@ class Module(ModuleManager.BaseModule): ret = new_event.eaten if expect_output and message_tags and not has_out: - server.send(utils.irc.protocol.tagmsg(target_str, - {"+draft/typing": "done"}), immediate=True) + line = self._tagmsg(target_str, {"+draft/typing": "done"}) + server.send(line, immediate=True) return ret diff --git a/modules/commands/outs.py b/modules/commands/outs.py index 9098df63..0fd8db7d 100644 --- a/modules/commands/outs.py +++ b/modules/commands/outs.py @@ -6,6 +6,14 @@ STR_MORE_LEN = len(STR_MORE.encode("utf8")) STR_CONTINUED = "(...continued) " WORD_BOUNDARY = ' ' +def _mesage_factory(command): + if not command in ["PRIVMSG", "NOTICE"]: + raise ValueError("Unknown command method '%s'" % method) + + def _(target, message): + return IRCLine.ParsedLine(command, [target, message]) + return _ + class Out(object): def __init__(self, server, module_name, target, target_str, tags): self.server = server @@ -39,15 +47,9 @@ class Out(object): text = text.replace("\n\n", "\n") full_text = "%s%s" % (prefix, text) - line_factory = None - if method == "PRIVMSG": - line_factory = utils.irc.protocol.privmsg - elif method == "NOTICE": - line_factory = utils.irc.protocol.notice - else: - raise ValueError("Unknown command method '%s'" % method) + message_factory = _mess_factory(method) - line = line_factory(self._target_str, full_text, tags=self._tags) + line = message_factory(self._target_str, full_text, tags=self._tags) if self._assured: line.assure() diff --git a/modules/ircv3_multiline.py b/modules/ircv3_multiline.py index e07b2400..c03448af 100644 --- a/modules/ircv3_multiline.py +++ b/modules/ircv3_multiline.py @@ -18,7 +18,8 @@ class Module(ModuleManager.BaseModule): batch = IRCLine.IRCSendBatch("draft/multiline", [target]) for line in lines: - batch.add_line(utils.irc.protocol.privmsg(target, line)) + line = IRCLine.ParsedLine("PRIVMSG", [target, line]) + batch.add_line(line) for line in batch.get_lines(): event["server"].send(line) diff --git a/modules/relay.py b/modules/relay.py index 9660f571..c40fb6c0 100644 --- a/modules/relay.py +++ b/modules/relay.py @@ -46,13 +46,14 @@ class Module(ModuleManager.BaseModule): relay_message = "[%s%s] %s" % (server_name, relay_prefix_channel, event["line"]) - message = utils.irc.protocol.privmsg(relay_channel.name, - relay_message) - server._relay_ignore.append(message.id) - self.bot.trigger(self._send_factory(server, message)) + self.bot.trigger(self._send_factory(server, relay_channel.name, + relay_message)) - def _send_factory(self, server, message): - return lambda: server.send(message) + def _send_factory(self, server, channel_name, message): + def _(): + message = server.send_message(channel_name, message) + server._relay_ignore.append(message.parsed_line.id) + return _ @utils.hook("formatted.message.channel") @utils.hook("formatted.notice.channel") diff --git a/modules/signals.py b/modules/signals.py index f3adcbb0..921b483c 100644 --- a/modules/signals.py +++ b/modules/signals.py @@ -1,5 +1,5 @@ import signal, sys -from src import Config, ModuleManager, utils +from src import Config, IRCLine, ModuleManager, utils class Module(ModuleManager.BaseModule): def on_load(self): @@ -24,7 +24,7 @@ class Module(ModuleManager.BaseModule): if server.connected: server.socket.clear_send_buffer() - line = utils.irc.protocol.quit("Shutting down") + line = IRCLine.ParsedLine("QUIT", ["Shutting down"]) sent_line = server.send(line, immediate=True) sent_line.events.on("send").hook(self._make_hook(server)) diff --git a/src/IRCServer.py b/src/IRCServer.py index 17b0bc13..87ed7f58 100644 --- a/src/IRCServer.py +++ b/src/IRCServer.py @@ -296,14 +296,18 @@ class Server(IRCObject.Object): def send_raw(self, line: str): return self.send(IRCLine.parse_line(line)) + def _line(self, command, args, tags={}): + return IRCLine.ParsedLine(command, + [arg for arg in args if not arg == None], tags=tags) + def send_user(self, username: str, realname: str ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.user(username, realname)) + return self.send(self._line("USER",[username, "0", "*", realname])) def send_nick(self, nickname: str) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.nick(nickname)) + return self.send(self._line("NICK", [nickname])) def send_capibility_ls(self) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.capability_ls()) + return self.send(self._line("CAP", ["LS", "302"])) def send_capability_queue(self): # textwrap works here because in ASCII, all chars are 1 bytes: capabilities = list(self.capability_queue.keys()) @@ -319,13 +323,13 @@ class Server(IRCObject.Object): for capability_batch in capability_batches: self.send_capability_request(capability_batch) - def send_capability_request(self, capability: str + def send_capability_request(self, capabilities: str ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.capability_request(capability)) + return self.send(self._line("CAP", ["REQ", capabilities])) def send_capability_end(self) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.capability_end()) + return self.send(self._line("CAP", ["END"])) def send_authenticate(self, text: str) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.authenticate(text)) + return self.send(self._line("AUTHENTICATE", [text])) def has_capability(self, capability: utils.irc.Capability) -> bool: return bool(self.available_capability(capability)) def has_capability_str(self, capability: str) -> bool: @@ -347,65 +351,67 @@ class Server(IRCObject.Object): self._capabilities_waiting.clear() def send_pass(self, password: str) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.password(password)) + return self.send(self._line("PASS", [password])) - def send_ping(self, nonce: str="hello" + def send_ping(self, token: str="hello" ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.ping(nonce), immediate=True) - def send_pong(self, nonce: str) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.pong(nonce), immediate=True) + return self.send(self._line("PING", [token])) + def send_pong(self, token: str) -> typing.Optional[IRCLine.SentLine]: + return self.send(self._line("PONG", [token])) - def send_join(self, channel_name: str, keys: typing.List[str]=None + def send_join(self, channel_name: str, key: typing.List[str]=None ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.join(channel_name, keys)) + return self.send(self._line("JOIN", [channel_name, key])) def send_joins(self, channel_names: typing.List[str], keys: typing.List[str]=None): - return self.send(utils.irc.protocol.join(",".join(channel_names), - keys)) + return self.send(self._line("JOIN", + [",".join(channel_names)]+(keys or []))) def send_part(self, channel_name: str, reason: str=None ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.part(channel_name, reason)) + return self.send(self._line("PART", [channel_name, reason])) def send_quit(self, reason: str="Leaving" ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.quit(reason)) + return self.send(self._line("QUIT", [reason])) def send_message(self, target: str, message: str, tags: dict={} ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.privmsg(target, message, tags)) + return self.send(self._line("PRIVMSG", [target, message], tags=tags)) def send_notice(self, target: str, message: str, tags: dict={} ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.notice(target, message, tags)) + return self.send(self._line("NOTICE", [target, message], tags=tags)) def send_tagmsg(self, target: str, tags: dict): - return self.send(utils.irc.protocol.tagmsg(target, tags)) + return self.send(self._line("TARGMSG", [], tags=tags)) def send_mode(self, target: str, mode: str=None, args: typing.List[str]=None ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.mode(target, mode, args)) + return self.send(self._line("MODE", [target, mode, args])) def send_topic(self, channel_name: str, topic: str ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.topic(channel_name, topic)) + return self.send(self._line("TOPIC", [channel_name, topic])) def send_kick(self, channel_name: str, target: str, reason: str=None ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.kick(channel_name, target, reason)) + return self.send(self._line("KICK", [channel_name, target, reason])) def send_names(self, channel_name: str) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.names(channel_name)) + return self.send(self._line("NAMES", [channel_name])) def send_list(self, search_for: str=None ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.list(search_for)) + return self.send(self._line("LIST", [search_for])) def send_invite(self, channel_name: str, target: str ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.invite(channel_name, target)) + return self.send(self._line("INVITE", [target, channel_name])) def send_whois(self, target: str) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.whois(target)) + return self.send(self._line("WHOIS", [target])) def send_whowas(self, target: str, amount: int=None, server: str=None ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.whowas(target, amount, server)) + amount_str = str(amount) if not amount == None else None + return self.send(self._line("WHOWAS", [target, amount_str, server])) def send_who(self, filter: str=None) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.who(filter)) + return self.send(self._line("WHO", [filter])) def send_whox(self, mask: str, filter: str, fields: str, label: str=None ) -> typing.Optional[IRCLine.SentLine]: - return self.send(utils.irc.protocol.whox(mask, filter, fields, label)) + flags = "%s%%%s%s" % (filter, fields, ","+label if label else "") + return self.send(self._line("WHO", [mask, flags])) diff --git a/src/utils/irc/__init__.py b/src/utils/irc/__init__.py index fa544c5d..b398cb56 100644 --- a/src/utils/irc/__init__.py +++ b/src/utils/irc/__init__.py @@ -1,6 +1,5 @@ import json, string, re, typing, uuid from src import utils -from . import protocol ASCII_UPPER = string.ascii_uppercase ASCII_LOWER = string.ascii_lowercase diff --git a/src/utils/irc/protocol.py b/src/utils/irc/protocol.py deleted file mode 100644 index ab2f7b5e..00000000 --- a/src/utils/irc/protocol.py +++ /dev/null @@ -1,90 +0,0 @@ -import typing -from src import IRCLine, utils - -def user(username: str, realname: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("USER", [username, "0", "*", realname]) -def nick(nickname: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("NICK", [nickname]) - -def capability_ls() -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("CAP", ["LS", "302"]) -def capability_request(capability: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("CAP", ["REQ", capability]) -def capability_end() -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("CAP", ["END"]) -def authenticate(text: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("AUTHENTICATE", [text]) - -def password(password: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("PASS", [password]) - -def ping(nonce: str="hello") -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("PING", [nonce]) -def pong(nonce: str="hello") -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("PONG", [nonce]) - -def join(channel_name: str, keys: typing.List[str]=None - ) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("JOIN", [channel_name]+( - keys if keys else [])) -def part(channel_name: str, reason: str=None) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("PART", [channel_name]+( - [reason] if reason else [])) -def quit(reason: str=None) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("QUIT", [reason] if reason else []) - -def privmsg(target: str, message: str, tags: typing.Dict[str, str]={} - ) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("PRIVMSG", [target, message], tags=tags) -def notice(target: str, message: str, tags: typing.Dict[str, str]={} - ) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("NOTICE", [target, message], tags=tags) -def tagmsg(target, tags: dict) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("TAGMSG", [target], tags=tags) - -def mode(target: str, mode: str=None, args: typing.List[str]=None - ) -> IRCLine.ParsedLine: - command_args = [target] - if mode: - command_args.append(mode) - if args: - command_args = command_args+args - return IRCLine.ParsedLine("MODE", command_args) - -def topic(channel_name: str, topic: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("TOPIC", [channel_name, topic]) -def kick(channel_name: str, target: str, reason: str=None - ) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("KICK", [channel_name, target]+( - [reason] if reason else [])) -def names(channel_name: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("NAMES", [channel_name]) -def list(search_for: str=None) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("LIST", [search_for] if search_for else []) -def invite(channel_name: str, target: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("INVITE", [target, channel_name]) - -def whois(target: str) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("WHOIS", [target]) -def whowas(target: str, amount: int=None, server: str=None - ) -> IRCLine.ParsedLine: - command_args = [target] - if amount: - command_args.append(str(amount)) - if server: - command_args.append(server) - return IRCLine.ParsedLine("WHOWAS", command_args) -def who(filter: str=None) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("WHO", [filter] if filter else []) -def whox(mask: str, filter: str, fields: str, label: str=None - ) -> IRCLine.ParsedLine: - flags = "%s%%%s%s" % (filter, fields, ","+label if label else "") - return IRCLine.ParsedLine("WHO", [mask, flags]) - -def batch_start(identifier: str, batch_type: str, tags: typing.Dict[str, str]={} - ) -> IRCLine.ParsedLine: - return IRCLine.ParsedLine("BATCH", ["+%s" % identifier, batch_type], - tags=tags) - -def batch_end(identifier: str, tags: typing.Dict[str, str]={}): - return IRCLine.ParsedLine("BATCH", ["-%s" % identifier], tags=tags) |