Better number formatting

rocketbot/cogs/kickstartercog.py

 		else:
 			lines.append(f"- Backer role configured as `{backer_role.name}`")
 		if stats.username_count > 0:
-			lines.append(f"- **{stats.username_count}** Discord usernames imported")
-			lines.append(f"- Last new import at <t:{stats.username_last_imported_at}:f>")
-			lines.append(f"- **{stats.username_found_count}** members linked successfully")
+			lines.append(f"- **{stats.username_count:,}** Discord usernames imported")
+			lines.append("- Last import with new records on " \
+				f"<t:{stats.username_last_imported_at}:f>")
+			lines.append(f"- **{stats.username_found_count:,}** members linked successfully")
 			if stats.username_not_found_count > 0:
-				lines.append(f"- **{stats.username_not_found_count}** imported " \
+				lines.append(f"- **{stats.username_not_found_count:,}** imported " \
 					"usernames not yet linked to Discord members")
 			if stats.username_unprocessed_count > 0:
-				lines.append(f"- **{stats.username_unprocessed_count}** " \
-					"usernames not yet attempted to sync")
+				lines.append(f"- **{stats.username_unprocessed_count:,}** " \
+					"usernames added since last sync")
 		else:
 			lines.append("- No Discord usernames imported yet. Use " \
 				f"`/{KickstarterCog.kickstarter.name} {KickstarterCog.upload.name}`")
 		text = f"{CONFIG['success_emoji']} Record for `@{normal_username}` reset. " \
 			"(No roles removed from member.)"
 		if old_member_id is not None:
-			text += f"\n- member_id: `{old_member_id}` --> `{record.discord_member_id}`"
+			text += f"\n- `discord_member_id` changed from `{old_member_id}` to `{record.discord_member_id}`"
 		if old_lookup_status is not None:
-			text += f"\n- lookup_status: `{_describe_lookup_status(old_lookup_status)}`" \
-				f" --> `{_describe_lookup_status(record.lookup_status)}`"
+			text += f"\n- `lookup_status` changed from `{_describe_lookup_status(old_lookup_status)}`" \
+				f" to `{_describe_lookup_status(record.lookup_status)}`"
 		await interaction.response.send_message(text, ephemeral=True)
 
 	@kickstarter.command(
 
 		await interaction.response.send_modal(_UploadUsernamesModal())
 
+	# @override
 	async def interaction_check(self, interaction: Interaction) -> bool:
 		if interaction.command is not None:
 			self.__trace(interaction.guild, f"@{interaction.user.name} used " \
 	) -> '_ImportResult':
 		"""Imports Discord usernames from an upload attachment."""
 		self.__trace(guild, f"Download - start - {attachment.filename} " \
-			f"({attachment.size} bytes, {attachment.content_type})")
+			f"({attachment.size:,} bytes, {attachment.content_type})")
 		file_bytes = await attachment.read()
 		file_str = file_bytes.decode('utf-8')
 		self.__trace(guild, "Download - complete")
 				self.__trace(guild, f"Not a Discord username: \"{line}\"")
 				malformed_usernames.append(line)
 				malformed_count += 1
-		self.__trace(guild, f"Parse - complete - {len(lines)} lines, {len(usernames)} " \
-			f"valid usernames, {malformed_count} malformed usernames")
+		self.__trace(guild, f"Parse - complete - {len(lines):,} lines, {len(usernames):,} " \
+			f"valid usernames, {malformed_count:,} malformed usernames")
 
-		self.__trace(guild, f"Storing - start - {len(usernames)} usernames")
+		self.__trace(guild, f"Storing - start - {len(usernames):,} usernames")
 		new_username_count = self.__store_kickstarter_usernames(guild.id, usernames)
-		self.__trace(guild, f"Storing - complete - {new_username_count} unique " \
+		self.__trace(guild, f"Storing - complete - {new_username_count:,} unique " \
 			"usernames stored")
 
 		return _ImportResult(
 					_LookupStatus.unprocessed,
 					_LookupStatus.username_not_found
 				})
-		self.__trace(guild, f"Fetch usernames - complete - found {len(usernames)}")
+		self.__trace(guild, f"Fetch usernames - complete - found {len(usernames):,}")
 		username_to_member_id: dict[str, int] = {}
 		if self.bot.intents.members:
 			self.__trace(guild, "Fetching guild members from API - start")
 			async for member in guild.fetch_members(limit=None):
 				username_to_member_id[member.name] = member.id
 			self.__trace(guild, "Fetching guild members from API - complete - " \
-				f"got {len(username_to_member_id)}")
+				f"got {len(username_to_member_id):,}")
 		async def username_loop_handler(username: _KickstarterDiscordUser):
 			nonlocal complete_count
 			nonlocal not_found_count
 		self.__trace(guild, "Sync loop - start")
 		failure_count = await self.__throttled_loop(guild, usernames,
 			username_loop_handler, update_seconds=10.0)
