Determinar si un directorio se puede escribir

¿Cuál sería la mejor manera en Python de determinar si un directorio es escribible para el usuario que ejecuta el script? Dado que esto probablemente involucrará el uso del módulo del sistema operativo, debo mencionar que lo estoy ejecutando en un entorno * nix.

Aunque lo que sugirió Christophe es una solución más Pythonic, el módulo os tiene la función os.access para verificar el acceso:

os.access('/path/to/folder', os.W_OK) # W_OK es para escribir, R_OK para leer, etc.

Puede parecer extraño sugerir esto, pero un modismo común de Python es

Es más fácil pedir perdón que pedir permiso

Siguiendo ese modismo, se podría decir:

Intente escribir en el directorio en cuestión y detecte el error si no tiene permiso para hacerlo.

Mi solución usando el tempfilemódulo:

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

Actualización: después de probar el código nuevamente en Windows, veo que, de hecho, hay un problema al usar el archivo temporal allí, consulte el problema 22107: el módulo del archivo temporal malinterpreta el error de acceso denegado en Windows . En el caso de un directorio que no se puede escribir, el código se cuelga durante varios segundos y finalmente arroja un IOError: [Errno 17] No usable temporary file name found. ¿Quizás esto es lo que estaba observando user2171842? Desafortunadamente, el problema no está resuelto por ahora, por lo que para manejarlo, el error también debe detectarse:

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

El retraso, por supuesto, todavía está presente en estos casos.

Tropecé con este hilo buscando ejemplos para alguien. Primer resultado en Google, ¡felicidades!

La gente habla sobre la forma Pythonic de hacerlo en este hilo, pero ¿no hay ejemplos de código simples? Aquí tiene, para cualquier otra persona que se tropiece:

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")

Esto intenta abrir un identificador de archivo para escritura y sale con un error si no se puede escribir en el archivo especificado: Esto es mucho más fácil de leer y es una forma mucho mejor de hacerlo en lugar de realizar comprobaciones previas en la ruta del archivo o el directorio. , ya que evita las condiciones de carrera; casos en los que el archivo no se puede escribir entre el momento en que ejecuta la comprobación previa y cuando realmente intenta escribir en el archivo.

Si solo te preocupan los permisos de archivo, os.access(path, os.W_OK)debes hacer lo que pidas. Si, en cambio, desea saber si puede escribir en el directorio, open()un archivo de prueba para escribir (no debería existir de antemano), capturar y examinar alguno IOError, y limpiar el archivo de prueba después.

De manera más general, para evitar ataques TOCTOU (solo un problema si su script se ejecuta con privilegios elevados, suid o cgi o algo así), no debe confiar realmente en estas pruebas anticipadas, pero elimine los privilegios, haga open()y espere el IOError.

Compruebe los bits de modo:

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)
     )

Aquí hay algo que creé basado en la respuesta 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")

más información sobre el acceso se puede encontrar aquí

Me encontré con esta misma necesidad al agregar un argumento a través de argparse. El integrado type=FileType('w')no funcionaría para mí ya que estaba buscando un directorio. Terminé escribiendo mi propio método para resolver mi problema. Aquí está el resultado con el fragmento 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()

Eso resulta en lo siguiente:

$ 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 ~

Regresé y agregué print opts.dir hasta el final, y todo parece estar funcionando como lo deseaba.

Si necesita verificar el permiso de otro usuario (sí, me doy cuenta de que esto contradice la pregunta, pero puede ser útil para alguien), puede hacerlo a través del pwdmódulo y los bits de modo del directorio.

Descargo de responsabilidad : no funciona en Windows, ya que no usa el modelo de permisos POSIX (y el pwdmódulo no está disponible allí), por ejemplo: solución solo para sistemas * nix.

Tenga en cuenta que un directorio debe tener todos los 3 bits establecidos: lectura, escritura y eXecute.
Ok, R no es una necesidad absoluta, pero sin ella no puede enumerar las entradas en el directorio (por lo que debe saber sus nombres). Por otro lado, ejecutar es absolutamente necesario, sin que el usuario no pueda leer los inodos del archivo; por lo que incluso teniendo W, sin X, los archivos no se pueden crear ni modificar. Explicación más detallada en este enlace.

Finalmente, los modos están disponibles en el statmódulo, sus descripciones están en inode (7) man .

Código de muestra cómo verificar:

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