Coverage for bot/irc_runtime.py: 92%

40 statements  

« prev     ^ index     » next       coverage.py v7.10.7, created at 2026-02-25 12:30 -0300

1import asyncio 

2from typing import Any 

3 

4from bot.irc_connection import IrcConnectionMixin 

5from bot.irc_handlers import IrcLineHandlersMixin 

6from bot.irc_management import IrcChannelManagementMixin 

7from bot.irc_state import IrcChannelStateMixin 

8from bot.observability import observability 

9from bot.runtime_config import ( 

10 OWNER_ID, 

11 TWITCH_TOKEN_REFRESH_TIMEOUT_SECONDS, 

12 TWITCH_TOKEN_VALIDATE_TIMEOUT_SECONDS, 

13 logger, 

14) 

15from bot.status_runtime import normalize_channel_login 

16from bot.twitch_tokens import TwitchTokenManager, TwitchTokenManagerSettings 

17 

18 

19class IrcByteBot( 

20 IrcChannelManagementMixin, 

21 IrcChannelStateMixin, 

22 IrcLineHandlersMixin, 

23 IrcConnectionMixin, 

24): 

25 def __init__( 

26 self, 

27 *, 

28 host: str, 

29 port: int, 

30 use_tls: bool, 

31 bot_login: str, 

32 channel_login: str | None = None, 

33 channel_logins: list[str] | None = None, 

34 user_token: str = "", 

35 token_manager: TwitchTokenManager | None = None, 

36 ) -> None: 

37 provided_channels = list(channel_logins or []) 

38 if channel_login: 

39 provided_channels.append(channel_login) 

40 

41 resolved_channels: list[str] = [] 

42 seen_channels: set[str] = set() 

43 for candidate in provided_channels: 

44 normalized = normalize_channel_login(candidate) 

45 if not normalized or normalized in seen_channels: 

46 continue 

47 seen_channels.add(normalized) 

48 resolved_channels.append(normalized) 

49 if not resolved_channels: 

50 raise RuntimeError("Defina ao menos 1 canal valido para o modo IRC.") 

51 

52 self.host = host 

53 self.port = port 

54 self.use_tls = use_tls 

55 self.bot_login = bot_login.lower() 

56 self.owner_id = OWNER_ID 

57 self.channel_logins = resolved_channels 

58 self.joined_channels = set(resolved_channels) 

59 self.primary_channel_login = resolved_channels[0] 

60 self.token_manager = token_manager or TwitchTokenManager( 

61 access_token=user_token, 

62 settings=TwitchTokenManagerSettings( 

63 validate_timeout_seconds=TWITCH_TOKEN_VALIDATE_TIMEOUT_SECONDS, 

64 refresh_timeout_seconds=TWITCH_TOKEN_REFRESH_TIMEOUT_SECONDS, 

65 ), 

66 observability=observability, 

67 logger=logger, 

68 ) 

69 self.reader: asyncio.StreamReader | None = None 

70 self.writer: Any = None 

71 self._line_reader_running = False 

72 self._line_reader_task: asyncio.Task[Any] | None = None 

73 self._pending_join_events: dict[str, asyncio.Event] = {} 

74 self._pending_part_events: dict[str, asyncio.Event] = {}