-		self.__trace(guild, f"Sync loop - complete - {complete_count} completed, " \
-			f"{not_found_count} not found")
+		self.__trace(guild, f"Sync loop - complete - {complete_count:,} completed, " \
+			f"{not_found_count:,} not found")
 		return _SyncUsernamesResult(complete_count, not_found_count, failure_count)
 
 	async def __throttled_loop(self,
 							f"retry_after={retry_header_value}")
 						await sleep(retry_after_millis / 1000.0)
 						sleep_length = 1.0 if sleep_length == 0.0 else sleep_length * 2.0
-						self.__trace(guild, f"Sleep increased to {sleep_length}s " \
+						self.__trace(guild, f"Sleep increased to {sleep_length:,}s " \
 							"due to rate limiting")
 					else:
 						dump_stacktrace(ex)
 			if not complete:
 				failure_count += 1
 			if update_seconds is not None and now_timestamp() - last_update_time >= update_seconds:
-				self.__trace(guild, f"Completed {iter_count + 1} iterations")
+				self.__trace(guild, f"Completed {iter_count + 1:,} iterations")
 				last_update_time = now_timestamp()
 		return failure_count
 
 	def summary_markdown(self) -> str:
 		lines: list[str] = []
 		if self.valid_record_count > 0:
-			lines.append(f"- Read {self.valid_record_count} valid records")
+			lines.append(f"- Read {self.valid_record_count:,} valid records")
 		else:
 			lines.append("- Upload contained **no valid records**")
 		if self.malformed_record_count > 0:
-			lines.append(f"- Read **{self.malformed_record_count} malformed records**")
+			lines.append(f"- Read **{self.malformed_record_count:,} malformed records**")
 		if self.new_record_count > 0:
-			lines.append(f"- Imported {self.new_record_count} new unique records")
+			lines.append(f"- Imported {self.new_record_count:,} new unique records")
 		else:
 			lines.append("- No new unique records (all previously imported)")
 		return "\n".join(lines)
 	def summary_markdown(self) -> str:
 		lines: list[str] = []
 		if self.complete_count > 0:
-			lines.append(f"- Gave backer role to {self.complete_count} new members")
+			lines.append(f"- Gave backer role to {self.complete_count:,} new members")
 		else:
 			lines.append("- No new members found")
 		if self.not_found_count > 0:
-			lines.append(f"- {self.not_found_count} members could not be found " \
+			lines.append(f"- {self.not_found_count:,} members could not be found " \
 				"by the provided username")
 		if self.failure_count > 0:
-			lines.append(f"- Failed to link {self.failure_count} members")
+			lines.append(f"- Failed to link {self.failure_count:,} members")
 		return "\n".join(lines)
 
 class _UploadUsernamesModal(Modal):
 	def __init__(self):
 		super().__init__(title='Upload Discord Usernames', timeout=None)
 
+	# @override
 	async def on_submit(self, interaction: Interaction) -> None:
 		# noinspection PyTypeChecker
 		upload_input: FileUpload = self.upload_label.component
 		attachment = upload_input.values[0]
 		await KickstarterCog.shared.on_username_upload_submit(interaction, attachment)
 
+	# @override
 	async def on_error(self, interaction: Interaction, error: Exception) -> None:
 		dump_stacktrace(error)
 		try: