Pattern cog converted to slash commands with some minimal autocomplete

rocketbot/cogs/patterncog.py

 Cog for matching messages against guild-configurable criteria and taking
 automated actions on them.
 """
+import re
 from datetime import datetime
-from typing import Optional, Literal
+from typing import Optional
 
 from discord import Guild, Member, Message, utils as discordutils, Permissions, Interaction
-from discord.app_commands import Group, rename
+from discord.app_commands import Choice, Group, autocomplete, rename
 from discord.ext import commands
 
 from config import CONFIG
 from rocketbot.pattern import PatternCompiler, PatternDeprecationError, \
 	PatternError, PatternStatement
 from rocketbot.storage import Storage
+from rocketbot.utils import dump_stacktrace
 
 class PatternContext:
 	"""
 		self.is_kicked = False
 		self.is_banned = False
 
+async def pattern_name_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
+	choices: list[Choice[str]] = []
+	try:
+		if interaction.guild is None:
+			return []
+		patterns: dict[str, PatternStatement] = PatternCog.shared.get_patterns(interaction.guild)
+		current_normal = current.lower().strip()
+		for name in sorted(patterns.keys()):
+			if len(current_normal) == 0 or current_normal.startswith(name.lower()):
+				choices.append(Choice(name=name, value=name))
+	except BaseException as e:
+		dump_stacktrace(e)
+	return choices
+
+async def action_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
+	# FIXME: WORK IN PROGRESS
+	print(f'autocomplete action - current = "{current}"')
+	regex = re.compile('^(.*?)([a-zA-Z]+)$')
+	match: Optional[re.Match[str]] = regex.match(current)
+	initial: str = ''
+	stub: str = current
+	if match:
+		initial = match.group(1).strip()
+		stub = match.group(2)
+	if PatternCompiler.ACTION_TO_ARGS.get(stub, None) is not None:
+		# Matches perfectly. Suggest another instead of completing the current.
+		initial = current.strip() + ', '
+		stub = ''
+	print(f'initial = "{initial}", stub = "{stub}"')
+
+	options: list[Choice[str]] = []
+	for action in sorted(PatternCompiler.ACTION_TO_ARGS.keys()):
+		if len(stub) == 0 or action.startswith(stub.lower()):
+			arg_types = PatternCompiler.ACTION_TO_ARGS[action]
+			arg_type_strs = []
+			for arg_type in arg_types:
+				if arg_type == PatternCompiler.TYPE_TEXT:
+					arg_type_strs.append('"message"')
+				else:
+					raise ValueError(f'Argument type {arg_type} not yet supported')
+			suffix = '' if len(arg_type_strs) == 0 else ' ' + (' '.join(arg_type_strs))
+			options.append(Choice(name=action, value=f'{initial.strip()} {action}{suffix}'))
+	return options
+
+async def priority_autocomplete(interaction: Interaction, current: str) -> list[Choice[str]]:
+	return [
+		Choice(name='very low (50)', value=50),
+		Choice(name='low (75)', value=75),
+		Choice(name='normal (100)', value=100),
+		Choice(name='high (125)', value=125),
+		Choice(name='very high (150)', value=150),
+	]
+
 class PatternCog(BaseCog, name='Pattern Matching'):
 	"""
 	Highly flexible cog for performing various actions on messages that match
 
 	SETTING_PATTERNS = CogSetting('patterns', None)
 
+	shared: Optional['PatternCog'] = None
+
 	def __init__(self, bot: Rocketbot):
 		super().__init__(
 			bot,
 			name='patterns',
 			short_description='Manages message pattern matching.',
 		)
+		PatternCog.shared = self
 
-	def __get_patterns(self, guild: Guild) -> dict[str, PatternStatement]:
+	def get_patterns(self, guild: Guild) -> dict[str, PatternStatement]:
 		"""
 		Returns a name -> PatternStatement lookup for the guild.
 		"""
 			# Ignore mods
 			return
 
-		patterns = self.__get_patterns(message.guild)
+		patterns = self.get_patterns(message.guild)
 		for statement in sorted(patterns.values(), key=lambda s : s.priority, reverse=True):
 			other_fields = {
 				'last_matched': self.__get_last_matched(message.guild, statement.name),
 			did_kick=context.is_kicked,
 			did_ban=context.is_banned))
 
-	spattern = Group(
+	pattern = Group(
 		name='pattern',
 		description='Manages message pattern matching.',
 		guild_only=True,
 		default_permissions=Permissions(Permissions.manage_messages.flag),
 	)
-	@spattern.command()
+
+	@pattern.command()
 	@rename(expression='if')
-	async def test(
+	@autocomplete(
+		name=pattern_name_autocomplete,
+		# actions=action_autocomplete
+	)
+	async def add(
 			self,
 			interaction: Interaction,
+			name: str,
 			actions: str,
 			expression: str
 	) -> None:
-		vals = [ actions, expression ]
-		arg_list = ''
-		for arg in vals:
-			if arg is not None:
-				arg_list += f'- "`{arg}`"\n'
-		await interaction.response.send_message(
-			"Got /pattern test call with arguments\n" + arg_list,
-			ephemeral=True,
-		)
+		"""
+		Adds a custom pattern.
 
