Bot messages broken up into multiple smaller ones when long. More linter fixes.

rocketbot/botmessage.py

 from typing import Any, Optional, Union
 
 from datetime import datetime
+
 from discord import Guild, Message, PartialEmoji, TextChannel
 
 from config import CONFIG
 		self.context: Optional[Any] = context
 		self.quote: Optional[str] = None
 		self.source_cog = None  # Set by `BaseCog.post_message()`
-		self.__posted_text: str = None  # last text posted, to test for changes
+		self.__posted_text: list[str] = []  # last text posted, to test for changes
 		self.__posted_emoji: set[str] = set()  # last emoji list posted
-		self.__message: Optional[Message] = None  # set once the message has been posted
+		self.__messages: list[Message] = []  # set once the message has been posted
 		self.__reply_to: Optional[Message] = reply_to
 		self.__suppress_embeds = suppress_embeds
 		self.__reactions: list[BotMessageReaction] = []
 		continue returning False even after calling BaseCog.post_message if
 		the guild has no configured warning channel.
 		"""
-		return self.__message is not None
+		return len(self.__messages) > 0
 
-	def message_id(self) -> Optional[int]:
-		'Returns the Message id or None if not sent.'
-		return self.__message.id if self.__message else None
+	def message_ids(self) -> list[int]:
+		"""Returns the ids of all actual Messages sent. One bot message may be
+		broken into multiple Discord messages."""
+		return [ m.id for m in self.__messages ]
 
 	def message_sent_at(self) -> Optional[datetime]:
-		'Returns when the message was sent or None if not sent.'
-		return self.__message.created_at if self.__message else None
+		"""Returns when the message was sent or None if not sent."""
+		return self.__messages[0].created_at if len(self.__messages) > 0 else None
 
 	def has_reactions(self) -> bool:
-		'Whether this message has any reactions defined.'
+		"""Whether this message has any reactions defined."""
 		return len(self.__reactions) > 0
 
 	async def set_text(self, new_text: str) -> None:
 		"""
 		for i, existing in enumerate(self.__reactions):
 			if (isinstance(reaction_or_emoji, str) and existing.emoji == reaction_or_emoji) or \
