Minor typing consistency

rocketbot/cogs/basecog.py

 		else:
 			context.last_warned = datetime.now()
 
-	def record_warnings(self, members: list):
+	def record_warnings(self, members: list[Member]):
 		"""
 		Records that mods have been warned about some members and do not need to
 		be warned about them again for a short while.

rocketbot/cogs/gamescog.py

 import math
 import random
+from typing import Any
 
 from discord import Interaction, UnfurledMediaItem
 from discord.app_commands import Range, command, guild_only
 		container = Container(section, accent_color=0xff0000)
 		self.add_item(container)
 
-def listed_items(items: list) -> str:
+def listed_items(items: list[Any]) -> str:
 	if len(items) == 0:
 		return 'nothing'
 	if len(items) == 1:

rocketbot/cogs/joinraidcog.py

 """
 import weakref
 from datetime import datetime, timedelta
+from typing import Optional
 
 from discord import Guild, Member
 from discord.ext.commands import Cog
 	"""
 	Data about a join raid.
 	"""
-	def __init__(self, join_members: list):
-		self.join_members = list(join_members)
-		self.kicked_members = set()
-		self.banned_members = set()
-		self.warning_message_ref = None
+	def __init__(self, join_members: list[Member]):
+		self.join_members: list[Member] = list(join_members)
+		self.kicked_members: set[Member] = set()
+		self.banned_members: set[Member] = set()
+		self.warning_message_ref: Optional[weakref.ReferenceType[BotMessage]] = None
 
 	def last_join_time(self) -> datetime:
 		"""Returns when the most recent member join was, in UTC"""
 		guild: Guild = bot_message.guild
 		raid: JoinRaidContext = bot_message.context
 		if reaction.emoji == CONFIG['kick_emoji']:
-			to_kick = set(raid.join_members) - raid.kicked_members
+			to_kick: set[Member] = set(raid.join_members) - raid.kicked_members
 			for member in to_kick:
 				await member.kick(
 					reason=f'Rocketbot: Part of join raid. Kicked by {reacted_by.name}.')

rocketbot/cogs/logcog.py

 import re
 from collections.abc import Sequence
 from datetime import datetime, timedelta, timezone
-from typing import Callable, Optional, Tuple, Union
+from typing import Any, Callable, Optional, Union
 
 from discord import (
 	AuditLogAction,
 		"""
 		return f'**{user.name}** ({user.display_name} {user.id})'
 
-	def __diff(self, a: str, b: str) -> Tuple[str, str]:
+	def __diff(self, a: str, b: str) -> tuple[str, str]:
 		# URLs don't work well in the diffs. Replace them with private use characters, one per unique URL.
 		preserved_sequences = []
 		def sub_token(match: re.Match) -> str:
 
 		return markdown_a, markdown_b
 
-	def __groupby(self, a_list: list, grouper: Callable[[any], any]) -> dict:
+	def __groupby(self, a_list: list[Any], grouper: Callable[[Any], Any]) -> dict:
 		"""itertools.groupby just less annoying"""
 		d = {}
 		for elem in a_list:

rocketbot/cogs/patterncog.py

 	actions have been carried out.
 	"""
 	def __init__(self, message: Message, statement: PatternStatement):
-		self.message = message
-		self.statement = statement
-		self.is_deleted = False
-		self.is_kicked = False
-		self.is_banned = False
+		self.message: Message = message
+		self.statement: PatternStatement = statement
+		self.is_deleted: bool = False
+		self.is_kicked: bool = False
+		self.is_banned: bool = False
 
 async def pattern_name_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
 	choices: list[Choice[str]] = []

rocketbot/cogsetting.py

 """
 
 from datetime import timedelta
-from typing import TYPE_CHECKING, Any, Literal, Optional, Type, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 from discord import Interaction, Permissions
 from discord.app_commands import Range, Transform, describe
 else:
 	BaseCog = 'BaseCog'
 
-def describe_type(datatype: Type) -> str:
+def describe_type(datatype: type) -> str:
 	if datatype is int:
 		return 'integer'
 	if datatype is float:
 
 	def __init__(self,
 			name: str,
-			datatype: Optional[Type],
+			datatype: Optional[type],
 			default_value: Any,
 			brief: Optional[str] = None,
 			description: Optional[str] = None,
 		----------
 		name: str
 			Setting identifier. Must follow variable naming conventions.
-		datatype: Optional[Type]
+		datatype: Optional[type]
 		    Datatype of the setting. E.g. int, float, str
 		default_value: Any
 			Value to use if a guild has not yet configured one.
 		  	Set of allowed values. None if unconstrained.
 		"""
 		self.name: str = name
-		self.datatype: Type = datatype
+		self.datatype: type = datatype
 		self.default_value = default_value
 		self.brief: Optional[str] = brief
 		self.description: str = description or ''  # Can't be None

rocketbot/utils.py

 import sys
 import traceback
 from datetime import datetime, timedelta
-from typing import Any, Optional, Type, Union
+from typing import Any, Optional, Union
 
 import discord
 from discord import Guild, Interaction, Permissions
 			return member
 	return None
 
-def bot_log(guild: Optional[Guild], cog_class: Optional[Type], message: Any) -> None:
+def bot_log(guild: Optional[Guild], cog_class: Optional[type], message: Any) -> None:
 	"""Logs a message to stdout with time, cog, and guild info."""
 	now: datetime = datetime.now() # local
 	s = f'[{now.strftime("%Y-%m-%dT%H:%M:%S")}|'