-	@commands.group(
-		brief='Manages message pattern matching',
-	)
-	@commands.has_permissions(ban_members=True)
-	@commands.guild_only()
-	async def pattern(self, context: commands.Context):
-		"""Message pattern matching command group"""
-		if context.invoked_subcommand is None:
-			await context.send_help()
+		Adds a custom pattern. Patterns use a simplified
+		expression language. Full documentation found here:
+		https://git.rixafrix.com/ialbert/python-app-rocketbot/src/branch/main/docs/patterns.md
 
-	@pattern.command(
-		brief='Adds a custom pattern',
-		description='Adds a custom pattern. Patterns use a simplified ' + \
-			'expression language. Full documentation found here: ' + \
-			'https://git.rixafrix.com/ialbert/python-app-rocketbot/src/' + \
-			'branch/main/docs/patterns.md',
-		usage='<pattern_name> <expression...>',
-		ignore_extra=True
-	)
-	async def add(self, context: commands.Context, name: str):
-		"""Command handler"""
-		pattern_str = PatternCompiler.expression_str_from_context(context, name)
+		Parameters
+		----------
+		interaction : Interaction
+		name : str
+			A name for the pattern.
+		actions : str
+			One or more actions to take when a message matches the expression.
+		expression : str
+			Criteria for matching chat messages.
+		"""
+		pattern_str = f'{actions} if {expression}'
+		guild = interaction.guild
 		try:
 			statement = PatternCompiler.parse_statement(name, pattern_str)
 			statement.check_deprecations()
-			patterns = self.__get_patterns(context.guild)
+			patterns = self.get_patterns(guild)
 			patterns[name] = statement
-			self.__save_patterns(context.guild, patterns)
-			await context.message.reply(
+			self.__save_patterns(guild, patterns)
+			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} Pattern `{name}` added.',
-				mention_author=False)
+				ephemeral=True,
+			)
 		except PatternError as e:
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["failure_emoji"]} Error parsing statement. {e}',
-				mention_author=False)
+				ephemeral=True,
+			)
 
 	@pattern.command(
-		brief='Removes a custom pattern',
-		usage='<pattern_name>'
+		description='Removes a custom pattern',
+		extras={
+			'usage': '<pattern_name>',
+		},
 	)
-	async def remove(self, context: commands.Context, name: str):
-		"""Command handler"""
-		patterns = self.__get_patterns(context.guild)
+	@autocomplete(name=pattern_name_autocomplete)
+	async def remove(self, interaction: Interaction, name: str):
+		"""
+		Command handler
+
+		Parameters
+		----------
+		interaction: Interaction
+		name: str
+			Name of the pattern to remove.
+		"""
+		guild = interaction.guild
+		patterns = self.get_patterns(guild)
 		if patterns.get(name) is not None:
 			del patterns[name]
-			self.__save_patterns(context.guild, patterns)
-			await context.message.reply(
+			self.__save_patterns(guild, patterns)
+			await interaction.response.send_message(
 				f'{CONFIG["success_emoji"]} Pattern `{name}` deleted.',
-				mention_author=False)
+				ephemeral=True,
+			)
 		else:
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["failure_emoji"]} No pattern named `{name}`.',
-				mention_author=False)
+				ephemeral=True,
+			)
 
 	@pattern.command(
-		brief='Lists all patterns'
+		description='Lists all patterns',
 	)
-	async def list(self, context: commands.Context) -> None:
-		"""Command handler"""
-		patterns = self.__get_patterns(context.guild)
+	async def list(self, interaction: Interaction) -> None:
+		"""
+		Command handler
+
+		Parameters
+		----------
+		interaction: Interaction
+		"""
+		guild = interaction.guild
+		patterns = self.get_patterns(guild)
 		if len(patterns) == 0:
-			await context.message.reply('No patterns defined.', mention_author=False)
+			await interaction.response.send_message(
+				'No patterns defined.',
+				ephemeral=True,
+			)
 			return
 		msg = ''
 		for name, statement in sorted(patterns.items()):
 			msg += f'Pattern `{name}` (priority={statement.priority}):\n```\n{statement.original}\n```\n'
-		await context.message.reply(msg, mention_author=False)
+		await interaction.response.send_message(msg, ephemeral=True)
 
 	@pattern.command(
-		brief='Sets a pattern\'s priority level',
-		description='Sets the priority for a pattern. Messages are checked ' +
-			'against patterns with the highest priority first. Patterns with ' +
-			'the same priority may be checked in arbitrary order. Default ' +
-			'priority is 100.',
+		description='Sets a pattern\'s priority level',
+		extras={
+			'long_description': 'Sets the priority for a pattern. Messages are checked ' +
+				'against patterns with the highest priority first. Patterns with ' +
+				'the same priority may be checked in arbitrary order. Default ' +
+				'priority is 100.',
+		},
 	)
-	async def setpriority(self, context: commands.Context, name: str, priority: int) -> None:
-		"""Command handler"""
-		patterns = self.__get_patterns(context.guild)
+	@autocomplete(name=pattern_name_autocomplete, priority=priority_autocomplete)
+	async def setpriority(self, interaction: Interaction, name: str, priority: int) -> None:
+		"""
+		Command handler
+
+		Parameters
+		----------
+		interaction: Interaction
+		name: str
+			A name for the pattern
+		priority: int
+			Priority for evaluating the pattern. Default is 100. Higher values match first.
+		"""
+		guild = interaction.guild
+		patterns = self.get_patterns(guild)
 		statement = patterns.get(name)
 		if statement is None:
-			await context.message.reply(
+			await interaction.response.send_message(
 				f'{CONFIG["failure_emoji"]} No such pattern `{name}`',
-				mention_author=False)
+				ephemeral=True,
+			)
 			return
 		statement.priority = priority
-		self.__save_patterns(context.guild, patterns)
-		await context.message.reply(
+		self.__save_patterns(guild, patterns)
+		await interaction.response.send_message(
 			f'{CONFIG["success_emoji"]} Priority for pattern `{name}` ' + \
-			f'updated to `{priority}`.',
-			mention_author=False)
+				f'updated to `{priority}`.',
+			ephemeral=True,
+		)

rocketbot/pattern.py

 import re
 from abc import ABCMeta, abstractmethod
 from datetime import datetime, timezone
-from typing import Any, Union
+from typing import Any, Union, Literal
 
 from discord import Message, utils as discordutils
 from discord.ext.commands import Context
 from rocketbot.utils import is_user_id, str_from_quoted_str, timedelta_from_str, \
 	user_id_from_mention
 
+PatternField = Literal['content.markdown', 'content', 'content.plain', 'author', 'author.id', 'author.joinage', 'author.name', 'lastmatched']
+PatternComparisonOperator = Literal['==', '!=', '<', '>', '<=', '>=', 'contains', '!contains', 'matches', '!matches', 'containsword', '!containsword']
+PatternBooleanOperator = Literal['!', 'and', 'or']
+PatternActionType = Literal['ban', 'delete', 'kick', 'modinfo', 'modwarn', 'reply']
+
 class PatternError(RuntimeError):
 	"""
 	Error thrown when parsing a pattern statement.
 	"""
 	Describes one action to take on a matched message or its author.
 	"""
