Question about maximum recursion depth

[therealfe1ix]

Im very new to programming with python and have an issue with my code on the RPI Pico that is supposed to control my ws2812 led strip. Down below i pasted the selector script that displays the selected mode and opens the python script. This al works fine, but if i switch between the selector.py and the other scripts a few times i get the max recursion depth error.
I know that it is possible to set the max recursion depth to a larger ammount in python, but it seems to not be possible on micropython.
Do you have any suggestions on how I can improve my code?

import machine
import neopixel
import time
import os

# Define the number of pixels in the strip
NUM_PIXELS = 10
PIXEL_PIN = 0
x = 0
BUTTON_PIN = machine.Pin(12, machine.Pin.IN, machine.Pin.PULL_UP)  # Button connected to GP12 and GND

# Create a NeoPixel object
pixels = neopixel.NeoPixel(machine.Pin(PIXEL_PIN), NUM_PIXELS)

# Function to set a single LED color
def set_pixel_color(pixel_index, color):
    if 0 <= pixel_index < NUM_PIXELS:
        pixels[pixel_index] = color
        pixels.write()

# Function to turn off all LEDs
def clear_pixels():
    pixels.fill((0, 0, 0))
    pixels.write()

# Function to check button state
def is_button_pressed():
    return BUTTON_PIN.value() == 0  # Button is active lowif

set_pixel_color(0, (0, 200, 0))
set_pixel_color(1, (30, 0, 0))
set_pixel_color(2, (30, 0, 0))
set_pixel_color(3, (30, 0, 0)) 
set_pixel_color(4, (30, 0, 0))
set_pixel_color(5, (30, 0, 0))

time.sleep(1)

# Main function
def main():
    global x
    try:
        while True:
            if is_button_pressed():
                print("[x] Button pressed")
                time.sleep(0.2)  # debounce
                if is_button_pressed():  # check if the button is still pressed for long press
                    print("[i] Button pressed long")
                    print("=== Open program ", x, " ===")
                    script_filename = f"{x}.py"  # Use f-string for correct formatting
                    try:
                        with open(script_filename, "r") as f:
                            script_code = f.read()
                        exec(script_code)
                    os._exit(0)
                    except OSError as e:  # Catch OSError instead of FileNotFoundError
                        print(f"Error opening script {script_filename}: {e}")
                    time.sleep(2)
                else:
                    print("[i] Button pressed short")
                    print("Old selection: ", x,)
                    x += 1
                    print("New selection: ", x,)
                    if x == 6:
                        set_pixel_color(5, (30, 0, 0))
                        set_pixel_color(0, (0, 200, 0))
                        x = 0
                    else:
                        set_pixel_color(x - 1, (30, 0, 0))
                        set_pixel_color(x, (0, 200, 0)) 
    except KeyboardInterrupt:
        clear_pixels()
        print("Program interrupted and exiting.")

if __name__ == "__main__":
    main()

[Josverl]

In the middle of the script you call exec(script_code) to run another script.
at that point the running script remains in memory ,
Recursion may a occur if the other scripts either do something similar , or if they call this script.
In that case the other scripts , will be stacked in the function calling stack , waiting to be returned at some point.
If they never return , but instead re-call this script , then at some point you will run out of recursion. ( or memory - whichever comes first)

Trying to solve this by raising the max recursion is like a band-aid for a arterial wound. It really won't help.

Instead take a look at your algorithm, in your case likely across scripts.
Does it return to the caller , and if not , why , is that really needed ?

also you may have a logic & syntax error in os._exit(0) ? ( but could be a c&p error)

• this is not valid micropython
• the indentation is incorrect
• the error may be hidden by the try/except
  I suggest complete removing that line , and replacing it with a proper indented print("\nCompleted script execution.")
  to get feedback that control is indeed returned.

                    script_filename = f"{x}.py"  # Use f-string for correct formatting
                    try:
                        with open(script_filename, "r") as f:
                            script_code = f.read()
                        exec(script_code)
                        print("\nCompleted script execution.")
                    except OSError as e:  # Catch OSError instead of FileNotFoundError
                        print(f"Error opening script {script_filename}: {e}")
                    time.sleep(2)

[therealfe1ix]

Thank you for your quick answer, the os exit was a "solution" that I found online and forgot to remove it.
You are right, the other scripts call this script. If you want I can upload one of them for you to see. Is there an option that avoids the recursion like completely stopping the script?
I need them to recall this script because this is basically my selection menu to switch between the different modes.

[Josverl]

If each of your helper apps/scripts have a method def do_stuff() that does all that needs doing, and at the end of that return

Then you can import each of these scripts just in time, and call the foo.do_stuff() method.

For increased flexibility you can use __import__ directly, and pass it the name of the module as a string, but I recommend to not use it unless there is no other way.
There is no Micropython docs on its use, that should give a clear hint.

CPython docs

[bixb922]

Also check if it makes sense for your case to replace exec(script_code) with import plus some additional logic. import uses way less resources than exec and is the standard way to group code in different files.