escritura atómica en archivo con Python

Un fragmento simple que implementa la escritura atómica usando Python tempfile.

with open_atomic('test.txt', 'w') as f:
    f.write("huzza")

O incluso leyendo y escribiendo desde y hacia el mismo archivo:

with open('test.txt', 'r') as src:
    with open_atomic('test.txt', 'w') as dst:
        for line in src:
            dst.write(line)

Usando dos gestores de contexto simples

import os
import tempfile as tmp
from contextlib import contextmanager

@contextmanager
def tempfile(suffix='', dir=None):
    """ Context for temporary file.

    Will find a free temporary filename upon entering
    and will try to delete the file on leaving, even in case of an exception.

    Parameters
    ----------
    suffix : string
        optional file suffix
    dir : string
        optional directory to save temporary file in
    """

    tf = tmp.NamedTemporaryFile(delete=False, suffix=suffix, dir=dir)
    tf.file.close()
    try:
        yield tf.name
    finally:
        try:
            os.remove(tf.name)
        except OSError as e:
            if e.errno == 2:
                pass
            else:
                raise

@contextmanager
def open_atomic(filepath, *args, **kwargs):
    """ Open temporary file object that atomically moves to destination upon
    exiting.

    Allows reading and writing to and from the same filename.

    The file will not be moved to destination in case of an exception.

    Parameters
    ----------
    filepath : string
        the file path to be opened
    fsync : bool
        whether to force write the file to disk
    *args : mixed
        Any valid arguments for :code:`open`
    **kwargs : mixed
        Any valid keyword arguments for :code:`open`
    """
    fsync = kwargs.get('fsync', False)

    with tempfile(dir=os.path.dirname(os.path.abspath(filepath))) as tmppath:
        with open(tmppath, *args, **kwargs) as file:
            try:
                yield file
            finally:
                if fsync:
                    file.flush()
                    os.fsync(file.fileno())
        os.rename(tmppath, filepath)

Hay un simple ayudante AtomicFile: https://github.com/sashka/atomicfile

Estoy usando este código para reemplazar/escribir un archivo atómicamente:

import os
from contextlib import contextmanager

@contextmanager
def atomic_write(filepath, binary=False, fsync=False):
    """ Writeable file object that atomically updates a file (using a temporary file).

    :param filepath: the file path to be opened
    :param binary: whether to open the file in a binary mode instead of textual
    :param fsync: whether to force write the file to disk
    """

    tmppath = filepath + '~'
    while os.path.isfile(tmppath):
        tmppath += '~'
    try:
        with open(tmppath, 'wb' if binary else 'w') as file:
            yield file
            if fsync:
                file.flush()
                os.fsync(file.fileno())
        os.rename(tmppath, filepath)
    finally:
        try:
            os.remove(tmppath)
        except (IOError, OSError):
            pass

Uso:

with atomic_write('path/to/file') as f:
    f.write("allons-y!\n")

Se basa en esta receta.

Dado que es muy fácil meterse con los detalles, recomiendo usar una pequeña biblioteca para eso. La ventaja de una biblioteca es que cuida todos estos detalles esenciales, y está siendo revisada y mejorada por una comunidad.

Una de estas bibliotecas es python-atomicwrites por untitaker que incluso tiene soporte adecuado para Windows:

• https://github.com/untitaker/python-atomicwrites

Del README:

from atomicwrites import atomic_write

with atomic_write('foo.txt', overwrite=True) as f:
    f.write('Hello world.')
    # "foo.txt" doesn't exist yet.

# Now it does.

Solución atómica para Windows a la carpeta de bucle y cambiar el nombre de los archivos. Probado, atómico para automatizar, puede aumentar la probabilidad de minimizar el riesgo de no evento de tener el mismo nombre de archivo. Usted biblioteca aleatoria para combinaciones de símbolos de letras utilizar al azar.método de elección, para digit str (random.aleatorio.rango(50,999999999,2). Puede variar el rango de dígitos como desee.

import os import random

path = "C:\\Users\\ANTRAS\\Desktop\\NUOTRAUKA\\"

def renamefiles():
    files = os.listdir(path)
    i = 1
    for file in files:
        os.rename(os.path.join(path, file), os.path.join(path, 
                  random.choice('ABCDEFGHIJKL') + str(i) + str(random.randrange(31,9999999,2)) + '.jpg'))
        i = i+1

for x in range(30):
    renamefiles()