+
+	TYPE_BAN: PatternActionType = 'ban'
+	TYPE_DELETE: PatternActionType = 'delete'
+	TYPE_KICK: PatternActionType = 'kick'
+	TYPE_INFORM_MODS: PatternActionType = 'modinfo'
+	TYPE_WARN_MODS: PatternActionType = 'modwarn'
+	TYPE_REPLY: PatternActionType = 'reply'
+
 	def __init__(self, action: str, args: list[Any]):
 		self.action = action
 		self.arguments = list(args)
 	Message matching expression with a simple "<field> <operator> <value>"
 	structure.
 	"""
-	def __init__(self, field: str, operator: str, value: Any):
+
+	FIELD_CONTENT_MARKDOWN: PatternField = 'content.markdown'
+	FIELD_CONTENT_PLAIN: PatternField = 'content.plain'
+	FIELD_AUTHOR_ID: PatternField = 'author.id'
+	FIELD_AUTHOR_JOINAGE: PatternField = 'author.joinage'
+	FIELD_AUTHOR_NAME: PatternField = 'author.name'
+	FIELD_LAST_MATCHED: PatternField = 'lastmatched'
+
+	# Less preferred but recognized field aliases
+	ALIAS_FIELD_CONTENT_MARKDOWN: PatternField = 'content'
+	ALIAS_FIELD_AUTHOR_ID: PatternField = 'author'
+
+	OP_EQUALS: PatternComparisonOperator = '=='
+	OP_NOT_EQUALS: PatternComparisonOperator = '!='
+	OP_LESS_THAN: PatternComparisonOperator = '<'
+	OP_GREATER_THAN: PatternComparisonOperator = '>'
+	OP_LESS_THAN_OR_EQUALS: PatternComparisonOperator = '<='
+	OP_GREATER_THAN_OR_EQUALS: PatternComparisonOperator = '>='
+	OP_CONTAINS: PatternComparisonOperator = 'contains'
+	OP_NOT_CONTAINS: PatternComparisonOperator = '!contains'
+	OP_MATCHES: PatternComparisonOperator = 'matches'
+	OP_NOT_MATCHES: PatternComparisonOperator = '!matches'
+	OP_CONTAINS_WORD: PatternComparisonOperator = 'containsword'
+	OP_NOT_CONTAINS_WORD: PatternComparisonOperator = '!containsword'
+
+	def __init__(self, field: PatternField, operator: PatternComparisonOperator, value: Any):
 		super().__init__()
-		self.field: str = field
-		self.operator: str = operator
+		self.field: PatternField = field
+		self.operator: PatternComparisonOperator = operator
 		self.value: Any = value
 
 	def __field_value(self, message: Message, other_fields: dict[str, Any]) -> Any:
-		if self.field in ('content.markdown', 'content'):
+		cls = PatternSimpleExpression
+		if self.field in (cls.FIELD_CONTENT_MARKDOWN, cls.ALIAS_FIELD_CONTENT_MARKDOWN):
 			return message.content
-		if self.field == 'content.plain':
+		if self.field == cls.FIELD_CONTENT_PLAIN:
 			return discordutils.remove_markdown(message.clean_content)
-		if self.field == 'author':
+		if self.field in (cls.FIELD_AUTHOR_ID, cls.ALIAS_FIELD_AUTHOR_ID):
 			return str(message.author.id)
-		if self.field == 'author.id':
-			return str(message.author.id)
-		if self.field == 'author.joinage':
+		if self.field == cls.FIELD_AUTHOR_JOINAGE:
 			return message.created_at - message.author.joined_at
-		if self.field == 'author.name':
+		if self.field == cls.FIELD_AUTHOR_NAME:
 			return message.author.name
-		if self.field == 'lastmatched':
+		if self.field == cls.FIELD_LAST_MATCHED:
 			long_ago = datetime(year=1900, month=1, day=1, hour=0, minute=0, second=0, tzinfo=timezone.utc)
 			last_matched = other_fields.get('last_matched') or long_ago
 			return message.created_at - last_matched
-		raise ValueError(f'Bad field name {self.field}')
+		raise ValueError(f'Bad field name "{self.field}"')
 
 	def matches(self, message: Message, other_fields: dict[str, Any]) -> bool:
+		cls = PatternSimpleExpression
 		field_value = self.__field_value(message, other_fields)
-		if self.operator == '==':
+		if self.operator == cls.OP_EQUALS:
 			if isinstance(field_value, str) and isinstance(self.value, str):
 				return field_value.lower() == self.value.lower()
 			return field_value == self.value
-		if self.operator == '!=':
+		if self.operator == cls.OP_NOT_EQUALS:
 			if isinstance(field_value, str) and isinstance(self.value, str):
 				return field_value.lower() != self.value.lower()
 			return field_value != self.value
-		if self.operator == '<':
+		if self.operator == cls.OP_LESS_THAN:
 			return field_value < self.value
-		if self.operator == '>':
+		if self.operator == cls.OP_GREATER_THAN:
 			return field_value > self.value
-		if self.operator == '<=':
+		if self.operator == cls.OP_LESS_THAN_OR_EQUALS:
 			return field_value <= self.value
-		if self.operator == '>=':
+		if self.operator == cls.OP_GREATER_THAN_OR_EQUALS:
 			return field_value >= self.value
-		if self.operator == 'contains':
+		if self.operator == cls.OP_CONTAINS:
 			return self.value.lower() in field_value.lower()
-		if self.operator == '!contains':
+		if self.operator == cls.OP_NOT_CONTAINS:
 			return self.value.lower() not in field_value.lower()
-		if self.operator in ('matches', 'containsword'):
+		if self.operator in (cls.OP_MATCHES, cls.OP_CONTAINS_WORD):
 			return self.value.search(field_value.lower()) is not None
-		if self.operator in ('!matches', '!containsword'):
+		if self.operator in (cls.OP_NOT_MATCHES, cls.OP_NOT_CONTAINS_WORD):
 			return self.value.search(field_value.lower()) is None
 		raise ValueError(f'Bad operator {self.operator}')
 
 	Message matching expression that combines several child expressions with
 	a boolean operator.
 	"""
