2

I know the similar questions were already answered:

What will happen if I modify a Python script while it's running?

When are .pyc files refreshed?

Is it possible to replace a python file while its running

changing a python script while it is running

but I still can't find the clear answer to my question.

I have main.py file and the other *.py modules that I import from main file. I run python.exe main.py from (Win) console and python interpreter generates *.pyc files. Than I change some *.py source files and in another console run again python.exe main.py (while the first instance is still running). Python interpreter regenerates only *.pyc files for *.py source files I changed, while the other *.pyc files remains intact.

As I understand and as answers to those questions suggest, the first instance of the running program loaded all (first version of) *.pyc files in memory, the second instance of the running program loaded all (second version of) *.pyc files in memory.

My question is:

Are there any circumstances where the first instance will need/want to reload *.pyc files to memory from disk again (some swap memory/disk or something) or it loaded *.pyc files to memory for good (until the end of running the first instance of the program). Because if there are, the first instance will then reload some of the new *.pyc files and it can probably crash.

I know I can deliberately reload the modules in my python source files:

How do I unload (reload) a module?

but I don't do that in my source files. Is there some other danger.

Why am I asking this question. I made a strategy to upgrade my python GUI program by just copying *.py files through LAN to client's shared folders. On the client (Win) PC, user can have opened for example two or three instances of python GUI program. While user is running those instances on his/her client PC, I make the upgrade (just copy some changed *.py files to their PCs through LAN). He/She closes one of those programs (aware of the upgrade or not, it doesn't matter), loads it again and python interpreter regenerates some *.pyc files. Again, is there any danger that the first two instances will ever need to reload *.pyc files or (as far as they are concerned) they are loaded into memory for good?

Just for fun, I did exactly that for test and even deleted all *.pyc files while all three instances were running and tested it and they never needed any of the *.pyc files again (they never regenerated them) in those sessions.

I just need confirmation that it works that way in order to be sure to make upgrades safely that way.

nenad
  • 164
  • 6
  • 17
  • Are your ``.py`` files self-contained – i.e. are they just *modules* or actual *packages*? Can you guarantee that you won't replace some files *while* the application restarts? Otherwise, the application may end up having *some* old and *some* new files. – MisterMiyagi Jun 12 '20 at 12:23
  • @MisterMiyagi Just modules. What do you mean by "Can you guarantee that you won't replace some files while the application restarts"? – nenad Jun 12 '20 at 13:12
  • You have described the process as a) you copying in new source files and b) the user occasionally restarting the program. Do you have any mechanism in place to avoid that the user restarts the program exactly when new source files are copied in? – MisterMiyagi Jun 12 '20 at 15:22
  • Good question, about securing the operation is atomic. Maybe checking in main.py if there are any changes (*.py vs *.pyc) and just show the message "The new version is installed. After quitting the program, please restart it." or something like that. Till user restarts the program, copying will be finished. A bit naive. Do you have some other suggestion? – nenad Jun 12 '20 at 16:19

0 Answers0