Help search less silly

rocketbot/cogs/helpcog.py

@@ -1,6 +1,7 @@
 """Provides help commands for getting info on using other commands and configuration."""
 import re
-from typing import Union, Optional
+import time
+from typing import Union, Optional, TypedDict
 
 from discord import Interaction, Permissions, AppCommandType, ButtonStyle, InteractionResponse
 from discord.app_commands import Group, Command, autocomplete, guild_only, command, Choice
@@ -12,6 +13,10 @@ from rocketbot.cogs.basecog import BaseCog
 from rocketbot.utils import MOD_PERMISSIONS, dump_stacktrace
 
 HelpTopic = Union[Command, Group, BaseCog]
+class HelpMeta(TypedDict):
+	id: str
+	text: str
+	topic: HelpTopic
 
 # Potential place to break text neatly in large help content
 PAGE_BREAK = '\f'
@@ -39,7 +44,7 @@ async def search_autocomplete(interaction: Interaction, current: str) -> list[Ch
 		return [
 			choice_from_topic(topic, include_full_command=True)
 			for topic in HelpCog.shared.topics_for_keywords(current, interaction.permissions)
-		]
+		][:25]
 	except BaseException as e:
 		dump_stacktrace(e)
 		return []
@@ -57,53 +62,60 @@ class HelpCog(BaseCog, name='Help'):
 
 	def __create_help_index(self) -> None:
 		"""
-		Populates self.topic_index and self.keyword_index. Bails if already
+		Populates self.id_to_topic and self.keyword_index. Bails if already
 		populated. Intended to be run on demand so all cogs and commands have
 		had time to get set up and synced.
 		"""
-		if getattr(self, 'topic_index', None) is not None:
+		if getattr(self, 'id_to_topic', None) is not None:
 			return
-		self.topic_index: dict[str, HelpTopic] = {}
-		self.keyword_index: dict[str, set[HelpTopic]] = {}
+		self.id_to_topic: dict[str, HelpTopic] = {}
+		self.topics: list[HelpMeta] = []
 
-		def add_text_to_index(topic: HelpTopic, text: str):
-			words = [
+		def process_text(t: str) -> str:
+			return ' '.join([
 				word
-				for word in re.split(r"[^a-zA-Z']+", text.lower())
-				if len(word) > 1 and word not in trivial_words
-			]
-			for word in words:
-				matches = self.keyword_index.get(word, set())
-				matches.add(topic)
-				self.keyword_index[word] = matches
+				for word in re.split(r"[^a-z']+", t.lower())
+				if word not in trivial_words
+			]).strip()
 
 		cmds = self.all_commands()
 		for cmd in cmds:
-			self.topic_index[f'cmd:{cmd.name}'] = cmd
-			self.topic_index[f'/{cmd.name}'] = cmd
-			add_text_to_index(cmd, cmd.name)
+			key = f'cmd:{cmd.name}'
+			self.id_to_topic[key] = cmd
+			self.id_to_topic[f'/{cmd.name}'] = cmd
+			text = cmd.name
 			if cmd.description:
-				add_text_to_index(cmd, cmd.description)
+				text += f' {cmd.description}'
+			if cmd.extras.get('long_description', None):
+				text += f' {cmd.extras["long_description"]}'
+			self.topics.append({ 'id': key, 'text': process_text(text), 'topic': cmd })
 			if isinstance(cmd, Group):
 				for subcmd in cmd.commands:
-					self.topic_index[f'subcmd:{cmd.name}.{subcmd.name}'] = subcmd
-					self.topic_index[f'/{cmd.name} {subcmd.name}'] = subcmd
-					add_text_to_index(subcmd, cmd.name)
-					add_text_to_index(subcmd, subcmd.name)
+					key = f'subcmd:{cmd.name}.{subcmd.name}'
+					self.id_to_topic[key] = subcmd
+					self.id_to_topic[f'/{cmd.name} {subcmd.name}'] = subcmd
+					text = cmd.name
+					text += f' {subcmd.name}'
 					if subcmd.description:
-						add_text_to_index(subcmd, subcmd.description)
+						text += f' {subcmd.description}'
+					if subcmd.extras.get('long_description', None):
+						text += f' {subcmd.extras["long_description"]}'
+					self.topics.append({ 'id': key, 'text': process_text(text), 'topic': subcmd })
 		for cog_qname, cog in self.bot.cogs.items():
 			if not isinstance(cog, BaseCog):
 				continue
 			key = f'cog:{cog_qname}'
-			self.topic_index[key] = cog
-			add_text_to_index(cog, cog.qualified_name)
-			if cog.description:
-				add_text_to_index(cog, cog.description)
+			self.id_to_topic[key] = cog
+			text = cog.qualified_name
+			if cog.short_description:
+				text += f' {cog.short_description}'
+			if cog.long_description:
+				text += f' {cog.long_description}'
+			self.topics.append({ 'id': key, 'text': process_text(text), 'topic': cog })
 
 	def topic_for_help_symbol(self, symbol: str) -> Optional[HelpTopic]:
 		self.__create_help_index()
-		return self.topic_index.get(symbol, None)
+		return self.id_to_topic.get(symbol, None)
 
 	def all_commands(self) -> list[Union[Command, Group]]:
 		# PyCharm not interpreting conditional return type correctly.
@@ -149,46 +161,41 @@ class HelpCog(BaseCog, name='Help'):
 		return topics
 
 	def topics_for_keywords(self, search: str, permissions: Optional[Permissions]) -> list[HelpTopic]:
+		start_time = time.perf_counter()
 		self.__create_help_index()
 
 		# Break into words (or word fragments)
 		words: list[str] = [
-			word.lower()
-			for word in re.split(r"[^a-zA-Z']+", search)
-			# if len(word) > 1 and word not in trivial_words
+			word
+			for word in re.split(r"[^a-z']+", search.lower())
 		]
 
-		# FIXME: This is a super weird way of doing this. Converting word fragments
-		# to known indexed keywords, then collecting those associated results. Should
-		# just keep corpuses of searchable, normalized text for each topic and do a
-		# direct `in` test.
-		matching_topics_set = None
-		for word in words:
-			word_matches = set()
-			for k in self.keyword_index.keys():
-				if word in k:
-					topics = self.keyword_index.get(k, None)
-					if topics is not None:
-						word_matches.update(topics)
-			if matching_topics_set is None:
-				matching_topics_set = word_matches
-			else:
-				matching_topics_set = matching_topics_set & word_matches
+		# Find matches
+		def topic_matches(meta: HelpMeta) -> bool:
+			for word in words:
+				if word not in meta['text']:
+					return False
+			return True
+		matching_topics: list[HelpTopic] = [ topic['topic'] for topic in self.topics if topic_matches(topic) ]
 
 		# Filter by accessibility
 		accessible_topics = [
 			topic
-			for topic in matching_topics_set or {}
+			for topic in matching_topics
 			if ((isinstance(topic, Command) or isinstance(topic, Group)) and can_use_command(topic, permissions)) or \
 			   (isinstance(topic, BaseCog) and can_use_cog(topic, permissions))
 		]
 
 		# Sort and return
-		return sorted(accessible_topics, key=lambda topic: (
+		result = sorted(accessible_topics, key=lambda topic: (
 			isinstance(topic, Command),
 			isinstance(topic, BaseCog),
 			topic.qualified_name if isinstance(topic, BaseCog) else topic.name
 		))
+		duration = time.perf_counter() - start_time
+		if duration > 0.01:
+			self.log(None, f'search "{search}" took {duration} seconds')
+		return result
 
 	@command(
 		name='help',