Simplified and improved generate_otp() performance in Steam class

[Genarito]

Hi! I hope you are doing well! This is a minimal change but using lists instead of string concatenations (to avoid the generation of new strings in each iteration) and avoiding the unnecessary casting of the int_code % total_chars to int can simplify and improve the performance (~18.5% faster) of the generate_otp method in the Steam class.

Here is a benchmark in case you are interested in measuring the time difference:

import timeit

# Constants for the OTP generation
STEAM_CHARS = "23456789BCDFGHJKMNPQRTVWXY"  # steam's custom alphabet
STEAM_DEFAULT_DIGITS = 5  # Steam TOTP code length


# A base class with a dummy implementation of generate_otp,
# which simply returns a fixed string.
class BaseOTP:
    def generate_otp(self, input: int) -> str:
        # For benchmarking purposes, return a constant numeric string.
        return "12345678"


# Original implementation of generate_otp
class OriginalOTP(BaseOTP):
    def generate_otp(self, input: int) -> str:
        """
        Generate an OTP using string concatenation.
        """
        str_code = super().generate_otp(input)
        int_code = int(str_code)

        steam_code = ""
        total_chars = len(STEAM_CHARS)

        for _ in range(STEAM_DEFAULT_DIGITS):
            pos = int_code % total_chars
            char = STEAM_CHARS[int(pos)]
            steam_code += char
            int_code //= total_chars

        return steam_code


# Optimized implementation of generate_otp using list accumulation
class OptimizedOTP(BaseOTP):
    def generate_otp(self, input: int) -> str:
        """
        Generate an OTP using list accumulation for improved performance.
        """
        int_code = int(super().generate_otp(input))
        total_chars = len(STEAM_CHARS)

        digits = []
        for _ in range(STEAM_DEFAULT_DIGITS):
            pos = int_code % total_chars
            digits.append(STEAM_CHARS[pos])
            int_code //= total_chars

        return "".join(digits)


# Create instances of each implementation
original = OriginalOTP()
optimized = OptimizedOTP()

# Number of iterations for the benchmark
iterations = 100_000_000

# Benchmark the original implementation
original_time = timeit.timeit(lambda: original.generate_otp(42), number=iterations)

# Benchmark the optimized implementation
optimized_time = timeit.timeit(lambda: optimized.generate_otp(42), number=iterations)

print(f"Original version time for {iterations} iterations: {original_time:.6f} seconds")
print(f"Optimized version time for {iterations} iterations: {optimized_time:.6f} seconds")

If you want, I can refactor the code to store int_code % total_chars in a variable called pos and make it more readable, but well, it would be slightly slower given its allocation.

Greetings!