Implémenter le tactile en utilisant Python ?

Question

touch est un utilitaire Unix qui définit les heures de modification et d'accès aux fichiers en fonction de l'heure du jour. Si le fichier n'existe pas, il est créé avec les permissions par défaut.

Comment l'implémenter en tant que fonction Python ? Essayez d'être multiplateforme et complet.

(Les résultats actuels de Google pour "python touch file" ne sont pas très bons, mais pointent vers os.utime .)

Answer 1

Cette solution tente d'être un peu plus exempte de race que les autres. (Les with est nouveau dans Python 2.5).

import os
def touch(fname, times=None):
    with open(fname, 'a'):
        os.utime(fname, times)

C'est à peu près l'équivalent de ce qui suit.

import os
def touch(fname, times=None):
    fhandle = open(fname, 'a')
    try:
        os.utime(fname, times)
    finally:
        fhandle.close()

Maintenant, pour qu'il n'y ait vraiment pas de course, vous devez utiliser futimes et modifier l'horodatage du dossier ouvert, au lieu d'ouvrir le fichier et de modifier ensuite l'horodatage du nom de fichier (qui peut avoir été renommé). Malheureusement, Python ne semble pas fournir de moyen d'appeler futimes sans passer par ctypes ou similaire...

---

EDITAR

Comme l'a noté Nate Parsons Python 3.3 sera ajouter spécifier un descripteur de fichier (lorsque os.supports_fd ) à des fonctions telles que os.utime qui utilisera l'option futimes au lieu de l'appel système utimes syscall sous le capot. En d'autres termes :

import os
def touch(fname, mode=0o666, dir_fd=None, **kwargs):
    flags = os.O_CREAT | os.O_APPEND
    with os.fdopen(os.open(fname, flags=flags, mode=mode, dir_fd=dir_fd)) as f:
        os.utime(f.fileno() if os.utime in os.supports_fd else fname,
            dir_fd=None if os.supports_fd else dir_fd, **kwargs)

Answer 2

def touch(fname):
    if os.path.exists(fname):
        os.utime(fname, None)
    else:
        open(fname, 'a').close()

Answer 3

Pourquoi ne pas essayer ceci ?

import os

def touch(fname):
    try:
        os.utime(fname, None)
    except OSError:
        open(fname, 'a').close()

Je pense que cela élimine toute condition de course importante. Si le fichier n'existe pas, une exception sera levée.

La seule condition de concurrence possible ici est que le fichier soit créé avant l'appel à open() mais après os.utime(). Mais cela n'a pas d'importance car, dans ce cas, le temps de modification sera conforme aux attentes puisqu'il a dû se produire pendant l'appel à touch().

Answer 4

Voici du code qui utilise ctypes (testé uniquement sous Linux) :

from ctypes import *
libc = CDLL("libc.so.6")

#  struct timespec {
#             time_t tv_sec;        /* seconds */
#             long   tv_nsec;       /* nanoseconds */
#         };
# int futimens(int fd, const struct timespec times[2]);

class c_timespec(Structure):
    _fields_ = [('tv_sec', c_long), ('tv_nsec', c_long)]

class c_utimbuf(Structure):
    _fields_ = [('atime', c_timespec), ('mtime', c_timespec)]

utimens = CFUNCTYPE(c_int, c_char_p, POINTER(c_utimbuf))
futimens = CFUNCTYPE(c_int, c_char_p, POINTER(c_utimbuf)) 

# from /usr/include/i386-linux-gnu/bits/stat.h
UTIME_NOW  = ((1l << 30) - 1l)
UTIME_OMIT = ((1l << 30) - 2l)
now  = c_timespec(0,UTIME_NOW)
omit = c_timespec(0,UTIME_OMIT)

# wrappers
def update_atime(fileno):
        assert(isinstance(fileno, int))
        libc.futimens(fileno, byref(c_utimbuf(now, omit)))
def update_mtime(fileno):
        assert(isinstance(fileno, int))
        libc.futimens(fileno, byref(c_utimbuf(omit, now)))

# usage example:
#
# f = open("/tmp/test")
# update_mtime(f.fileno())

Answer 5

Simplicité :

def touch(fname):
    open(fname, 'a').close()
    os.utime(fname, None)

• En open s'assure qu'il y a un fichier à cet endroit
• les utime garantit la mise à jour des horodatages

Théoriquement, il est possible que quelqu'un supprime le fichier après que le open ce qui conduit utime à lever une exception. Mais on peut dire que ce n'est pas grave, puisqu'il s'est passé quelque chose de grave.