Python-Interpreter | An online python interpreter

I don't have an easy access to a Linux where I can test it, but I think I now understand what's happening.

1. matplotlibcpp uses a static variable to hold the Python interpreter (see line 129 inside interkeeper(bool should_kill)). Like C++ static function variables, it's initialized on the first time the function is called and destructed on program's exit (reference).

2. When main finishes, libc runs cleanup routines for all the shared libraries and for your program (that's __run_exit_handlers in the stacktrace). Since your program is a C++ program, part of its exit handler is destructing all the static variables that were used. One of them is the Python interpreter. Its destructor calls Py_Finalize() which is Python's cleanup routine. Until now, everything's fine.

3. Python has a similar atexit mechanism that allows Python code from everywhere to register functions that should be called during the interpreter shutdown. Apparently, the backend matplotlib chose to use here is PyQt5. It seems to register such atexit callbacks.

4. PyQt5's callback gets called, and crashes. Notice that this is internal PyQt5 code now. Why does this crash? My "educated" guess is that Qt's library exit handler was already called in step 2, before your program's exit handler was called. This apparently causes some weird state in the library (maybe some objects were freed?) and crashes.

This leaves two interesting questions:

1. How to fix this? The solution should be to destruct ctx before your program exits, so the Python interpreter is destructed before any shared libraries terminate themselves. Static lifetimes are known for causing similar problems. If changing matplotlibcpp's interface to not use global static states is not a possible solution, I think you really have to manually call plt::detail::_interpreter::kill() at the end of your main function. You should be able to use atexit() and register a callback that kills the interpreter before the library teardown - I haven't tested it though.

2. Why did this ever work? My guess is that maybe something in PyQt5's callbacks has changed that now causes this crash, or that you use a different backend in Python 2. If no other library is destructively terminating before the program exits, this is fine.

A clean way to move your project is right-clicking on your project folder in "Project view" (Alt +1 ) , choosing Refactor and then Move Directory.

• The $PROJECT_DIR$ variable is dynamic and taken from the directory your project is in, so that isn't a problem

• Your .idea folder should be recreated by PyCharm even if you completely delete it. However I wouldn't advise deleting your folder mainly because you will loose your project-level dictionary (wordlist).

• Invalidating caches has a wider impact because it will clear IDE wide settings not just project specific settings. (It's mostly useful if your cache becomes outdated, which tends to manifest itself by inexplicable errors.)

If something goes wrong just open the moved directory as a new project going to File > Open. For a simple project there are 2 main settings that you should check and may have to adjust:

• In settings "Settings" (Ctrl + Alt + S) go to Project: your_project_name and there check that Project Structure makes sense and retains your configurations.

• In Run > Edit Configurations make sure that Script path and Working directory are set to the locations you want.

Is there anything wrong with this procedure, anything I'm not aware of?

From your description you took the right steps since refactor didn't work, just ensure the above configurations are met and if the IDE doesn't issue any errors you should be good.

Should I edit some of the files in the .idea folder?

This would rarely be necessary and is generally discouraged. The files in the .idea are IDE generated and should not be touched. Any necessary changes should be made using the IDE graphical interface to set configurations (which means you don't have to worry about the contents of .idea).

ansible_python_interpreter controls the version of python that is used on the target machine.

As an example on my ubuntu 18.04 machine (localhost used as target), python3 is used by default but I can switch to python 2.7: