Question

I need to modify a text file at runtime but restore its original state later (even if the computer crash).

My program runs in regular sessions. Once a session ended, the original state of that file can be changed, but the original state won’t change at runtime.

There are several instances of this text file with the same name in several directories. My program runs in each directory (but not in parallel), but depending on the directory content’s it does different things. The order of choosing a working directory like this is completely arbitrary.

Since the file’s name is the same in each directory, it seems a good idea to store the backed up file in slightly different places (ie. the parent directory name could be appended to the backup target path).

What I do now is backup and restore the file with a self-written class, and also check at startup if the previous backup for the current directory was properly restored.
But my implementation needs serious refactoring, and now I’m interested if there are libraries already implemented for this kind of task.

edit

version control seems like a good idea, but actually it’s a bit overkill since it requires network connection and often a server. Other VCS need clients to be installed. I would be happier with a pure-python solution, but at least it should be cross-platform, portable and small enough (<10mb for example).

Answer 1

Why not just do what every unix , mac , window file has done for years — create a lockfile/working file concept.

When a file is selected for edit:

1. Check to see if there is an active lock or a crashed backup.
2. If the file is locked or crashed, give a “recover” option
3. Otherwise, begin editing the file…

The editing tends to do one or more of a few things:

1. Copy the original file into a “.%(filename)s.backup”
2. Create a “.%(filename)s.lock” to prevent others from working on it
3. When editing is achieved, the lock goes away and the .backup is removed

Sometimes things are slightly reversed, and the original stays in place while a .backup is the active edit; on success the .backup replaces the original

If you crash vi or some other text programs on a linux box, you’ll see these files created . note that they usually have a dot(.) prefix so they’re normally hidden on the command line. Word/Powerpoint/etc all do similar things.