Know if are run from REPL or from main.py

[FoxFreejack]

Hi all,

I would like to tell if the program was started from local main.py file or being run through REPL, in this case with Thonny.

My goal is to automatically enable Dev variables when I run code via REPL (through Thonny), but use production settings otherwise.

I was wondering if there is a constant or variable set in micropython for this. I did not find this yet. The other possibility that I searched for is the current filename code is being run from, still didn't find anything yet for this.

Is there any way to achieve this?

Thank you,

Dave

[jimmo]

I don't think this is possible with any built-in variable or anything. main.py is a bit special because it isn't imported.

Probably the best thing to do is have your main.py set a variable while it is running and always clear it when finishing (or being interrupted)

main.py:

def main():
  # all my program code runs from here

try:
  in_main = True
  main()
finally:
  in_main = False

You could set in_main = False in boot.py to ensure the variable is always available even if main.py didn't run.

[FoxFreejack]

Hi,

Thank you for the answer, but this is not exactly what I had in mind.

While I was writing my response, I did explore another avenue... I knew that when an Exception occured, that traceback was showing the file as "stdin" instead of a real filename. At the time I haven't found a way to put the traceback in a variable. I am still learning Python and I later found how...

In the spirit of answering my own question, here is how I detect if it is run from Thonny, but it's a bit of cluge...

try:
    z=42/0
except Exception as e:
    from io import StringIO
    s=StringIO()
    sys.print_exception(e, s)
    sv = s.getvalue()
    if sv.find("<stdin>") >= 0:
        print("We are run from REPL")
        IN_DEV = True
    else:
        print("We are run from a file")

[jimmo]

That will indeed work!

I'm curious though, why didn't what I suggested work for you?

[FoxFreejack]

I could have misunderstood how to implement it, but the way I understand it, the call to main() is within the same main.py file. Since I chose to keep file names the same on the PC and on the microcontroller, transferring as-is to the device wouldn't have switched the context automatically.

Let me know if I indeed misunderstood your example. Thanks again.

[jimmo]

The idea is that if code is being called from main() (or anything that main() calls), then the global in_main will be True. Otherwise (i.e. at the REPL) the in_main variable will be false.

If you want to make this work across multiple files, then you could have

replcheck.py:

is_repl = True

def main(fn):
  try:
    is_repl = False
    fn()
  finally:
    is_repl = True

main.py:

import replcheck
import something

def main():
  # your program here
  something.whatever()

replcheck.run(main)

Then anywhere in your program (from any file) you can do

import replcheck

def foo():
  if replcheck.is_repl:
    print("we're being called from the REPL")
  else:
    print("we're being called from main")

[cwalther]

I don’t know if that helps in your case, but you can distinguish whether main.py is being run from MicroPython startup or from import main by checking __name__, as commonly done in CPython:

if __name__ == '__main__':
    # called from startup
else:
    # __name__ == 'main'
    # called from import

(Example)

[aivarannamaa]

Expanding on @cwalther's approach...

You could try to differentiate between imported and lauched mode of executing a module (like we do in CPython).

I'd put my logic into separate file (let's call it therealthing.py):

def main(as_main):
    print("as_main", as_main)
    
if __name__ == "__main__":
    main(as_main=True)

When testing the logic in Thonny, I would run this file directly and this would make __name__ == "__main__".

For automatic running, I would create main.py with following content:

import therealthing
therealthing.main(as_main=False)

[jmparatte]

Hi,
In file C:\Thonny\Lib\site-packages\thonny\plugins\micropython\mp_back.py (my Thonny is installed in C:\Thonny), I've inserted a line 158 like that:

            self._prepare_rtc()
            self._execute("THONNY_IDE={'name': 'Thonny', 'version': '4.0.1'}") #jmP 2022-09-20T10:15+0200
            self._send_ready_message()

It's easy to chek if variable 'THONNY_IDE' is added at boot, to know if execution is in Thonny environment.

[davidhuwmorgan]

Adding to jmparatte's answer:
So the fact that there is no easy way to tell if a micropython program is running from boot or under REPL is odd (at best). The obvious use case is providing full debug information running under REPL, while running from boot would produce debug information for failure cases only.

Back to the point ... Thonny already has variables available when in REPL. '__thonny_helper', '__thonny_answer', and '__thonny_names' show up in locals() for me (it is possible those last 2 are as a result of the Files panel being open). So the clever little hack to mp_back.py is not needed.

But again, doesn't work if you're not using Thonny.

[davidhuwmorgan]

Nah forget it. Those Thonny vars only show up if your actually in the Thonny interactive window.

[sosi-deadeye]

Try this:

def main():
    if __name__ != "__main__":
        print("main called by repl")
    else:
        print(f"Normal start. Module name: {__name__}")


if __name__ == "__main__":
    main()