xhlho commented 1 year ago

Traceback (most recent call last): File "C:/Users/xhlho/Desktop/FFWM-master/train_ffwm.py", line 58, in dataset_train = create_dataset(opt, is_val=False) File "C:\Users\xhlho\Desktop\FFWM-master\data__init__.py", line 58, in create_dataset data_loader = CustomDatasetDataLoader(opt, isval=is_val) File "C:\Users\xhlho\Desktop\FFWM-master\data__init.py", line 74, in init self.dataset = dataset_class(opt, isval) File "C:\Users\xhlho\Desktop\FFWM-master\data\face_dataset.py", line 29, in init__ self.pairs = self.get_pairs() File "C:\Users\xhlho\Desktop\FFWM-master\data\face_dataset.py", line 133, in get_pairs dataroot = join(self.opt.dataroot, self.opt.datamode) File "D:\python\anaconda\envs\pytorch\lib\ntpath.py", line 76, in join path = os.fspath(path) TypeError: expected str, bytes or os.PathLike object, not NoneType 运行出现问题，不知道怎么找到指定的变量

xhlho commented 1 year ago

def join(path, *paths): path = os.fspath(path)

def get_pairs(self):
    dataroot = join(self.opt.dataroot, self.opt.datamode)

csyxwei commented 1 year ago

可以给一下你执行的命令吗，看起来可能是没有指定--dataroot参数造成的。

xhlho commented 1 year ago

我就是一小白，就普通将代码运行了下，我看了社区里面是说没有给指定路径这是倒数出问题的程序

Module 'ntpath' -- common operations on WinNT/Win95 pathnames

"""Common pathname manipulations, WindowsNT/95 version.

Instead of importing this module directly, import os and refer to this module as os.path. """

strings representing various path-related bits and pieces

These are primarily for export; internally, they are hardcoded.

Should be set before imports for resolving cyclic dependency.

curdir = '.' pardir = '..' extsep = '.' sep = '\' pathsep = ';' altsep = '/' defpath = '.;C:\bin' devnull = 'nul'

import os import sys import stat import genericpath from genericpath import *

all = ["normcase","isabs","join","splitdrive","split","splitext", "basename","dirname","commonprefix","getsize","getmtime", "getatime","getctime", "islink","exists","lexists","isdir","isfile", "ismount", "expanduser","expandvars","normpath","abspath", "curdir","pardir","sep","pathsep","defpath","altsep", "extsep","devnull","realpath","supports_unicode_filenames","relpath", "samefile", "sameopenfile", "samestat", "commonpath"]

def _get_bothseps(path): if isinstance(path, bytes): return b'\/' else: return '\/'

Normalize the case of a pathname and map slashes to backslashes.

Other normalizations (such as optimizing '../' away) are not done

(this is done by normpath).

def normcase(s): """Normalize case of pathname.

Makes all characters lowercase and all slashes into backslashes."""
s = os.fspath(s)
try:
    if isinstance(s, bytes):
        return s.replace(b'/', b'\\').lower()
    else:
        return s.replace('/', '\\').lower()
except (TypeError, AttributeError):
    if not isinstance(s, (bytes, str)):
        raise TypeError("normcase() argument must be str or bytes, "
                        "not %r" % s.__class__.__name__) from None
    raise

Return whether a path is absolute.

Trivial in Posix, harder on Windows.

For Windows it is absolute if it starts with a slash or backslash (current

volume), or if a pathname after the volume-letter-and-colon or UNC-resource

starts with a slash or backslash.

def isabs(s): """Test whether a path is absolute""" s = os.fspath(s) s = splitdrive(s)[1] return len(s) > 0 and s[0] in _get_bothseps(s)

Join two (or more) paths.

def join(path, *paths): path = os.fspath(path) if isinstance(path, bytes): sep = b'\' seps = b'\/' colon = b':' else: sep = '\' seps = '\/' colon = ':' try: if not paths: path[:0] + sep #23780: Ensure compatible data type even if p is null. result_drive, result_path = splitdrive(path) for p in map(os.fspath, paths): p_drive, p_path = splitdrive(p) if p_path and p_path[0] in seps:

