def on_created(self, event):
if event.event_type == 'created':
file_is_incomplete = True
last_file_size = -1
image_path = event.src_path
_LOGGER.debug(
f"New image file detected : {image_path}. Waiting untill file is fully written to disk..."
)
while file_is_incomplete:
info = QFileInfo(image_path)
size = info.size()
_LOGGER.debug(f"File {image_path}'s size = {size}")
if size == last_file_size:
file_is_incomplete = False
_LOGGER.debug(
f"File {image_path} has been fully written to disk")
last_file_size = size
self.msleep(DEFAULT_SCAN_SIZE_RETRY_PERIOD_MS)
_LOGGER.info(f"New image ready to be processed : {image_path}")
_LOGGER.debug(
f"'created' signal emitted from MyEventHandler.on_created. Image path = {image_path}"
)
self.created_signal.emit(image_path)
def startSearch(self, query):
print("search started..", query)
filters = QDir.Files
nameFilters = ["*.cpp"]
iterator = QDirIterator("/home/alexanderb", nameFilters, filters,
QDirIterator.Subdirectories)
while (iterator.hasNext()):
filePath = iterator.next()
fileInfo = QFileInfo(filePath)
currentFile = QFile(filePath)
currentFile.open(QFile.ReadOnly | QFile.Text)
fileContents = currentFile.readAll().data().decode('utf8',
errors='ignore')
if (fileContents.find(query) != -1):
qtwItem = QTreeWidgetItem()
qtwItem.setText(0, fileInfo.fileName())
qtwItem.setText(1, fileInfo.suffix())
qtwItem.setText(2, str(fileInfo.size() / 1024))
qtwItem.setText(3,
fileInfo.lastModified().toString("MM/dd/yyyy"))
qtwItem.setText(4, fileInfo.created().toString("MM/dd/yyyy"))
qtwItem.setText(5, str("...here is the content..."))
qtwItem.setText(6, filePath)
self.qtwItems.append(qtwItem)
self.match_found.emit(qtwItem)
self.finished.emit()
def is_img_so_big(path):
'''判断图片是否大于2G'''
file_info = QFileInfo(path)
file_g_size = file_info.size() / 1024 / 1024 / 1024
if file_g_size >= 2: # 大于2G
return True
else:
return False
def init_ui(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
file_name = self.save_file_name_dialog()
info = QFileInfo(file_name)
self.file_size = info.size()
self.show()
return file_name
def GetFile(self, typeOfFile, suff):
options = QFileDialog.Options()
fileName, _ = QFileDialog.getOpenFileName(
self,
"Open {} File".format(typeOfFile),
"",
"{}".format(suff),
options=options)
if fileName:
if typeOfFile == "any":
myCipher.fileToBeSigned = fileName
f = QFileInfo(fileName)
n = f.fileName()
file_info = "Informations about the file:\n \n"
file_info += "Name: " + n + "\n"
p = f.filePath()
file_info += "Path: " + p + "\n"
suf = f.suffix()
file_info += "Suffix: " + suf + "\n"
size = f.size()
file_info += "Size (in bytes): " + str(size) + "\n"
lastModify = f.lastModified().toPyDateTime()
file_info += "Date of last change: " + str(lastModify)
self.fileInfo.setText(file_info)
elif typeOfFile == "Signed":
myCipher.userFile = fileName
elif typeOfFile == "Private key":
myCipher.privPath = fileName
with open(fileName, "r") as f:
f.seek(4)
base64Text = f.readline()
decodedBase64D = self.decodeFromBase64(base64Text)
myCipher.d = int(decodedBase64D, 10)
base64Text2 = f.readline()
decodedBase64N = self.decodeFromBase64(base64Text2)
myCipher.n = int(decodedBase64N, 10)
elif typeOfFile == "Public key":
myCipher.pubPath = fileName
with open(fileName, "r") as f:
f.seek(4)
base64Text = f.readline()
decodedBase64E = self.decodeFromBase64(base64Text)
myCipher.e = int(decodedBase64E, 10)
base64Text2 = f.readline()
decodedBase64N = self.decodeFromBase64(base64Text2)
myCipher.n = int(decodedBase64N, 10)
elif typeOfFile == "Zip":
myCipher.zipPath = fileName
with zipfile.ZipFile(fileName, "r") as z:
z.extractall("Extracted_files")
elif typeOfFile == "Sign":
myCipher.fileToBeVerified = fileName
with open(fileName, "r") as f:
f.seek(13)
base64Text = f.readline()
decodedBase64 = self.decodeFromBase64(base64Text)
myCipher.toVerifyMessage = list(decodedBase64)
def is_img_big(path):
'''判断一副图像是否是大图 分界 <=200M'''
file_info = QFileInfo(path)
file_m_size = file_info.size() / 1024 / 1024
if file_m_size > 200: # 大于2G
return True
else:
return False
def start_search(self, query, search_directory):
self.keep_searching = True
print("search started..", query)
filters = QDir.Files
nameFilters = [
"*.cpp", "*.txt", "*.pdf", "*.doc", "*.docx", "*.xlsx", "*.xls",
"*.ppt", "*.pptx"
]
iterator = QDirIterator(search_directory, nameFilters, filters,
QDirIterator.Subdirectories)
while (iterator.hasNext()):
QApplication.processEvents()
if (self.keep_searching):
file_path = iterator.next()
if (os.access(file_path, os.R_OK)):
try:
file_info = QFileInfo(file_path)
file_contents = parser.from_file(file_path)
except:
continue
if (file_contents['status'] == 200
and 'content' in file_contents.keys()
and file_contents['content'] is not None):
found_index = file_contents['content'].find(query)
if (found_index != -1):
snippet = file_contents['content'].strip().replace(
'\n', ' ').replace('\r', '')
snippet_index = snippet.find(query)
qtw_item = QTreeWidgetItem()
qtw_item.setText(0, file_info.fileName())
qtw_item.setText(1, file_info.suffix())
qtw_item.setText(2, str(file_info.size() / 1024))
qtw_item.setText(
3,
file_info.lastModified().toString(
"MM/dd/yyyy"))
qtw_item.setText(
4,
file_info.created().toString("MM/dd/yyyy"))
qtw_item.setText(
5,
str(snippet)[snippet_index - 5:snippet_index +
10])
qtw_item.setText(6, file_path)
self.qtw_items.append(qtw_item)
self.match_found.emit(qtw_item)
self.finished.emit()
def convert_to_digital_str(self):
file_path = QFileDialog.getOpenFileName()[0]
if file_path != "":
username = self.username_label.text()
file_info = QFileInfo(file_path)
file_size = file_info.size()
file_type = Path(file_path).suffix
self.file_name_field.setText(file_path)
dynamo = DynamoModule()
self.item_id = dynamo.create_item(username, str(time.time()),
file_type, str(file_size))
digital_string = OCR.handwritten_to_string(file_path)
self.uploaded_text_field.setText(digital_string)
def ImageSelectedEvent(self, path):
def HumanSize(size, decimal_places):
for unit in ['', 'KB', 'MB', 'GB', 'TB']:
if size < 1024.0:
break
size /= 1024.0
return f"{size:.{decimal_places}f} {unit}"
finfo = QFileInfo(path)
self.imagePathBox.setText(finfo.absoluteFilePath())
self.imageFileSizeBox.setText(HumanSize(finfo.size(), 3))
date = finfo.lastModified().toString('yyyy-dd-MM hh:mm:ss')
self.imageModifyTimeBox.setText(date)
self.currentSelectPic = finfo
def complete(self) -> None:
info = QFileInfo(self.finalFilename)
mbox = QMessageBox(windowTitle='Success',
windowIcon=self.parent.windowIcon(),
minimumWidth=500,
iconPixmap=self.successIcon.pixmap(48, 49),
textFormat=Qt.RichText)
mbox.setText(
'''
<style>
table.info { margin:8px; padding:4px 15px; }
td.label { font-weight:bold; font-size:9pt; text-align:right; background-color:#444; color:#FFF; }
td.value { background-color:#FFF !important; font-size:10pt; }
</style>
<p>Your video was successfully created.</p>
<p align="center">
<table class="info" cellpadding="6" cellspacing="0">
<tr>
<td class="label"><b>Filename</b></td>
<td class="value" nowrap>%s</td>
</tr>
<tr>
<td class="label"><b>Size</b></td>
<td class="value">%s</td>
</tr>
<tr>
<td class="label"><b>Runtime</b></td>
<td class="value">%s</td>
</tr>
</table>
</p>
<p>How would you like to proceed?</p>''' %
(QDir.toNativeSeparators(
self.finalFilename), self.sizeof_fmt(int(info.size())),
self.deltaToQTime(self.totalRuntime).toString(self.timeformat)))
play = mbox.addButton('Play', QMessageBox.AcceptRole)
play.setIcon(self.completePlayIcon)
play.clicked.connect(self.openResult)
fileman = mbox.addButton('Open', QMessageBox.AcceptRole)
fileman.setIcon(self.completeOpenIcon)
fileman.clicked.connect(self.openFolder)
end = mbox.addButton('Exit', QMessageBox.AcceptRole)
end.setIcon(self.completeExitIcon)
end.clicked.connect(self.close)
new = mbox.addButton('Restart', QMessageBox.AcceptRole)
new.setIcon(self.completeRestartIcon)
new.clicked.connect(self.startNew)
mbox.setDefaultButton(new)
mbox.setEscapeButton(new)
mbox.exec_()
def get_path_datasize(path):
file_info = QFileInfo(path)
data_size = 0
if file_info.isDir():
data_size, files_count = get_directory_size(
file_info.absoluteFilePath())
# logger.info("path (folder) %s %u elements size now=%u (%s)",
# file_info.absoluteFilePath(), files_count, data_size, pretty_bytes(data_size))
else:
# logger.info("path (file) %s size=%u", file_info.path(), file_info.size())
data_size = file_info.size()
files_count = 1
return data_size, files_count
def complete(self) -> None:
info = QFileInfo(self.finalFilename)
mbox = QMessageBox(icon=self.thumbsupIcon,
windowTitle='VIDCUTTING COMPLETE',
minimumWidth=500,
textFormat=Qt.RichText)
mbox.setText(
'''
<style>
table.info { margin:6px; padding:4px 15px; }
td.label { font-weight:bold; font-size:10.5pt; text-align:right; }
td.value { font-size:10.5pt; }
</style>
<table class="info" cellpadding="4" cellspacing="0">
<tr>
<td class="label"><b>File:</b></td>
<td class="value" nowrap>%s</td>
</tr>
<tr>
<td class="label"><b>Size:</b></td>
<td class="value">%s</td>
</tr>
<tr>
<td class="label"><b>Length:</b></td>
<td class="value">%s</td>
</tr>
</table><br/>''' %
(QDir.toNativeSeparators(
self.finalFilename), self.sizeof_fmt(int(info.size())),
self.deltaToQTime(self.totalRuntime).toString(self.timeformat)))
play = mbox.addButton('Play', QMessageBox.AcceptRole)
play.setIcon(self.completePlayIcon)
play.clicked.connect(self.openResult)
fileman = mbox.addButton('Open', QMessageBox.AcceptRole)
fileman.setIcon(self.completeOpenIcon)
fileman.clicked.connect(self.openFolder)
end = mbox.addButton('Exit', QMessageBox.AcceptRole)
end.setIcon(self.completeExitIcon)
end.clicked.connect(self.close)
new = mbox.addButton('Restart', QMessageBox.AcceptRole)
new.setIcon(self.completeRestartIcon)
new.clicked.connect(self.parent.restart)
mbox.setDefaultButton(new)
mbox.setEscapeButton(new)
mbox.adjustSize()
mbox.exec_()
def actualizarImagen(self, event):
from PyQt5.QtCore import QByteArray, QFileInfo
from PyQt5.QtWidgets import QFileDialog, QMessageBox
fileName = QFileDialog.getOpenFileName(
self, "Abrir", filter="Images (*.png *.jpg)"
) # options=QtWidgets.QFileDialog.DontUseNativeDialog
if all(fileName):
info = QFileInfo(fileName[0])
if info.size() > 32000:
QMessageBox.warning(self, "¡Error!",
"No se permite archivos de mas de 32kb")
return
str_base64 = Logica.imageToByteArray(fileName[0])
if str_base64 is None:
QMessageBox.warning(self, "¡Error!",
"Fallo al cargar la imagen")
return
self.lblImagen.setPixmap(Logica.byteArrayToImage(str_base64))
self.dispositivo.image = str_base64
def on_created(self, event):
if event.event_type == 'created':
file_is_incomplete = True
last_file_size = -1
image_path = event.src_path
_LOGGER.debug(
f"File creation detected : {image_path}. Waiting until file is complete and readable ..."
)
while file_is_incomplete:
info = QFileInfo(image_path)
size = info.size()
_LOGGER.debug(f"File {image_path}'s size = {size}")
if size == last_file_size:
file_is_incomplete = False
_LOGGER.debug(f"File {image_path} is ready to be read")
last_file_size = size
time.sleep(_DEFAULT_SCAN_FILE_SIZE_RETRY_PERIOD_IN_SEC)
self.broadcast_image(read_disk_image(Path(image_path)))
def addFilesToExplorer(self,
fileName,
fileType,
scaler,
extensionTag,
isVideo=True):
if fileName:
info = QFileInfo(fileName)
if info.baseName() == self.importedVideo and isVideo:
QMessageBox.critical(self,
"Error",
"Video already exist",
buttons=QMessageBox.Ok)
elif info.baseName() == self.importedCSV and not isVideo:
QMessageBox.critical(self,
"Error",
"CSV file already exist",
buttons=QMessageBox.Ok)
else:
if (isVideo):
self.removeItemFromTable("video")
self.importedVideoPath = QUrl.fromLocalFile(fileName)
self.importedVideo = info.baseName()
cap = cv2.VideoCapture(r'{}'.format(
self.importedVideoPath.toString()))
fps = cap.get(cv2.CAP_PROP_FPS
) # OpenCV2 version 2 used "CV_CAP_PROP_FPS"
frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
self.durationChanged(int(frame_count / fps))
self.statusBar().showMessage('Status: Video/Image added')
else:
self.removeItemFromTable("csv")
self.importedCSVPath = info.absoluteFilePath()
self.readCSV(info.absoluteFilePath(), info.baseName())
self.statusBar().showMessage('Status: CSV File added')
size = str(info.size() / scaler) + extensionTag
last_modified = info.lastModified().toString()[4:10]
self.addItemToTable(
self.explorerView,
[info.baseName(), size, fileType, last_modified])
def set_data(self, _file):
ff = QFileInfo(_file)
self.short_title(ff.fileName())
self.ui.lsize.setText(naturalsize(ff.size(), format="%.1f "))
if ff.isDir():
self.ui.litems.show()
self.ui.label_3.show()
self.ui.litems.setText(str(len(glob(_file + "/*"))))
else:
self.ui.label_3.hide()
self.ui.litems.hide()
self.ui.lcreated.setText(ff.created().toString())
self.ui.lmodified.setText(ff.lastModified().toString())
self.ui.laccessed.setText(ff.lastRead().toString())
self.ui.luser.setText(ff.owner())
self.ui.luid.setText(str(ff.ownerId()))
self.ui.lgroup.setText(str(ff.group()))
self.ui.lgid.setText(str(ff.groupId()))
self.ui.lpath.setText(ff.path())
def updateDetails(self, path):
"""
Updates the elements in the right menu based on arguments
:param path: path of the file
:return: nothing
"""
info = QFileInfo(path)
bullet = html.unescape("•")
value: str = bullet + " File not saved!"
# Get the file info and update all the respective fields
if info is not None and path is not None:
value = ""
i_s = "<i>"
i_e = "</i>"
br = "<br>"
size = info.size()
units = ['Bytes', 'KB', 'MB', 'GB']
unit = 0
while len(str(round(size, 0))) > 3:
size /= 1000
unit += 1
value += bullet + " Name: " + i_s + info.fileName() + i_e + br
value += bullet + " Path: " + i_s + info.path() + i_e + br
value += bullet + " Size: " + i_s + str(size) + " " + units[unit] + i_e + br
value += bullet + " Owner: " + i_s + (str(info.owner())) + i_e + br
value += bullet + " Viewed: " + i_s + \
(info.lastRead().toString(self.format_time)) + i_e + br
value += bullet + " Modified: " + i_s + \
(info.lastModified().toString(self.format_time)) + i_e
self.col_metadata_contents.setText(value)
# Update the summary from file
self.updateSummary()
def on_btnInfo_size_clicked(self):
self.__showBtnInfo(self.sender())
fileInfo = QFileInfo(self.ui.editFile.text())
btCount = fileInfo.size() #字节数
text = "%d Bytes" % btCount
self.ui.textEdit.appendPlainText(text + "\n")
def get_filesize(self, path):
if path.startswith('file:///'):
path = path.strip('file:///')
file = QFileInfo(QFile(path))
self._filesize = file.size()
return self._filesize
