def test_fileSearch(self):
"""
Unittest: Do some searches on the local directory -- this will fail if
files are added or deleted.
This test does several tests on a file list generated from this directory.
"""
# Find python files (2) (minus pyc)
# Find all files >= python files.
allFL = FileList(directories=['.'])
noPycFL = FileList(directories=['.'], exclude_regexps=[r'\.pyc$'])
allFiles = allFL.getFiles()
noPycFiles = noPycFL.getFiles()
# We should have four non .pyc files
self.assertEqual(len(noPycFiles), 4)
# We could have some pyc files
self.assertTrue(len(noPycFiles) <= len(allFiles))
# Make sure our Module and test were found.
self.assertIn(os.path.join('.', 'FileList.py'), allFiles)
self.assertIn(os.path.join('.', 'test_FileList.py'), allFiles)
self.assertIn(os.path.join('.', 'FileList.py'), noPycFiles)
self.assertIn(os.path.join('.', 'test_FileList.py'), noPycFiles)
print allFL.FileInfo
def __init__(self, session, leftactive, selectedid):
Screen.__init__(self, session)
HelpableScreen.__init__(self)
self.selectedFiles = []
self.selectedid = selectedid
path_left = config.plugins.filecommander.path_left_tmp.value or None
path_right = config.plugins.filecommander.path_right_tmp.value or None
# set filter
filter = self.fileFilter()
# set current folder
self["list_left_head1"] = Label(path_left)
self["list_left_head2"] = List()
self["list_right_head1"] = Label(path_right)
self["list_right_head2"] = List()
if leftactive:
self["list_left"] = MultiFileSelectList(self.selectedFiles, path_left, matchingPattern=filter)
self["list_right"] = FileList(path_right, matchingPattern=filter)
self.SOURCELIST = self["list_left"]
self.TARGETLIST = self["list_right"]
self.onLayoutFinish.append(self.listLeft)
else:
self["list_left"] = FileList(path_left, matchingPattern=filter)
self["list_right"] = MultiFileSelectList(self.selectedFiles, path_right, matchingPattern=filter)
self.SOURCELIST = self["list_right"]
self.TARGETLIST = self["list_left"]
self.onLayoutFinish.append(self.listRight)
self["key_red"] = Label(_("Delete"))
self["key_green"] = Label(_("Move"))
self["key_yellow"] = Label(_("Copy"))
self["key_blue"] = Label(_("Skip selection"))
self["actions"] = HelpableActionMap(self, ["ChannelSelectBaseActions", "WizardActions", "FileNavigateActions", "MenuActions", "NumberActions", "ColorActions", "InfobarActions"], {
"ok": (self.ok, _("Select (source list) or enter directory (target list)")),
"back": (self.exit, _("Leave multi-select mode")),
"nextMarker": (self.listRight, _("Activate right-hand file list as multi-select source")),
"prevMarker": (self.listLeft, _("Activate left-hand file list as multi-select source")),
"nextBouquet": (self.listRight, _("Activate right-hand file list as multi-select source")),
"prevBouquet": (self.listLeft, _("Activate left-hand file list as multi-select source")),
"info": (self.openTasklist, _("Show task list")),
"directoryUp": (self.goParentfolder, _("Go to parent directory")),
"up": (self.goUp, _("Move up list")),
"down": (self.goDown, _("Move down list")),
"left": (self.goLeft, _("Page up list")),
"right": (self.goRight, _("Page down list")),
"red": (self.goRed, _("Delete the selected files or directories")),
"green": (self.goGreen, _("Move files/directories to target directory")),
"yellow": (self.goYellow, _("Copy files/directories to target directory")),
"blue": (self.goBlue, _("Leave multi-select mode")),
"0": (self.doRefresh, _("Refresh screen")),
"showMovies": (self.ok, _("Select")),
}, -1)
self.onLayoutFinish.append(self.onLayout)
def get_recurse_filelist(self):
file_list = FileList()
file_list.path _ self.__analysis_path
file_list.extension1 = self.__analysis_extension1
file_list.extension2 = self.__analysis_extension2
file_list.set_recurse_list()
self.__analysis_filelist = file_list.file_list
def __init__(self, title, buttons, results, directory=None):
GenericDialog.__init__(self, title, buttons, results)
if directory == None:
directory = os.curdir
directory = os.path.abspath(directory)
# Path access.
self._pathframe = HFrame()
self._pathframe.minsize = 200, self._pathframe.minsize[1]
self._pathframe.padding = 0
self._pathframe.border = BORDER_NONE
self._lblpath = Label("#Path:")
self._txtpath = Entry(directory)
self._txtpath.minsize = 165, self._txtpath.minsize[1]
self._lblpath.widget = self._txtpath
self._pathframe.add_child(self._lblpath, self._txtpath)
# File list browser.
self._filelist = FileList(200, 160, directory)
self.content.add_child(self._pathframe, self._filelist)
# Align anything on the right.
self.main.align = ALIGN_RIGHT
# Events.
self._txtpath.connect_signal(SIG_INPUT, self._set_directory)
self._filelist.connect_signal(SIG_LISTCHANGED, self._set_path)
def upload_file():
result = {"result": False, "msg": "上传失败"}
if request.method == 'POST':
files = request.files.get('mp4File')
print(files)
f = request.files['mp4File']
# f.filename
(filepath, ext) = os.path.splitext(f.filename)
filename = getCurrentTime()
path = os.path.join(os.path.dirname(__file__), 'upload')
if not os.path.exists(path):
os.makedirs(path)
upload_path = os.path.join(os.path.dirname(__file__), 'upload',
filename + ext)
f.save(upload_path)
fileObj = {
"fileName": f.filename,
"filePath": upload_path,
"id": filename
}
instance = FileList()
instance.addFile(fileObj)
result["result"] = True
result["msg"] = "上传成功"
result["path"] = upload_path
return result
return result
def test_DirectoriesEmpty(self):
"""
UnitTest: Make sure directories are empty on empty constructor
"""
# Check Empty
fl = FileList()
self.assertTrue(len(fl.directories) == 0)
def test_DirectoriesMatch(self):
"""
Unittest: Make sure directories passed into constructor are set
"""
# Check that it matches
directories = ['a', 'b', 'c']
fl = FileList(directories=directories)
self.assertEqual(directories, fl.directories)
def deleteFile(id):
try:
instance = FileList()
isSuccess = instance.deleteFile(id)
if isSuccess:
resultData(True, "", "")
return resultData(False, "删除失败", "")
except Exception as identifier:
print(identifier)
return resultData(False, "删除异常")
def __init__(self, config={}):
"""
Constructor
@param[in] config Will be *something*. For now, just a dict.
"""
## Store our config (or load it?)
self.config = config
## Our file list, created from the configuration
self.FileList = FileList(
directories=self.config['directories'],
exclude_regexps=self.config['exclude_regexps'])
## This will be a class soon, so it can handle removeable media.
# For now, it's just a directory.
self.Destination = self.config['destination']
## Copy of our files to backup
self.FilesToBackup = None
def __init__(self):
""" Create the main window, add the file list and the image display
widgets."""
QMainWindow.__init__(self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setWindowTitle("FITSBrowse")
self.main_widget = QWidget(self)
layout = QVBoxLayout(self.main_widget)
# Default size of the image display is 800x800 and axes are displayed.
image_display_figure = StaticImageDisplayWindow(self.main_widget,
width=8, height=8,
dpi=100)
file_list = FileList(image_display_figure)
# The layout has the list widget above the image display widget.
layout.addWidget(file_list)
layout.addWidget(image_display_figure)
self.main_widget.setFocus()
self.setCentralWidget(self.main_widget)
def __init__(self, session, path_left=None):
# path_left == "" means device list, whereas path_left == None means saved or default value
if path_left is None:
if config.plugins.filecommander.savedir_left.value and config.plugins.filecommander.path_left.value and os.path.isdir(config.plugins.filecommander.path_left.value):
path_left = config.plugins.filecommander.path_left.value
elif config.plugins.filecommander.path_default.value and os.path.isdir(config.plugins.filecommander.path_default.value):
path_left = config.plugins.filecommander.path_default.value
if config.plugins.filecommander.savedir_right.value and config.plugins.filecommander.path_right.value and os.path.isdir(config.plugins.filecommander.path_right.value):
path_right = config.plugins.filecommander.path_right.value
elif config.plugins.filecommander.path_default.value and os.path.isdir(config.plugins.filecommander.path_default.value):
path_right = config.plugins.filecommander.path_default.value
else:
path_right = None
if path_left and os.path.isdir(path_left) and path_left[-1] != "/":
path_left += "/"
if path_right and os.path.isdir(path_right) and path_right[-1] != "/":
path_right += "/"
if path_left == "":
path_left = None
if path_right == "":
path_right = None
self.session = session
Screen.__init__(self, session)
HelpableScreen.__init__(self)
# set filter
filter = self.fileFilter()
self.jobs = 0
self.updateDirs = set()
self.containers = []
# set current folder
self["list_left_head1"] = Label(path_left)
self["list_left_head2"] = List()
self["list_right_head1"] = Label(path_right)
self["list_right_head2"] = List()
self["list_left"] = FileList(path_left, matchingPattern=filter)
self["list_right"] = FileList(path_right, matchingPattern=filter)
self["key_red"] = Label(_("Delete"))
self["key_green"] = Label(_("Move"))
self["key_yellow"] = Label(_("Copy"))
self["key_blue"] = Label(_("Rename"))
self["VKeyIcon"] = Boolean(False)
self["actions"] = HelpableActionMap(self, ["ChannelSelectBaseActions", "WizardActions", "FileNavigateActions", "MenuActions", "NumberActions", "ColorActions", "InfobarActions", "InfobarTeletextActions", "InfobarSubtitleSelectionActions"], {
"ok": (self.ok, _("Play/view/edit/install/extract/run file or enter directory")),
"back": (self.exit, _("Leave File Commander")),
"menu": (self.goContext, _("Open settings/actions menu")),
"nextMarker": (self.listRight, _("Activate right-hand file list as source")),
"prevMarker": (self.listLeft, _("Activate left-hand file list as source")),
"nextBouquet": (self.listRight, _("Activate right-hand file list as source")),
"prevBouquet": (self.listLeft, _("Activate left-hand file list as source")),
"1": (self.gomakeDir, _("Create directory/folder")),
"2": (self.gomakeSym, _("Create user-named symbolic link")),
"3": (self.gofileStatInfo, _("File/directory status information")),
"4": (self.call_change_mode, _("Change execute permissions (755/644)")),
"5": (self.goDefaultfolder, _("Go to bookmarked folder")),
"6": (self.run_file, self.help_run_file),
"7": (self.run_ffprobe, self.help_run_ffprobe),
# "8": (self.run_mediainfo, self.help_run_mediainfo),
"9": (self.run_hashes, _("Calculate file checksums")),
"startTeletext": (self.file_viewer, _("View or edit file (if size < 1MB)")),
"info": (self.openTasklist, _("Show task list")),
"directoryUp": (self.goParentfolder, _("Go to parent directory")),
"up": (self.goUp, _("Move up list")),
"down": (self.goDown, _("Move down list")),
"left": (self.goLeft, _("Page up list")),
"right": (self.goRight, _("Page down list")),
"red": (self.goRed, _("Delete file or directory (and all its contents)")),
"green": (self.goGreen, _("Move file/directory to target directory")),
"yellow": (self.goYellow, _("Copy file/directory to target directory")),
"blue": (self.goBlue, _("Rename file/directory")),
"0": (self.doRefresh, _("Refresh screen")),
"showMovies": (self.listSelect, _("Enter multi-file selection mode")),
"subtitleSelection": self.downloadSubtitles, # Unimplemented
}, -1)
if config.plugins.filecommander.path_left_selected:
self.onLayoutFinish.append(self.listLeft)
else:
self.onLayoutFinish.append(self.listRight)
self.onLayoutFinish.append(self.onLayout)
class FileIOTests:
'''Base class implementing a general set of file I/O tests useful for
testing ancient filesystems.
This class is intended to be mixed in to a TestCase class for testing
a specific filesystem type.
targetDir property specifies root directory in which to perform tests.
This property must be set by the subclass.
fileList property accumulates a list of FileListEntry objects describing
the files created by the test. After the tests are run, these can be used
to verify the contents of the filesystem as seen from the legacy OS.
testConfig property contains per-test configuration parameters which can be
overridden by a subclass if necessary.
'''
fileList = FileList()
testConfig = obj({
'ReadWriteFile': {
'FileSizes': [10, 1000, 500000],
'WriteSizes': [
[1, 3, 10],
[13, 256, 1000],
[513, 4093, 65536],
],
'ReadSizes': [
[1, 3, 10, 512],
[1, 3, 10, 512],
[11, 1024, 4093, 65536],
]
},
'OverwriteFile': {
'FileSizes': [2011, 30303, 166420],
'StripeSizes': [
[10, 5, 2],
[512, 200, 64, 11, 8],
[32768, 512, 127, 61, 32],
]
},
'TruncateFile': {
'FileSizes': [16, 65536, 800 * 1024],
'Ratios': [2, 10, 0]
},
'ExtendFile': {
'FileSizes': [2000, 3000, 60000, 199999]
},
'ReadWriteSparseFile': {
'FileSizes': [1024, 10000, 500000], # TODO: 10000000
'SkipSizes': [[32, 100], [512, 127], [32767, 75000],
[500000, 1024 * 1024]],
'ReadSizes': [[1, 3, 10, 512], [1, 3, 10, 512],
[11, 1024, 4093, 32768], [65535, 256 * 1024 - 1]]
},
'ChangeFileMode': {
'Modes': [
stat.S_IRUSR, stat.S_IWUSR, stat.S_IXUSR, stat.S_IRGRP,
stat.S_IWGRP, stat.S_IXGRP, stat.S_IROTH, stat.S_IWOTH,
stat.S_IXOTH, stat.S_ISUID | stat.S_IXUSR,
stat.S_ISGID | stat.S_IXGRP
]
},
'ChangeDirectoryMode': {
'Modes': [
stat.S_IRUSR, stat.S_IWUSR, stat.S_IXUSR, stat.S_IRGRP,
stat.S_IWGRP, stat.S_IXGRP, stat.S_IROTH, stat.S_IWOTH,
stat.S_IXOTH, stat.S_ISVTX | stat.S_IXOTH
]
},
})
def setUp(self):
super().setUp()
# generate deterministic random data based on the name of the
# test being invoked.
random.seed(self.id())
# ---------- Basic File Tests ----------
def test_01_CreateFile(self):
'''Create File'''
fn = os.path.join(self.targetDir, 'f01')
with open(fn, "w+") as f:
pass
statRes = os.stat(fn)
self.assertEqual(statRes.st_size, 0)
self.fileList.append(
FileListEntry(fn, 'f', size=0, mode=statRes.st_mode, linkCount=1))
def test_02_DeleteFile(self):
'''Delete File'''
fn = os.path.join(self.targetDir, 'f02')
with open(fn, "w+") as f:
pass
statRes = os.stat(fn)
self.assertEqual(statRes.st_size, 0)
os.unlink(fn)
with self.assertRaises(OSError) as cm:
os.stat(fn)
def test_03_RenameFile(self):
'''Rename File'''
fn1 = os.path.join(self.targetDir, 'f03-1')
fn2 = os.path.join(self.targetDir, 'f03-2')
with open(fn1, "w+") as f1:
pass
stat1 = os.stat(fn1)
self.assertEqual(stat1.st_size, 0)
os.rename(fn1, fn2)
with self.assertRaises(OSError) as cm:
os.stat(fn1)
stat2 = os.stat(fn2)
self.assertEqual(stat2.st_size, 0)
self.assertEqual(stat2.st_mode, stat1.st_mode)
# TODO: Test preservation mod time?
self.fileList.append(
FileListEntry(fn2, 'f', size=0, mode=stat2.st_mode, linkCount=1))
def test_04_CreateFileLink(self):
'''Create File Link'''
fn1 = os.path.join(self.targetDir, 'f04-1')
fn2 = os.path.join(self.targetDir, 'f04-2')
fn3 = os.path.join(self.targetDir, 'f04-3')
with open(fn1, "w+") as f1:
pass
stat1 = os.stat(fn1)
self.assertEqual(stat1.st_size, 0)
os.link(fn1, fn2)
stat2 = os.stat(fn2)
self.assertEqual(stat2.st_size, 0)
stat1 = os.stat(fn1)
self.assertEqual(stat1.st_size, 0)
os.link(fn2, fn3)
stat3 = os.stat(fn3)
self.assertEqual(stat3.st_size, 0)
stat2 = os.stat(fn2)
self.assertEqual(stat2.st_size, 0)
self.fileList.append(
FileListEntry(fn1, 'f', size=0, mode=stat1.st_mode, linkCount=3))
self.fileList.append(
FileListEntry(fn2, 'f', size=0, mode=stat2.st_mode, linkCount=3))
self.fileList.append(
FileListEntry(fn3, 'f', size=0, mode=stat3.st_mode, linkCount=3))
def test_05_DeleteFileLink(self):
'''Delete File Link'''
fn1 = os.path.join(self.targetDir, 'f05-1')
fn2 = os.path.join(self.targetDir, 'f05-2')
with open(fn1, "w+") as f1:
pass
stat1 = os.stat(fn1)
self.assertEqual(stat1.st_size, 0)
os.link(fn1, fn2)
os.unlink(fn1)
with self.assertRaises(OSError) as cm:
os.stat(fn1)
stat2 = os.stat(fn2)
self.assertEqual(stat2.st_size, 0)
self.fileList.append(
FileListEntry(fn2, 'f', size=0, mode=stat2.st_mode, linkCount=1))
def test_06_ChangeFileMode(self):
'''Change File Mode'''
config = self.testConfig.ChangeFileMode
for i in range(0, len(config.Modes)):
mode = config.Modes[i]
fn = os.path.join(self.targetDir, 'f06-%d' % (i + 1))
with open(fn, "w+") as f:
pass
os.chown(fn, -1, os.getegid()
) # make sure the file's group is our effective gid
os.chmod(fn, mode)
statRes = os.stat(fn)
self.assertEqual(stat.S_IMODE(statRes.st_mode), mode)
self.fileList.append(
FileListEntry(fn,
'f',
size=0,
mode=statRes.st_mode,
linkCount=1))
def test_07_ChangeFileTimes(self):
'''Change File Times'''
ts = 157795200
fn = os.path.join(self.targetDir, 'f07-1')
with open(fn, "w+") as f:
pass
os.utime(fn, times=(ts, ts))
statRes = os.stat(fn)
self.assertEqual(statRes.st_atime, ts)
self.assertEqual(statRes.st_mtime, ts)
self.fileList.append(
FileListEntry(fn, 'f', size=0, mode=statRes.st_mode, linkCount=1))
def test_08_ChangeFileGroup(self):
'''Change File Group'''
try:
gid = grp.getgrnam('users').gr_gid
except KeyError:
gid = None
if gid not in os.getgroups():
try:
gid = grp.getgrnam('everyone').gr_gid
except KeyError:
gid = None
if gid not in os.getgroups():
self.skipTest("Suitable group not found")
fn = os.path.join(self.targetDir, 'f08-1')
with open(fn, "w+") as f:
pass
os.chown(fn, -1, gid)
statRes = os.stat(fn)
self.assertEqual(statRes.st_gid, gid)
self.fileList.append(
FileListEntry(fn, 'f', size=0, mode=statRes.st_mode, linkCount=1))
# ---------- File Read/Write Tests ----------
def test_10_ReadWriteFile(self):
'''Read/Write File'''
config = self.testConfig.ReadWriteFile
# for each of various file sizes...
for i in range(0, len(config.FileSizes)):
fileName = os.path.join(self.targetDir, 'f10-%d' % (i + 1))
fileSize = config.FileSizes[i]
readSizes = config.ReadSizes[i]
writeSizes = config.WriteSizes[i]
for writeSize in writeSizes:
if os.path.exists(fileName):
os.remove(fileName)
with ShadowedFile(fileName) as f:
# write the file
f.writeRandom(fileSize, chunkSize=writeSize)
# verify the reported size of the file on disk
stat1 = os.stat(fileName)
self.assertEqual(stat1.st_size, fileSize)
# read and verify the contents of the file, in various size chunks
for readSize in readSizes:
f.reopen()
f.readVerify(chunkSize=readSize)
# compute the file's checksum
expectedCksum = cksumFile(fileName)[0]
# add the file to the list of generated files.
self.fileList.append(
FileListEntry(fileName,
'f',
size=fileSize,
linkCount=1,
cksum=expectedCksum))
def test_11_OverwriteFile(self):
'''Overwrite File'''
config = self.testConfig.OverwriteFile
# for each of various file sizes...
for i in range(0, len(config.FileSizes)):
fileName = os.path.join(self.targetDir, 'f11-%d' % (i + 1))
fileSize = config.FileSizes[i]
stripeSizes = config.StripeSizes[i]
with ShadowedFile(fileName) as f:
# write the file
f.writeRandom(fileSize)
# for each stripe size, overwrite the file in stripes spaced
# equidistant from each other. verify the contents of the
# file at each pass.
for stripeSize in stripeSizes:
f.reopen()
writePos = 0
while writePos < fileSize:
remainingSize = fileSize - writePos
writeSize = remainingSize if remainingSize < stripeSize else stripeSize
f.writeRandom(writeSize, chunkSize=writeSize)
writePos = f.seek(stripeSize,
os.SEEK_CUR) # seek to next stripe
f.readVerify()
# compute the file's final checksum
f.seek(0)
expectedCksum = cksumStream(f)[0]
# add the file to the list of generated files.
self.fileList.append(
FileListEntry(fileName,
'f',
size=fileSize,
linkCount=1,
cksum=expectedCksum))
def test_12_ExtendFile(self):
'''Extend File'''
config = self.testConfig.ExtendFile
# for each of various file sizes...
for i in range(0, len(config.FileSizes)):
fileSize = config.FileSizes[i]
# create a file of the target size and then extend it to half again
# its initial size.
fileName = os.path.join(self.targetDir, 'f12-%d' % (i + 1))
with ShadowedFile(fileName) as f:
extendSize = int(math.floor(fileSize / 2))
newFileSize = fileSize + extendSize
f.writeRandom(fileSize)
f.reopen()
f.seek(0, whence=os.SEEK_END)
f.writeRandom(extendSize)
f.close()
# verify file size on disk
s = os.stat(fileName)
self.assertEqual(s.st_size, newFileSize)
# verify the file's contents
f.open()
f.readVerify()
# compute the file's final checksum
f.seek(0)
expectedCksum = cksumStream(f)[0]
# add the file to the list of generated files.
self.fileList.append(
FileListEntry(fileName,
'f',
size=newFileSize,
linkCount=1,
cksum=expectedCksum))
def test_13_TruncateFile(self):
'''Truncate File'''
config = self.testConfig.TruncateFile
# for each of various file sizes...
for i in range(0, len(config.FileSizes)):
fileSize = config.FileSizes[i]
# for each of various truncation ratios...
for ratio in config.Ratios:
# create a file of the target size and then truncate it based
# on the current size ratio
fileName = os.path.join(self.targetDir,
'f13-%d-%d' % (i + 1, ratio))
with ShadowedFile(fileName) as f:
f.writeRandom(fileSize)
f.reopen()
newFileSize = int(math.floor(fileSize /
ratio)) if ratio > 0 else 0
f.truncate(newFileSize)
f.close()
# verify file size on disk
s = os.stat(fileName)
self.assertEqual(s.st_size, newFileSize)
# verify the file's contents
f.open()
f.readVerify()
# compute the file's final checksum
f.seek(0)
expectedCksum = cksumStream(f)[0]
# add the file to the list of generated files.
self.fileList.append(
FileListEntry(fileName,
'f',
size=newFileSize,
linkCount=1,
cksum=expectedCksum))
def test_14_ReadWriteSparseFile(self):
'''Read/Write Sparse File'''
config = self.testConfig.ReadWriteSparseFile
chunkSize = 512
# for each of various file sizes...
for i in range(0, len(config.FileSizes)):
fileSize = config.FileSizes[i]
readSizes = config.ReadSizes[i]
skipSizes = config.SkipSizes[i]
fileName = os.path.join(self.targetDir, 'f14-%d' % (i + 1))
# for each skip size...
for skipSize in skipSizes:
if os.path.exists(fileName):
os.remove(fileName)
with ShadowedFile(fileName) as f:
# write the file in 512 byte chunks, skipping skipSize spans
# between chunks, up to the target file size, but always
# writting the last bytes in the file to ensure the proper length.
remainingSize = fileSize
while remainingSize > 0:
if remainingSize > skipSize:
f.seek(skipSize, os.SEEK_CUR)
remainingSize -= skipSize
else:
f.seek(fileSize - 1, os.SEEK_SET)
remainingSize = 1
writeSize = remainingSize if remainingSize < chunkSize else chunkSize
f.writeRandom(writeSize)
remainingSize -= writeSize
# verify the reported size of the file on disk
stat1 = os.stat(fileName)
self.assertEqual(stat1.st_size, fileSize)
# read and verify the contents of the file, in various size chunks
for readSize in readSizes:
f.reopen()
f.readVerify(chunkSize=readSize)
# compute the file's final checksum
expectedCksum = cksumFile(fileName)[0]
# add the file to the list of generated files.
self.fileList.append(
FileListEntry(fileName,
'f',
size=fileSize,
linkCount=1,
cksum=expectedCksum))
# ---------- Directory Tests ----------
def test_20_CreateDirectory(self):
'''Create Directory'''
dn = os.path.join(self.targetDir, 'd20')
os.mkdir(dn)
statRes = os.stat(dn)
self.assertTrue(stat.S_ISDIR(statRes.st_mode))
self.fileList.append(FileListEntry(dn, 'd', mode=statRes.st_mode))
for i in range(0, 20):
fn = os.path.join(dn, "f20-%d" % (i + 1))
with open(fn, "w+") as f:
pass
statRes = os.stat(fn)
self.assertEqual(statRes.st_size, 0)
self.fileList.append(
FileListEntry(fn,
'f',
size=0,
mode=statRes.st_mode,
linkCount=1))
def test_21_RemoveDirectory(self):
'''Remove Directory'''
# make directory 1
dn = os.path.join(self.targetDir, 'd21-1')
os.mkdir(dn)
statRes = os.stat(dn)
self.assertTrue(stat.S_ISDIR(statRes.st_mode))
# remove directory 1
os.rmdir(dn)
# ensure directory 1 is gone
with self.assertRaises(OSError) as cm:
os.stat(dn)
# make directory 2
dn = os.path.join(self.targetDir, 'd21-2')
os.mkdir(dn)
statRes = os.stat(dn)
self.assertTrue(stat.S_ISDIR(statRes.st_mode))
self.fileList.append(FileListEntry(dn, 'd', mode=statRes.st_mode))
# create file in directory 2
fn = os.path.join(dn, "f21")
with open(fn, "w+") as f:
pass
statRes = os.stat(fn)
self.assertEqual(statRes.st_size, 0)
self.fileList.append(
FileListEntry(fn, 'f', size=0, mode=statRes.st_mode, linkCount=1))
# verify error attempting to remove non-empty directory 2
with self.assertRaises(OSError) as cm:
os.rmdir(dn)
def test_22_RenameDirectory(self):
'''Rename Directory'''
dn = os.path.join(self.targetDir, 'd22-1')
os.mkdir(dn)
statRes = os.stat(dn)
self.assertTrue(stat.S_ISDIR(statRes.st_mode))
fn = os.path.join(dn, "f22")
with open(fn, "w+") as f:
pass
statRes = os.stat(fn)
self.assertEqual(statRes.st_size, 0)
dn2 = os.path.join(self.targetDir, 'd22-2')
os.rename(dn, dn2)
statRes = os.stat(dn2)
self.assertTrue(stat.S_ISDIR(statRes.st_mode))
self.fileList.append(FileListEntry(dn2, 'd', mode=statRes.st_mode))
fn2 = os.path.join(dn2, "f22")
statRes = os.stat(fn2)
self.assertEqual(statRes.st_size, 0)
self.fileList.append(
FileListEntry(fn2, 'f', size=0, mode=statRes.st_mode, linkCount=1))
def test_23_CreateNestedDirectories(self):
'''Create Nested Directories'''
dn = self.targetDir
for i in range(0, 10):
dn = os.path.join(dn, 'd23-%d' % (i + 1))
os.mkdir(dn)
statRes = os.stat(dn)
self.assertTrue(stat.S_ISDIR(statRes.st_mode))
self.fileList.append(FileListEntry(dn, 'd', mode=statRes.st_mode))
def test_24_MoveDirectory(self):
'''Move Directory'''
# make dir 1
dn1 = os.path.join(self.targetDir, 'd24-1')
os.mkdir(dn1)
# make dir 2
dn2 = os.path.join(self.targetDir, 'd24-2')
os.mkdir(dn2)
# make dir 3 within dir 1
dn3 = os.path.join(dn1, 'd24-3')
os.mkdir(dn3)
# make file 1 within dir 1
fn1 = os.path.join(dn1, "f24-1")
with open(fn1, "w+") as f:
pass
# make file 2 within dir 2
fn2 = os.path.join(dn2, "f24-2")
with open(fn2, "w+") as f:
pass
# make file 3 within dir 3
fn3 = os.path.join(dn3, "f24-3")
with open(fn3, "w+") as f:
pass
# move dir 2 under dir 3 and rename
newdn2 = os.path.join(dn3, 'd24-2-new')
os.rename(dn2, newdn2)
# verify dir 2 exists in new location with new name
statRes = os.stat(newdn2)
self.assertTrue(stat.S_ISDIR(statRes.st_mode))
# verify ".." entry in dir 2 now refers to dir 3
self.assertTrue(
os.stat(os.path.join(newdn2, "..")).st_ino,
os.stat(dn3).st_ino)
# verify that file 2 still exists within dir 2
newfn2 = os.path.join(newdn2, "f24-2")
statRes = os.stat(newfn2)
self.assertTrue(stat.S_ISREG(statRes.st_mode))
# verify that file 1 still exists withing dir 1
statRes = os.stat(fn1)
self.assertTrue(stat.S_ISREG(statRes.st_mode))
# verify error attempting to move dir 1 under dir 2 (i.e. under itself)
with self.assertRaises(OSError) as cm:
newdn1 = os.path.join(newdn2, 'd24-1-new')
os.rename(dn3, newdn1)
self.fileList.append(FileListEntry(dn1, 'd'))
self.fileList.append(FileListEntry(newdn2, 'd'))
self.fileList.append(FileListEntry(dn3, 'd'))
self.fileList.append(FileListEntry(fn1, 'f'))
self.fileList.append(FileListEntry(newfn2, 'f'))
self.fileList.append(FileListEntry(fn3, 'f'))
def test_25_ChangeDirectoryMode(self):
'''Change Directory Mode'''
config = self.testConfig.ChangeDirectoryMode
for i in range(0, len(config.Modes)):
mode = config.Modes[i]
dn = os.path.join(self.targetDir, 'd25-%d' % (i + 1))
os.mkdir(dn)
os.chmod(dn, mode)
statRes = os.stat(dn)
self.assertEqual(stat.S_IMODE(statRes.st_mode), mode)
self.fileList.append(FileListEntry(dn, 'd', mode=statRes.st_mode))
from UserInterface import UserInterface
from FileList import FileList
userInterface = UserInterface()
try:
#create the gui window
userInterface.createTkWindow()
except:
#if that fails then use terminal input instead
print("Interface window Could not be opened... Defaulting to text")
userInterface.getTerminalInput()
#get the form data from the user input
directoryPath = userInterface.directoryPath
searchString = userInterface.searchString
outputOrder = userInterface.outputOrder
files = FileList(directoryPath)
import os
from FileList import FileList
import yaml
import pprint # for better print
# Set Path
input_folder_prefix = os.path.join(os.path.dirname(__file__), "txt")
input_foldername_prefix = "dayTraining_"
output_folder_prefix = os.path.join(os.path.dirname(__file__), "yaml")
for i in range(1, 3):
input_folder = os.path.join(input_folder_prefix, input_foldername_prefix) + str(i)
flist = FileList(input_folder)
for item in flist.getFilesPathList():
# for every .txt
# print(item)
# Read content
item_list = []
with open(item, "r") as rf:
for row in rf:
item_list.append(row)
output_yaml = {'annotation': {'filename': '000001.jpg',
'folder': 'VOC2007',
'object': [],
'owner': {'flickrid': 'Fried Camels',
def getFileList():
instance = FileList()
obj = resultData(True, "", instance.getList())
return obj
