ftplib vérifie si un fichier est un dossier?

Comment puis-je vérifier si un fichier sur un ftp distant est un dossier ou non à l'aide de ftplib?

Meilleure façon que j'ai le droit maintenant de faire un nlst, et parcourir l'appel de la taille de chacun des fichiers, si le fichier d'erreur, alors c'est un dossier?

Est-il un meilleur moyen? Je ne peut pas analyser la sortie de la liste, car il ya environ une douzaine de différents serveurs ftp(beaucoup de très vieilles.)

Que dois-je faire?

source d'informationauteur UberJumper

6

FTP est assez rudimentaire protocole et il n'est pas intégré dans le protocole de requête vous permettant d'obtenir le type de fichier (dir) de chaque nœud, donc une heuristique comme celui que vous avez trouvé est la seule solution.

Si l'obtention de la taille de chaque nœud ne fonctionne pas, peut-être vous devriez envisager de demander FTP.nlst() sur chacun de ces nœuds: ceux que l'erreur sera fichiers, plutôt que de dirs.
4

FTP.dir retourne une liste de répertoire, que vous pouvez analyser avec une fonction de rappel pour savoir si c'est un répertoire. Par exemple, comme ceci:
```
def parse(line):
    if line[0] == 'd':
        print(line.rpartition(' ')[2])   # gives you the name of a directory

ftp.dir(parse)
```
4

Il n'y a pas "isdir" et "isfile" définitions dans ftplib. Si vous n'avez pas à utiliser ftplib, je vous recommande d'utiliser ftputil.

Tout d'abord, vous devez installer ftputil paquet. Pour arriver à cela, utilisez cette commande: python -m pip install ftputil. Après l'installation, vous pouvez importer la bibliothèque de votre code. Je pense que c'est assez d'explication. Donc, nous allons aller à la mise en œuvre:
```
import ftputil
with ftputil.FTPHost("host", "username", "password") as ftp_host:
    ftp_host.chdir("/directory/")   
    list = ftp_host.listdir(ftp_host.curdir)
    for fname in list:
        if ftp_host.path.isdir(fname):
            print(fname + " is a directory")
        else:
            print(fname + " is not a directory")
```
3

Vous pouvez utiliser MLST commande:
```
import ftplib
f = ftplib.FTP()
f.connect("localhost")
f.login()
print f.sendcmd('MLST /')
```
Contre pyftpdlib serveur le code ci-dessus imprime:
```
250-Listing "/":
 modify=20111212124834;perm=el;size=12288;type=dir;unique=807g100001; /
250 End MLST.
```
Ce que vous avez à faire est d'analyser cette chaîne et de regarder pour le "type=dir" ou "type=redc" (répertoire actuel, comme dans ".") ou "type=pdir" (parent dir comme dans "..") via une expression régulière.
Si vous obtenez un match, cela signifie que le chemin indiqué se réfère à un répertoire.
2
```
def is_file(filename):
    return ftp.size(filename) is not None
```
Cela fonctionne parce que http://ftp.size retourne Aucun si c'est un répertoire.

Je l'ai utilisé pendant ftplib:

import ftplib
from ftplib import FTP
ftp=FTP("ftp address")
ftp.login("user","password")

path = "/is/this/a/file/or/a/folder/"

try:
    ftp.cwd(path)
    print "it's a folder!"
except ftplib.error_perm:
    print "it's not a folder!"

C'est ce que j'utilise pour trouver les répertoires dans un répertoire donné. Je retourne les noms de répertoire comme un ensemble, parce que je utiliser des ensembles plus tard dans le programme, mais vous pouvez laisser de côté l'ensemble de la création à la fin et retour le répertoire des noms de la liste, tuple, etc.

def get_directories(ftp_server):
    """
    Returns a set of directories in the current directory on the FTP server

    Stdout output of ftp_server.dir() is redirected to an IO object and then
    reset, because ftp_server.dir() only prints its results to stdout.

    @param ftp_server: Open connection to FTP server
    @return: Set of directory names
    """
    # Redirect stdout
    old_stdout = sys.stdout
    sys.stdout = new_stdout = StringIO()
    # Get directory listing
    ftp_server.dir()
    # Reset stdout
    sys.stdout = old_stdout

    directory_listing = new_stdout.getvalue().split("\n")
    # Directories are listed starting with "d" for "directory"
    only_directories = (x for x in directory_listing if x.startswith("d"))
    # This only deals with directory names without spaces.
    directory_names = set(dirname.split()[-1] for dirname in only_directories)
    return directory_names

0
```
def is_file(filename):
    current = ftp.pwd()
    try:
        ftp.cwd(filename)
    except:
        ftp.cwd(current)
        return True
    ftp.cwd(current)
    return False
```
Ici est une autre solution. La moitié manière de l'écrire, j'ai réalisé qu'il a un problème. Si vous n'avez pas l'autorisation de modifier un dossier, il va lire un fichier à la place. Cela fonctionnera si vous avez accès à tout le dossier.

J'ai toujours affiché ce parce que peut-être il donnera quelques idées.

J'ai trouvé une solution, mais c'est peut-être pas le meilleur et je pense que ça peut être utile pour vous.

> def isfile(remote_name):
>     try:
>         ftp.sendcmd('MDTM ' + remote_name)
>     except:
>         return False
>     else:
>         return True

Cette fonction retourne TRUE si 'remote_name' est un fichier régulier, sinon retourne False.

Toute ma solution ressemble à ceci:

def is_file(filename):
    try:
        ftp.cwd(filename)
    except Exception as e:
        if "550" in e:
            return True
    return False

ftp_conn = FTP(host=host_name, user=user_name, passwd=password, acct='', timeout=None, source_address=None)
ftp_conn.cwd(path_ftp)
for data_dir in ftp_conn.mlsd():
    print(data_dir)

De sortie:

('3', {'modify': '20170719134928', 'perm': 'flcdmpe', 'type': 'dir', 'unique': '804U485826E', 'unix.group': '10000', 'unix.mode': '0755', 'unix.owner': '10754'})

see 'type': 'dir'

def _get_file_type(self, path):
    """
Returns string parsed from MLST command
    """
    try:
        return_str = self.ftp.sendcmd('MLST ' + path)
    except BaseException as e:
        raise BaseException("No such file or directory")
    c = re.search('Type=(dir|file);', return_str)
    try:
        filetype = c.group(1)
    except AttributeError as e:
        raise BaseException("Unable to parse")
    return filetype


def is_file(self,path):
    """
Returns if a filepath is a file
    """
    filetype = self._get_file_type(path)
    if filetype == 'file':
        return True
    return False

-3

Tous les fichiers ont une extension, en utilisant split('.') il peut être décomposé en une liste de taille 2. Alors que pour les répertoires de la taille de la liste sera l'un après l'utilisation de split('.'). Donc par vérifier la taille de la liste que l'on peut identifier si c'est un fichier ou un répertoire.
```
os.chdir(r"path")
ftp = ftplib.FTP('ftp.some.server')
ftp.login('username','password')
filelist=ftp.nlst()
for file in filelist:
    fildir=file.split('.')
    filsize=len(fildir)
    if(filsize>1):
        ftp.retrbinary('RETR %s' %file, open(file, 'wb').write)
ftp.close()
```

Vous devez vous connecter pour publier un commentaire.