Second path is absolute

            if p_drive or not result_drive:
                result_drive = p_drive
            result_path = p_path
            continue
        elif p_drive and p_drive != result_drive:
            if p_drive.lower() != result_drive.lower():
                # Different drives =&gt; ignore the first path entirely
                result_drive = p_drive
                result_path = p_path
                continue
            # Same drive in different case
            result_drive = p_drive
        # Second path is relative to the first
        if result_path and result_path[-1] not in seps:
            result_path = result_path + sep
        result_path = result_path + p_path
    ## add separator between UNC and non-absolute path
    if (result_path and result_path[0] not in seps and
        result_drive and result_drive[-1:] != colon):
        return result_drive + sep + result_path
    return result_drive + result_path
except (TypeError, AttributeError, BytesWarning):
    genericpath._check_arg_types('join', path, *paths)
    raise

Split a path in a drive specification (a drive letter followed by a

colon) and the path specification.

It is always true that drivespec + pathspec == p

def splitdrive(p): """Split a pathname into drive/UNC sharepoint and relative path specifiers. Returns a 2-tuple (drive_or_unc, path); either part may be empty.

If you assign
    result = splitdrive(p)
It is always true that:
    result[0] + result[1] == p

If the path contained a drive letter, drive_or_unc will contain everything
up to and including the colon.  e.g. splitdrive("c:/dir") returns ("c:", "/dir")

If the path contained a UNC path, the drive_or_unc will contain the host name
and share up to but not including the fourth directory separator character.
e.g. splitdrive("//host/computer/dir") returns ("//host/computer", "/dir")

Paths cannot contain both a drive letter and a UNC path.

"""
p = os.fspath(p)
if len(p) &gt;= 2:
    if isinstance(p, bytes):
        sep = b'\\'
        altsep = b'/'
        colon = b':'
    else:
        sep = '\\'
        altsep = '/'
        colon = ':'
    normp = p.replace(altsep, sep)
    if (normp[0:2] == sep*2) and (normp[2:3] != sep):
        # is a UNC path:
        # vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
        # \\machine\mountpoint\directory\etc\...
        #           directory ^^^^^^^^^^^^^^^
        index = normp.find(sep, 2)
        if index == -1:
            return p[:0], p
        index2 = normp.find(sep, index + 1)
        # a UNC path can't have two slashes in a row
        # (after the initial two)
        if index2 == index + 1:
            return p[:0], p
        if index2 == -1:
            index2 = len(p)
        return p[:index2], p[index2:]
    if normp[1:2] == colon:
        return p[:2], p[2:]
return p[:0], p

Split a path in head (everything up to the last '/') and tail (the

rest). After the trailing '/' is stripped, the invariant

join(head, tail) == p holds.

The resulting head won't end in '/' unless it is the root.

def split(p): """Split a pathname.

Return tuple (head, tail) where tail is everything after the final slash.
Either part may be empty."""
p = os.fspath(p)
seps = _get_bothseps(p)
d, p = splitdrive(p)
# set i to index beyond p's last slash
i = len(p)
while i and p[i-1] not in seps:
    i -= 1
head, tail = p[:i], p[i:]  # now tail has no slashes
# remove trailing slashes from head, unless it's all slashes
head = head.rstrip(seps) or head
return d + head, tail

Split a path in root and extension.

The extension is everything starting at the last dot in the last

pathname component; the root is everything before that.

It is always true that root + ext == p.

def splitext(p): p = os.fspath(p) if isinstance(p, bytes): return genericpath._splitext(p, b'\', b'/', b'.') else: return genericpath._splitext(p, '\', '/', '.') splitext.doc = genericpath._splitext.doc

Return the tail (basename) part of a path.

def basename(p): """Returns the final component of a pathname""" return split(p)[1]

Return the head (dirname) part of a path.

def dirname(p): """Returns the directory component of a pathname""" return split(p)[0]

Is a path a symbolic link?

This will always return false on systems where os.lstat doesn't exist.

def islink(path): """Test whether a path is a symbolic link. This will always return false for Windows prior to 6.0. """ try: st = os.lstat(path) except (OSError, AttributeError): return False return stat.S_ISLNK(st.st_mode)

Being true for dangling symbolic links is also useful.

def lexists(path): """Test whether a path exists. Returns True for broken symbolic links""" try: st = os.lstat(path) except OSError: return False return True

Is a path a mount point?

Any drive letter root (eg c:)

Any share UNC (eg \server\share)

Any volume mounted on a filesystem folder

#

No one method detects all three situations. Historically we've lexically

detected drive letter roots and share UNCs. The canonical approach to

detecting mounted volumes (querying the reparse tag) fails for the most

common case: drive letter roots. The alternative which uses GetVolumePathName

fails if the drive letter is the result of a SUBST.

try: from nt import _getvolumepathname except ImportError: _getvolumepathname = None def ismount(path): """Test whether a path is a mount point (a drive root, the root of a share, or a mounted volume)""" path = os.fspath(path) seps = _get_bothseps(path) path = abspath(path) root, rest = splitdrive(path) if root and root[0] in seps: return (not rest) or (rest in seps) if rest in seps: return True

if _getvolumepathname:
    return path.rstrip(seps) == _getvolumepathname(path).rstrip(seps)
else:
    return False

Expand paths beginning with '~' or '~user'.

'~' means $HOME; '~user' means that user's home directory.

If the path doesn't begin with '~', or if the user or $HOME is unknown,

the path is returned unchanged (leaving error reporting to whatever

function is called with the expanded path as argument).

(A function should also be defined to do full *sh-style environment

variable expansion.)

def expanduser(path): """Expand ~ and ~user constructs.

If user or $HOME is unknown, do nothing."""
path = os.fspath(path)
if isinstance(path, bytes):
    tilde = b'~'
else:
    tilde = '~'
if not path.startswith(tilde):
    return path
i, n = 1, len(path)
while i < n and path[i] not in _get_bothseps(path):
    i += 1

if 'HOME' in os.environ:
    userhome = os.environ['HOME']
elif 'USERPROFILE' in os.environ:
    userhome = os.environ['USERPROFILE']
elif not 'HOMEPATH' in os.environ:
    return path
else:
    try:
        drive = os.environ['HOMEDRIVE']
    except KeyError:
        drive = ''
    userhome = join(drive, os.environ['HOMEPATH'])

if isinstance(path, bytes):
    userhome = os.fsencode(userhome)

if i != 1: #~user
    userhome = join(dirname(userhome), path[1:i])

return userhome + path[i:]

Expand paths containing shell variable substitutions.

The following rules apply:

- no expansion within single quotes

- '$$' is translated into '$'

- '%%' is translated into '%' if '%%' are not seen in %var1%%var2%

- ${varname} is accepted.

- $varname is accepted.

- %varname% is accepted.

- varnames can be made out of letters, digits and the characters '_-'

(though is not verified in the ${varname} and %varname% cases)

XXX With COMMAND.COM you can use any characters in a variable name,

XXX except '^|<>='.

def expandvars(path): """Expand shell variables of the forms $var, ${var} and %var%.

Unknown variables are left unchanged."""
path = os.fspath(path)
if isinstance(path, bytes):
    if b'$' not in path and b'%' not in path:
        return path
    import string
    varchars = bytes(string.ascii_letters + string.digits + '_-', 'ascii')
    quote = b'\''
    percent = b'%'
    brace = b'{'
    rbrace = b'}'
    dollar = b'$'
    environ = getattr(os, 'environb', None)
else:
    if '$' not in path and '%' not in path:
        return path
    import string
    varchars = string.ascii_letters + string.digits + '_-'
    quote = '\''
    percent = '%'
    brace = '{'
    rbrace = '}'
    dollar = '$'
    environ = os.environ
res = path[:0]
index = 0
pathlen = len(path)
while index < pathlen:
    c = path[index:index+1]
    if c == quote:   # no expansion within single quotes
        path = path[index + 1:]
        pathlen = len(path)
        try:
            index = path.index(c)
            res += c + path[:index + 1]
        except ValueError:
            res += c + path
            index = pathlen - 1
    elif c == percent:  # variable or '%'
        if path[index + 1:index + 2] == percent:
            res += c
            index += 1
        else:
            path = path[index+1:]
            pathlen = len(path)
            try:
                index = path.index(percent)
            except ValueError:
                res += percent + path
                index = pathlen - 1
            else:
                var = path[:index]
                try:
                    if environ is None:
                        value = os.fsencode(os.environ[os.fsdecode(var)])
                    else:
                        value = environ[var]
                except KeyError:
                    value = percent + var + percent
                res += value
    elif c == dollar:  # variable or '$$'
        if path[index + 1:index + 2] == dollar:
            res += c
            index += 1
        elif path[index + 1:index + 2] == brace:
            path = path[index+2:]
            pathlen = len(path)
            try:
                index = path.index(rbrace)
            except ValueError:
                res += dollar + brace + path
                index = pathlen - 1
            else:
                var = path[:index]
                try:
                    if environ is None:
                        value = os.fsencode(os.environ[os.fsdecode(var)])
                    else:
                        value = environ[var]
                except KeyError:
                    value = dollar + brace + var + rbrace
                res += value
        else:
            var = path[:0]
            index += 1
            c = path[index:index + 1]
            while c and c in varchars:
                var += c
                index += 1
                c = path[index:index + 1]
            try:
                if environ is None:
                    value = os.fsencode(os.environ[os.fsdecode(var)])
                else:
                    value = environ[var]
            except KeyError:
                value = dollar + var
            res += value
            if c:
                index -= 1
    else:
        res += c
    index += 1
return res

Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A\B.

Previously, this function also truncated pathnames to 8+3 format,

but as this module is called "ntpath", that's obviously wrong!

def normpath(path): """Normalize path, eliminating double slashes, etc.""" path = os.fspath(path) if isinstance(path, bytes): sep = b'\' altsep = b'/' curdir = b'.' pardir = b'..' special_prefixes = (b'\\.\', b'\\?\') else: sep = '\' altsep = '/' curdir = '.' pardir = '..' special_prefixes = ('\\.\', '\\?\') if path.startswith(special_prefixes):

in the case of paths with these prefixes:

    # \\.\ -&gt; device names
    # \\?\ -&gt; literal paths
    # do not do any normalization, but return the path unchanged
    return path
path = path.replace(altsep, sep)
prefix, path = splitdrive(path)

# collapse initial backslashes
if path.startswith(sep):
    prefix += sep
    path = path.lstrip(sep)

comps = path.split(sep)
i = 0
while i < len(comps):
    if not comps[i] or comps[i] == curdir:
        del comps[i]
    elif comps[i] == pardir:
        if i &gt; 0 and comps[i-1] != pardir:
            del comps[i-1:i+1]
            i -= 1
        elif i == 0 and prefix.endswith(sep):
            del comps[i]
        else:
            i += 1
    else:
        i += 1
# If the path is now empty, substitute '.'
if not prefix and not comps:
    comps.append(curdir)
return prefix + sep.join(comps)

def _abspath_fallback(path): """Return the absolute version of a path as a fallback function in case nt._getfullpathname is not available or raises OSError. See bpo-31047 for more.

"""

path = os.fspath(path)
if not isabs(path):
    if isinstance(path, bytes):
        cwd = os.getcwdb()
    else:
        cwd = os.getcwd()
    path = join(cwd, path)
return normpath(path)

Return an absolute path.

try: from nt import _getfullpathname

except ImportError: # not running on Windows - mock up something sensible abspath = _abspath_fallback

else: # use native Windows method on Windows def abspath(path): """Return the absolute version of a path.""" try: return normpath(_getfullpathname(path)) except (OSError, ValueError): return _abspath_fallback(path)

realpath is a no-op on systems without islink support

realpath = abspath

Win9x family and earlier have no Unicode filename support.

supports_unicode_filenames = (hasattr(sys, "getwindowsversion") and sys.getwindowsversion()[3] >= 2)

def relpath(path, start=None): """Return a relative version of a path""" path = os.fspath(path) if isinstance(path, bytes): sep = b'\' curdir = b'.' pardir = b'..' else: sep = '\' curdir = '.' pardir = '..'

if start is None:
    start = curdir

if not path:
    raise ValueError("no path specified")

start = os.fspath(start)
try:
    start_abs = abspath(normpath(start))
    path_abs = abspath(normpath(path))
    start_drive, start_rest = splitdrive(start_abs)
    path_drive, path_rest = splitdrive(path_abs)
    if normcase(start_drive) != normcase(path_drive):
        raise ValueError("path is on mount %r, start on mount %r" % (
            path_drive, start_drive))

    start_list = [x for x in start_rest.split(sep) if x]
    path_list = [x for x in path_rest.split(sep) if x]
    # Work out how much of the filepath is shared by start and path.
    i = 0
    for e1, e2 in zip(start_list, path_list):
        if normcase(e1) != normcase(e2):
            break
        i += 1

    rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
    if not rel_list:
        return curdir
    return join(*rel_list)
except (TypeError, ValueError, AttributeError, BytesWarning, DeprecationWarning):
    genericpath._check_arg_types('relpath', path, start)
    raise

Return the longest common sub-path of the sequence of paths given as input.

The function is case-insensitive and 'separator-insensitive', i.e. if the

only difference between two paths is the use of '\' versus '/' as separator,

they are deemed to be equal.

#

However, the returned path will have the standard '\' separator (even if the

given paths had the alternative '/' separator) and will have the case of the

