Proper file overwrites in Python

For Nektoon I’m implementing a storage service in Python. It will work with individual text files that it exposes over a REST API.

I struggled a bit with how to correctly handle file overwrites. In the end I came up with this code:

    import os
    import portalocker

    if os.name == 'posix':
        # Rely on the atomicity of Posix renames.
        rename = os.rename
    else:
        def _rename(src, dst):
            """Rename the file or directory src to dst. If dst exists and is a
            file, it will be replaced silently if the user has permission.
            """
            if os.path.exists(src) and os.path.isfile(dst):
                os.remove(dst)
            os.rename(src, dst)

    def write(filename, contents):
        filename_tmp = filename + '.TMP'
        with open(filename_tmp, 'a') as lockfile:
            portalocker.lock(lockfile, portalocker.LOCK_EX)
            with open(filename_tmp, 'w') as out_file:
                out_file.write(contents)
        rename(filename_tmp, filename)

There are two important parts here.

First the locking - with which I struggled most. Locking only works properly on file objects. But if I open a file in write mode then it gets overwritten before the lock is even checked. That’s why I first open the file in append mode, which is non-destructive. Then I open a lock and only continue to open the file in the destructive write mode if I get that lock. The pattern is the same - wether you use the built-in fcntl.flock directly or the excellent portalocker, which abstracts away platform differences.

The second part is the rename. Unfortunately the rename function won’t work on MS Windows platforms if the target file already exists. On Posix platforms it works. And this behaviour is even required because rename guarantees atomicity. So I implement a compatible (but non-atomic!) rename for all non-posix platforms so that the code will still work for developers on MS Windows. But it should only be used in production on Posix platforms.

Has anybody seen a better lock handling in Python that will solve those issues?