Annotating pattern, utils

rocketbot/pattern.py

 		pass
 
 	@abstractmethod
-	def matches(self, message: Message, other_fields: dict[str: Any]) -> bool:
+	def matches(self, message: Message, other_fields: dict[str, Any]) -> bool:
 		"""
 		Whether a message matches this expression. other_fields are additional
 		fields that can be queried not contained in the message itself.
 	"""
 	def __init__(self, field: str, operator: str, value: Any):
 		super().__init__()
-		self.field = field
-		self.operator = operator
-		self.value = value
+		self.field: str = field
+		self.operator: str = operator
+		self.value: Any = value
 
 	def __field_value(self, message: Message, other_fields: dict[str: Any]) -> Any:
 		if self.field in ('content.markdown', 'content'):
 	the given actions should be performed.
 	"""
 
-	DEFAULT_PRIORITY = 100
+	DEFAULT_PRIORITY: int = 100
 
 	def __init__(self,
 			name: str,
 			expression: PatternExpression,
 			original: str,
 			priority: int = DEFAULT_PRIORITY):
-		self.name = name
-		self.actions = list(actions)  # PatternAction[]
-		self.expression = expression
-		self.original = original
-		self.priority = priority
+		self.name: str = name
+		self.actions: list[PatternAction] = list(actions)  # PatternAction[]
+		self.expression: PatternExpression = expression
+		self.original: str = original
+		self.priority: int = priority
 
 	def check_deprecations(self) -> None:
 		"""
 			for oper in c.operands:
 				cls.__check_deprecations(oper)
 
-	def to_json(self) -> dict:
+	def to_json(self) -> dict[str, Any]:
 		"""
 		Returns a JSON representation of this statement.
 		"""
 		}
 
 	@classmethod
-	def from_json(cls, json: dict):
+	def from_json(cls, json: dict[str, Any]):
 		"""
 		Gets a PatternStatement from its JSON representation.
 		"""
 	"""
 	Parses a user-provided message filter statement into a PatternStatement.
 	"""
-	TYPE_FLOAT = 'float'
-	TYPE_ID = 'id'
-	TYPE_INT = 'int'
-	TYPE_MEMBER = 'Member'
-	TYPE_REGEX = 'regex'
-	TYPE_TEXT = 'text'
-	TYPE_TIMESPAN = 'timespan'
+	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,
 
 	OPERATORS_IDENTITY: set[str] = set([ '==', '!=' ])
 	OPERATORS_COMPARISON: set[str] = set([ '<', '>', '<=', '>=' ])
-	OPERATORS_NUMERIC = OPERATORS_IDENTITY | OPERATORS_COMPARISON
-	OPERATORS_TEXT = OPERATORS_IDENTITY | set([
+	OPERATORS_NUMERIC: set[str] = OPERATORS_IDENTITY | OPERATORS_COMPARISON
+	OPERATORS_TEXT: set[str] = OPERATORS_IDENTITY | set([
 		'contains', '!contains',
 		'containsword', '!containsword',
 		'matches', '!matches',
 	])
-	OPERATORS_ALL = OPERATORS_IDENTITY | OPERATORS_COMPARISON | OPERATORS_TEXT
+	OPERATORS_ALL: set[str] = OPERATORS_IDENTITY | OPERATORS_COMPARISON | OPERATORS_TEXT
 
 	TYPE_TO_OPERATORS: dict[str, set[str]] = {
 		TYPE_ID: OPERATORS_IDENTITY,
 		TYPE_TIMESPAN: OPERATORS_NUMERIC,
 	}
 
-	WHITESPACE_CHARS = ' \t\n\r'
-	STRING_QUOTE_CHARS = '\'"'
-	SYMBOL_CHARS = 'abcdefghijklmnopqrstuvwxyz.'
-	VALUE_CHARS = '0123456789dhms<@!>'
-	OP_CHARS = '<=>!(),'
+	WHITESPACE_CHARS: str = ' \t\n\r'
+	STRING_QUOTE_CHARS: str = '\'"'
+	SYMBOL_CHARS: str = 'abcdefghijklmnopqrstuvwxyz.'
+	VALUE_CHARS: str = '0123456789dhms<@!>'
+	OP_CHARS: str = '<=>!(),'
 
-	MAX_EXPRESSION_NESTING = 8
+	MAX_EXPRESSION_NESTING: int = 8
 
 	@classmethod
 	def expression_str_from_context(cls, context: Context, name: str) -> str:
 		"""
 		Extracts the statement string from an "add" command context.
 		"""
-		pattern_str = context.message.content
+		pattern_str: str = context.message.content
 		command_chain = [ name ]
 		cmd = context.command
 		while cmd:
 		Parses a user-provided message filter statement into a PatternStatement.
 		Raises PatternError on failure.
 		"""
-		tokens = cls.__tokenize(statement)
-		token_index = 0
+		tokens: list[str] = cls.__tokenize(statement)
+		token_index: int = 0
 		actions, token_index = cls.__read_actions(tokens, token_index)
 		expression, token_index = cls.__read_expression(tokens, token_index)
 		return PatternStatement(name, actions, expression, statement)
 		Converts a message filter statement into a list of tokens.
 		"""
 		tokens: list[str] = []
-		in_quote = False
-		in_escape = False
-		all_token_types = set([ 'sym', 'op', 'val' ])
-		possible_token_types = set(all_token_types)
-		current_token = ''
+		in_quote: bool = False
+		in_escape: bool = False
+		all_token_types: set[str] = set([ 'sym', 'op', 'val' ])
+		possible_token_types: set[str] = set(all_token_types)
+		current_token: str = ''
 		for ch in statement:
 			if in_quote:
 				if in_escape:

rocketbot/utils.py

 """
 import re
 from datetime import datetime, timedelta
+from typing import Any, Union
+
 from discord import Guild
 from discord.ext.commands import Cog, Group
 
 	"1h30m"
 	"73d18h22m52s"
 	"""
-	p = re.compile('^(?:[0-9]+[dhms])+$')
+	p: re.Pattern = re.compile('^(?:[0-9]+[dhms])+$')
 	if p.match(s) is None:
 		raise ValueError("Illegal timespan value '{s}'.")
 	p = re.compile('([0-9]+)([dhms])')
-	days = 0
-	hours = 0
-	minutes = 0
-	seconds = 0
+	days: int = 0
+	hours: int = 0
+	minutes: int = 0
+	seconds: int = 0
 	for m in p.finditer(s):
 		scalar = int(m.group(1))
 		unit = m.group(2)
 	"""
 	Encodes a timedelta as a str. E.g. "3d2h"
 	"""
-	d = td.days
-	h = td.seconds // 3600
-	m = (td.seconds // 60) % 60
-	s = td.seconds % 60
-	components = []
+	d: int = td.days
+	h: int = td.seconds // 3600
+	m: int = (td.seconds // 60) % 60
+	s: int = td.seconds % 60
+	components: list[str] = []
 	if d != 0:
 		components.append(f'{d}d')
 	if h != 0:
 	"""
 	Formats a human-readable description of a time span. E.g. "3 days 2 hours".
 	"""
-	d = td.days
-	h = td.seconds // 3600
-	m = (td.seconds // 60) % 60
-	s = td.seconds % 60
-	components = []
+	d: int = td.days
+	h: int = td.seconds // 3600
+	m: int = (td.seconds // 60) % 60
+	s: int = td.seconds % 60
+	components: list[str] = []
 	if d != 0:
 		components.append('1 day' if d == 1 else f'{d} days')
 	if h != 0:
 			return member
 	return None
 
-def bot_log(guild: Guild, cog_class, message: str) -> None:
+def bot_log(guild: Guild, cog_class, message: Any) -> None:
 	'Logs a message to stdout with time, cog, and guild info.'
-	now = datetime.now() # local
+	now: datetime = datetime.now() # local
 	s = f'[{now.strftime("%Y-%m-%dT%H:%M:%S")}|'
 	s += f'{cog_class.__name__}|' if cog_class else '-|'
 	s += f'{guild.name}] ' if guild else '-] '
-	s += message
+	s += str(message)
 	print(s)
 
-__QUOTE_CHARS = '\'"'
-__ID_REGEX = re.compile('^[0-9]{17,20}$')
-__MENTION_REGEX = re.compile('^<@[!&]([0-9]{17,20})>$')
-__USER_MENTION_REGEX = re.compile('^<@!([0-9]{17,20})>$')
-__ROLE_MENTION_REGEX = re.compile('^<@&([0-9]{17,20})>$')
+__QUOTE_CHARS: str = '\'"'
+__ID_REGEX: re.Pattern = re.compile('^[0-9]{17,20}$')
+__MENTION_REGEX: re.Pattern = re.compile('^<@[!&]([0-9]{17,20})>$')
+__USER_MENTION_REGEX: re.Pattern = re.compile('^<@!([0-9]{17,20})>$')
+__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.'
 		return m.group(1)
 	raise ValueError(f'"{mention}" is not an @ user mention')
 
-def mention_from_user_id(user_id: str) -> str:
+def mention_from_user_id(user_id: Union[str, int]) -> str:
 	'Returns a markdown user mention from a user id.'
 	return f'<@!{user_id}>'
 
-def mention_from_role_id(role_id: str) -> str:
+def mention_from_role_id(role_id: Union[str, int]) -> str:
 	'Returns a markdown role mention from a role id.'
 	return f'<@&{role_id}>'