first path given in the sequence. Additionally, any trailing separator is

stripped from the returned path.

def commonpath(paths): """Given a sequence of path names, returns the longest common sub-path."""

if not paths:
    raise ValueError('commonpath() arg is an empty sequence')

paths = tuple(map(os.fspath, paths))
if isinstance(paths[0], bytes):
    sep = b'\\'
    altsep = b'/'
    curdir = b'.'
else:
    sep = '\\'
    altsep = '/'
    curdir = '.'

try:
    drivesplits = [splitdrive(p.replace(altsep, sep).lower()) for p in paths]
    split_paths = [p.split(sep) for d, p in drivesplits]

    try:
        isabs, = set(p[:1] == sep for d, p in drivesplits)
    except ValueError:
        raise ValueError("Can't mix absolute and relative paths") from None

    # Check that all drive letters or UNC paths match. The check is made only
    # now otherwise type errors for mixing strings and bytes would not be
    # caught.
    if len(set(d for d, p in drivesplits)) != 1:
        raise ValueError("Paths don't have the same drive")

    drive, path = splitdrive(paths[0].replace(altsep, sep))
    common = path.split(sep)
    common = [c for c in common if c and c != curdir]

    split_paths = [[c for c in s if c and c != curdir] for s in split_paths]
    s1 = min(split_paths)
    s2 = max(split_paths)
    for i, c in enumerate(s1):
        if c != s2[i]:
            common = common[:i]
            break
    else:
        common = common[:len(s1)]

    prefix = drive + sep if isabs else drive
    return prefix + sep.join(common)