-	def __init__(self, operator: str, operands: list[PatternExpression]):
+	OP_NOT = '!'
+	OP_AND = 'and'
+	OP_OR = 'or'
+
+	def __init__(self, operator: PatternBooleanOperator, operands: list[PatternExpression]):
 		super().__init__()
-		self.operator = operator
+		self.operator: PatternBooleanOperator = operator
 		self.operands = list(operands)
 
 	def matches(self, message: Message, other_fields: dict[str, Any]) -> bool:
-		if self.operator == '!':
+		if self.operator == PatternCompoundExpression.OP_NOT:
 			return not self.operands[0].matches(message, other_fields)
-		if self.operator == 'and':
+		if self.operator == PatternCompoundExpression.OP_AND:
 			for op in self.operands:
 				if not op.matches(message, other_fields):
 					return False
 			return True
-		if self.operator == 'or':
+		if self.operator == PatternCompoundExpression.OP_OR:
 			for op in self.operands:
 				if op.matches(message, other_fields):
 					return True
 		raise ValueError(f'Bad operator "{self.operator}"')
 
 	def __str__(self) -> str:
-		if self.operator == '!':
+		if self.operator == PatternCompoundExpression.OP_NOT:
 			return f'(!( {self.operands[0]} ))'
 		strs = map(str, self.operands)
 		joined = f' {self.operator} '.join(strs)
 	"""
 	Parses a user-provided message filter statement into a PatternStatement.
 	"""
-	TYPE_FLOAT: str = 'float'
-	TYPE_ID: str = 'id'
-	TYPE_INT: str = 'int'
-	TYPE_MEMBER: str = 'Member'
-	TYPE_REGEX: str = 'regex'
-	TYPE_TEXT: str = 'text'
-	TYPE_TIMESPAN: str = 'timespan'
-
-	FIELD_TO_TYPE: dict[str, str] = {
-		'author': TYPE_MEMBER,
-		'author.id': TYPE_ID,
-		'author.joinage': TYPE_TIMESPAN,
-		'author.name': TYPE_TEXT,
-		'content': TYPE_TEXT, # deprecated, use content.markdown or content.plain
-		'content.markdown': TYPE_TEXT,
-		'content.plain': TYPE_TEXT,
-		'lastmatched': TYPE_TIMESPAN,
+	DATATYPE_FLOAT: str = 'float'
+	DATATYPE_ID: str = 'id'
+	DATATYPE_INT: str = 'int'
+	DATATYPE_MEMBER: str = 'Member'
+	DATATYPE_REGEX: str = 'regex'
+	DATATYPE_TEXT: str = 'text'
+	DATATYPE_TIMESPAN: str = 'timespan'
+
+	FIELD_TO_DATATYPE: dict[PatternField, str] = {
+		PatternSimpleExpression.ALIAS_FIELD_AUTHOR_ID: DATATYPE_MEMBER,
+		PatternSimpleExpression.FIELD_AUTHOR_ID: DATATYPE_ID,
+		PatternSimpleExpression.FIELD_AUTHOR_JOINAGE: DATATYPE_TIMESPAN,
+		PatternSimpleExpression.FIELD_AUTHOR_NAME: DATATYPE_TEXT,
+		PatternSimpleExpression.ALIAS_FIELD_CONTENT_MARKDOWN: DATATYPE_TEXT, # deprecated, use content.markdown or content.plain
+		PatternSimpleExpression.FIELD_CONTENT_MARKDOWN: DATATYPE_TEXT,
+		PatternSimpleExpression.FIELD_CONTENT_PLAIN: DATATYPE_TEXT,
+		PatternSimpleExpression.FIELD_LAST_MATCHED: DATATYPE_TIMESPAN,
 	}
-	DEPRECATED_FIELDS: set[str] = { 'content' }
-
-	ACTION_TO_ARGS: dict[str, list[str]] = {
-		'ban': [],
-		'delete': [],
-		'kick': [],
-		'modinfo': [],
-		'modwarn': [],
-		'reply': [ TYPE_TEXT ],
+	DEPRECATED_FIELDS: set[PatternField] = { 'content' }
+
+	ACTION_TO_ARGS: dict[PatternActionType, list[str]] = {
+		PatternAction.TYPE_BAN: [],
+		PatternAction.TYPE_DELETE: [],
+		PatternAction.TYPE_KICK: [],
+		PatternAction.TYPE_INFORM_MODS: [],
+		PatternAction.TYPE_WARN_MODS: [],
+		PatternAction.TYPE_REPLY: [ DATATYPE_TEXT ],
 	}
 
-	OPERATORS_IDENTITY: set[str] = { '==', '!=' }
-	OPERATORS_COMPARISON: set[str] = { '<', '>', '<=', '>=' }
-	OPERATORS_NUMERIC: set[str] = OPERATORS_IDENTITY | OPERATORS_COMPARISON
-	OPERATORS_TEXT: set[str] = OPERATORS_IDENTITY | {
-		'contains', '!contains',
-		'containsword', '!containsword',
-		'matches', '!matches',
+	OPERATORS_IDENTITY: set[PatternComparisonOperator] = {
+		PatternSimpleExpression.OP_EQUALS,
+		PatternSimpleExpression.OP_NOT_EQUALS,
+	}
+	OPERATORS_COMPARISON: set[PatternComparisonOperator] = {
+		PatternSimpleExpression.OP_LESS_THAN,
+		PatternSimpleExpression.OP_GREATER_THAN,
+		PatternSimpleExpression.OP_LESS_THAN_OR_EQUALS,
+		PatternSimpleExpression.OP_GREATER_THAN_OR_EQUALS,
+	}
+	OPERATORS_NUMERIC: set[PatternComparisonOperator] = OPERATORS_IDENTITY | OPERATORS_COMPARISON
+	OPERATORS_TEXT: set[PatternComparisonOperator] = OPERATORS_IDENTITY | {
+		PatternSimpleExpression.OP_CONTAINS,
+		PatternSimpleExpression.OP_NOT_CONTAINS,
+		PatternSimpleExpression.OP_CONTAINS_WORD,
+		PatternSimpleExpression.OP_NOT_CONTAINS_WORD,
+		PatternSimpleExpression.OP_MATCHES,
+		PatternSimpleExpression.OP_NOT_MATCHES,
 	}
 	OPERATORS_ALL: set[str] = OPERATORS_IDENTITY | OPERATORS_COMPARISON | OPERATORS_TEXT
 
-	TYPE_TO_OPERATORS: dict[str, set[str]] = {
-		TYPE_ID: OPERATORS_IDENTITY,
-		TYPE_MEMBER: OPERATORS_IDENTITY,
-		TYPE_TEXT: OPERATORS_TEXT,
-		TYPE_INT: OPERATORS_NUMERIC,
-		TYPE_FLOAT: OPERATORS_NUMERIC,
-		TYPE_TIMESPAN: OPERATORS_NUMERIC,
+	DATATYPE_TO_OPERATORS: dict[str, set[PatternComparisonOperator]] = {
+		DATATYPE_ID: OPERATORS_IDENTITY,
+		DATATYPE_MEMBER: OPERATORS_IDENTITY,
+		DATATYPE_TEXT: OPERATORS_TEXT,
+		DATATYPE_INT: OPERATORS_NUMERIC,
+		DATATYPE_FLOAT: OPERATORS_NUMERIC,
+		DATATYPE_TIMESPAN: OPERATORS_NUMERIC,
 	}
 
 	WHITESPACE_CHARS: str = ' \t\n\r'
 					return subexpressions[0], token_index
 				return (PatternCompoundExpression(last_compound_operator,
 					subexpressions), token_index)
-			if tokens[token_index] in { "and", "or" }:
+			if tokens[token_index] in { PatternCompoundExpression.OP_AND, PatternCompoundExpression.OP_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] == '!':
+			if tokens[token_index] == PatternCompoundExpression.OP_NOT:
 				(exp, next_index) = cls.__read_expression(tokens,
 						token_index + 1, depth + 1, one_subexpression=True)
 				subexpressions.append(PatternCompoundExpression('!', [exp]))
 			raise PatternError('Expression nests too deeply')
 		if token_index >= len(tokens):
 			raise PatternError('Expected field name, found EOL')
-		field = tokens[token_index]
+		field: PatternField = tokens[token_index]
 		token_index += 1
 
-		datatype = cls.FIELD_TO_TYPE.get(field)
+		datatype = cls.FIELD_TO_DATATYPE.get(field, None)
 		if datatype is None:
 			raise PatternError(f'No such field "{field}"')
 
 		op = tokens[token_index]
 		token_index += 1
 
-		if op == '!':
+		if op == PatternCompoundExpression.OP_NOT:
 			if token_index >= len(tokens):
 				raise PatternError('Expected operator, found EOL')
 			op = '!' + tokens[token_index]
 			token_index += 1
 
-		allowed_ops = cls.TYPE_TO_OPERATORS[datatype]
+		allowed_ops = cls.DATATYPE_TO_OPERATORS[datatype]
 		if op not in allowed_ops:
 			if op in cls.OPERATORS_ALL:
 				raise PatternError(f'Operator {op} cannot be used with ' + \
 		"""
 		Converts a value token to its Python value. Raises ValueError on failure.
 		"""
-		if datatype == cls.TYPE_ID:
+		if datatype == cls.DATATYPE_ID:
 			if not is_user_id(value):
 				raise ValueError(f'Illegal user id value: {value}')
 			return value
-		if datatype == cls.TYPE_MEMBER:
+		if datatype == cls.DATATYPE_MEMBER:
 			return user_id_from_mention(value)
-		if datatype == cls.TYPE_TEXT:
+		if datatype == cls.DATATYPE_TEXT:
 			s = str_from_quoted_str(value)
 			if op in ('matches', '!matches'):
 				try:
 				except re.error as e:
 					raise ValueError(f'Invalid regex: {e}') from e
 			return s
-		if datatype == cls.TYPE_INT:
+		if datatype == cls.DATATYPE_INT:
 			return int(value)
-		if datatype == cls.TYPE_FLOAT:
+		if datatype == cls.DATATYPE_FLOAT:
 			return float(value)
-		if datatype == cls.TYPE_TIMESPAN:
+		if datatype == cls.DATATYPE_TIMESPAN:
 			return timedelta_from_str(value)
 		raise ValueError(f'Unhandled datatype {datatype}')