-				(isinstance(reaction_or_emoji, BotMessageReaction) and \
+				(isinstance(reaction_or_emoji, BotMessageReaction) and
 					existing.emoji == reaction_or_emoji.emoji):
 				self.__reactions.pop(i)
 				await self.update_if_sent()
 		the guild, otherwise does nothing. Does not need to be called by
 		BaseCog subclasses.
 		"""
-		if self.__message:
+		if len(self.__messages) > 0:
 			await self.update()
 
 	async def update(self) -> None:
 		Sends or updates an already sent message based on BotMessage state.
 		Does not need to be called by BaseCog subclasses.
 		"""
-		content: str = self.__formatted_message()
-		if self.__message:
-			if content != self.__posted_text:
-				await self.__message.edit(content=content)
-				self.__posted_text = content
-		else:
-			if self.__reply_to:
-				self.__message = await self.__reply_to.reply(content=content, mention_author=False)
-				self.__posted_text = content
-			else:
-				channel_id = Storage.get_config_value(self.guild, ConfigKey.WARNING_CHANNEL_ID)
-				if channel_id is None:
-					bot_log(self.guild, \
-						type(self.source_cog) if self.source_cog else None, \
-						'\u0007No warning channel set! No warning issued.')
-					return
-				channel: TextChannel = self.guild.get_channel(channel_id)
-				if channel is None:
-					channel = await self.guild.fetch_channel(channel_id)
-				if channel is None:
-					bot_log(self.guild, \
-						type(self.source_cog) if self.source_cog else None, \
-						f'\u0007Configured warning channel does not exist for guild {self.guild.name} ({self.guild.id})!')
-					return
-				self.__message = await channel.send(content=content, suppress_embeds=self.__suppress_embeds)
-				self.__posted_text = content
+		message_bodies: list[str] = self.__formatted_message()
+		if len(self.__messages) > 0:
+			if message_bodies != self.__posted_text:
+				while len(self.__messages) > len(message_bodies):
+					last_message = self.__messages.pop(-1)
+					await last_message.delete()
+					del Storage.get_bot_messages(self.guild)[last_message.id]
+				for i in range(min(len(message_bodies), len(self.__messages))):
+					await self.__messages[i].edit(content=message_bodies[i])
+				while len(self.__messages) < len(message_bodies):
+					body = message_bodies[len(self.__messages)]
+					message = await self.__messages[0].channel.send(content=body, suppress_embeds=self.__suppress_embeds)
+					Storage.get_bot_messages(self.guild)[message.id] = self
+					self.__messages.append(message)
+				self.__posted_text = message_bodies
+		else: # No messages posted yet
+			channel: Optional[TextChannel] = None
+			for index, body in enumerate(message_bodies):
+				if index == 0 and self.__reply_to:
+					message = await self.__reply_to.reply(content=body, mention_author=False)
+					Storage.get_bot_messages(self.guild)[message.id] = self
+					self.__messages.append(message)
+					channel = self.__reply_to.channel
+				else:
+					if channel is None:
+						channel_id = Storage.get_config_value(self.guild, ConfigKey.WARNING_CHANNEL_ID)
+						if channel_id is None:
+							bot_log(self.guild,
+								type(self.source_cog) if self.source_cog else None,
+								'\u0007No warning channel set! No warning issued.')
+							return
+						channel: TextChannel = self.guild.get_channel(channel_id) or await self.guild.fetch_channel(channel_id)
+						if channel is None:
+							bot_log(self.guild,
+								type(self.source_cog) if self.source_cog else None,
+								f'\u0007Configured warning channel does not exist for guild {self.guild.name} ({self.guild.id})!')
+							return
+					message = await channel.send(content=body, suppress_embeds=self.__suppress_embeds)
+					Storage.get_bot_messages(self.guild)[message.id] = self
+					self.__messages.append(message)
+			self.__posted_text = message_bodies
+
 		emoji_to_remove = self.__posted_emoji.copy()
 		for reaction in self.__reactions:
 			if reaction.is_enabled:
 				if reaction.emoji not in self.__posted_emoji:
-					await self.__message.add_reaction(reaction.emoji)
+					await self.__messages[-1].add_reaction(reaction.emoji)
 					self.__posted_emoji.add(reaction.emoji)
 				if reaction.emoji in emoji_to_remove:
 					emoji_to_remove.remove(reaction.emoji)
 		for emoji in emoji_to_remove:
-			await self.__message.clear_reaction(emoji)
+			await self.__messages[-1].clear_reaction(emoji)
 			if emoji in self.__posted_emoji:
 				self.__posted_emoji.remove(emoji)
 
-	def __formatted_message(self) -> str:
+	def __formatted_message(self) -> list[str]:
 		"""
-		Composes the entire message markdown from components. Includes the main
-		message, quoted text, summary of available reactions, etc.
+		Composes the entire message Markdown from components. Includes the main
+		message, quoted text, summary of available reactions, etc. Returned as
+		array of message bodies small enough to fit in a Discord message.
 		"""
 		s: str = ''
 
 				else:
 					s += f'\n     {reaction.description}'
 
-		return s
+		# API complains if *request* is >2000. Unsure how much of that payload is overhead, so will define a max length
+		# conservatively of 85-90% of that.
+		ideal_message_length = 1700
+		max_message_length = 1800
+		# First time cutting up message
+		bodies = [s]
+		while len(bodies[-1]) > max_message_length:
+			# Try to cut at last newline before length limit, otherwise last space, otherwise hard cut at limit
+			last_body = bodies.pop(-1)
+			cut_before = ideal_message_length
+			cut_after = ideal_message_length
+			last_newline_index = last_body.rfind('\n', max_message_length // 2, max_message_length)
+			if last_newline_index >= 0:
+				cut_before = last_newline_index
+				cut_after = last_newline_index + 1
+			else:
+				last_space_index = last_body.rfind(' ', max_message_length // 2, max_message_length)
+				if last_space_index >= 0:
+					cut_before = last_space_index
+					cut_after = last_space_index + 1
+			body = last_body[:cut_before].strip()
+			remainder = last_body[cut_after:].strip()
+			while body.endswith('\n>'):
+				body = body[:-2]
+			while remainder.endswith('\n>'):
+				remainder = remainder[:-2]
+			bodies.append(body)
+			bodies.append(remainder)
+
+		return bodies

rocketbot/cogs/basecog.py

 	# Bot message handling
 
 	@classmethod
-	def __bot_messages(cls, guild: Guild) -> AgeBoundDict:
+	def __bot_messages(cls, guild: Guild) -> AgeBoundDict[int, BotMessage]:
 		bm = Storage.get_state_value(guild, 'bot_messages')
 		if bm is None:
 			far_future = datetime.now(timezone.utc) + timedelta(days=1000)
 		"""
 		message.source_cog = self
 		await message.update()
-		if message.has_reactions() and message.is_sent():
-			guild_messages = self.__bot_messages(message.guild)
-			guild_messages[message.message_id()] = message
 		return message.is_sent()
 
 	@commands.Cog.listener()
 	async def on_raw_reaction_add(self, payload: RawReactionActionEvent):
-		'Event handler'
+		"""Event handler"""
 		# Avoid any unnecessary requests. Gets called for every reaction
 		# multiplied by every active cog.
 		if payload.user_id == self.bot.user.id:
 			# Possibly a DM
 			return
 
-		guild_messages = self.__bot_messages(guild)
+		guild_messages: dict[int, BotMessage] = Storage.get_bot_messages(guild)
 		bot_message = guild_messages.get(payload.message_id)
 		if bot_message is None:
 			# Unknown message (expired or was never tracked)

rocketbot/collections.py

 """
 
 from abc import ABCMeta, abstractmethod
+from typing import Generic, TypeVar
 
 # Abstract collections
 
-class AbstractMutableList(list, metaclass=ABCMeta):
+K = TypeVar('K')
+V = TypeVar('V')
+
+class AbstractMutableList(list[V], Generic[V], metaclass=ABCMeta):
 	"""
 	Abstract list with hooks for custom logic before and after mutation
 	operations.
 		self.post_mutate()
 		return ret_val
 
-class AbstractMutableSet(set, metaclass=ABCMeta):
+class AbstractMutableSet(set[V], Generic[V], metaclass=ABCMeta):
 	"""
 	Abstract set with hooks for custom logic before and after mutation
 	operations.
 		self.post_mutate()
 		return ret_val
 
-class AbstractMutableDict(dict, metaclass=ABCMeta):
+class AbstractMutableDict(dict[K, V], Generic[K, V], metaclass=ABCMeta):
 	"""
 	Abstract dict with hooks for custom logic before and after mutation
 	operations.
 
 # Collections with limited number of elements
 
-class SizeBoundList(AbstractMutableList):
+class SizeBoundList(AbstractMutableList[V], Generic[V]):
 	"""
 	Subclass of `list` that enforces a maximum number of elements.
 
 	`self.max_element_count`, then each element will be tested for its "age,"
 	and the "oldest" elements will be removed until the total size is back
 	within the limit. "Age" is determined via a provided lambda function. It is
-	a value with arbitrary numeric value that is used comparitively to find
+	a value with arbitrary numeric value that is used comparatively to find
 	the element with the smallest value.
 
 	The `element_age` lambda takes two arguments: the element index and the
 	def copy(self):
 		return SizeBoundList(self.max_element_count, self.element_age, super())
 
-class SizeBoundSet(AbstractMutableSet):
+class SizeBoundSet(AbstractMutableSet[V], Generic[V]):
 	"""
 	Subclass of `set` that enforces a maximum number of elements.
 
 	`self.max_element_count`, then each element will be tested for its "age,"
 	and the "oldest" elements will be removed until the total size is back
 	within the limit. "Age" is determined via a provided lambda function. It is
-	a value with arbitrary numeric value that is used comparitively to find
+	a value with arbitrary numeric value that is used comparatively to find
 	the element with the smallest value.
 
 	The `element_age` lambda takes one argument: the element value. It must
 	def copy(self):
 		return SizeBoundSet(self.max_element_count, self.element_age, super())
 
-class SizeBoundDict(AbstractMutableDict):
+class SizeBoundDict(AbstractMutableDict[K, V], Generic[K, V]):
 	"""
 	Subclass of `dict` that enforces a maximum number of elements.
 
 	`self.max_element_count`, then each element will be tested for its "age,"
 	and the "oldest" elements will be removed until the total size is back
 	within the limit. "Age" is determined via a provided lambda function. It is
-	a value with arbitrary numeric value that is used comparitively to find
+	a value with arbitrary numeric value that is used comparatively to find
 	the element with the smallest value.
 
 	The `element_age` lambda takes two arguments: the key and the value of a
 
 # Collections with limited age of elements
 
-class AgeBoundList(AbstractMutableList):
+class AgeBoundList(AbstractMutableList[V], Generic[V]):
 	"""
 	Subclass of `list` that enforces a maximum "age" of elements.
 
 	After each mutating operation, the minimum and maximum "age" of the elements
 	are determined. If the span between the newest and oldest exceeds
-	`self.max_age` then then the oldest elements will be purged until that is
+	`self.max_age` then the oldest elements will be purged until that is
 	no longer the case. "Age" is determined via a provided lambda function. It
-	is a value with arbitrary numeric value that is used comparitively.
+	is a value with arbitrary numeric value that is used comparatively.
 
 	The `element_age` lambda takes two arguments: the element index and the
 	element value. It must return values that can be compared to one another
 	def copy(self):
 		return AgeBoundList(self.max_age, self.element_age, super())
 
-class AgeBoundSet(AbstractMutableSet):
+class AgeBoundSet(AbstractMutableSet[V], Generic[V]):
 	"""
 	Subclass of `set` that enforces a maximum "age" of elements.
 
 	After each mutating operation, the minimum and maximum "age" of the elements
 	are determined. If the span between the newest and oldest exceeds
-	`self.max_age` then then the oldest elements will be purged until that is
+	`self.max_age` then the oldest elements will be purged until that is
 	no longer the case. "Age" is determined via a provided lambda function. It
-	is a value with arbitrary numeric value that is used comparitively.
+	is a value with arbitrary numeric value that is used comparatively.
 
 	The `element_age` lambda takes one argument: the element value. It must
 	return values that can be compared to one another and be added and
 	def copy(self):
 		return AgeBoundSet(self.max_age, self.element_age, super())
 
-class AgeBoundDict(AbstractMutableDict):
+class AgeBoundDict(AbstractMutableDict[K, V], Generic[K, V]):
 	"""
 	Subclass of `dict` that enforces a maximum "age" of elements.
 
 	After each mutating operation, the minimum and maximum "age" of the elements
 	are determined. If the span between the newest and oldest exceeds
-	`self.max_age` then then the oldest elements will be purged until that is
+	`self.max_age` then the oldest elements will be purged until that is
 	no longer the case. "Age" is determined via a provided lambda function. It
-	is a value with arbitrary numeric value that is used comparitively.
+	is a value with arbitrary numeric value that is used comparatively.
 
 	The `element_age` lambda takes two arguments: the key and value of a pair.
 	It must return values that can be compared to one another and be added and

rocketbot/pattern.py

 import re
 from abc import ABCMeta, abstractmethod
 from datetime import datetime, timezone
-from typing import Any
+from typing import Any, Union
 
 from discord import Message, utils as discordutils
 from discord.ext.commands import Context
 		self.operator: str = operator
 		self.value: Any = value
 
-	def __field_value(self, message: Message, other_fields: dict[str: Any]) -> Any:
+	def __field_value(self, message: Message, other_fields: dict[str, Any]) -> Any:
 		if self.field in ('content.markdown', 'content'):
 			return message.content
 		if self.field == 'content.plain':
-			return discordutils.remove_markdown(message.clean_content)
+			return discordutils.remove_markdown(message.clean_content())
 		if self.field == 'author':
 			return str(message.author.id)
 		if self.field == 'author.id':
 		'content.plain': TYPE_TEXT,
 		'lastmatched': TYPE_TIMESPAN,
 	}
-	DEPRECATED_FIELDS: set[str] = set([ 'content' ])
+	DEPRECATED_FIELDS: set[str] = { 'content' }
 
 	ACTION_TO_ARGS: dict[str, list[str]] = {
 		'ban': [],
 		'reply': [ TYPE_TEXT ],
 	}
 
-	OPERATORS_IDENTITY: set[str] = set([ '==', '!=' ])
-	OPERATORS_COMPARISON: set[str] = set([ '<', '>', '<=', '>=' ])
+	OPERATORS_IDENTITY: set[str] = { '==', '!=' }
+	OPERATORS_COMPARISON: set[str] = { '<', '>', '<=', '>=' }
 	OPERATORS_NUMERIC: set[str] = OPERATORS_IDENTITY | OPERATORS_COMPARISON
-	OPERATORS_TEXT: set[str] = OPERATORS_IDENTITY | set([
+	OPERATORS_TEXT: set[str] = OPERATORS_IDENTITY | {
 		'contains', '!contains',
 		'containsword', '!containsword',
 		'matches', '!matches',
-	])
+	}
 	OPERATORS_ALL: set[str] = OPERATORS_IDENTITY | OPERATORS_COMPARISON | OPERATORS_TEXT
 
 	TYPE_TO_OPERATORS: dict[str, set[str]] = {
 		Converts a message filter statement into a list of tokens.
 		"""
 		tokens: list[str] = []
-		in_quote: bool = False
+		in_quote: Union[bool, str] = False
 		in_escape: bool = False
-		all_token_types: set[str] = set([ 'sym', 'op', 'val' ])
+		all_token_types: set[str] = { 'sym', 'op', 'val' }
 		possible_token_types: set[str] = set(all_token_types)
 		current_token: str = ''
 		for ch in statement:
 			token = tokens[token_index]
 			if token == 'if':
 				if len(current_action_tokens) > 0:
-					a = PatternAction(current_action_tokens[0], \
+					a = PatternAction(current_action_tokens[0],
 						current_action_tokens[1:])
 					cls.__validate_action(a)
 					actions.append(a)
 			elif token == ',':
 				if len(current_action_tokens) < 1:
 					raise PatternError('Unexpected ,')
-				a = PatternAction(current_action_tokens[0], \
+				a = PatternAction(current_action_tokens[0],
 					current_action_tokens[1:])
 				cls.__validate_action(a)
 				actions.append(a)
 					return (subexpressions[0], token_index)
 				return (PatternCompoundExpression(last_compound_operator,
 					subexpressions), token_index)
-			if tokens[token_index] in set(["and", "or"]):
+			if tokens[token_index] in { "and", "or" }:
 				compound_operator = tokens[token_index]
 				if last_compound_operator and \
 						compound_operator != last_compound_operator:
 				last_compound_operator = compound_operator
 				token_index += 1
 			if tokens[token_index] == '!':
-				(exp, next_index) = cls.__read_expression(tokens, \
+				(exp, next_index) = cls.__read_expression(tokens,
 						token_index + 1, depth + 1, one_subexpression=True)
 				subexpressions.append(PatternCompoundExpression('!', [exp]))
 				token_index = next_index

rocketbot/storage.py

 Handles storage of persisted and non-persisted data for the bot.
 """
 import json
+from datetime import datetime, timezone, timedelta
 from os.path import exists
 from typing import Any, Optional
 from discord import Guild
 
 from config import CONFIG
+from rocketbot.collections import AgeBoundDict
+
 
 class ConfigKey:
 	"""
 		cls.__write_guild_config(guild, config)
 
 	@classmethod
+	def get_bot_messages(cls, guild: Guild) -> AgeBoundDict:
+		"""Returns all the bot messages for a guild."""
+		bm = cls.get_state_value(guild, 'bot_messages')
+		if bm is None:
+			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)
+		return bm
+
+	@classmethod
 	def __write_guild_config(cls, guild: Guild, config: dict[str, Any]) -> None:
 		"""
 		Saves config for a guild to a JSON file on disk.

rocketbot/utils.py

 	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: