Optimizing real-time ASCII playback in Python when each frame is fetched as a PNG via GET

I first tried to fetch an image via my browser just to see what I would be displaying, but I am currently getting redirected. I will certainly try again later and I may have more to say when I am able to execute your code. For now here are some suggestions:

Endless Loop Issue

With your current code, if there is an error loading an image (and there was an exception raised due to the server being down), at_frame never gets incremented and an attempt is made to reload the same page over and over again in an endless loop. The best course of action on such an error would be to terminate the script.

Be More Pythonic

• You have a loop variable at_frame (would frame_num be a better name?) that is initialized, tested and incremented. The Pythonic way of handling such a loop would be to use the range built-in function:

for at_frame in range(1, 29):
    ...

at_frame will take on successive integer values between 1 and 28. This will also solve the "endless loop issue" described above, but my suggestion would be to terminate the script on such an error.

• Your "infinite playback loop" controlled by variable frame_num can also be made more Pythonic in a similar way.

• You have the expression int(width / 2). This should be instead width // 2.

Use Multithreading to Improve Image Download Time

Investigate either the concurrent.futures.ThreadPool or multiprocessing.pool.ThreadPool class to download multiple images concurrently.

Use a Session

Since you are doing multiple requests to the same site, it is recommended that you use a Session instance for making your get requests. See Advanced Usage.

Possible Performance Improvement

In your code a certain amount of calculations needs to be done executing frame.to_terminal(columns=n_columns, width_ratio=2). Looking at the implementation of metthod to_terminal I see:

def to_terminal(self, ...):
    art = self._img_to_art(...)
    print(art)
    return art

This suggests that we can process each frame initially to crate a new frame that can be directly outputted with a print statement.

Reduce Flicker

Instead of clearing your screen prior to outputting each frame, use an ASCII escape sequence to position the cursor to the first row of the terminal.

Putting It All Together

"""
Live ASCII Rickroll generator.

Downloads 28 PNG frames from a PHP endpoint, converts them to ASCII using
ascii-magic, stores them in memory, and plays them in a continuous loop.
"""

import os
import time
import requests
from io import BytesIO, StringIO
from multiprocessing.pool import ThreadPool
from functools import partial
from contextlib import redirect_stdout

from PIL import Image
from ascii_magic import AsciiArt

def main():
    def clear_screen():
        """Clear the terminal screen based on the operating system."""
        if os.name == 'nt':
            os.system('cls')
        else:
            os.system('clear')

    def download_image(session, frame_num):
        """Download and process a single frame."""
        try:
            url = f"http://chipz1.atwebpages.com/rick.php?q={frame_num}"
            response = session.get(url, allow_redirects=True)
            response.raise_for_status()

            # Open image in memory
            img = Image.open(BytesIO(response.content))

            # Convert to ASCII and return it
            return AsciiArt.from_pillow_image(img)
        except OSError as e:
            return e

    with requests.Session() as session, ThreadPool(28) as pool:
        worker = partial(download_image, session)
        frames = pool.map(worker, range(1, 29))

    # See if any exceptions returned:
    for frame_num, frame in enumerate(frames, 1):
        if isinstance(frame, Exception):
            print(f'Could not load the image for frame number {frame_num}, server said: {frame}')
            return

    # Get terminal size
    size = os.get_terminal_size()
    width = size.columns
    n_columns = width // 2

    # Convert frames for viewing:
    new_stdout = StringIO()
    with redirect_stdout(new_stdout):
        for frame_num in range(28):
            frames[frame_num] = frames[frame_num].to_terminal(columns=n_columns, width_ratio=2)
            new_stdout.seek(0, 0)  # have next frame write over current frame

    clear_screen()  # clear screen first
    try:
        # Loop to display images
        while True:
            for frame in frames:
                print("\033[1;1H", frame, sep="", flush=True)
                time.sleep(0.05)
    except KeyboardInterrupt:
        clear_screen()
    except Exception as e:
        print(f"An error has occurred: {e}")

if __name__ == '__main__':
    main()