def test_samefile(self):
f = open(test_support.TESTFN + "1", "wb")
try:
f.write("foo")
f.close()
self.assertIs(posixpath.samefile(test_support.TESTFN + "1", test_support.TESTFN + "1"), True)
# If we don't have links, assume that os.stat doesn't return resonable
# inode information and thus, that samefile() doesn't work
if hasattr(os, "symlink"):
os.symlink(test_support.TESTFN + "1", test_support.TESTFN + "2")
self.assertIs(posixpath.samefile(test_support.TESTFN + "1", test_support.TESTFN + "2"), True)
os.remove(test_support.TESTFN + "2")
f = open(test_support.TESTFN + "2", "wb")
f.write("bar")
f.close()
self.assertIs(posixpath.samefile(test_support.TESTFN + "1", test_support.TESTFN + "2"), False)
finally:
if not f.close():
f.close()
try:
os.remove(test_support.TESTFN + "1")
except os.error:
pass
try:
os.remove(test_support.TESTFN + "2")
except os.error:
pass
self.assertRaises(TypeError, posixpath.samefile)
def test_samefile(self):
f = open(test_support.TESTFN + "1", "wb")
try:
f.write("foo")
f.close()
self.assertIs(
posixpath.samefile(test_support.TESTFN + "1",
test_support.TESTFN + "1"), True)
# If we don't have links, assume that os.stat doesn't return
# reasonable inode information and thus, that samefile() doesn't
# work.
if hasattr(os, "symlink"):
os.symlink(test_support.TESTFN + "1",
test_support.TESTFN + "2")
self.assertIs(
posixpath.samefile(test_support.TESTFN + "1",
test_support.TESTFN + "2"), True)
os.remove(test_support.TESTFN + "2")
f = open(test_support.TESTFN + "2", "wb")
f.write("bar")
f.close()
self.assertIs(
posixpath.samefile(test_support.TESTFN + "1",
test_support.TESTFN + "2"), False)
finally:
if not f.close():
f.close()
def test_samefile_on_links(self) -> None:
test_fn1 = support.TESTFN + "1"
test_fn2 = support.TESTFN + "2"
self._create_file(test_fn1)
os.symlink(test_fn1, test_fn2)
self.assertTrue(posixpath.samefile(test_fn1, test_fn2))
os.remove(test_fn2)
self._create_file(test_fn2)
self.assertFalse(posixpath.samefile(test_fn1, test_fn2))
def test_samefile_on_links(self):
test_fn1 = support.TESTFN + "1"
test_fn2 = support.TESTFN + "2"
self._create_file(test_fn1)
os.symlink(test_fn1, test_fn2)
self.assertTrue(posixpath.samefile(test_fn1, test_fn2))
os.remove(test_fn2)
self._create_file(test_fn2)
self.assertFalse(posixpath.samefile(test_fn1, test_fn2))
def assertNotSameFile(self, file1, file2):
"""Assert files are not the same.
Assertion fails if first file does not exist.
"""
self.assertTrue(posixpath.exists(file1))
if posixpath.exists(file2):
self.assertFalse(posixpath.samefile(file1, file2))
def unload_dtags(rootpath, dirpath):
"""Remove symlinks using a directory's dtags."""
tags = dtags.list_tags(dirpath)
dirpath = pathlib.readlink(dirpath)
for tagname in tags:
tagpath = tagnames.tag2path(rootpath, tagname)
if posixpath.samefile(dirpath, tagpath):
os.unlink(tagpath)
def untag(rootpath, path, directory):
"""Untag file from a directory.
Args:
rootpath: Rootpath to resolve tagnames.
path: Path of file or directory to tag.
directory: Directory path.
"""
target = path
to_unlink = []
for filepath in pathlib.listdirpaths(directory):
if posixpath.samefile(target, filepath):
to_unlink.append(filepath)
for filepath in to_unlink:
base.unlink(rootpath, filepath)
def untag(rootpath, path, directory):
"""Untag file from a directory.
Args:
rootpath: Rootpath to resolve tagnames.
path: Path of file or directory to tag.
directory: Directory path.
"""
target = path
to_unlink = []
for filepath in pathlib.listdirpaths(directory):
if posixpath.samefile(target, filepath):
to_unlink.append(filepath)
for filepath in to_unlink:
base.unlink(rootpath, filepath)
def list_links(top, path):
"""List all links to the target file.
Args:
top: Path to top of directory tree to search.
path: Path of file.
Returns:
Generator yielding paths.
"""
target = path
for (dirpath, dirnames, filenames) in os.walk(top):
for name in chain(dirnames, filenames):
filepath = posixpath.join(dirpath, name)
if posixpath.samefile(target, filepath):
yield filepath
def test_samefile(self) -> None:
test_fn = support.TESTFN + "1"
self._create_file(test_fn)
self.assertTrue(posixpath.samefile(test_fn, test_fn))
self.assertRaises(TypeError, posixpath.samefile)
def copyfile(
originalfile,
newfile,
copy=False,
create_new=False,
use_hardlink=True,
copy_related_files=True,
):
"""
Copy or link files.
If ``use_hardlink`` is True, and the file can be hard-linked, then a
link is created, instead of copying the file.
If a hard link is not created and ``copy`` is False, then a symbolic
link is created.
.. admonition:: Copy options for existing files
* symlink
* to regular file originalfile (keep if symlinking)
* to same dest as symlink originalfile (keep if symlinking)
* to other file (unlink)
* regular file
* hard link to originalfile (keep)
* copy of file (same hash) (keep)
* different file (diff hash) (unlink)
.. admonition:: Copy options for new files
* ``use_hardlink`` & ``can_hardlink`` => hardlink
* ``~hardlink`` & ``~copy`` & ``can_symlink`` => symlink
* ``~hardlink`` & ``~symlink`` => copy
Parameters
----------
originalfile : :obj:`str`
full path to original file
newfile : :obj:`str`
full path to new file
copy : Bool
specifies whether to copy or symlink files
(default=False) but only for POSIX systems
use_hardlink : Bool
specifies whether to hard-link files, when able
(Default=False), taking precedence over copy
copy_related_files : Bool
specifies whether to also operate on related files, as defined in
``related_filetype_sets``
Returns
-------
None
"""
newhash = None
orighash = None
logger.debug(newfile)
if create_new:
while op.exists(newfile):
base, fname, ext = split_filename(newfile)
s = re.search("_c[0-9]{4,4}$", fname)
i = 0
if s:
i = int(s.group()[2:]) + 1
fname = fname[:-6] + "_c%04d" % i
else:
fname += "_c%04d" % i
newfile = base + os.sep + fname + ext
# Don't try creating symlinks on CIFS
if copy is False and on_cifs(newfile):
copy = True
keep = False
if op.lexists(newfile):
if op.islink(newfile):
if all(
(
os.readlink(newfile) == op.realpath(originalfile),
not use_hardlink,
not copy,
)
):
keep = True
elif posixpath.samefile(newfile, originalfile):
keep = True
else:
newhash = hash_file(newfile)
logger.debug("File: %s already exists,%s, copy:%d", newfile, newhash, copy)
orighash = hash_file(originalfile)
keep = newhash == orighash
if keep:
logger.debug(
"File: %s already exists, not overwriting, copy:%d", newfile, copy
)
else:
os.unlink(newfile)
if not keep and use_hardlink:
try:
logger.debug("Linking File: %s->%s", newfile, originalfile)
# Use realpath to avoid hardlinking symlinks
os.link(op.realpath(originalfile), newfile)
except OSError:
use_hardlink = False # Disable hardlink for associated files
else:
keep = True
if not keep and not copy and os.name == "posix":
try:
logger.debug("Symlinking File: %s->%s", newfile, originalfile)
os.symlink(originalfile, newfile)
except OSError:
copy = True # Disable symlink for associated files
else:
keep = True
if not keep:
try:
logger.debug("Copying File: %s->%s", newfile, originalfile)
shutil.copyfile(originalfile, newfile)
except shutil.Error as e:
logger.warning(e.message)
# Associated files
if copy_related_files:
related_file_pairs = (
get_related_files(f, include_this_file=False)
for f in (originalfile, newfile)
)
for alt_ofile, alt_nfile in zip(*related_file_pairs):
if op.exists(alt_ofile):
copyfile(
alt_ofile,
alt_nfile,
copy,
use_hardlink=use_hardlink,
copy_related_files=False,
)
return newfile
def test_samefile(self):
test_fn = support.TESTFN + "1"
self._create_file(test_fn)
self.assertTrue(posixpath.samefile(test_fn, test_fn))
self.assertRaises(TypeError, posixpath.samefile)
def assertSameFile(self, file1, file2):
"""Assert both files are the same by inode."""
self.assertTrue(posixpath.samefile(file1, file2))
def copyfile(originalfile, newfile, copy=False, create_new=False,
hashmethod=None, use_hardlink=False,
copy_related_files=True):
"""Copy or link ``originalfile`` to ``newfile``.
If ``use_hardlink`` is True, and the file can be hard-linked, then a
link is created, instead of copying the file.
If a hard link is not created and ``copy`` is False, then a symbolic
link is created.
Parameters
----------
originalfile : str
full path to original file
newfile : str
full path to new file
copy : Bool
specifies whether to copy or symlink files
(default=False) but only for POSIX systems
use_hardlink : Bool
specifies whether to hard-link files, when able
(Default=False), taking precedence over copy
copy_related_files : Bool
specifies whether to also operate on related files, as defined in
``related_filetype_sets``
Returns
-------
None
"""
newhash = None
orighash = None
fmlogger.debug(newfile)
if create_new:
while os.path.exists(newfile):
base, fname, ext = split_filename(newfile)
s = re.search('_c[0-9]{4,4}$', fname)
i = 0
if s:
i = int(s.group()[2:]) + 1
fname = fname[:-6] + "_c%04d" % i
else:
fname += "_c%04d" % i
newfile = base + os.sep + fname + ext
if hashmethod is None:
hashmethod = config.get('execution', 'hash_method').lower()
# Don't try creating symlinks on CIFS
if copy is False and on_cifs(newfile):
copy = True
# Existing file
# -------------
# Options:
# symlink
# to regular file originalfile (keep if symlinking)
# to same dest as symlink originalfile (keep if symlinking)
# to other file (unlink)
# regular file
# hard link to originalfile (keep)
# copy of file (same hash) (keep)
# different file (diff hash) (unlink)
keep = False
if os.path.lexists(newfile):
if os.path.islink(newfile):
if all((os.readlink(newfile) == os.path.realpath(originalfile),
not use_hardlink, not copy)):
keep = True
elif posixpath.samefile(newfile, originalfile):
keep = True
else:
if hashmethod == 'timestamp':
hashfn = hash_timestamp
elif hashmethod == 'content':
hashfn = hash_infile
newhash = hashfn(newfile)
fmlogger.debug("File: %s already exists,%s, copy:%d" %
(newfile, newhash, copy))
orighash = hashfn(originalfile)
keep = newhash == orighash
if keep:
fmlogger.debug("File: %s already exists, not overwriting, copy:%d"
% (newfile, copy))
else:
os.unlink(newfile)
# New file
# --------
# use_hardlink & can_hardlink => hardlink
# ~hardlink & ~copy & can_symlink => symlink
# ~hardlink & ~symlink => copy
if not keep and use_hardlink:
try:
fmlogger.debug("Linking File: %s->%s" % (newfile, originalfile))
# Use realpath to avoid hardlinking symlinks
os.link(os.path.realpath(originalfile), newfile)
except OSError:
use_hardlink = False # Disable hardlink for associated files
else:
keep = True
if not keep and not copy and os.name == 'posix':
try:
fmlogger.debug("Symlinking File: %s->%s" % (newfile, originalfile))
os.symlink(originalfile, newfile)
except OSError:
copy = True # Disable symlink for associated files
else:
keep = True
if not keep:
try:
fmlogger.debug("Copying File: %s->%s" % (newfile, originalfile))
shutil.copyfile(originalfile, newfile)
except shutil.Error as e:
fmlogger.warn(e.message)
# Associated files
if copy_related_files:
related_file_pairs = (get_related_files(f, include_this_file=False)
for f in (originalfile, newfile))
for alt_ofile, alt_nfile in zip(*related_file_pairs):
if os.path.exists(alt_ofile):
copyfile(alt_ofile, alt_nfile, copy, hashmethod=hashmethod,
use_hardlink=use_hardlink, copy_related_files=False)
return newfile
def copyfile(originalfile,
newfile,
copy=False,
create_new=False,
hashmethod=None,
use_hardlink=False):
"""Copy or link ``originalfile`` to ``newfile``.
If ``use_hardlink`` is True, and the file can be hard-linked, then a
link is created, instead of copying the file.
If a hard link is not created and ``copy`` is False, then a symbolic
link is created.
Parameters
----------
originalfile : str
full path to original file
newfile : str
full path to new file
copy : Bool
specifies whether to copy or symlink files
(default=False) but only for POSIX systems
use_hardlink : Bool
specifies whether to hard-link files, when able
(Default=False), taking precedence over copy
Returns
-------
None
"""
newhash = None
orighash = None
fmlogger.debug(newfile)
if create_new:
while os.path.exists(newfile):
base, fname, ext = split_filename(newfile)
s = re.search('_c[0-9]{4,4}$', fname)
i = 0
if s:
i = int(s.group()[2:]) + 1
fname = fname[:-6] + "_c%04d" % i
else:
fname += "_c%04d" % i
newfile = base + os.sep + fname + ext
if hashmethod is None:
hashmethod = config.get('execution', 'hash_method').lower()
# Existing file
# -------------
# Options:
# symlink
# to originalfile (keep if not (use_hardlink or copy))
# to other file (unlink)
# regular file
# hard link to originalfile (keep)
# copy of file (same hash) (keep)
# different file (diff hash) (unlink)
keep = False
if os.path.lexists(newfile):
if os.path.islink(newfile):
if all(
os.path.readlink(newfile) == originalfile,
not use_hardlink, not copy):
keep = True
elif posixpath.samefile(newfile, originalfile):
keep = True
else:
if hashmethod == 'timestamp':
hashfn = hash_timestamp
elif hashmethod == 'content':
hashfn = hash_infile
newhash = hashfn(newfile)
fmlogger.debug("File: %s already exists,%s, copy:%d" %
(newfile, newhash, copy))
orighash = hashfn(originalfile)
keep = newhash == orighash
if keep:
fmlogger.debug(
"File: %s already exists, not overwriting, copy:%d" %
(newfile, copy))
else:
os.unlink(newfile)
# New file
# --------
# use_hardlink & can_hardlink => hardlink
# ~hardlink & ~copy & can_symlink => symlink
# ~hardlink & ~symlink => copy
if not keep and use_hardlink:
try:
fmlogger.debug("Linking File: %s->%s" % (newfile, originalfile))
# Use realpath to avoid hardlinking symlinks
os.link(os.path.realpath(originalfile), newfile)
except OSError:
use_hardlink = False # Disable hardlink for associated files
else:
keep = True
if not keep and not copy and os.name == 'posix':
try:
fmlogger.debug("Symlinking File: %s->%s" % (newfile, originalfile))
os.symlink(originalfile, newfile)
except OSError:
copy = True # Disable symlink for associated files
else:
keep = True
if not keep:
try:
fmlogger.debug("Copying File: %s->%s" % (newfile, originalfile))
shutil.copyfile(originalfile, newfile)
except shutil.Error as e:
fmlogger.warn(e.message)
# Associated files
if originalfile.endswith(".img"):
hdrofile = originalfile[:-4] + ".hdr"
hdrnfile = newfile[:-4] + ".hdr"
matofile = originalfile[:-4] + ".mat"
if os.path.exists(matofile):
matnfile = newfile[:-4] + ".mat"
copyfile(matofile,
matnfile,
copy,
hashmethod=hashmethod,
use_hardlink=use_hardlink)
copyfile(hdrofile,
hdrnfile,
copy,
hashmethod=hashmethod,
use_hardlink=use_hardlink)
elif originalfile.endswith(".BRIK"):
hdrofile = originalfile[:-5] + ".HEAD"
hdrnfile = newfile[:-5] + ".HEAD"
copyfile(hdrofile,
hdrnfile,
copy,
hashmethod=hashmethod,
use_hardlink=use_hardlink)
return newfile
def copyfile(originalfile,
newfile,
copy=False,
create_new=False,
hashmethod=None,
use_hardlink=False,
copy_related_files=True):
"""Copy or link ``originalfile`` to ``newfile``.
If ``use_hardlink`` is True, and the file can be hard-linked, then a
link is created, instead of copying the file.
If a hard link is not created and ``copy`` is False, then a symbolic
link is created.
Parameters
----------
originalfile : str
full path to original file
newfile : str
full path to new file
copy : Bool
specifies whether to copy or symlink files
(default=False) but only for POSIX systems
use_hardlink : Bool
specifies whether to hard-link files, when able
(Default=False), taking precedence over copy
copy_related_files : Bool
specifies whether to also operate on related files, as defined in
``related_filetype_sets``
Returns
-------
None
"""
newhash = None
orighash = None
fmlogger.debug(newfile)
if create_new:
while os.path.exists(newfile):
base, fname, ext = split_filename(newfile)
s = re.search('_c[0-9]{4,4}$', fname)
i = 0
if s:
i = int(s.group()[2:]) + 1
fname = fname[:-6] + "_c%04d" % i
else:
fname += "_c%04d" % i
newfile = base + os.sep + fname + ext
if hashmethod is None:
hashmethod = config.get('execution', 'hash_method').lower()
# Don't try creating symlinks on CIFS
if copy is False and on_cifs(newfile):
copy = True
# Existing file
# -------------
# Options:
# symlink
# to regular file originalfile (keep if symlinking)
# to same dest as symlink originalfile (keep if symlinking)
# to other file (unlink)
# regular file
# hard link to originalfile (keep)
# copy of file (same hash) (keep)
# different file (diff hash) (unlink)
keep = False
if os.path.lexists(newfile):
if os.path.islink(newfile):
if all((os.readlink(newfile) == os.path.realpath(originalfile),
not use_hardlink, not copy)):
keep = True
elif posixpath.samefile(newfile, originalfile):
keep = True
else:
if hashmethod == 'timestamp':
hashfn = hash_timestamp
elif hashmethod == 'content':
hashfn = hash_infile
newhash = hashfn(newfile)
fmlogger.debug('File: %s already exists,%s, copy:%d', newfile,
newhash, copy)
orighash = hashfn(originalfile)
keep = newhash == orighash
if keep:
fmlogger.debug('File: %s already exists, not overwriting, copy:%d',
newfile, copy)
else:
os.unlink(newfile)
# New file
# --------
# use_hardlink & can_hardlink => hardlink
# ~hardlink & ~copy & can_symlink => symlink
# ~hardlink & ~symlink => copy
if not keep and use_hardlink:
try:
fmlogger.debug('Linking File: %s->%s', newfile, originalfile)
# Use realpath to avoid hardlinking symlinks
os.link(os.path.realpath(originalfile), newfile)
except OSError:
use_hardlink = False # Disable hardlink for associated files
else:
keep = True
if not keep and not copy and os.name == 'posix':
try:
fmlogger.debug('Symlinking File: %s->%s', newfile, originalfile)
os.symlink(originalfile, newfile)
except OSError:
copy = True # Disable symlink for associated files
else:
keep = True
if not keep:
try:
fmlogger.debug('Copying File: %s->%s', newfile, originalfile)
shutil.copyfile(originalfile, newfile)
except shutil.Error as e:
fmlogger.warn(e.message)
# Associated files
if copy_related_files:
related_file_pairs = (get_related_files(f, include_this_file=False)
for f in (originalfile, newfile))
for alt_ofile, alt_nfile in zip(*related_file_pairs):
if os.path.exists(alt_ofile):
copyfile(alt_ofile,
alt_nfile,
copy,
hashmethod=hashmethod,
use_hardlink=use_hardlink,
copy_related_files=False)
return newfile
def update_event(self, inp=-1):
self.set_output_val(0, posixpath.samefile(self.input(0),
self.input(1)))
