Fixing iter issue. More linter cleanup

rocketbot/cogs/autokickcog.py

 from datetime import datetime, timedelta
-from typing import cast
 
 from discord import Guild, Member, Status
 from discord.ext import commands, tasks
 		self.add_setting(AutoKickCog.SETTING_BAN_COUNT)
 		self.add_setting(AutoKickCog.SETTING_OFFLINE_ONLY)
 		self.status_check_members = []
-		timer: Loop = cast(Loop, self.status_check_timer)
+		timer: Loop = self.status_check_timer
 		timer.start()
 
 	@commands.group(
 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def autokick(self, context: commands.Context):
-		'Auto-kick'
+		"""Auto-kick"""
 		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
 
 	@tasks.loop(seconds=5.0)
 	async def status_check_timer(self):
-		'Checks status of new members shortly after joining to see if they go offline'
+		"""Checks status of new members shortly after joining to see if they go offline"""
 		contexts = self.status_check_members.copy()
 		self.status_check_members = []
 		now = datetime.now()
 
 	@staticmethod
 	def ordinal(val: int):
-		'Formats an integer with an ordinal suffix (English only)'
+		"""Formats an integer with an ordinal suffix (English only)"""
 		if val % 100 < 10 or val % 100 > 20:
 			if val % 10 == 1:
 				return f'{val}st'

rocketbot/cogs/basecog.py

 	def get_cog_default(cls, key: str):
 		"""
 		Convenience method for getting a cog configuration default from
-		`CONFIG['cogs'][<cogname>][<key>]`. These values are used for
+		`CONFIG['cogs'][<cog_name>][<key>]`. These values are used for
 		CogSettings when no guild-specific value is configured yet.
 		"""
 		cogs: dict = CONFIG['cog_defaults']
 		commands will be created instead which set the setting to True/False.
 
 		If the cog has a command group it will be detected automatically and
-		the commands added to that. Otherwise the commands will be added at
+		the commands added to that. Otherwise, the commands will be added at
 		the top level.
 
 		Changes to settings can be detected by overriding `on_setting_updated`.
 
 	@commands.Cog.listener()
 	async def on_ready(self):
-		'Event listener'
+		"""Event listener"""
 		if not self.are_settings_setup:
 			self.are_settings_setup = True
 			CogSetting.set_up_all(self, self.bot, self.settings)

rocketbot/cogs/crosspostcog.py

 
 	@commands.Cog.listener()
 	async def on_message(self, message: Message):
-		'Event handler'
+		"""Event handler"""
 		if message.author is None or \
 				message.author.bot or \
 				message.channel is None or \
 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def crosspost(self, context: commands.Context):
-		'Crosspost detection command group'
+		"""Crosspost detection command group"""
 		if context.invoked_subcommand is None:
 			await context.send_help()

rocketbot/cogs/generalcog.py

 
 	@commands.Cog.listener()
 	async def on_connect(self):
-		'Event handler'
+		"""Event handler"""
 		if self.is_first_connect:
 			self.log(None, 'Connected')
 			self.is_first_connect = False
 
 	@commands.Cog.listener()
 	async def on_disconnect(self):
-		'Event handler'
+		"""Event handler"""
 		self.log(None, 'Disconnected')
 
 	@commands.Cog.listener()
 	async def on_ready(self):
-		'Event handler'
+		"""Event handler"""
 		self.log(None, 'Bot done initializing')
 		self.is_ready = True
 		if self.is_first_ready:
 
 	@commands.Cog.listener()
 	async def on_resumed(self):
-		'Event handler'
+		"""Event handler"""
 		self.log(None, 'Session resumed')
 
 	@commands.command(
 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def testwarn(self, context):
-		'Command handler'
+		"""Command handler"""
 		if Storage.get_config_value(context.guild, ConfigKey.WARNING_CHANNEL_ID) is None:
 			await context.message.reply(
 				f'{CONFIG["warning_emoji"]} No warning channel set!',
 			'bot is working properly.',
 	)
 	async def hello(self, context):
-		'Command handler'
+		"""Command handler"""
 		await context.message.reply(
 			f'Hey, {context.author.name}!',
 		 	mention_author=False)
 	@commands.has_permissions(administrator=True)
 	@commands.guild_only()
 	async def shutdown(self, context: commands.Context):
-		'Command handler'
+		"""Command handler"""
 		await context.message.add_reaction('👋')
 		await self.bot.close()
 
 	@commands.has_permissions(manage_messages=True)
 	@commands.guild_only()
 	async def deletemessages(self, context, user: str, age: str) -> None:
-		'Command handler'
+		"""Command handler"""
 		member_id = self.__parse_member_id(user)
 		if member_id is None:
 			await context.message.reply(

rocketbot/cogs/logcog.py

 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def logging(self, context: commands.Context):
-		'Logging command group'
+		"""Logging command group"""
 		if context.invoked_subcommand is None:
 			await context.send_help()
 
 	@commands.Cog.listener()
 	async def on_invite_create(self, invite: Invite) -> None:
 		"""
-		Called when an Invite is created. You must have manage_channels to receive this.
+		Called when an `Invite` is created. You must have manage_channels to receive this.
 
 		https://discordpy.readthedocs.io/en/stable/api.html#discord.on_invite_create
 		"""
 	@commands.Cog.listener()
 	async def on_invite_delete(self, invite: Invite) -> None:
 		"""
-		Called when an Invite is deleted. You must have manage_channels to receive this.
+		Called when an `Invite` is deleted. You must have manage_channels to receive this.
 
 		https://discordpy.readthedocs.io/en/stable/api.html#discord.on_invite_delete
 		"""
 			changes.append(f'Guild avatar: <{before_guild_avatar}> -> <{after_guild_avatar}>')
 		if after.flags != before.flags:
 			flag_changes = []
-			for (name, after_value) in after.iter():
-				before_value = getattr(before, name)
+			for (name, after_value) in iter(after.flags):
+				before_value = getattr(before.flags, name)
 				if after_value != before_value:
 					flag_changes.append(f'`{name}` = `{before_value}` -> `{after_value}`')
 			if len(flag_changes) > 0:
 		if len(changes) == 0:
 			return
 		text = f'Details for member {self.__describe_user(before)} changed:\n'
-		text += '* ' + '\n* '.join(changes)
+		text += '* ' + ('\n* '.join(changes))
 		bot_message = BotMessage(guild, text, BotMessage.TYPE_LOG)
 		await bot_message.update()
 
 
 	def __describe_user(self, user: Union[User, Member]) -> str:
 		"""
-		Standardized markdown describing a user or member.
+		Standardized Markdown describing a user or member.
 		"""
 		return f'**{user.name}** ({user.display_name} {user.id})'
 
 		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)
+		return markdown_a, markdown_b

rocketbot/cogs/patterncog.py

 class PatternCog(BaseCog, name='Pattern Matching'):
 	"""
 	Highly flexible cog for performing various actions on messages that match
-	various critera. Patterns can be defined by mods for each guild.
+	various criteria. Patterns can be defined by mods for each guild.
 	"""
 
 	SETTING_PATTERNS = CogSetting('patterns', None)
 
 	@commands.Cog.listener()
 	async def on_message(self, message: Message) -> None:
-		'Event listener'
+		"""Event listener"""
 		if message.author is None or \
 				message.author.bot or \
 				message.channel is None or \
 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def pattern(self, context: commands.Context):
-		'Message pattern matching command group'
+		"""Message pattern matching command group"""
 		if context.invoked_subcommand is None:
 			await context.send_help()
 
 		ignore_extra=True
 	)
 	async def add(self, context: commands.Context, name: str):
-		'Command handler'
+		"""Command handler"""
 		pattern_str = PatternCompiler.expression_str_from_context(context, name)
 		try:
 			statement = PatternCompiler.parse_statement(name, pattern_str)
 		usage='<pattern_name>'
 	)
 	async def remove(self, context: commands.Context, name: str):
-		'Command handler'
+		"""Command handler"""
 		patterns = self.__get_patterns(context.guild)
 		if patterns.get(name) is not None:
 			del patterns[name]
 		brief='Lists all patterns'
 	)
 	async def list(self, context: commands.Context) -> None:
-		'Command handler'
+		"""Command handler"""
 		patterns = self.__get_patterns(context.guild)
 		if len(patterns) == 0:
 			await context.message.reply('No patterns defined.', mention_author=False)
 			'priority is 100.',
 	)
 	async def setpriority(self, context: commands.Context, name: str, priority: int) -> None:
-		'Command handler'
+		"""Command handler"""
 		patterns = self.__get_patterns(context.guild)
 		statement = patterns.get(name)
 		if statement is None:

rocketbot/cogs/urlspamcog.py

 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def urlspam(self, context: commands.Context):
-		'URL spam command group'
+		"""URL spam command group"""
 		if context.invoked_subcommand is None:
 			await context.send_help()
 
 	@commands.Cog.listener()
 	async def on_message(self, message: Message):
-		'Event listener'
+		"""Event listener"""
 		if message.author is None or \
 				message.author.bot or \
 				message.guild is None or \
 		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'
+		"""Checks if the message was sent too recently by a new user"""
 		action = self.get_guild_setting(message.guild, self.SETTING_ACTION)
 		join_seconds = self.get_guild_setting(message.guild, self.SETTING_JOIN_AGE)
 		min_join_age = timedelta(seconds=join_seconds)
 
 	async def check_deceptive_links(self, message: Message):
 		"""
-		Checks if the message contains deceptive URL markdown, e.g.
+		Checks if the message contains deceptive URL Markdown, e.g.
 		`[nicewebsite.com](https://evilwebsite.com)'`
 		"""
 		action = self.get_guild_setting(message.guild, self.SETTING_DECEPTIVE_ACTION)
-		if action == None or action == 'nothing':
+		if action is None or action == 'nothing':
 			return
 
 		if not self.contains_deceptive_links(message.content):
 				delete_message_days=1)
 
 	def contains_deceptive_links(self, content: str) -> bool:
-		# Strip markdown that can safely contain URL sequences
+		# 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)
 		return False
 
 	def is_url(self, s: str):
-		'Tests if a string is strictly a URL'
+		"""Tests if a string is strictly a URL"""
 		ipv6_host_pattern = r'\[[0-9a-fA-F:]+\]'
 		ipv4_host_pattern = r'[0-9\.]+'
 		hostname_pattern = r'[a-zA-Z0-9-]+\.[a-zA-Z0-9-\.]+'
 		port_pattern = '(?::[0-9]+)?'
 		path_pattern = r'(?:/[^ \]\)]*)?'
 		pattern = r'^http[s]?://' + host_pattern + port_pattern + path_pattern + '$'
-		return re.match(pattern, s, re.IGNORECASE) != None
+		return re.match(pattern, s, re.IGNORECASE) is not None
 
 	def is_casual_url(self, s: str):
-		'Tests if a string is a "casual URL" with no scheme included'
+		"""Tests if a string is a "casual URL" with no scheme included"""
 		ipv6_host_pattern = r'\[[0-9a-fA-F:]+\]'
 		ipv4_host_pattern = r'[0-9\.]+'
 		hostname_pattern = r'[a-zA-Z0-9-]+\.[a-zA-Z0-9-\.]+'

rocketbot/cogs/usernamecog.py

 	@commands.has_permissions(ban_members=True)
 	@commands.guild_only()
 	async def username(self, context: commands.Context):
-		'Username pattern command group'
+		"""Username pattern command group"""
 		if context.invoked_subcommand is None:
 			await context.send_help()
 
 		usage='<pattern>'
 	)
 	async def add(self, context: commands.Context, pattern: str) -> None:
-		'Command handler'
+		"""Command handler"""
 		norm_pattern = pattern.lower()
 		patterns: list[str] = self.__get_patterns(context.guild)
 		if norm_pattern in patterns:
 		usage='<pattern>'
 	)
 	async def remove(self, context: commands.Context, pattern: str) -> None:
-		'Command handler'
+		"""Command handler"""
 		norm_pattern = pattern.lower()
 		guild: Guild = context.guild
 		patterns: list[str] = self.__get_patterns(guild)
 		brief='Lists username patterns'
 	)
 	async def list(self, context: commands.Context) -> None:
-		'Command handler'
+		"""Command handler"""
 		guild: Guild = context.guild
 		patterns: list[str] = self.__get_patterns(guild)
 		if len(patterns) == 0:
 
 	@commands.Cog.listener()
 	async def on_member_join(self, member: Member) -> None:
-		'Event handler'
+		"""Event handler"""
 		for pattern in self.__get_patterns(member.guild):
 			if self.matches(pattern, member.name):
 				await self.handle_match(member, pattern)
 				await self.handle_match(member, pattern)
 
 	def matches(self, pattern: str, subject: str) -> bool:
-		'Checks if a username matches a given pattern'
+		"""Checks if a username matches a given pattern"""
 		if pattern is None:
 			return False
 		if subject is None:

rocketbot/pattern.py

 				if ch in cls.STRING_QUOTE_CHARS:
 					if len(current_token) > 0:
 						tokens.append(current_token)
-						current_token = ''
 						possible_token_types |= all_token_types
 					in_quote = ch
 					current_token = ch
 					cls.__validate_action(a)
 					actions.append(a)
 				token_index += 1
-				return (actions, token_index)
+				return actions, token_index
 			elif token == ',':
 				if len(current_action_tokens) < 1:
 					raise PatternError('Unexpected ,')
 		while token_index < len(tokens):
 			if one_subexpression:
 				if len(subexpressions) == 1:
-					return (subexpressions[0], token_index)
+					return subexpressions[0], token_index
 				if len(subexpressions) > 1:
 					raise PatternError('Too many subexpressions')
-			compound_operator = None
 			if tokens[token_index] == ')':
 				if len(subexpressions) == 0:
 					raise PatternError('No subexpressions')
 				if len(subexpressions) == 1:
-					return (subexpressions[0], token_index)
+					return subexpressions[0], token_index
 				return (PatternCompoundExpression(last_compound_operator,
 					subexpressions), token_index)
 			if tokens[token_index] in { "and", "or" }:
 		if len(subexpressions) == 0:
 			raise PatternError('No subexpressions')
 		elif len(subexpressions) == 1:
-			return (subexpressions[0], token_index)
+			return subexpressions[0], token_index
 		else:
-			return (PatternCompoundExpression(last_compound_operator,
-				subexpressions), token_index)
+			return PatternCompoundExpression(last_compound_operator,
+				subexpressions), token_index
 
 	@classmethod
 	def __read_simple_expression(cls,
 
 		token_index += 1
 		exp = PatternSimpleExpression(field, op, value)
-		return (exp, token_index)
+		return exp, token_index
 
 	@classmethod
 	def __parse_value(cls, value: str, datatype: str, op: str = None) -> Any: