Déterminer si un répertoire est accessible en écriture

Quel serait le meilleur moyen en Python de déterminer si un répertoire est accessible en écriture pour l'utilisateur exécutant le script? Comme cela impliquera probablement l'utilisation du module os, je dois mentionner que je l'exécute sous un environnement * nix.

Bien que ce que Christophe suggère soit une solution plus pythonique, le module os dispose de la fonction os.access pour vérifier l'accès:

os.access('/path/to/folder', os.W_OK) # W_OK est pour écrire, R_OK pour lire, etc.

Cela peut sembler étrange à suggérer, mais un idiome Python commun est

Il est plus facile de demander pardon que de permission

Suivant cet idiome, on pourrait dire:

Essayez d'écrire dans le répertoire en question et détectez l'erreur si vous n'avez pas l'autorisation de le faire.

Ma solution utilisant le tempfilemodule:

import tempfile
import errno

def isWritable(path):
    try:
        testfile = tempfile.TemporaryFile(dir = path)
        testfile.close()
    except OSError as e:
        if e.errno == errno.EACCES:  # 13
            return False
        e.filename = path
        raise
    return True

Mise à jour: Après avoir testé à nouveau le code sur Windows, je vois qu'il y a effectivement un problème lors de l'utilisation de tempfile là-bas, voir issue22107: le module tempfile interprète mal une erreur d'accès refusé sur Windows . Dans le cas d'un répertoire non accessible en écriture, le code se bloque pendant plusieurs secondes et lance finalement un fichier IOError: [Errno 17] No usable temporary file name found. C'est peut-être ce qu'observait user2171842? Malheureusement, le problème n'est pas résolu pour l'instant, donc pour gérer cela, l'erreur doit également être détectée:

    except (OSError, IOError) as e:
        if e.errno == errno.EACCES or e.errno == errno.EEXIST:  # 13, 17

Le retard est bien sûr toujours présent dans ces cas alors.

Je suis tombé sur ce fil à la recherche d'exemples pour quelqu'un. Premier résultat sur Google, bravo!

Les gens parlent de la manière pythonique de le faire dans ce fil, mais pas d'exemples de code simples? Ici vous allez, pour toute autre personne qui trébuche:

import sys

filepath = 'C:\\path\\to\\your\\file.txt'

try:
    filehandle = open( filepath, 'w' )
except IOError:
    sys.exit( 'Unable to write to file ' + filepath )

filehandle.write("I am writing this text to the file\n")

Cela tente d'ouvrir un descripteur de fichier pour l'écriture et se termine avec une erreur si le fichier spécifié ne peut pas être écrit: C'est beaucoup plus facile à lire et c'est une bien meilleure façon de le faire plutôt que de faire des pré-vérifications sur le chemin du fichier ou le répertoire , car il évite les conditions de course; les cas où le fichier devient inscriptible entre le moment où vous exécutez la pré-vérification et le moment où vous essayez réellement d'écrire dans le fichier.

Si vous ne vous souciez que des fichiers permanents, os.access(path, os.W_OK)faites ce que vous demandez. Si vous voulez plutôt savoir si vous pouvez écrire dans le répertoire, open()un fichier de test pour l'écriture (il ne devrait pas exister auparavant), attraper et examiner tout IOError, et nettoyer le fichier de test par la suite.

