tipos de ruta de directorio con argparse

Question

Mi script en Python necesita leer archivos de un directorio pasado en la línea de comandos. He definido un tipo de archivo legible como se muestra a continuación para usarlo con argparse para validar que el directorio pasado en la línea de comando es existente y legible. Además, también se ha especificado un valor predeterminado (/ tmp/non_existent_dir en el ejemplo a continuación) para el argumento del directorio. El problema aquí es que argparse invoca a readable_dir() en el valor predeterminado incluso en una situación en la que un argumento de directorio se pasa explícitamente en la línea de comando. Esto provoca que la secuencia de comandos falle ya que la ruta predeterminada/tmp/non_existent_dir no existe en un contexto donde un directorio se pasa explícitamente en la línea de comando. Podría evitar esto al no especificar un valor predeterminado y hacer que este argumento sea obligatorio, o posponiendo la validación hasta más adelante en el guión, pero ¿es una solución más elegante de la que todos tengan conocimiento?

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

def readable_dir(prospective_dir): 
    if not os.path.isdir(prospective_dir): 
    raise Exception("readable_dir:{0} is not a valid path".format(prospective_dir)) 
    if os.access(prospective_dir, os.R_OK): 
    return prospective_dir 
    else: 
    raise Exception("readable_dir:{0} is not a readable dir".format(prospective_dir)) 

parser = argparse.ArgumentParser(description='test', fromfile_prefix_chars="@") 
parser.add_argument('-l', '--launch_directory', type=readable_dir, default='/tmp/non_existent_dir') 
args = parser.parse_args() 

Answer 1

Puede crear una acción personalizada en lugar de un tipo:

import argparse 
import os 
import tempfile 
import shutil 
import atexit 

class readable_dir(argparse.Action): 
    def __call__(self, parser, namespace, values, option_string=None): 
     prospective_dir=values 
     if not os.path.isdir(prospective_dir): 
      raise argparse.ArgumentTypeError("readable_dir:{0} is not a valid path".format(prospective_dir)) 
     if os.access(prospective_dir, os.R_OK): 
      setattr(namespace,self.dest,prospective_dir) 
     else: 
      raise argparse.ArgumentTypeError("readable_dir:{0} is not a readable dir".format(prospective_dir)) 

ldir = tempfile.mkdtemp() 
atexit.register(lambda dir=ldir: shutil.rmtree(ldir)) 

parser = argparse.ArgumentParser(description='test', fromfile_prefix_chars="@") 
parser.add_argument('-l', '--launch_directory', action=readable_dir, default=ldir) 
args = parser.parse_args() 
print (args) 

Pero esto parece un poco sospechoso para mí - si no se da directorio, se pasa a un directorio no se puede leer lo que parece para derrotar el propósito de verificar si el directorio es accesible en primer lugar.

Tenga en cuenta que, como se señala en los comentarios, podría ser mejor que
raise argparse.ArgumentError(self, ...) en lugar de argparse.ArgumentTypeError.

EDITAR

Por lo que yo sé, no hay manera de validar el argumento predeterminado. Supongo que los desarrolladores de argparse simplemente asumieron que si está proporcionando un valor predeterminado, entonces debería ser válido. Lo más rápido y más fácil de hacer aquí es simplemente validar los argumentos inmediatamente después de analizarlos. Parece que solo intentas obtener un directorio temporal para hacer algo de trabajo. Si ese es el caso, puede usar el módulo tempfile para obtener un nuevo directorio para trabajar. Actualicé mi respuesta anterior para reflejar esto. Creo un directorio temporal, utilicelo como el argumento predeterminado (tempfile ya garantiza que el directorio que crea será grabable) y luego lo registro para que se elimine cuando se cierre el programa.

Answer 2

Si la secuencia de comandos no puede funcionar sin una válida launch_directory entonces deberían utilizarse de un argumento obligatorio:

parser.add_argument('launch_directory', type=readable_dir) 

por cierto, se debe utilizar en lugar de argparse.ArgumentTypeErrorException en readable_dir().

Answer 3

presenté a patch for "path arguments" to the Python standard library mailing list hace unos meses.

Con esta clase PathType, sólo tiene que especificar el tipo siguiente argumento para que coincida con única un directorio existente - cualquier otra cosa le dará un mensaje de error:

type = PathType(exists=True, type='dir') 

está el código Aquí, lo que podría ser fácilmente modificado para requerir permisos específicos de archivo/directorio también:

from argparse import ArgumentTypeError as err 
import os 

class PathType(object): 
    def __init__(self, exists=True, type='file', dash_ok=True): 
     '''exists: 
       True: a path that does exist 
       False: a path that does not exist, in a valid parent directory 
       None: don't care 
      type: file, dir, symlink, None, or a function returning True for valid paths 
       None: don't care 
      dash_ok: whether to allow "-" as stdin/stdout''' 

     assert exists in (True, False, None) 
     assert type in ('file','dir','symlink',None) or hasattr(type,'__call__') 

     self._exists = exists 
     self._type = type 
     self._dash_ok = dash_ok 

    def __call__(self, string): 
     if string=='-': 
      # the special argument "-" means sys.std{in,out} 
      if self._type == 'dir': 
       raise err('standard input/output (-) not allowed as directory path') 
      elif self._type == 'symlink': 
       raise err('standard input/output (-) not allowed as symlink path') 
      elif not self._dash_ok: 
       raise err('standard input/output (-) not allowed') 
     else: 
      e = os.path.exists(string) 
      if self._exists==True: 
       if not e: 
        raise err("path does not exist: '%s'" % string) 

       if self._type is None: 
        pass 
       elif self._type=='file': 
        if not os.path.isfile(string): 
         raise err("path is not a file: '%s'" % string) 
       elif self._type=='symlink': 
        if not os.path.symlink(string): 
         raise err("path is not a symlink: '%s'" % string) 
       elif self._type=='dir': 
        if not os.path.isdir(string): 
         raise err("path is not a directory: '%s'" % string) 
       elif not self._type(string): 
        raise err("path not valid: '%s'" % string) 
      else: 
       if self._exists==False and e: 
        raise err("path exists: '%s'" % string) 

       p = os.path.dirname(os.path.normpath(string)) or '.' 
       if not os.path.isdir(p): 
        raise err("parent path is not a directory: '%s'" % p) 
       elif not os.path.exists(p): 
        raise err("parent directory does not exist: '%s'" % p) 

     return string