292 lines
8.1 KiB
Python
292 lines
8.1 KiB
Python
"""
|
|
Minimal IRC client intended to connect to one channel and send a message.
|
|
"""
|
|
|
|
import asyncio
|
|
import aiohttp
|
|
import time
|
|
import re
|
|
|
|
from . import logger
|
|
|
|
|
|
ACTIONS = (
|
|
"JOIN",
|
|
"PART",
|
|
"PING",
|
|
"PRIVMSG",
|
|
"PRIVMSG(ECHO)",
|
|
"USERSTATE",
|
|
"MODE",
|
|
"WHISPER",
|
|
"USERNOTICE",
|
|
"NOTICE",
|
|
)
|
|
ACTIONS2 = ("USERSTATE", "ROOMSTATE", "PRIVMSG", "USERNOTICE", "WHISPER")
|
|
USER_SUB = re.compile(r":(?P<user>.*)!")
|
|
MESSAGE_RE = re.compile(
|
|
r":(?P<useraddr>\S+) (?P<action>\S+) (?P<channel>\S+)( :(?P<message>.*))?$"
|
|
)
|
|
FAST_RETURN = {
|
|
"RECONNECT": {"code": 0, "action": "RECONNECT"},
|
|
"PING": {"action": "PING"},
|
|
}
|
|
|
|
|
|
def parser(data: str, nick: str):
|
|
groups = data.split()
|
|
action = groups[1] if groups[1] == "JOIN" else groups[-2]
|
|
channel = None
|
|
message = None
|
|
user = None
|
|
badges = None
|
|
|
|
_group_len = len(groups)
|
|
|
|
if action in FAST_RETURN:
|
|
return FAST_RETURN[action]
|
|
|
|
elif groups[1] in FAST_RETURN:
|
|
return FAST_RETURN[groups[1]]
|
|
|
|
elif (
|
|
groups[1] in ACTIONS
|
|
or (_group_len > 2 and groups[2] in ACTIONS)
|
|
or (_group_len > 3 and groups[3] in {"PRIVMSG", "PRIVMSG(ECHO)"})
|
|
):
|
|
result = re.search(MESSAGE_RE, data)
|
|
if not result:
|
|
logger.error("****** MESSAGE_RE Failed! ******")
|
|
raise ValueError("Could not parse message '%s' as IRC message" % data)
|
|
user = result.group("useraddr").split("!")[0]
|
|
action = result.group("action")
|
|
channel = result.group("channel").lstrip("#")
|
|
message = result.group("message")
|
|
|
|
if action == "WHISPER":
|
|
channel = None
|
|
|
|
if action in ACTIONS2:
|
|
prebadge = groups[0].split(";")
|
|
badges = {}
|
|
|
|
for badge in prebadge:
|
|
badge = badge.split("=")
|
|
|
|
try:
|
|
badges[badge[0]] = badge[1]
|
|
except IndexError:
|
|
pass
|
|
|
|
if action == "USERSTATE" and badges.get("display-name"):
|
|
user = badges["display-name"].lower()
|
|
|
|
if action == "USERNOTICE" and badges.get("login"):
|
|
user = badges["login"].lower()
|
|
elif action not in ACTIONS:
|
|
action = None
|
|
|
|
if not user:
|
|
try:
|
|
user = re.search(USER_SUB, groups[0]).group("user")
|
|
except (AttributeError, ValueError):
|
|
pass
|
|
|
|
try:
|
|
code = int(groups[1])
|
|
except ValueError:
|
|
code = 0
|
|
|
|
batches = []
|
|
if code == 353:
|
|
channel = groups[4]
|
|
if channel[0] == "#":
|
|
channel = channel[1:]
|
|
else:
|
|
logger.warning(f" (353) parse failed? ||{channel}||")
|
|
|
|
if user is None:
|
|
user = groups[-1][1:].lower()
|
|
for b in groups[5:-1]:
|
|
if b[0] == ":":
|
|
b = b[1:]
|
|
|
|
if "\r\n:" in b:
|
|
batches.append(b.split("\r\n:")[0])
|
|
break
|
|
else:
|
|
batches.append(b)
|
|
|
|
return dict(
|
|
data=data,
|
|
nick=nick,
|
|
groups=groups,
|
|
action=action,
|
|
channel=channel,
|
|
user=user,
|
|
badges=badges,
|
|
code=code,
|
|
message=message,
|
|
batches=batches,
|
|
)
|
|
|
|
|
|
class FocusChannel:
|
|
IRC_URI = "wss://irc-ws.chat.twitch.tv:443"
|
|
|
|
def __init__(self, channel: str, token: str, session: aiohttp.ClientSession):
|
|
self.channel = channel.lower()
|
|
self.token = token
|
|
self.session = session
|
|
|
|
self._socket = None
|
|
self._keeper: asyncio.Task | None = None
|
|
self._ws_ready_event: asyncio.Event = asyncio.Event()
|
|
self._joined: asyncio.Event = asyncio.Event()
|
|
|
|
self.is_ready: asyncio.Event = asyncio.Event()
|
|
|
|
self.modes = ("commands",)
|
|
self._last_ping = 0
|
|
self._reconnect_requested = False
|
|
|
|
@property
|
|
def is_alive(self):
|
|
return self._socket is not None and not self._socket.closed
|
|
|
|
async def wait_until_ready(self):
|
|
await self.is_ready.wait()
|
|
|
|
async def connect(self):
|
|
self.is_ready.clear()
|
|
|
|
if self._keeper:
|
|
self._keeper.cancel()
|
|
if self.is_alive:
|
|
await self._socket.close()
|
|
|
|
try:
|
|
self._socket = await self.session.ws_connect(url=self.IRC_URI)
|
|
except Exception as e:
|
|
logger.error(f"FocusChannel IRC connection failed: {e}")
|
|
raise
|
|
|
|
self._reconnect_requested = False
|
|
self._keeper = asyncio.create_task(self._keep_alive())
|
|
self._ws_ready_event.set()
|
|
|
|
async def authenticate(self):
|
|
if not self.is_alive:
|
|
raise ValueError("Cannot authenticate before connection.")
|
|
await self.send(f"PASS oauth:{self.token}\r\n")
|
|
await self.send(f"NICK {self.channel}\r\n")
|
|
|
|
for cap in self.modes:
|
|
await self.send(f"CAP REQ :twitch.tv/{cap}")
|
|
|
|
async def join(self):
|
|
if not self.is_alive:
|
|
raise ValueError("Cannot join before connection.")
|
|
|
|
self._joined.clear()
|
|
|
|
await self.send(f"JOIN #{self.channel}\r\n")
|
|
await self._joined.wait()
|
|
|
|
async def send(self, message: str):
|
|
await self._socket.send_str(message + "\r\n")
|
|
|
|
async def _process_data(self, data: str):
|
|
data = data.rstrip()
|
|
parsed = parser(data, self.channel)
|
|
|
|
if parsed["action"] == "PING":
|
|
return await self._ping()
|
|
elif parsed["action"] == "RECONNECT":
|
|
return await self._reconnect(parsed)
|
|
elif parsed["code"] != 0:
|
|
return await self._code(parsed, parsed["code"])
|
|
elif data.startswith(":tmi.twitch.tv NOTICE * :Login unsuccessful"):
|
|
logger.error(f"Failed to login to Twitch IRC channel {self.channel}")
|
|
return await self._close()
|
|
else:
|
|
# TODO: We could handle other actions here
|
|
return None
|
|
|
|
async def _code(self, parsed, code: int):
|
|
logger.info(f"{self!r} received '{code}': {parsed}")
|
|
|
|
if code == 1:
|
|
logger.info(f"FocusChannel logged into '{self.channel}'")
|
|
elif code == 353:
|
|
pass
|
|
elif code in (2, 3, 4, 366, 372, 375):
|
|
pass
|
|
elif code == 376:
|
|
pass
|
|
else:
|
|
pass
|
|
|
|
async def _ping(self):
|
|
self._last_ping = time.monotonic()
|
|
await self.send("PONG :tmi.twitch.tv\r\n")
|
|
|
|
async def _close(self):
|
|
if self._keeper:
|
|
self._keeper.cancel()
|
|
|
|
self.is_ready.clear()
|
|
if self._socket:
|
|
await self._socket.close()
|
|
|
|
async def _join(self, parsed):
|
|
channel = parsed["channel"]
|
|
logger.info(f"ACTION: JOIN:: {channel}")
|
|
|
|
if self.channel != channel.lower():
|
|
logger.info(
|
|
f"FocusChannel '{self.channel}' got join event for '{channel}'.. ignoring"
|
|
)
|
|
else:
|
|
self._joined.set()
|
|
|
|
async def _keep_alive(self):
|
|
await self._ws_ready_event.wait()
|
|
self._ws_ready_event.clear()
|
|
|
|
if not self._last_ping:
|
|
self._last_ping = time.monotonic()
|
|
while not self._socket.closed and not self._reconnect_requested:
|
|
msg = await self._socket.receive()
|
|
|
|
if msg.type is aiohttp.WSMsgType.CLOSED:
|
|
logger.error(f"Websocket connection closed: {msg.extra}")
|
|
break
|
|
data = msg.data
|
|
if data:
|
|
logger.debug(f" < {data}")
|
|
events = data.split("\r\n")
|
|
for event in events:
|
|
if not event:
|
|
continue
|
|
try:
|
|
await self._process_data(event)
|
|
except Exception:
|
|
logger.exception(
|
|
"Websocket message processing failed: %s", str(event)
|
|
)
|
|
|
|
async def _reconnect(self, parsed):
|
|
logger.info(f"ACTION: {self!r} recconecting")
|
|
self._reconnect_requested = True
|
|
if self._keeper:
|
|
self._keeper.cancel()
|
|
asyncio.create_task(self.connect())
|
|
|
|
async def send_msg(self, content: str):
|
|
logger.debug(f"Sending: {content}")
|
|
await self._socket.send_str(content)
|
|
|
|
async def delete_msg(self, msgid: str):
|
|
return await self.send_msg(f"/delete {msgid}")
|