from collections import defaultdict from datetime import datetime, timedelta from typing import Optional import random import twitchio from twitchio import PartialUser, Scopes, eventsub from twitchio.ext import commands as cmds from data.queries import JOINTYPE, ORDER from meta import Bot, Context from meta.sockets import Channel, register_channel from utils.lib import utc_now, strfdelta from . import logger from .data import SubathonData, Subathon, RunningSubathon, SubathonContribution, SubathonGoal class TimerChannel(Channel): name = 'SubTimer' def __init__(self, cog: 'SubathonComponent', **kwargs): super().__init__(**kwargs) self.cog = cog # This is horribly inefficient but will be deprecated by the web update self.communities = defaultdict(set) # Map of communityid -> listening websockets async def on_connection(self, websocket, event): # TODO: Properly this should be communityid # Which is retrieved via API call to the profiles module for the channel # This should also be a different error so we can pass it back to the client. if not event.get('channelid', None): raise ValueError("Subtimer connection missing channel!") community = await self.cog.bot.profiles.profiles.get_community_twitch(event['channelid']) if community is None: raise ValueError('Requested channel is not registered. Add the bot first.') await super().on_connection(websocket, event) self.communities[community.communityid].add(websocket) await self.send_set( **await self.get_args_for(community.communityid), websocket=websocket, ) async def del_connection(self, websocket): for wss in self.communities.values(): wss.discard(websocket) await super().del_connection(websocket) async def send_updates(self, communityid: int): args = await self.get_args_for(communityid) for ws in self.communities[communityid]: await self.send_set( **args, websocket=ws ) async def get_args_for(self, communityid: int): active = await self.cog.get_active_subathon(communityid) if active is not None: ending = utc_now() + timedelta(seconds=await active.get_remaining()) # TODO: Next goal info and overall goal progress, maybe last contrib return { 'end_at': ending, 'running': active.running } else: return { 'end_at': utc_now, 'running': False, } async def send_set(self, end_at, running, websocket=None): await self.send_event({ 'type': "DO", 'method': 'setTimer', 'args': { 'end_at': end_at.isoformat(), 'running': running, } }, websocket=websocket) class ActiveSubathon: def __init__(self, subathondata: Subathon, runningdata: RunningSubathon | None): self.subathondata = subathondata self.runningdata = runningdata @property def running(self): return self.runningdata is not None @property def name(self): return self.subathondata.name or 'Subathon' async def check_cap(self): if not (cap := self.subathondata.timecap): return False else: score = await self.get_score() time_earned = self.get_score_time(score) total_time = self.subathondata.initial_time + time_earned return total_time >= cap async def pause(self): if not self.running: raise ValueError("This subathon is not running!") assert self.runningdata is not None new_duration = self.get_duration() await self.subathondata.update(duration=new_duration) await self.runningdata.delete() self.runningdata = None async def resume(self): if self.running: raise ValueError("This subathon is already running!") self.runningdata = await RunningSubathon.create(subathon_id=self.subathondata.subathon_id) async def get_score(self) -> float: rows = await SubathonContribution.fetch_where(subathon_id=self.subathondata.subathon_id) return sum(row.score for row in rows) def get_score_time(self, score: float) -> int: # Get time contributed by this score return int(score * self.subathondata.score_time) def get_duration(self) -> int: # Get the duration of this subathon so far duration = self.subathondata.duration if self.runningdata: now = utc_now() added = int( (now - self.runningdata.last_started).total_seconds() ) duration += added return duration async def get_remaining(self) -> int: # Get the remaining time score = await self.get_score() time_earned = self.get_score_time(score) total_time = self.subathondata.initial_time + time_earned if cap := self.subathondata.timecap: total_time = min(total_time, cap) return total_time - self.get_duration() async def add_contribution(self, profileid: int | None, score: float, event_id: int | None) -> SubathonContribution: return await SubathonContribution.create( subathon_id=self.subathondata.subathon_id, profileid=profileid, score=score, event_id=event_id ) async def get_goals(self) -> list[SubathonGoal]: goals = await SubathonGoal.fetch_where(subathon_id=self.subathondata.subathon_id).order_by('required_score') return goals class SubathonComponent(cmds.Component): # TODO: Add explicit dependencies and version checks # for profile and event tracker modules def __init__(self, bot: Bot): self.bot = bot self.data = bot.dbconn.load_registry(SubathonData()) self.channel = TimerChannel(self) register_channel('SubTimer', self.channel) # ----- API ----- async def component_load(self): await self.data.init() await self.bot.version_check(*self.data.VERSION) async def component_teardown(self): pass # ----- Methods ----- async def get_active_subathon(self, communityid: int) -> ActiveSubathon | None: rows = await Subathon.fetch_where(communityid=communityid, ended_at=None) if rows: subathondata = rows[0] running = await RunningSubathon.fetch(subathondata.subathon_id) subba = ActiveSubathon(subathondata, running) return subba async def goalcheck(self, active: ActiveSubathon, channel: PartialUser): goals = await active.get_goals() score = await active.get_score() for i, goal in enumerate(goals): if not goal.notified and goal.required_score <= score: # Goal completed, notify channel await channel.send_message( f"We have reached Goal #{i+1}: {goal.description} !! Thank you everyone for your support <3", sender=self.bot.bot_id, ) await goal.update(notified=True) # ----- Event Handlers ----- @cmds.Component.listener() async def event_safe_bits_use(self, payload): event_row, detail_row, bits_payload = payload if (active := await self.get_active_subathon(event_row['communityid'])) is not None: # In an active subathon pid = event_row['profileid'] uid = event_row['user_id'] score = detail_row['bits'] * active.subathondata.bit_score await active.add_contribution(pid, score, event_row['event_id']) # Send message to channel sec = active.get_score_time(score) added_min = int(sec // 60) if added_min > 0: added = f"{added_min} minutes" else: added = f"{sec} seconds" name = bits_payload.user.name pl = 's' if bits_payload.bits != 1 else '' contrib_str = f"{name} contributed {score} point{pl}" if not await active.check_cap(): contrib_str += f" and added {added} to the timer! Thank you <3" else: contrib_str += " towards our subathon! Thank you <3" await bits_payload.broadcaster.send_message( contrib_str, sender=self.bot.bot_id ) await self.channel.send_updates(event_row['communityid']) await self.goalcheck(active, bits_payload.broadcaster) # Check goals @cmds.Component.listener() async def event_safe_subscription(self, payload): event_row, detail_row, sub_payload = payload if sub_payload.gift: # Ignore gifted here return if (active := await self.get_active_subathon(event_row['communityid'])) is not None: data = active.subathondata # In an active subathon pid = event_row['profileid'] tier = int(sub_payload.tier) if tier == 1000: mult = data.sub1_score elif tier == 2000: mult = data.sub2_score elif tier == 3000: mult = data.sub3_score else: raise ValueError(f"Unknown sub tier {sub_payload.tier}") score = mult * 1 await active.add_contribution(pid, score, event_row['event_id']) # Send message to channel added_min = int(active.get_score_time(score) // 60) added = f"{added_min} minutes" name = sub_payload.user.name pl = 's' if score > 1 else '' contrib_str = f"{name} contributed {score} point{pl}" if not await active.check_cap(): contrib_str += f" and added {added} to the timer! Thank you <3" else: contrib_str += " towards our subathon! Thank you <3" await sub_payload.broadcaster.send_message( contrib_str, sender=self.bot.bot_id ) await self.channel.send_updates(event_row['communityid']) # Check goals await self.goalcheck(active, sub_payload.broadcaster) @cmds.Component.listener() async def event_safe_subscription_gift(self, payload): event_row, detail_row, gift_payload = payload if (active := await self.get_active_subathon(event_row['communityid'])) is not None: data = active.subathondata # In an active subathon pid = event_row['profileid'] tier = int(gift_payload.tier) if tier == 1000: mult = data.sub1_score elif tier == 2000: mult = data.sub2_score elif tier == 3000: mult = data.sub3_score else: raise ValueError(f"Unknown sub tier {gift_payload.tier}") score = mult * gift_payload.total await active.add_contribution(pid, score, event_row['event_id']) # Send message to channel added_min = int(active.get_score_time(score) // 60) added = f"{added_min} minutes" name = gift_payload.user.name if gift_payload.user else 'Anonymous' contrib_str = f"{name} contributed {score} points" if not await active.check_cap(): contrib_str += f" and added {added} to the timer! Thank you <3" else: contrib_str += " towards our subathon! Thank you <3" await gift_payload.broadcaster.send_message( contrib_str, sender=self.bot.bot_id ) await self.channel.send_updates(event_row['communityid']) # Check goals await self.goalcheck(active, gift_payload.broadcaster) @cmds.Component.listener() async def event_safe_subscription_message(self, payload): event_row, detail_row, sub_payload = payload if (active := await self.get_active_subathon(event_row['communityid'])) is not None: data = active.subathondata # In an active subathon pid = event_row['profileid'] tier = int(sub_payload.tier) if tier == 1000: mult = data.sub1_score elif tier == 2000: mult = data.sub2_score elif tier == 3000: mult = data.sub3_score else: raise ValueError(f"Unknown sub tier {sub_payload.tier}") score = mult * 1 await active.add_contribution(pid, score, event_row['event_id']) # Send message to channel added_min = int(active.get_score_time(score) // 60) added = f"{added_min} minutes" name = sub_payload.user.name pl = 's' if score > 1 else '' contrib_str = f"{name} contributed {score} points{pl}" if not await active.check_cap(): contrib_str += f" and added {added} to the timer! Thank you <3" else: contrib_str += " towards our subathon! Thank you <3" await sub_payload.broadcaster.send_message( contrib_str, sender=self.bot.bot_id ) await self.channel.send_updates(event_row['communityid']) # Check goals await self.goalcheck(active, sub_payload.broadcaster) # end stream => Automatically pause the timer @cmds.Component.listener() async def event_stream_offline(self, payload: twitchio.StreamOffline): community = await self.bot.profiles.fetch_community(payload.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: if active.running: await active.pause() await payload.broadcaster.send_message( "Paused the subathon timer because the stream went offline!", sender=self.bot.bot_id ) await self.channel.send_updates(cid) # ----- Commands ----- @cmds.group(name='subathon', aliases=['studython'], invoke_fallback=True) async def group_subathon(self, ctx: cmds.Context): community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: score = await active.get_score() goals = await active.get_goals() total_goals = len(goals) donegoals = len([goal for goal in goals if score >= goal.required_score]) goalstr = f"{donegoals}/{total_goals} goals achieved" secs = await active.get_remaining() remaining = strfdelta(timedelta(seconds=secs)) secs = active.get_duration() duration = strfdelta(timedelta(seconds=secs)) text = ( f"{active.name} running for {duration}! {score} points recieved, {goalstr}, and {remaining} left on the timer" ) await ctx.reply(text) else: await ctx.reply("No active subathon running!") # subathon start @group_subathon.command(name='setup', alias='start') @cmds.is_broadcaster() async def cmd_setup(self, ctx: cmds.Context, name: str, initial_hours: float, sub1: float, sub2: float, sub3: float, bit: float, timescore: int, timecap: Optional[int]=None): """ Creates a new subathon. USAGE: {prefix}subathon setup [timecap] Arguments: initial_hours = number of hours to start the timer with sub1_points = points per T1 sub sub2_points = points per T2 sub sub3_points = points per T3 sub bit_points = points per bit timepoints = seconds to be added to the timer per point timecap (optional) = number of seconds to cap the timer at. """ community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: await ctx.reply("There is already an active subathon running! Use !subathon stop to stop it!") return initial_time = initial_hours * 60 * 60 active = await Subathon.create( communityid=cid, name=name, initial_time=initial_time, sub1_score=sub1, sub2_score=sub2, sub3_score=sub3, bit_score=bit, score_time=timescore, timecap=timecap ) base_timer_url = self.bot.config.subathon['timer_url'] timer_link = f"{base_timer_url}?channelid={ctx.channel.id}" await ctx.reply(f"Setup your {name}! Use !subathon resume to get the timer running. Your timer link: {timer_link}") await self.channel.send_updates(cid) # subathon stop @group_subathon.command(name='stop') @cmds.is_broadcaster() async def cmd_stop(self, ctx: cmds.Context): community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: if active.running: await active.pause() await self.channel.send_updates(cid) await active.subathondata.update(ended_at=utc_now()) total = await active.get_score() dursecs = active.get_duration() dur = strfdelta(timedelta(seconds=dursecs)) await ctx.reply( f"{active.name} complete after {dur} with a total of {total} points, congratulations!" ) else: await ctx.reply("No active subathon to stop.") # subathon pause @group_subathon.command(name='pause') @cmds.is_moderator() async def cmd_pause(self, ctx: cmds.Context): community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: if active.running: await active.pause() await ctx.reply(f"{active.name} timer paused!") await self.channel.send_updates(cid) else: await ctx.reply(f"{active.name} timer already paused!") else: await ctx.reply("No active subathon to pause") # subathon resume @group_subathon.command(name='resume') @cmds.is_moderator() async def cmd_resume(self, ctx: cmds.Context): community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: if not active.running: await active.resume() await ctx.reply(f"{active.name} timer resumed!") await self.channel.send_updates(cid) else: await ctx.reply(f"{active.name} timer already running!") else: await ctx.reply("No active subathon to resume") # subathon adjust @group_subathon.command(name='adjust') @cmds.is_moderator() async def cmd_subathon_adjust(self, ctx: Context, amount: int, *, user: Optional[twitchio.User] = None): """ Directly add or remove points from the subathon. If a user is provided, will adjust their contributed amount. USAGE: {prefix}subathon adjust [@user] Arguments: 'amount' is an integer number of points to adjust by. It may be negative to remove points. '@user' is an optional user name or mention to adjust for. Examples: '{prefix}subathon adjust 10' '{prefix}subathon adjust -10 @machinestalkerwolfie' """ community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: if user is not None: profile = await self.bot.profiles.fetch_profile(user) name = user.display_name or profile.nickname or 'Unknown' pid = profile.profileid else: profile = None name = None pid = None await active.add_contribution(pid, amount, None) await self.channel.send_updates(cid) # Build message if amount > 0: amountstr = f"Added {amount} point(s) to the timer" elif amount < 0: amountstr = f"Removed {-amount} point(s) from the timer" else: amountstr = "Did nothing to the timer" namestr = f"on behalf of {name}" if profile else "" message = f"{amountstr} {namestr}" await ctx.reply(message) else: await ctx.reply("No active subathon to adjust") @group_subathon.command(name='leaderboard', aliases=('top', 'lb',)) async def cmd_subathon_lb(self, ctx: Context): """ Display top contributors by points contributed, up to 10. Anonymous contributions are gathered as one user. """ # TODO: Might want to extend stats to select/show last subathon as well # IDEA: We could also offer full export as csv via web community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid caller_profile = await self.bot.profiles.fetch_profile(ctx.chatter) caller_pid = caller_profile.profileid if (active := await self.get_active_subathon(cid)) is not None: # Get totals for all contributors query = self.data.subathon_contributions.select_where(subathon_id=active.subathondata.subathon_id) query.join('user_profiles', using=('profileid',), join_type=JOINTYPE.LEFT) query.select('subathon_id', 'profileid', total="SUM(score)") query.order_by('total', direction=ORDER.DESC) query.group_by('subathon_id', 'profileid') query.with_no_adapter() results = await query parts = [] caller_idx = None for i, row in enumerate(results): if pid := row['profileid']: profile = await self.bot.profiles.profiles.get_profile(pid) name = (profile.nickname if profile else None) or 'Unknown' if pid == caller_pid: caller_idx = i else: name = 'Anonymous' score = row['total'] part = f"{name}: {score} points" parts.append(part) header = "" leaderboard = ', '.join(parts[:10]) footer = "" if len(parts) > 10: header = f"{active.name} top 10 leaderboard: " leaderboard = ', '.join(parts[:10]) if caller_idx is not None and caller_idx >= 10: caller_part = parts[caller_idx] footer = f" ... {caller_part}" elif parts: header = f"{active.name} contribution leaderboard: " else: header = "No contributions to show yet!" message = f"{header} {leaderboard} {footer}" await ctx.reply(message) else: await ctx.reply("No active subathon to show leaderboard of!") # Subathon goals @cmds.group(name='goals', invoke_fallback=True) async def group_goals(self, ctx: cmds.Context): # List the goals community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: goals = await active.get_goals() goalstrs = [] for i, goal in enumerate(goals, start=1): line = f"{goal.required_score} points: {goal.description}" goalstrs.append(line) if goals: text = ', '.join(goalstrs) await ctx.reply(f"{active.name} Goals! -- {text}") else: await ctx.reply("No goals have been configured!") else: await ctx.reply("No active subathon running!") @group_goals.command(name='add') @cmds.is_moderator() async def cmd_add(self, ctx: cmds.Context, required: int, *, description: str): community = await self.bot.profiles.fetch_community(ctx.broadcaster) cid = community.communityid if (active := await self.get_active_subathon(cid)) is not None: await SubathonGoal.create( subathon_id=active.subathondata.subathon_id, required_score=required, description=description, ) await ctx.reply("Goal added!") else: await ctx.reply("No active subathon to add goal to!")