PyCharm linter stuff. URLs now handled better in edit log message diffs

.gitignore

 # Rocketbot stuff
 /config.py
 /config/**
+
+# PyCharm
+.idea

README.md

 
 Experimental Discord bot written in Python.
 
+## Requirements
+
+* Written for Python 3.9
+* Install dependencies with `pip3.9 install -r requirements.txt`
+
 ## Usage
 
 * To see the list of commands, type `$rb_help`.

requirements.txt

+discord.py == 2.3.2

rocketbot/botmessage.py

 		s += self.text
 
 		if self.quote:
-			s += f'\n\n> {self.quote}'
+			quoted = '\n> '.join(self.quote.splitlines())
+			s += f'\n\n> {quoted}'
 
 		if len(self.__reactions) > 0:
 			s += '\n\nAvailable actions:'

rocketbot/cogs/autokickcog.py

 from rocketbot.cogs.basecog import BaseCog, BotMessage, CogSetting
 from rocketbot.collections import AgeBoundDict
 from rocketbot.storage import Storage
-from rocketbot.utils import bot_log
 
 class AutoKickContext:
 	"""
 			self.log(guild, f'New member {member.name} status is {member.status}')
 			self.status_check_members.append(StatusCheckContext(member))
 			return
-		self.__kick_or_ban_if_needed(member)
+		await self.__kick_or_ban_if_needed(member)
 
 	@tasks.loop(seconds=5.0)
 	async def status_check_timer(self):
 	@staticmethod
 	def ordinal(val: int):
 		'Formats an integer with an ordinal suffix (English only)'
-		if val % 10 == 1:
-			return f'{val}st'
-		if val % 10 == 2:
-			return f'{val}nd'
-		if val % 10 == 3:
-			return f'{val}rd'
+		if val % 100 < 10 or val % 100 > 20:
+			if val % 10 == 1:
+				return f'{val}st'
+			if val % 10 == 2:
+				return f'{val}nd'
+			if val % 10 == 3:
+				return f'{val}rd'
 		return f'{val}th'

rocketbot/cogs/basecog.py

 """
 Base cog class and helper classes.
 """
-from datetime import datetime, timedelta
-from discord import Guild, Member, Message, RawReactionActionEvent
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from discord import Guild, Member, Message, RawReactionActionEvent, TextChannel
 from discord.abc import GuildChannel
 from discord.ext import commands
 
 	def __bot_messages(cls, guild: Guild) -> AgeBoundDict:
 		bm = Storage.get_state_value(guild, 'bot_messages')
 		if bm is None:
-			far_future = datetime.utcnow() + timedelta(days=1000)
+			far_future = datetime.now(timezone.utc) + timedelta(days=1000)
 			bm = AgeBoundDict(timedelta(seconds=600),
 				lambda k, v : v.message_sent_at() or far_future)
 			Storage.set_state_value(guild, 'bot_messages', bm)
 			# Can't use this reaction with this message
 			return
 
-		channel: GuildChannel = guild.get_channel(payload.channel_id) or await guild.fetch_channel(payload.channel_id)
-		if channel is None:
+		g_channel: GuildChannel = guild.get_channel(payload.channel_id) or await guild.fetch_channel(payload.channel_id)
+		if g_channel is None:
 			# Possibly a DM
 			return
+		if not isinstance(g_channel, TextChannel):
+			return
+		channel: TextChannel = g_channel
 		member: Member = payload.member
 		if member is None:
 			return
 	# Helpers
 
 	@classmethod
-	def log(cls, guild: Guild, message) -> None:
+	def log(cls, guild: Optional[Guild], message) -> None:
 		"""
 		Writes a message to the console. Intended for significant events only.
 		"""

rocketbot/cogs/configcog.py

 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def config(self, context: commands.Context):
-		'General guild configuration command group'
+		"""General guild configuration command group"""
 		if context.invoked_subcommand is None:
 			await context.send_help()
 
 			'will not be posted!',
 	)
 	async def setwarningchannel(self, context: commands.Context) -> None:
-		'Command handler'
+		"""Command handler"""
 		guild: Guild = context.guild
 		channel: TextChannel = context.channel
 		Storage.set_config_value(guild, ConfigKey.WARNING_CHANNEL_ID,
 			'warnings will be posted.',
 	)
 	async def getwarningchannel(self, context: commands.Context) -> None:
-		'Command handler'
+		"""Command handler"""
 		guild: Guild = context.guild
 		channel_id = Storage.get_config_value(guild, ConfigKey.WARNING_CHANNEL_ID)
 		if channel_id is None:
 	async def setwarningmention(self,
 			context: commands.Context,
 			mention: str = None) -> None:
-		'Command handler'
+		"""Command handler"""
 		guild: Guild = context.guild
 		Storage.set_config_value(guild, ConfigKey.WARNING_MENTION, mention)
 		if mention is None:
 			'warning messages.'
 	)
 	async def getwarningmention(self, context: commands.Context) -> None:
-		'Command handler'
+		"""Command handler"""
 		guild: Guild = context.guild
 		mention: str = Storage.get_config_value(guild, ConfigKey.WARNING_MENTION)
 		if mention is None:

rocketbot/cogs/crosspostcog.py

 			message_type: int = BotMessage.TYPE_INFO if self.was_warned_recently(context.member) \
 				else BotMessage.TYPE_MOD_WARNING
 			message = BotMessage(context.member.guild, '', message_type, context)
-			message.quote = discordutils.remove_markdown(first_spam_message.clean_content)
+			message.quote = discordutils.remove_markdown(first_spam_message.clean_content())
 			self.record_warning(context.member)
 		if context.is_autobanned:
 			text = f'User {context.member.mention} auto banned for ' + \

rocketbot/cogs/generalcog.py

 Cog for handling most ungrouped commands and basic behaviors.
 """
 import re
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
 from discord import Message
 from discord.errors import DiscordException
 from discord.ext import commands
 				f'{CONFIG["failure_emoji"]} age must be a timespan, like "30s", "10m", "1h30m"',
 				mention_author=False)
 			return
-		cutoff: datetime = datetime.utcnow() - age_delta
+		cutoff: datetime = datetime.now(timezone.utc) - age_delta
 		def predicate(message: Message) -> bool:
 			return str(message.author.id) == member_id and message.created_at >= cutoff
 		deleted_messages = []
 			f'messages by <@!{member_id}> from the past {describe_timedelta(age_delta)}.',
 			mention_author=False)
 
-	def __parse_member_id(self, arg: str) -> str:
+	def __parse_member_id(self, arg: str) -> Optional[str]:
 		p = re.compile('^<@!?([0-9]+)>$')
 		m = p.match(arg)
 		if m:

rocketbot/cogs/joinagecog.py

 import weakref
 
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from discord import Guild, Member
 from discord.ext import commands
 
 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def joinage(self, context: commands.Context):
-		'Join age tracking'
+		"""Join age tracking"""
 		if context.invoked_subcommand is None:
 			await context.send_help()
 
 		usage='<time_period>'
 	)
 	async def search(self, context: commands.Context, timespan: str):
-		'Command handler'
+		"""Command handler"""
 		guild: Guild = context.guild
 		recent_joins: AgeBoundList = Storage.get_state_value(guild, self.STATE_KEY_RECENT_JOINS)
 		if recent_joins is None:
 			max_age: timedelta = timedelta(seconds=self.get_guild_setting(guild, self.SETTING_JOIN_TIME))
-			recent_joins = AgeBoundList(max_age, lambda i, member : member.joined_at)
+			recent_joins = AgeBoundList(max_age, lambda i, member0 : member0.joined_at)
 			Storage.set_state_value(guild, self.STATE_KEY_RECENT_JOINS, recent_joins)
 		results: list = []
 		ts: timedelta = timedelta_from_str(timespan)
-		cutoff: datetime = datetime.utcnow() - ts
+		cutoff: datetime = datetime.now(timezone.utc) - ts
 		for member in recent_joins:
 			if member.joined_at > cutoff:
 				results.append(member)
 
 	@commands.Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
-		'Event handler'
+		"""Event handler"""
 		guild: Guild = member.guild
 		if not self.get_guild_setting(guild, self.SETTING_ENABLED):
 			return

rocketbot/cogs/joinraidcog.py

 		self.warning_message_ref = None
 
 	def last_join_time(self) -> datetime:
-		'Returns when the most recent member join was, in UTC'
+		"""Returns when the most recent member join was, in UTC"""
 		return self.join_members[-1].joined_at
 
 class JoinRaidCog(BaseCog, name='Join Raids'):
 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def joinraid(self, context: commands.Context):
-		'Join raid detection command group'
+		"""Join raid detection command group"""
 		if context.invoked_subcommand is None:
 			await context.send_help()
 
 
 	@commands.Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
-		'Event handler'
+		"""Event handler"""
 		guild: Guild = member.guild
 		if not self.get_guild_setting(guild, self.SETTING_ENABLED):
 			return

rocketbot/cogs/logcog.py

 """
 Cog for detecting large numbers of guild joins in a short period of time.
 """
-import weakref
 from collections.abc import Sequence
-from datetime import datetime, timedelta
+from datetime import datetime
 from discord import AuditLogAction, AuditLogEntry, Emoji, Guild, GuildSticker, Invite, Member, Message, RawBulkMessageDeleteEvent, RawMessageDeleteEvent, RawMessageUpdateEvent, Role, Thread, User
 from discord.abc import GuildChannel
 from discord.ext import commands
 from discord.utils import escape_markdown
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Tuple, Union
 import difflib
-import traceback
+import re
 
-from config import CONFIG
-from rocketbot.cogs.basecog import BaseCog, BotMessage, BotMessageReaction, CogSetting
-from rocketbot.collections import AgeBoundList
-from rocketbot.storage import Storage
+from rocketbot.cogs.basecog import BaseCog, BotMessage, CogSetting
 
 class LoggingCog(BaseCog, name='Logging'):
 	"""
 			# Most likely an embed being asynchronously populated by server
 			return
 		if content_changed:
-			(before_markdown, after_markdown) = self.__diff(self.__quote_markdown(before.content), \
+			(before_markdown, after_markdown) = self.__diff(self.__quote_markdown(before.content),
 													  self.__quote_markdown(after.content))
 		else:
 			before_markdown = self.__quote_markdown(before.content)
 		return f'**{user.name}** ({user.display_name} {user.id})'
 
 	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:
+			seq = match.group(0)
+			sequence_index = len(preserved_sequences)
+			if seq in preserved_sequences:
+				sequence_index = preserved_sequences.index(seq)
+			else:
+				preserved_sequences.append(seq)
+			return chr(0xe000 + sequence_index)
+		url_regex = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
+		a = re.sub(url_regex, sub_token, a)
+		b = re.sub(url_regex, sub_token, b)
+
 		deletion_start = '~~'
 		deletion_end = '~~'
 		addition_start = '**'
 			markdown_a += deletion_end
 		if b_open:
 			markdown_b += addition_end
+
+		# Sub URLs back in
+		def unsub_token(match: re.Match) -> str:
+			char = match.group(0)
+			index = ord(char) - 0xe000
+			if 0 <= index < len(preserved_sequences):
+				return preserved_sequences[index]
+			return char
+		markdown_a = re.sub(r'[\ue000-\uefff]', unsub_token, markdown_a)
+		markdown_b = re.sub(r'[\ue000-\uefff]', unsub_token, markdown_b)
+
 		return (markdown_a, markdown_b)

rocketbot/cogs/patterncog.py

 automated actions on them.
 """
 from datetime import datetime
+from typing import Optional
+
 from discord import Guild, Member, Message, utils as discordutils
 from discord.ext import commands
 
 	def __save_patterns(cls,
 			guild: Guild,
 			patterns: dict[str, PatternStatement]) -> None:
-		to_save: list[dict] = list(map(PatternStatement.to_json, patterns.values()))
+		to_save: list[dict] = list(map(lambda ps: ps.to_json(), patterns.values()))
 		cls.set_guild_setting(guild, cls.SETTING_PATTERNS, to_save)
 
 	@classmethod
-	def __get_last_matched(cls, guild: Guild, name: str) -> datetime:
-		last_matched: dict[name, datetime] = Storage.get_state_value(guild, 'PatternCog.last_matched')
+	def __get_last_matched(cls, guild: Guild, name: str) -> Optional[datetime]:
+		last_matched: dict[str, datetime] = Storage.get_state_value(guild, 'PatternCog.last_matched')
 		if last_matched:
 			return last_matched.get(name)
 		return None
 
 	@classmethod
 	def __set_last_matched(cls, guild: Guild, name: str, time: datetime) -> None:
-		last_matched: dict[name, datetime] = Storage.get_state_value(guild, 'PatternCog.last_matched')
+		last_matched: dict[str, datetime] = Storage.get_state_value(guild, 'PatternCog.last_matched')
 		if last_matched is None:
 			last_matched = {}
 			Storage.set_state_value(guild, 'PatternCog.last_matched', last_matched)
 				type=message_type,
 				context=context)
 			self.record_warning(message.author)
-			bm.quote = discordutils.remove_markdown(message.clean_content)
+			bm.quote = discordutils.remove_markdown(message.clean_content())
 			await bm.set_reactions(BotMessageReaction.standard_set(
 				did_delete=context.is_deleted,
 				did_kick=context.is_kicked,

rocketbot/cogs/urlspamcog.py

 	SETTING_ACTION = CogSetting('action', str,
 			brief='action to take on spam',
 			description='The action to take on detected URL spam.',
-			enum_values=set(['nothing', 'modwarn', 'delete', 'kick', 'ban']))
+			enum_values={'nothing', 'modwarn', 'delete', 'kick', 'ban'})
 	SETTING_JOIN_AGE = CogSetting('joinage', float,
 			brief='seconds since member joined',
 			description='The minimum seconds since the user joined the ' + \
 			brief='action to take on deceptive link markdown',
 			description='The action to take on chat messages with links ' + \
 				'where the text looks like a different URL than the actual link.',
-			enum_values=set(['nothing', 'modwarn', 'modwarndelete', \
-				'chatwarn', 'chatwarndelete', 'delete', 'kick', 'ban']))
+			enum_values={'nothing', 'modwarn', 'modwarndelete',
+				'chatwarn', 'chatwarndelete', 'delete', 'kick', 'ban'})
 
 	def __init__(self, bot):
 		super().__init__(bot)
 			return
 		if not self.get_guild_setting(message.guild, self.SETTING_ENABLED):
 			return
-		await self.check_message_recency(message);
-		await self.check_deceptive_links(message);
+		await self.check_message_recency(message)
+		await self.check_deceptive_links(message)
 
 	async def check_message_recency(self, message: Message):
 		'Checks if the message was sent too recently by a new user'
 					f'{join_age_str} after joining.',
 					type = BotMessage.TYPE_MOD_WARNING if needs_attention else BotMessage.TYPE_INFO,
 					context = context)
-			bm.quote = discordutils.remove_markdown(message.clean_content)
+			bm.quote = discordutils.remove_markdown(message.clean_content())
 			await bm.set_reactions(BotMessageReaction.standard_set(
 				did_delete=context.is_deleted,
 				did_kick=context.is_kicked,
 		# Strip markdown that can safely contain URL sequences
 		content = re.sub(r'`[^`]+`', '', content)  # `inline code`
 		content = re.sub(r'```.+?```', '', content, re.DOTALL)  # ``` code block ```
-		matches = re.findall(r'\[([^\]]+)\]\(([^\)]+)\)', content)
+		matches = re.findall(r'\[([^]]+)]\(([^)]+)\)', content)
 		for match in matches:
 			original_label: str = match[0].strip()
 			original_link: str = match[1].strip()
 		port_pattern = '(?::[0-9]+)?'
 		path_pattern = r'(?:/[^ \]\)]*)?'
 		pattern = r'^' + host_pattern + port_pattern + path_pattern + '$'
-		return re.match(pattern, s, re.IGNORECASE) != None
+		return re.match(pattern, s, re.IGNORECASE) is not None
 
 	async def on_mod_react(self,
 			bot_message: BotMessage,
 
 	@classmethod
 	def __contains_url(cls, text: str) -> bool:
-		p = re.compile(r'http(?:s)?://[^\s]+')
+		p = re.compile(r'https?://\S+')
 		return p.search(text) is not None

rocketbot/cogs/usernamecog.py

 """
 Cog for detecting username patterns.
 """
+from typing import Optional
+
 from discord import Guild, Member
 from discord.ext import commands
 
 	"""
 	def __init__(self, member: Member) -> None:
 		self.member: Member = member
-		self.kicked_by: Member = None
-		self.banned_by: Member = None
-		self.ignored_by: Member = None
+		self.kicked_by: Optional[Member] = None
+		self.banned_by: Optional[Member] = None
+		self.ignored_by: Optional[Member] = None
 
 	def reactions(self) -> list[BotMessageReaction]:
 		"""

rocketbot/cogsetting.py

 """
 A guild configuration setting available for editing via bot commands.
 """
-from types import coroutine
-from typing import Any, Optional, Type
+from typing import Any, Callable, Coroutine, Optional, Type
 
 from discord.ext import commands
-from discord.ext.commands import Bot, Cog, Command, Context, Group
+from discord.ext.commands import Bot, Command, Context, Group, Cog
 
 from config import CONFIG
 from rocketbot.storage import Storage
 from rocketbot.utils import first_command_group
 
+def _fix_command(command: Command) -> None:
+	"""
+	HACK: Fixes bug in discord.py 2.3.2 where it's requiring the user to
+	supply the context argument. This removes that argument from the list.
+	"""
+	params = command.params
+	del params['context']
+	command.params = params
+
 class CogSetting:
 	"""
 	Describes a configuration setting for a guild that can be edited by the
 	"""
 	def __init__(self,
 			name: str,
-			datatype: Type,
+			datatype: Optional[Type],
 			brief: Optional[str] = None,
 			description: Optional[str] = None,
 			usage: Optional[str] = None,
 
 	def __make_getter_command(self, cog: Cog) -> Command:
 		setting: CogSetting = self
-		async def getter(cog: Cog, context: Context) -> None:
+		async def getter(cog0: Cog, context: Context) -> None:
 			setting_name = setting.name
-			if context.command.parent:
+			if isinstance(context.command.parent, Group):
 				setting_name = f'{context.command.parent.name}.{setting_name}'
-			key = f'{cog.__class__.__name__}.{setting.name}'
+			key = f'{cog0.__class__.__name__}.{setting.name}'
 			value = Storage.get_config_value(context.guild, key)
 			if value is None:
-				value = cog.get_cog_default(setting.name)
+				value = cog0.get_cog_default(setting.name)
 				await context.message.reply(
 					f'{CONFIG["info_emoji"]} `{setting_name}` is using default of `{value}`',
 					mention_author=False)
 				commands.guild_only(),
 			])
 		command.cog = cog
-		self.__fix_command(command)
+		_fix_command(command)
 		return command
 
 	def __make_setter_command(self, cog: Cog) -> Command:
 		setting: CogSetting = self
-		async def setter_common(cog: Cog, context: Context, new_value) -> None:
+		async def setter_common(cog0: Cog, context: Context, new_value) -> None:
 			try:
 				setting.validate_value(new_value)
 			except ValueError as ve:
 					mention_author=False)
 				return
 			setting_name = setting.name
-			if context.command.parent:
+			if isinstance(context.command.parent, Group):
 				setting_name = f'{context.command.parent.name}.{setting_name}'
-			key = f'{cog.__class__.__name__}.{setting.name}'
+			key = f'{cog0.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(context.guild, key, new_value)
 			await context.message.reply(
 				f'{CONFIG["success_emoji"]} `{setting_name}` is now set to `{new_value}`',
 				mention_author=False)
-			await cog.on_setting_updated(context.guild, setting)
-			cog.log(context.guild, f'{context.author.name} set {key} to {new_value}')
-
-		async def setter_int(cog, context, new_value: int):
-			await setter_common(cog, context, new_value)
-		async def setter_float(cog, context, new_value: float):
-			await setter_common(cog, context, new_value)
-		async def setter_str(cog, context, new_value: str):
-			await setter_common(cog, context, new_value)
-		async def setter_bool(cog, context, new_value: bool):
-			await setter_common(cog, context, new_value)
-
-		setter: coroutine = None
+			await cog0.on_setting_updated(context.guild, setting)
+			cog0.log(context.guild, f'{context.author.name} set {key} to {new_value}')
+
+		async def setter_int(cog1, context, new_value: int):
+			await setter_common(cog1, context, new_value)
+		async def setter_float(cog2, context, new_value: float):
+			await setter_common(cog2, context, new_value)
+		async def setter_str(cog3, context, new_value: str):
+			await setter_common(cog3, context, new_value)
+		async def setter_bool(cog4, context, new_value: bool):
+			await setter_common(cog4, context, new_value)
+
+		setter: Callable[[Cog, Context, Any], Coroutine]
 		if setting.datatype == int:
 			setter = setter_int
 		elif setting.datatype == float:
 		# HACK: Passing `cog` in init gets ignored and set to `None` so set after.
 		# This ensures the callback is passed the cog as `self` argument.
 		command.cog = cog
-		self.__fix_command(command)
+		_fix_command(command)
 		return command
 
 	def __make_enable_command(self, cog: Cog) -> Command:
 		setting: CogSetting = self
-		async def enabler(cog: Cog, context: Context) -> None:
-			key = f'{cog.__class__.__name__}.{setting.name}'
+		async def enabler(cog0: Cog, context: Context) -> None:
+			key = f'{cog0.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(context.guild, key, True)
 			await context.message.reply(
 				f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} enabled.',
 				mention_author=False)
-			await cog.on_setting_updated(context.guild, setting)
-			cog.log(context.guild, f'{context.author.name} enabled {cog.__class__.__name__}')
+			await cog0.on_setting_updated(context.guild, setting)
+			cog0.log(context.guild, f'{context.author.name} enabled {cog0.__class__.__name__}')
 
 		command = Command(
 			enabler,
 				commands.guild_only(),
 			])
 		command.cog = cog
-		self.__fix_command(command)
+		_fix_command(command)
 		return command
 
 	def __make_disable_command(self, cog: Cog) -> Command:
 		setting: CogSetting = self
-		async def disabler(cog: Cog, context: Context) -> None:
-			key = f'{cog.__class__.__name__}.{setting.name}'
+		async def disabler(cog0: Cog, context: Context) -> None:
+			key = f'{cog0.__class__.__name__}.{setting.name}'
 			Storage.set_config_value(context.guild, key, False)
 			await context.message.reply(
 				f'{CONFIG["success_emoji"]} {setting.brief.capitalize()} disabled.',
 				mention_author=False)
-			await cog.on_setting_updated(context.guild, setting)
-			cog.log(context.guild, f'{context.author.name} disabled {cog.__class__.__name__}')
+			await cog0.on_setting_updated(context.guild, setting)
+			cog0.log(context.guild, f'{context.author.name} disabled {cog0.__class__.__name__}')
 
 		command = Command(
 			disabler,
 				commands.guild_only(),
 			])
 		command.cog = cog
-		self.__fix_command(command)
+		_fix_command(command)
 		return command
 
-	def __fix_command(self, command: Command) -> None:
-		"""
-		HACK: Fixes bug in discord.py 2.3.2 where it's requiring the user to
-		supply the context argument. This removes that argument from the list.
-		"""
-		params = command.params
-		del params['context']
-		command.params = params
-
 	@classmethod
 	def set_up_all(cls, cog: Cog, bot: Bot, settings: list) -> None:
 		"""

rocketbot/pattern.py

 """
 import re
 from abc import ABCMeta, abstractmethod
-from datetime, timezone import datetime
+from datetime import datetime, timezone
 from typing import Any
 
 from discord import Message, utils as discordutils

rocketbot/utils.py

 		components = components[0:max_components]
 	return ' '.join(components)
 
-def first_command_group(cog: Cog) -> Group:
-	'Returns the first command Group found in a cog.'
+def first_command_group(cog: Cog) -> Optional[Group]:
+	"""Returns the first command Group found in a cog."""
 	for member_name in dir(cog):
 		member = getattr(cog, member_name)
 		if isinstance(member, Group):
 	return 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.'
+	"""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")}|'
 	s += f'{cog_class.__name__}|' if cog_class else '-|'
 __ROLE_MENTION_REGEX: re.Pattern = re.compile('^<@&([0-9]{17,20})>$')
 
 def is_user_id(val: str) -> bool:
-	'Tests if a string is in user/role ID format.'
+	"""Tests if a string is in user/role ID format."""
 	return __ID_REGEX.match(val) is not None
 
 def is_mention(val: str) -> bool:
-	'Tests if a string is a user or role mention.'
+	"""Tests if a string is a user or role mention."""
 	return __MENTION_REGEX.match(val) is not None
 
 def is_role_mention(val: str) -> bool:
-	'Tests if a string is a role mention.'
+	"""Tests if a string is a role mention."""
 	return __ROLE_MENTION_REGEX.match(val) is not None
 
 def is_user_mention(val: str) -> bool:
-	'Tests if a string is a user mention.'
+	"""Tests if a string is a user mention."""
 	return __USER_MENTION_REGEX.match(val) is not None
 
 def user_id_from_mention(mention: str) -> str:
-	'Extracts the user ID from a mention. Raises a ValueError if malformed.'
+	"""Extracts the user ID from a mention. Raises a ValueError if malformed."""
 	m = __USER_MENTION_REGEX.match(mention)
 	if m:
 		return m.group(1)
 	raise ValueError(f'"{mention}" is not an @ user mention')
 
 def mention_from_user_id(user_id: Union[str, int]) -> str:
-	'Returns a markdown user mention from a user id.'
+	"""Returns a markdown user mention from a user id."""
 	return f'<@!{user_id}>'
 
 def mention_from_role_id(role_id: Union[str, int]) -> str:
-	'Returns a markdown role mention from a role id.'
+	"""Returns a markdown role mention from a role id."""
 	return f'<@&{role_id}>'
 
 def str_from_quoted_str(val: str) -> str:
-	'Removes the leading and trailing quotes from a string.'
+	"""Removes the leading and trailing quotes from a string."""
 	if len(val) < 2 or val[0:1] not in __QUOTE_CHARS or val[-1:] not in __QUOTE_CHARS:
 		raise ValueError(f'Not a quoted string: {val}')
 	return val[1:-1]