except (TypeError, AttributeError):
    genericpath._check_arg_types('commonpath', *paths)
    raise

determine if two files are in fact the same file

try:

GetFinalPathNameByHandle is available starting with Windows 6.0.

# Windows XP and non-Windows OS'es will mock _getfinalpathname.
if sys.getwindowsversion()[:2] &gt;= (6, 0):
    from nt import _getfinalpathname
else:
    raise ImportError

except (AttributeError, ImportError):

On Windows XP and earlier, two files are the same if their absolute

# pathnames are the same.
# Non-Windows operating systems fake this method with an XP
# approximation.
def _getfinalpathname(f):
    return normcase(abspath(f))

try:

The genericpath.isdir implementation uses os.stat and checks the mode

# attribute to tell whether or not the path is a directory.
# This is overkill on Windows - just pass the path to GetFileAttributes
# and check the attribute from there.
from nt import _isdir as isdir

except ImportError:

Use genericpath.isdir as imported above.

pass

------------------ 原始邮件 ------------------ 发件人: "csyxwei/FFWM" @.>; 发送时间: 2023年4月10日(星期一) 晚上9:30 @.>; @.**@.>; 主题: Re: [csyxwei/FFWM] TypeError: expected str, bytes or os.PathLike object, not NoneType (Issue #14)

可以给一下你的执行的命令吗，看起来可能是没有指定--dataroot参数造成的。

— Reply to this email directly, view it on GitHub, or unsubscribe. You are receiving this because you authored the thread.Message ID: @.***>

csyxwei commented 1 year ago

可以参考README里的Testing部分的提示运行命令Testing，具体如下：

Testing

Download the models from GoogleDrive or BaiduNetDisk (l98p) to ./checkpoints folder or use your pretrained models. The models are structured as follows:

./checkpoints
      ├── ffwm
      │       ├── latest_net_flowNetF.pth
      │       └── latest_net_netG.pth
      ├── lightCNN_10_checkpoint.pth (pretrained)
      └── LightCNN_29Layers_checkpoint.pth (original)

Test on MultiPIE

python test_ffwm.py \
            --dataroot path/to/dataset \
            --lightcnn path/to/pretrained lightcnn \
            --preload

Test on LFW

python test_ffwm.py \
            --datamode lfw \
            --dataroot path/to/dataset \
            --lightcnn path/to/pretrained lightcnn \
            --preload

这里的path/to/xxx要换成你对应的数据集和模型的路径，具体的数据集准备方法可以参考这里。

xhlho commented 1 year ago

感谢🙏

csyxwei / FFWM

TypeError: expected str, bytes or os.PathLike object, not NoneType #14

Module 'ntpath' -- common operations on WinNT/Win95 pathnames

strings representing various path-related bits and pieces

These are primarily for export; internally, they are hardcoded.

Should be set before imports for resolving cyclic dependency.

Normalize the case of a pathname and map slashes to backslashes.

Other normalizations (such as optimizing '../' away) are not done

(this is done by normpath).

Return whether a path is absolute.

Trivial in Posix, harder on Windows.

For Windows it is absolute if it starts with a slash or backslash (current

volume), or if a pathname after the volume-letter-and-colon or UNC-resource

starts with a slash or backslash.

Join two (or more) paths.

Second path is absolute

Split a path in a drive specification (a drive letter followed by a

colon) and the path specification.

It is always true that drivespec + pathspec == p

Split a path in head (everything up to the last '/') and tail (the

rest). After the trailing '/' is stripped, the invariant

join(head, tail) == p holds.

The resulting head won't end in '/' unless it is the root.

Split a path in root and extension.

The extension is everything starting at the last dot in the last

pathname component; the root is everything before that.

It is always true that root + ext == p.

Return the tail (basename) part of a path.

Return the head (dirname) part of a path.

Is a path a symbolic link?

This will always return false on systems where os.lstat doesn't exist.

Being true for dangling symbolic links is also useful.

Is a path a mount point?

Any drive letter root (eg c:)

Any share UNC (eg \server\share)

Any volume mounted on a filesystem folder

No one method detects all three situations. Historically we've lexically

detected drive letter roots and share UNCs. The canonical approach to

detecting mounted volumes (querying the reparse tag) fails for the most

common case: drive letter roots. The alternative which uses GetVolumePathName

fails if the drive letter is the result of a SUBST.

Expand paths beginning with '~' or '~user'.

'~' means $HOME; '~user' means that user's home directory.

If the path doesn't begin with '~', or if the user or $HOME is unknown,

the path is returned unchanged (leaving error reporting to whatever

function is called with the expanded path as argument).

See also module 'glob' for expansion of *, ? and [...] in pathnames.

(A function should also be defined to do full *sh-style environment

variable expansion.)

Expand paths containing shell variable substitutions.

The following rules apply:

- no expansion within single quotes

- '$$' is translated into '$'

- '%%' is translated into '%' if '%%' are not seen in %var1%%var2%

- ${varname} is accepted.

- $varname is accepted.

- %varname% is accepted.

- varnames can be made out of letters, digits and the characters '_-'

(though is not verified in the ${varname} and %varname% cases)

XXX With COMMAND.COM you can use any characters in a variable name,

XXX except '^|<>='.

Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A\B.

Previously, this function also truncated pathnames to 8+3 format,

but as this module is called "ntpath", that's obviously wrong!

in the case of paths with these prefixes:

Return an absolute path.

realpath is a no-op on systems without islink support

Win9x family and earlier have no Unicode filename support.

Return the longest common sub-path of the sequence of paths given as input.

The function is case-insensitive and 'separator-insensitive', i.e. if the

only difference between two paths is the use of '\' versus '/' as separator,

they are deemed to be equal.

However, the returned path will have the standard '\' separator (even if the

given paths had the alternative '/' separator) and will have the case of the

first path given in the sequence. Additionally, any trailing separator is

stripped from the returned path.

determine if two files are in fact the same file

GetFinalPathNameByHandle is available starting with Windows 6.0.

On Windows XP and earlier, two files are the same if their absolute

The genericpath.isdir implementation uses os.stat and checks the mode