Plus généralement, pour éviter les attaques TOCTOU (seulement un problème si votre script s'exécute avec des privilèges élevés - suid ou cgi ou plus), vous ne devriez pas vraiment faire confiance à ces tests à l'avance, mais abandonner privs, faire le open(), et attendre le IOError.

Vérifiez les bits de mode:

def isWritable(name):
  uid = os.geteuid()
  gid = os.getegid()
  s = os.stat(dirname)
  mode = s[stat.ST_MODE]
  return (
     ((s[stat.ST_UID] == uid) and (mode & stat.S_IWUSR)) or
     ((s[stat.ST_GID] == gid) and (mode & stat.S_IWGRP)) or
     (mode & stat.S_IWOTH)
     )

Voici quelque chose que j'ai créé sur la base de la réponse de ChristopheD:

import os

def isWritable(directory):
    try:
        tmp_prefix = "write_tester";
        count = 0
        filename = os.path.join(directory, tmp_prefix)
        while(os.path.exists(filename)):
            filename = "{}.{}".format(os.path.join(directory, tmp_prefix),count)
            count = count + 1
        f = open(filename,"w")
        f.close()
        os.remove(filename)
        return True
    except Exception as e:
        #print "{}".format(e)
        return False

directory = "c:\\"
if (isWritable(directory)):
    print "directory is writable"
else:
    print "directory is not writable"

 if os.access(path_to_folder, os.W_OK) is not True:
            print("Folder not writable")
 else :
            print("Folder writable")

plus d'informations sur l'accès peuvent être trouvées ici

J'ai rencontré ce même besoin en ajoutant un argument via argparse. Le intégré type=FileType('w')ne fonctionnait pas pour moi car je cherchais un répertoire. J'ai fini par écrire ma propre méthode pour résoudre mon problème. Voici le résultat avec l'extrait argparse.

#! /usr/bin/env python
import os
import argparse

def writable_dir(dir):
    if os.access(dir, os.W_OK) and os.path.isdir(dir):
        return os.path.abspath(dir)
    else:
        raise argparse.ArgumentTypeError(dir + " is not writable or does not exist.")

parser = argparse.ArgumentParser()
parser.add_argument("-d","--dir", type=writable_dir(), default='/tmp/',
    help="Directory to use. Default: /tmp")
opts = parser.parse_args()

Cela se traduit par ce qui suit:

$ python dir-test.py -h
usage: dir-test.py [-h] [-d DIR]

optional arguments:
  -h, --help         show this help message and exit
  -d DIR, --dir DIR  Directory to use. Default: /tmp

$ python dir-test.py -d /not/real
usage: dir-test.py [-h] [-d DIR]
dir-test.py: error: argument -d/--dir: /not/real is not writable or does not exist.

$ python dir-test.py -d ~

Je suis retourné et j'ai ajouté print opts.dir à la fin, et tout semble fonctionner comme souhaité.

Si vous avez besoin de vérifier la permission d' un autre utilisateur (oui, je réalise que cela contredit la question, mais peut être utile pour quelqu'un), vous pouvez le faire via le pwdmodule et les bits de mode du répertoire.

Clause de non- responsabilité - ne fonctionne pas sous Windows, car il n'utilise pas le modèle d'autorisations POSIX (et le pwdmodule n'y est pas disponible), par exemple - solution uniquement pour les systèmes * nix.

Notez qu'un répertoire doit avoir tous les 3 bits définis: lecture, écriture et exécution.
Ok, R n'est pas un must absolu, mais sans lui, vous ne pouvez pas lister les entrées dans le répertoire (vous devez donc connaître leurs noms). Exécuter en revanche est absolument nécessaire - sans cela, l'utilisateur ne peut pas lire les inodes du fichier; donc même avoir W, sans X, les fichiers ne peuvent pas être créés ou modifiés. Explication plus détaillée sur ce lien.

Enfin, les modes sont disponibles dans le statmodule, leurs descriptions sont en inode (7) man .

Exemple de code comment vérifier:

import pwd
import stat
import os

def check_user_dir(user, directory):
    dir_stat = os.stat(directory)

    user_id, group_id = pwd.getpwnam(user).pw_uid, pwd.getpwnam(user).pw_gid
    directory_mode = dir_stat[stat.ST_MODE]

    # use directory_mode as mask 
    if user_id == dir_stat[stat.ST_UID] and stat.S_IRWXU & directory_mode == stat.S_IRWXU:     # owner and has RWX
        return True
    elif group_id == dir_stat[stat.ST_GID] and stat.S_IRWXG & directory_mode == stat.S_IRWXG:  # in group & it has RWX
        return True
    elif stat.S_IRWXO & directory_mode == stat.S_IRWXO:                                        # everyone has RWX
        return True

    # no permissions
    return False