What design pattern might help us implement a simple stream filter (or interpreter)?

This is kind of a "white-board" question instead a "keyboard" question as it is not language-specific.

I often have a stream of characters which must be translated from one "language" to another...

EXAMPLE ONE: UPS & DOWNS

+---------------+---------+--------+---------+--------+---------+---------+---------+
| INPUT STREAM  | (-1, 0) | (0, 1) | (0, 1)  | (0, 1) | (0, -1) | (0, 1)  | (0, 1)  |
+---------------+---------+--------+---------+--------+---------+---------+---------+
| OUTPUT STREAM | "left"  | "up"   | "right" | "up"   | "down"  | "right" | "right" |
+---------------+---------+--------+---------+--------+---------+---------+---------+

EXAMPLE TWO: Toggling Between Cases

You can force stream output to be pure lower-case or pure upper-case and use a "$" character to toggle between different modes:

+---------+----------+-------------+-----------+----------------+----------------+---------------+---------------+--------------+--------------+
| INPUT:  | "ApPleS" |     "$"     | "BaNaNaS" |      "$"       | "BLACKberries" |      "$"      | "BlUeBeRrIeS" |     "$"      | "CaNtAlOuPe" |
+---------+----------+-------------+-----------+----------------+----------------+---------------+---------------+--------------+--------------+
| OUTPUT: | "APPLES" | toggle mode | "bananas" | "BLACKBERRIES" | toggle mode    | "blueberries" | toggle mode   | toggle mode  | "CANTALOUPE" |
+---------+----------+-------------+-----------+----------------+----------------+---------------+---------------+--------------+--------------+

Suppose that you had a class named CharEater which eats elements of a stream and sends new (translated) elements to another stream.

Exactly what characters the CharEater outputs should vary depending on what "mode" the stream filter is in.

Maybe are only a handful of modes (4 to 7 modes) that the class can be in.

I usually write very ugly code which amounts to a bunch of:

• nested loops
• if-else clauses
• boolean flags.

For some reason, my boolean flags usually have names beginning with the word "is" or "has", such as:

• "is_valid"
• "is_digit"
• "is_red".
• "is_blue".
• "has_hit_rock_bottom".

An example of some ugly code is shown below:

import io

def eat_the_string(chars:str):
    """
    The implementation here is ugly

    However...
        we accept a string as input

        we convert letters to upper case or lower case

        A dollar sign ($) is used to toggle between upper-case mode
        and lower-case mode.

    EXAMPLE
        INPUT:
            "ApPleS $ BaNaNaS $ BLACKberries $ BlUeBeRrIeS $ CaNtAlOuPe"
        OUTPUT:
            "APPLES  bananas  BLACKBERRIES  blueberries  CANTALOUPE"
    """
    strm = io.StringIO() # a string stream
    is_lowercase = False
    for ch in chars:
        if ch == "$":
            is_lowercase = not is_lowercase
        else:
            if is_lowercase:
                print(
                    ch.lower(),
                    file=strm, sep = "", end = ""
                )
            else: # in uppercase mode
                print(
                    ch.upper(),
                    file=strm, sep="", end=""
                )
    return strm.getvalue()

I am seeking a more elegant solution.

A bunch of nested loops with a handful of boolean flags is not great for many reasons.

Two drawbacks are:

• the mess of boolean flags and test conditions is difficult for human beings to read and understand
• a lot of the test-conditions are redundant. I sometimes an if statement for is_first_iteration == True even though it is guaranteed that is_first_iteration will be False after the first loop iteration.

What is an example of a better design pattern (or approach) for implementing a stream filter whose output changes based on what mode the stream filter is in? We probably do not need a full-blown general-purpose parser and interpreter, but that is one option.

Below is one attempt to re-factor the mess of nested-loops with boolean flags. Feel free to steer me in a different direction.

# import tools for abstract base classes
import io
from abc import ABC, abstractmethod

class PacAbstract(ABC):
    # This is an abstract base class

    @abstractmethod
    def process_a_char(this, ch: str):
        """
            Input paramater `old_ch` is a char, such as the letter "A"
        """
        pass  # `pass` is no_op().... no_operation()... do nothing.


class PacModeLowercase(PacAbstract):
    """
        `PacModeLowercase` converts
        string characters into lower-case letters
    """

    def process_a_char(this: PacAbstract, ch: str):
        """
            Input parameter `old_ch` is a char, such as the letter "A"
        """
        return ch.lower()


class PacModeUppercase(PacAbstract):
    """
         This class represents a **mode**
         for an `PacMan` to be in.

        `PacModeUppercase` converts
        string characters into upper-case letters
    """

    def process_a_char(this: PacAbstract, ch: str):
        # Input paramter `old_ch` is a string, such as "hello world"
        return ch.upper()


class PacMan(PacAbstract):
    PacModeUppercase = PacModeUppercase
    PacModeLowercase = PacModeLowercase
    # Like the videogame character named "pacman,"
    # a `PacMan` eats things.
    #
    # a PacMan has a pointer (or reference) to a PacMode
    # `PacMode` represents the **mode** which the PacMan is in
    #
    # The mode determines what PacMan outputs.

    def __init__(this: PacAbstract, *, mode: str = "lower"):
        # __init__ is sort of like a class constructor.
        #
        # However, the true constructor is type.__call__()
        #
        # In other languages,
        # `__call__()` is sometimes known as ``
        #
        # All of the following are equvilant:
        #    instance = PacMan(1, 2, 3)
        #    instance = type.__call__(PacMan, 1, 2, 3)

        # Error checking. make sure mode is string-like
        mode = "".join(str(ch) for ch in mode)

        # Get modified copy with trimmed leading and traiPacAbstract white space
        mode = mode.strip()

        # Get modified copy with uppercase letters
        # converted to lowercase letters
        mode = mode.lower()

        if mode == "lower":
            this._pac_mode = type(this).PacModeLowercase()
        else:
            this._pac_mode = type(this).PacModeUppercase()

    def process_a_char(this: PacAbstract, ch: str):
        """
            Input paramter `old_ch` is a string, such as "hello world"
        """
        return this._pac_mode.process_a_char(ch)


pacman = PacMan()

strm = io.StringIO()
inputs = "ApPleS $ BaNaNaS $ BLACKberries $ BlUeBeRrIeS $ CaNtAlOuPe"
for old_ch in inputs:
    new_ch = pacman.process_a_char(old_ch)
    print(new_ch, file=strm, sep="", end="")

print(strm.getvalue())
# output is "apples $ bananas $ blackberries $ blueberries $ cantaloupe"

Anyway.... what is the name of a design pattern such that the data coming out of a stream filter varies depending on what "mode" the stream filter is in?

Below is code written to convert camel-case to lower-case letters and under-scores.

The code is written in the anti-pattern of nested loops, boolean flags, and buffers:

def camel_to_underscore(chars:str):
    """
    The implementation here is an anti-pattern 

    The code is hideous mess of nested-loops, boolean
    flags, test-conditions, and string buffers. 

    EXAMPLE A:
        INPUT:  "getUserInput()"
        OUTPUT: "get_user_input()
        
    EXAMPLE B:
        INPUTS: 
                RedDeliciousApples
                GrannySmithApples
                ConcordGrapes
                GreenGrapes
        Outputs:
                red_delicious_apples
                granny_smith_apples
                concord_grapes
                green_grapes
    """
    chars = "".join(str(ch) for ch in chars)
    it = iter(chars)
    buffer = []
    buffer.append(next(it).lower())
    for ch in it:
        low_ch = ch.lower()
        if low_ch != ch:
            buffer.append("_")
        buffer.append(low_ch)
    return "".join(buffer)

If you do not have the name of a design pattern, do you have some pseudo-code different from the nest-loops with boolean flags? Maybe some sort of class object whose method outputs change depending on what "mode" the class is in?

EXAMPLE THREE: Removing Consecutive Duplicates

An example of a more complicated application might be to delete repeated sub-strings:

• we read a string from left to right
• if the same sub-string repeats itself ("Echo Echo Echo Echo") then we delete the redundant copies.
• we allow a single character to repeat up to 2 times, but no other string may repeat.

INPUT	OUTPUT
"Misssssssssissssssssippppppppppi"	"Mississippi"
"apple apple apple apple"	"apple"
"orange orange orange orange orange"	"orange"
"\n\n\n\n\n\n\n\n"	"\n"