def update_directory_info():
global dict_photos
# Get list of all entries in directory and count files with supported file name extension
dir = QDir(window.edit_src_dir.text())
list_files = dir.entryInfoList()
# Clear data from previous runs
dict_photos = dict()
window.list_files.clear()
QApplication.processEvents()
QApplication.setOverrideCursor(Qt.WaitCursor)
# Actual scanning of selected directory
start = time.time()
for entry in list_files:
# lbl_current_file.setText("Current file: {0}".format(entry.absoluteFilePath()))
if entry.isFile():
# Processing and capture time extraction
print("Processing: {0}".format(entry.absoluteFilePath()))
md = pyexiv2.ImageMetadata(entry.absoluteFilePath())
try:
md.read()
capture_time = md['Exif.Photo.DateTimeOriginal'].value
print("Photo taken: {0}".format(capture_time))
dict_photos[entry.absoluteFilePath()] = capture_time
except:
print("Skipping file")
QApplication.setOverrideCursor(Qt.ArrowCursor)
print("\n\n")
end = time.time()
duration = end - start
print("Processing took {:2.4f}s".format(duration))
window.lbl_dir_info.setText("Directory contains {0} images".format(
len(dict_photos)))
print("Valid image files: {0}/{1}".format(len(dict_photos),
len(list_files)))
if len(dict_photos) > 0:
update_file_list()
def selectSystemTranslation(self, language, typemodule):
dirsystem = "systemnet" if typemodule == True else "system"
dirsyslan = QDir(self.mDir + QDir.separator() + dirsystem)
if dirsyslan.exists():
if QFileInfo(dirsyslan.path() + QDir.separator() + language +
".qm").exists():
translator = QTranslator(self)
translator.load(dirsyslan.path() + QDir.separator() + language)
self.mApp.installTranslator(translator)
else:
language = language.split('_')[0]
if len(language) == 2:
if QFileInfo(dirsyslan.path() + QDir.separator() +
language + ".qm").exists():
translator = QTranslator(self)
translator.load(dirsyslan.path() + QDir.separator() +
language)
self.mApp.installTranslator(translator)
def connectToDatabase(logger):
database = QSqlDatabase.database()
if not database.isValid():
database = QSqlDatabase.addDatabase('QSQLITE')
if not database.isValid():
logger.error('Cannot add database')
write_dir = QDir()
if not write_dir.mkpath('.'):
logger.error('Failed to create writable directory')
# Ensure that we have a writable location on all devices.
filename = '{}/chat-database.sqlite3'.format(write_dir.absolutePath())
# When using the SQLite driver, open() will create the SQLite database if it doesn't exist.
database.setDatabaseName(filename)
if not database.open():
logger.error('Cannot open database')
QFile.remove(filename)
def select_images(self):
# This takes one or more images for a single detector.
if self.ui.aps_imageseries.isChecked():
files = QDir(self.parent_dir).entryInfoList(QDir.Files)
selected_files = []
for file in files:
selected_files.append(file.absoluteFilePath())
else:
caption = HexrdConfig().images_dirtion = 'Select image file(s)'
selected_files, selected_filter = QFileDialog.getOpenFileNames(
self.ui, caption, dir=self.parent_dir)
if selected_files:
self.update_allowed = False
self.reset_data()
self.load_image_data(selected_files)
self.create_table()
self.setup_gui()
self.enable_read()
def connectToDatabase():
database = QSqlDatabase.database()
if not database.isValid():
database = QSqlDatabase.addDatabase("QSQLITE")
if not database.isValid():
logger.error("Cannot add database")
writeDir = QDir()
# writeDir = QStandardPaths.writableLocation(QStandardPaths.AppDataLocation)
if not writeDir.mkpath("."):
logger.error("Failed to create writable directory")
# Ensure that we have a writable location on all devices
fileName = writeDir.absolutePath() + "/chat-database.sqlite3"
database.setDatabaseName(fileName)
# open() will create the SQLite database if it doesn't exist
if not database.open():
logger.error("Cannot open database")
QFile.remove(fileName)
def actionCacheOnCompleted(self): #version 1.1 up thesamodule
boolAction = False
if self.actionCache_ == "deleteOnCompleted":
sysdir = QDir(self.mDir + QDir.separator() + _dirSystem)
DIR_QML_SYS = sysdir.path()
for the_file in os.listdir(DIR_QML_SYS):
file_path = os.path.join(DIR_QML_SYS, the_file)
try:
if os.path.isfile(file_path):
if ".qml" in file_path:
os.unlink(file_path)
elif os.path.isdir(file_path):
shutil.rmtree(file_path)
boolAction = True
except Exception as e:
boolAction = False
print(e)
else:
boolAction = True
return boolAction
def findFile(self, _filePath):
# 通过递归的方式，遍历所有动画文件
animationFilePath = QDir(_filePath)
animationFilePath.setFilter(QDir.Dirs | QDir.Files
| QDir.NoDotAndDotDot)
animationFilePath.setSorting(QDir.DirsFirst)
list = animationFilePath.entryInfoList()
if (len(list) < 1):
return
i = 0
# 采用递归算法
while (i < len(list)):
fileInfo = list[i]
bisDir = fileInfo.isDir()
if (bisDir):
self.findFile(fileInfo.filePath())
else:
self.AnimationFileList.append(fileInfo.filePath())
i += 1
def analysisList() -> list:
files = QDir(HistoryManager.appDirectory()).entryList(
["*.json"], QDir.Files | QDir.Readable)
analysis = {}
for f in files:
f = f.rstrip(".json")
name, date_str = "@".join(f.split("@")[:-1]), f.split("@")[-1]
date = QDateTime.fromString(date_str, HistoryManager.DATE_FORMAT)
analysis[date] = {
"name": name,
"file": f,
"date": date.toString("dd/MM/yyyy")
}
names = []
for k in sorted(analysis.keys(), reverse=True):
names.append(analysis[k])
return names
def selectCoreTranslation(self, language, settings):
settings.setValue("translate", "en")
dircorelan = QDir(self.mDir + QDir.separator() + "corelocale")
if dircorelan.exists():
if QFileInfo(dircorelan.path() + QDir.separator() + language +
".qm").exists():
settings.setValue("translate", language)
translator = QTranslator(self)
translator.load(dircorelan.path() + QDir.separator() +
language)
self.mApp.installTranslator(translator)
else:
language = language.split('_')[0]
if len(language) == 2:
if QFileInfo(dircorelan.path() + QDir.separator() +
language + ".qm").exists():
settings.setValue("translate", language)
translator = QTranslator(self)
translator.load(dircorelan.path() + QDir.separator() +
language)
self.mApp.installTranslator(translator)
def openFile(self):
dir = QDir()
docsPath = '{}/Documents'.format(dir.homePath())
if not dir.exists(docsPath):
docsPath = '{}/Documentos'.format(dir.homePath())
#Regresa una tupla (filename, filter)
filename = QFileDialog.getOpenFileName(self, 'Abrir', docsPath,
self.fileFilter)
if not filename: return
self.filename = filename[0]
file = QFile(self.filename)
if not file.open(QIODevice.ReadOnly): return
data = file.readAll()
file.close()
self.textContent.clear()
self.textContent.setText(str(data, encoding='utf-8'))
self.setWindowTitle('{} - {}'.format(self.windowTitle(),
self.filename))
def __init__(self, parent=None):
super(Loader, self).__init__(parent=parent)
self.ui = Ui_Loader()
self.ui.setupUi(self)
self.dir = QDir(QDir.currentPath() + '/programs/')
self.dir.setFilter(QDir.Files or QDir.NoDotAndDotDot)
self.fs_watcher = QFileSystemWatcher(self.dir.path())
self.fs_watcher.addPath(self.dir.path())
self.fs_watcher.directoryChanged.connect(self.update_program_list)
self.send_status = QProgressDialog
self.sender = Sender
self.serialpropertiesvalues = \
{
'baudrate': Serial.BAUDRATES,
'parity': Serial.PARITIES,
'databits': Serial.BYTESIZES,
'stopbits': Serial.STOPBITS,
'flowcontrol': ['NoControl', 'SoftwareControl', 'HardwareControl']
}
self.update_program_list()
self.update_serial_port_list()
# self.set_serial_port_options()
self.ui.updateProgramListButton.clicked.connect(self.refresh)
self.ui.programListWidget.itemSelectionChanged.connect(
self.selection_changed)
self.ui.sendButton.clicked.connect(self.send_program)
self.ui.serialPortChooser.currentTextChanged.connect(
self.selection_changed)
self.ui.serialPortChooser.currentTextChanged.connect(save_port)
# self.ui.baudRateInput.textChanged.connect(save_baud)
# self.ui.parityChooser.currentTextChanged.connect(save_parity)
# self.ui.dataBitsChooser.currentTextChanged.connect(save_databits)
# self.ui.stopBitsChooser.currentTextChanged.connect(save_stopbits)
# self.ui.flowControlChooser.currentTextChanged.connect(save_flowcontrol)
self.thread_pool = QThreadPool()
def __init__(self) -> None:
"""
Create elements of View and Controller
:return None:
"""
# initialize logging for app
self.log_output = OutputWindow()
self.settings = QSettings("Red Scientific", "Companion")
self.settings.beginGroup("logging")
if not self.settings.contains("loglevel"):
self.settings.setValue("loglevel", "DEBUG")
logginglevel = eval('logging.' + self.settings.value('loglevel'))
self.settings.endGroup()
logging.basicConfig(
filename=self.__setup_log_output_file("companion_app_log.txt"),
filemode='w',
level=logginglevel,
format='%(levelname)s - %(name)s - %(funcName)s: %(message)s')
self.logger = logging.getLogger(__name__)
self.formatter = logging.Formatter(
'%(levelname)s - %(name)s - %(funcName)s: %(message)s')
self.ch = logging.StreamHandler(self.log_output)
self.ch.setLevel(logginglevel)
self.ch.setFormatter(self.formatter)
self.logger.addHandler(self.ch)
self.logger.info("RS Companion app version: " + current_version_str)
self.logger.debug("Initializing")
# set up ui
ui_min_size = QSize(950, 740)
dock_size = QSize(850, 160)
button_box_size = QSize(205, 120)
info_box_size = QSize(230, 120)
flag_box_size = QSize(80, 120)
note_box_size = QSize(250, 120)
tab_box_width_range = (350, 320)
self.ui = CompanionWindow(ui_min_size, self.ch)
self.menu_bar = MenuBar(self.ui, self.ch)
self.control_dock = ControlDock(self.ui, dock_size, self.ch)
self.button_box = ButtonBox(self.control_dock, button_box_size,
self.ch)
self.info_box = InfoBox(self.control_dock, info_box_size, self.ch)
self.flag_box = FlagBox(self.control_dock, flag_box_size, self.ch)
self.note_box = NoteBox(self.control_dock, note_box_size, self.ch)
self.graph_box = DisplayContainer(self.ui, self.__refresh_all_graphs,
self.ch)
self.tab_box = TabContainer(self.ui, tab_box_width_range, self.ch)
self.file_dialog = QFileDialog(self.ui)
self.dev_con_manager = RSDeviceConnectionManager(self.ch)
self.__setup_managers()
self.settings.endGroup()
# Initialize storage and state
self.__controller_classes = dict()
self.__controller_inits = dict()
self.__graph_inits = dict()
self.__populate_func_dicts()
self.__graphs = dict()
self.__exp_created = False
self.__exp_running = False
self.__num_drts = 0
self.__num_vogs = 0
self.__current_cond_name = ""
self.__device_controllers = dict()
self.__save_file_name = ""
self.__save_dir = QDir().homePath()
self.__device_spacers = dict()
self.__devices_to_add = dict()
# Assemble View objects
self.__initialize_view()
self.__init_controller_classes()
self.logger.debug("Initialized")
class MainWidget(QWidget):
# Home do usuário.
home = QDir().home().path()
def __init__(self):
super().__init__()
# Título da janela.
self.setWindowTitle('PySide2 QFileDialog().')
# Ícone da janela principal
icon = QIcon()
icon.addPixmap(QPixmap('../../../images/icons/icon.png'))
self.setWindowIcon(icon)
# Tamanho inicial da janela.
screen_size = app.desktop().geometry()
# screen_size = app.primaryScreen().geometry()
width = screen_size.width()
height = screen_size.height()
self.resize(width / 2, height / 2)
# Tamanho mínimo da janela.
self.setMinimumSize(width / 2, height / 2)
# Tamanho maximo da janela.
self.setMaximumSize(width - 200, height - 200)
# Widgets.
vbox = QVBoxLayout()
self.setLayout(vbox)
self.label = QLabel('Clique em um dos botões')
self.label.setAutoFillBackground(True)
self.label.setAlignment(Qt.AlignCenter)
vbox.addWidget(self.label)
btn_open_file = QPushButton('Selecionar arquivo')
btn_open_file.clicked.connect(self.open_file_dialog)
vbox.addWidget(btn_open_file)
btn_open_files = QPushButton('Selecionar arquivos')
btn_open_files.clicked.connect(self.open_files_dialog)
vbox.addWidget(btn_open_files)
btn_open_dir = QPushButton('Selecionar um diretório')
btn_open_dir.clicked.connect(self.open_dir_dialog)
vbox.addWidget(btn_open_dir)
btn_save_file = QPushButton('Salvar um arquivo')
btn_save_file.clicked.connect(self.open_save_dialog)
vbox.addWidget(btn_save_file)
def open_file_dialog(self):
file = QFileDialog().getOpenFileName(
parent=self,
caption='Selecione um arquivo',
dir=str(self.home),
filter=('PNG (*.png);;JPG (*.jpg, *.jpeg);;'
'TXT (*.txt);;Todos (*.*)'),
)
if file[0]:
self.label.setText(
f'<b>Arquivo selecionado</b>: {file[0]}<br>'
f'<b>Filtro utilizado</b>: {file[1]}', )
def open_files_dialog(self):
files = QFileDialog().getOpenFileNames(
parent=self,
caption='Selecione os arquivos',
dir=str(self.home),
filter=('PNG (*.png);;JPG (*.jpg, *.jpeg);;'
'TXT (*.txt);;Todos (*.*)'),
)
if files[0]:
text = '<b>Arquivos selecionados</b>:<br>'
for file in files[0]:
text += f'- {file}<br>'
text += f'<b>Filtro utilizado</b>: {files[1]}'
self.label.setText(text)
def open_dir_dialog(self):
path = QFileDialog().getExistingDirectory(
parent=self,
caption='Selecione um diretório',
dir=str(self.home),
)
if path:
self.label.setText(f'<b>Diretório selecionado</b>: {path}')
def open_save_dialog(self):
file = QFileDialog().getSaveFileName(
parent=self,
caption='Salvar arquivo',
dir=str(self.home),
filter='.png;;.txt;;.jpg;;',
)
if file[0]:
if file[0].endswith(file[1]):
text = f'<b>Arquivo salvo em</b>: {file[0]}<br>'
else:
text = f'<b>Arquivo salvo em</b>: {file[0]}{file[1]}<br>'
text += f'<b>Filtro utilizado</b>: {file[1]}'
self.label.setText(text)
def InstallApk(self, Name = "", ListoptionADB = ""):#Locate APK in ressources dir
DossierProject = QDir(self.PathProject)
DossierProject.cd('Ressource')
PathAPK = DossierProject.absoluteFilePath(Name)
print(self.CallADB("install "+ListoptionADB+" "+PathAPK))
class OperatorFile(QWidget):
_tr = QCoreApplication.translate
dir = QDir()
def __init__(self, parent=None):
super().__init__(parent)
def saveGraphData(self, graphData=None, filename=None):
curPath = self.dir.currentPath()
title = self._tr("OperatorFile", "保存文件")
filt = self._tr("OperatorFile", "*.xlsx;;*.graph")
file_full = QFileInfo(filename + '.xlsx')
if not file_full.exists():
fileName, flt = QFileDialog.getSaveFileName(
self, title, curPath, filt)
else:
fileName = file_full.fileName()
flt = file_full.suffix()
if fileName == "":
return
if flt.find('xlsx') >= 0:
fileName = self.saveExcel(fileName, graphData)
elif flt.find('graph') >= 0:
self.saveGraph()
return fileName
def openGraphData(self):
curPath = self.dir.currentPath()
title = self._tr("OperatorFile", "打开文件")
filt = self._tr("OperatorFile", "*.xlsx;;*.graph")
fileName, flt = QFileDialog.getOpenFileName(self, title, curPath, filt)
if fileName == "":
return
if flt.find('xlsx') >= 0:
return self.openExcel(fileName)
elif flt.find('graph') >= 0:
self.saveGraph()
return False
def outputData(self, graph):
curPath = self.dir.currentPath()
nodeColumns = ['顶点ID', '权重']
edgeColumns = ['边ID', '始点', '终点', '权重']
title = self._tr("OperatorFile", "导出图数据")
filt = self._tr("OperatorFile", "*.xlsx")
fileName, flt = QFileDialog.getSaveFileName(self, title, curPath, filt)
if fileName == "":
return
file_full = QFileInfo(fileName)
if file_full.exists():
title = self._tr("OperatorFile", '警告')
info = self._tr("OperatorFile", '文件即将被覆盖')
result = QMessageBox.question(self, title, info,
QMessageBox.Yes | QMessageBox.Cancel)
else:
result = QMessageBox.Yes
if result == QMessageBox.Yes:
graphName = file_full.baseName()
nodeName = "V" + f'({graphName})'
edgeName = "E" + f'({graphName})'
dataDict = ["图名称", "顶点集", "边集", "图类型"]
graphList = [graphName, nodeName, edgeName, graph[0]]
graphFrame = DataFrame(graphList, index=dataDict)
graphFrame = graphFrame.T
nodeFrame = DataFrame(graph[1], columns=nodeColumns)
edgeFrame = DataFrame(graph[2], columns=edgeColumns)
try:
with ExcelWriter(fileName) as writer:
graphFrame.to_excel(writer,
sheet_name=graphName,
index=None)
nodeFrame.to_excel(writer, sheet_name=nodeName, index=None)
edgeFrame.to_excel(writer, sheet_name=edgeName, index=None)
writer.save()
writer.close()
except Exception as e:
text = self._tr("OperatorFile", '权限不足')
QMessageBox.warning(self, text, str(e))
return False
elif result == QMessageBox.Cancel:
return
return True
def inputData(self):
curPath = self.dir.currentPath()
title = self._tr("OperatorFile", "打开文件")
filt = self._tr("OperatorFile", "*.xlsx")
fileName, flt = QFileDialog.getOpenFileName(self, title, curPath, filt)
if fileName == "":
return
graphData = ExcelFile(fileName)
sheetNames = graphData.sheet_names
graphFrame = read_excel(fileName, sheetNames[0])
nodeFrame = read_excel(fileName, sheetNames[1])
edgeFrame = read_excel(fileName, sheetNames[2])
mode = int(graphFrame.iloc[0, 3])
graphName = str(graphFrame.iloc[0, 0])
nodeDataList = []
edgeDataList = []
for i in range(nodeFrame.shape[0]):
data = []
for j in range(nodeFrame.shape[1]):
if not isnan(nodeFrame.iloc[i, j]):
data.append(int(nodeFrame.iloc[i, j]))
else:
QMessageBox.warning(
self,
QCoreApplication.translate("OperatorFile", "警告！"),
QCoreApplication.translate("OperatorFile",
"对不起，您的数据有误，系统无法识别！"))
return None
if len(data) >= 2:
nodeDataList.append(data)
else:
QMessageBox.warning(
self, QCoreApplication.translate("OperatorFile", "警告！"),
QCoreApplication.translate(
"OperatorFile", "顶点ID和权重为必须信息，您的信息不完整，请补充信息后，再次尝试。"))
return None
for i in range(edgeFrame.shape[0]):
data = []
for j in range(edgeFrame.shape[1]):
if not isnan(edgeFrame.iloc[i, j]):
data.append(int(edgeFrame.iloc[i, j]))
if len(data) >= 2:
edgeDataList.append(data)
return [graphName, mode, nodeDataList, edgeDataList]
def saveExcel(self, fileName, graph: list):
nodeColumns = ['顶点ID', '权重', 'x坐标', 'y坐标']
edgeColumns = [
'边ID', '始点', '终点', '权重', '1点x坐标', '1点y坐标', '2点x坐标', '2点y坐标',
'3点x坐标', '3点y坐标', '4点x坐标', '4点y坐标', '中心点x坐标', '中心点y坐标'
]
textColumns = ['文本ID', '文本内容', 'x坐标', 'y坐标']
file_full = QFileInfo(fileName)
graphName = file_full.baseName()
nodeName = "V" + f'({graphName})'
edgeName = "E" + f'({graphName})'
textName = "T" + f'({graphName})'
dataDict = ["图名称", "顶点集", "边集", "文本集", "图类型"]
graphList = [graphName, nodeName, edgeName, textName, graph[0]]
graphFrame = DataFrame(graphList, index=dataDict)
graphFrame = graphFrame.T
nodeFrame = DataFrame(graph[1], columns=nodeColumns)
edgeFrame = DataFrame(graph[2], columns=edgeColumns)
textFrame = DataFrame(graph[3], columns=textColumns)
try:
with ExcelWriter(fileName) as writer:
graphFrame.to_excel(writer, sheet_name=graphName, index=None)
nodeFrame.to_excel(writer, sheet_name=nodeName, index=None)
edgeFrame.to_excel(writer, sheet_name=edgeName, index=None)
textFrame.to_excel(writer, sheet_name=textName, index=None)
writer.save()
writer.close()
except Exception as e:
text = self._tr("OperatorFile", '权限不足')
QMessageBox.warning(self, text, str(e))
return
return file_full
def saveExcelAs(self, graph: list):
curPath = self.dir.currentPath()
title = self._tr("OperatorFile", "保存文件")
filt = self._tr("OperatorFile", "*.xlsx;;*.graph")
fileName, flt = QFileDialog.getSaveFileName(
self,
title,
curPath,
filt,
options=QFileDialog.DontConfirmOverwrite)
if fileName == "":
return
file_full = QFileInfo(fileName)
while file_full.exists():
fileName = f'{file_full.baseName()}_副本.xlsx'
file_full = QFileInfo(fileName)
nodeColumns = ['顶点ID', '权重', 'x坐标', 'y坐标']
edgeColumns = [
'边ID', '始点', '终点', '权重', '1点x坐标', '1点y坐标', '2点x坐标', '2点y坐标',
'3点x坐标', '3点y坐标', '4点x坐标', '4点y坐标', '中心点x坐标', '中心点y坐标'
]
textColumns = ['文本ID', '文本内容', 'x坐标', 'y坐标']
graphName = file_full.baseName()
nodeName = "V" + f'({graphName})'
edgeName = "E" + f'({graphName})'
textName = "T" + f'({graphName})'
dataDict = ["图名称", "顶点集", "边集", "文本集", "图类型"]
graphList = [graphName, nodeName, edgeName, textName, graph[0]]
graphFrame = DataFrame(graphList, index=dataDict)
graphFrame = graphFrame.T
nodeFrame = DataFrame(graph[1], columns=nodeColumns)
edgeFrame = DataFrame(graph[2], columns=edgeColumns)
textFrame = DataFrame(graph[3], columns=textColumns)
try:
with ExcelWriter(fileName) as writer:
graphFrame.to_excel(writer, sheet_name=graphName, index=None)
nodeFrame.to_excel(writer, sheet_name=nodeName, index=None)
edgeFrame.to_excel(writer, sheet_name=edgeName, index=None)
textFrame.to_excel(writer, sheet_name=textName, index=None)
writer.save()
writer.close()
except Exception as e:
text = self._tr("OperatorFile", '权限不足')
QMessageBox.warning(self, text, str(e))
return
return file_full
# def saveGraph(self):
#
# return True
def openExcel(self, fileName):
graphData = ExcelFile(fileName)
sheetNames = graphData.sheet_names
graphFrame = read_excel(fileName, sheetNames[0])
nodeFrame = read_excel(fileName, sheetNames[1])
edgeFrame = read_excel(fileName, sheetNames[2])
textFrame = read_excel(fileName, sheetNames[3])
mode = int(graphFrame.iloc[0, 4])
graphName = str(graphFrame.iloc[0, 0])
nodeDataList = []
edgeDataList = []
textDataList = []
for i in range(nodeFrame.shape[0]):
data = []
for j in range(nodeFrame.shape[1]):
if not isnan(nodeFrame.iloc[i, j]):
data.append(int(nodeFrame.iloc[i, j]))
else:
QMessageBox.warning(
self,
QCoreApplication.translate("OperatorFile", "警告！"),
QCoreApplication.translate("OperatorFile",
"对不起，您的数据有误，系统无法识别！"))
return None
if len(data) >= 2:
nodeDataList.append(data)
for i in range(edgeFrame.shape[0]):
data = []
for j in range(edgeFrame.shape[1]):
if not isnan(edgeFrame.iloc[i, j]):
data.append(int(edgeFrame.iloc[i, j]))
if len(data) >= 2:
edgeDataList.append(data)
for i in range(textFrame.shape[0]):
data = []
for j in range(textFrame.shape[1]):
if type(textFrame.iloc[i, j]) is not str:
data.append(int(textFrame.iloc[i, j]))
else:
data.append(textFrame.iloc[i, j])
if len(data) >= 2:
textDataList.append(data)
return [graphName, mode, nodeDataList, edgeDataList, textDataList]
def setUp(self):
self.original = QDir("./")
if __name__ == "__main__":
logger.info("Application started")
import sys
from src.controllers.maincontroller import MainController
app = QApplication(sys.argv)
qss = "qt_design/stylesheet.qss"
with open(qss, "r") as fh:
app.setStyleSheet(fh.read())
app.setApplicationName("CSCreator")
data_location = QStandardPaths.writableLocation(
QStandardPaths.AppDataLocation)
data_dir = QDir(data_location)
if not data_dir.exists():
data_dir.mkpath(data_location)
if not data_dir.exists("importers"):
data_dir.mkdir("importers")
if os.environ.get("DEBUG") is not None:
copytree("src/data/importers", os.path.join(data_location,
"importers"))
main_controller = MainController()
main_view = main_controller.get_window()
main_view.show()
sys.exit(app.exec_())
class MainWidget(QWidget):
# Home do usuário.
home = QDir().home().path()
def __init__(self):
super(MainWidget, self).__init__()
# Caminho até o arquivo de interface.
# path = QDir(__file__).currentPath()
# ui_file = QDir(path).filePath('MainWindow.ui')
ui_file = QDir(QDir(__file__).currentPath()).filePath('MainWindow.ui')
self.ui = QUiLoader().load(ui_file, None)
# Widgets.
self.label = self.ui.findChild(QObject, 'label')
btn_open_file = self.ui.findChild(QObject, 'btn_open_file')
btn_open_file.clicked.connect(self.open_file_dialog)
btn_open_files = self.ui.findChild(QObject, 'btn_open_files')
btn_open_files.clicked.connect(self.open_files_dialog)
btn_open_dir = self.ui.findChild(QObject, 'btn_open_dir')
btn_open_dir.clicked.connect(self.open_dir_dialog)
btn_save_file = self.ui.findChild(QObject, 'btn_save_file')
btn_save_file.clicked.connect(self.open_save_dialog)
self.ui.show()
def open_file_dialog(self):
file = QFileDialog().getOpenFileName(
parent=self,
caption='Selecione um arquivo',
dir=str(self.home),
filter=('PNG (*.png);;JPG (*.jpg, *.jpeg);;'
'TXT (*.txt);;Todos (*.*)'),
)
if file[0]:
self.label.setText(
f'<b>Arquivo selecionado</b>: {file[0]}<br>'
f'<b>Filtro utilizado</b>: {file[1]}', )
def open_files_dialog(self):
files = QFileDialog().getOpenFileNames(
parent=self,
caption='Selecione os arquivos',
dir=str(self.home),
filter=('PNG (*.png);;JPG (*.jpg, *.jpeg);;'
'TXT (*.txt);;Todos (*.*)'),
)
if files[0]:
text = '<b>Arquivos selecionados</b>:<br>'
for file in files[0]:
text += f'- {file}<br>'
text += f'<b>Filtro utilizado</b>: {files[1]}'
self.label.setText(text)
def open_dir_dialog(self):
path = QFileDialog().getExistingDirectory(
parent=self,
caption='Selecione um diretório',
dir=str(self.home),
)
if path:
self.label.setText(f'<b>Diretório selecionado</b>: {path}')
def open_save_dialog(self):
file = QFileDialog().getSaveFileName(
parent=self,
caption='Salvar arquivo',
dir=str(self.home),
filter='.png;;.txt;;.jpg;;',
)
if file[0]:
if file[0].endswith(file[1]):
text = f'<b>Arquivo salvo em</b>: {file[0]}<br>'
else:
text = f'<b>Arquivo salvo em</b>: {file[0]}{file[1]}<br>'
text += f'<b>Filtro utilizado</b>: {file[1]}'
self.label.setText(text)
def isComplete(self):
"""Conditions to unlock next button"""
return (True if (QDir(self.project_path_edit.text()).exists()
and self.project_path_edit.text()
and self.project_name_edit.text()) else False)
def hasAnalysis() -> bool:
files = QDir(HistoryManager.appDirectory()).entryList(
["*.json"], QDir.Files | QDir.Readable)
return len(files) > 0
def on_error(self, err: QNetworkReply.NetworkError):
"""This method is called by self.reply.error signal
Args:
err (QNetworkReply.NetworkError)
"""
self.reply.deleteLater()
def human_readable_bytes(self, num, suffix="B"):
for unit in ["", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"]:
if abs(num) < 1024.0:
return "%3.1f%s%s" % (num, unit, suffix)
num /= 1024.0
return "%.1f%s%s" % (num, "Yi", suffix)
if __name__ == "__main__":
app = QApplication(sys.argv)
dialog = DownloadDialog()
dialog.set_source(
QUrl(
"http://hgdownload.cse.ucsc.edu/goldenPath/hg19/bigZips/mrna.fa.gz"
))
dialog.set_destination(QDir("/tmp/"))
dialog.start()
dialog.show()
app.exec_()
def find_csv_file(self):
fname = QFileDialog.getOpenFileName(
self, 'Open file',
QDir().home().path() + '/Downloads', "CSV (*.csv)")
self.pathText.setText(fname[0])
def rechargeNet(self, preferences, username):
#version 1.1 up thesamodule
data = self.m_qjsonnetwork.callDirect(
"version internal", "model.thesamodule.config.search_read",
[[], 0, 1, [], ["internal_version"], preferences])
if not data["data"] == "error":
self.internal_version = data["data"]["result"][0][
"internal_version"]
if float(self.internal_version) > 1.0:
data = self.m_qjsonnetwork.callDirect(
"cachedel", "model.thesamodule.config.search_read",
[[], 0, 1, [], ["deletecache"], preferences])
if not data["data"] == "error":
if data["data"]["result"][0]["deletecache"] == True:
self.actionCache_ = "deleteOnCompleted"
else:
self.actionCache_ = "notDelete"
sysdir = QDir(self.mDir + QDir.separator() + _dirSystem)
DIR_QML_SYS = sysdir.path()
DIR_QML_SYS_LOST = DIR_QML_SYS + QDir.separator() + "lost"
sysdirlost = QDir(DIR_QML_SYS_LOST)
#revisar folder systemnet
if sysdir.exists() == False:
s = QDir(self.mDir)
s.mkdir(_dirSystem)
#revisar folder systemnet lost
if sysdirlost.exists() == False:
sl = QDir(DIR_QML_SYS)
sl.mkdir("lost")
#find all files en folder net
listSysFiles = os.listdir(DIR_QML_SYS)
if "lost" in listSysFiles:
listSysFiles.remove("lost")
#
data = {}
data["data"] = "error"
if float(self.internal_version) > 1.1:
data = self.m_qjsonnetwork.callDirect(
"findforuser", "model.thesamodule.usersfolder.search_read", [[
"AND", ["users.user.name", "=", username],
["activefolder", "=", True]
], 0, 1, [], ["qmlfiles"], preferences])
if not data["data"] == "error":
result = data["data"]["result"]
if len(result) > 0:
idfiles = result[0]["qmlfiles"]
data = self.m_qjsonnetwork.callDirect(
"rechargeNetStep1",
"model.thesamodule.thesamodule.read",
[idfiles, [
"checksum",
"filename",
], preferences])
if len(idfiles) == 0:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 15, {"noqmlfiles": ""})
else: #buscar default
data = self.m_qjsonnetwork.callDirect(
"findforuser",
"model.thesamodule.usersfolder.search_read", [[
"AND", ["type", "=", "default"],
["activefolder", "=", True]
], 0, 1, [], ["qmlfiles"], preferences])
if not data["data"] == "error":
result = data["data"]["result"]
if len(result) > 0:
idfiles = result[0]["qmlfiles"]
data = self.m_qjsonnetwork.callDirect(
"rechargeNetStep1",
"model.thesamodule.thesamodule.read", [
idfiles, [
"checksum",
"filename",
], preferences
])
if len(idfiles) == 0:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 15, {"noqmlfiles": ""})
else:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 12, {"noqmlfiles": ""})
else:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 13, {"error": ""})
else:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 13, {"error": ""})
else:
data = self.m_qjsonnetwork.callDirect(
"rechargeNetStep1",
"model.thesamodule.thesamodule.search_read",
[[], 0, 1000, [], ["checksum", "filename"], preferences])
if not data["data"] == "error":
resultnet = data["data"]["result"]
mapnet = {}
mapids = {}
listNetFiles = []
for file in resultnet:
mapnet[file["filename"]] = file["checksum"]
mapids[file["filename"]] = file["id"]
listNetFiles.append(file["filename"])
#buscar faltantes en system y los updates
#buscar los que ya no deben estar
mapsysnet = {}
listToUpdate = set() #new or update
listToErase = []
for file in listSysFiles:
try:
with open(DIR_QML_SYS + QDir.separator() + file,
"rb") as binary_file:
data = binary_file.read()
chek = hashlib.md5(data).hexdigest()
mapsysnet[file] = chek
except:
listToUpdate.add(file)
for file in listNetFiles:
if file in listSysFiles:
if mapnet[file] != mapsysnet[file]:
listToUpdate.add(file) # update
else:
listToUpdate.add(file) # new
for file in listSysFiles:
if not file in listNetFiles:
listToErase.append(file) # erase
listToUpdate = list(listToUpdate)
ids = []
for file in listToUpdate:
ids.append(mapids[file])
data = self.m_qjsonnetwork.callDirect(
"rechargeNetStep2", "model.thesamodule.thesamodule.read",
[ids, [
"filebinary",
"filename",
], preferences])
errors = []
if not data["data"] == "error":
resultnet = data["data"]["result"]
for file in resultnet:
filename = DIR_QML_SYS + QDir.separator(
) + file["filename"]
qfile = QFile(filename)
if qfile.open(QIODevice.WriteOnly) == False:
errors.append(filename)
print("error", filename, qfile.errorString())
else:
print("update", file["filename"])
bafile = QByteArray.fromBase64(
file["filebinary"]["base64"].encode())
qfile.write(bafile)
qfile.close()
if len(errors) > 0:
self.m_qjsonnetwork.signalResponse.emit(
"systemnet", 33, {"error": errors})
return False
#erase
for file in listToErase:
print("moviendo", file)
shutil.move(DIR_QML_SYS + QDir.separator() + file,
DIR_QML_SYS_LOST + QDir.separator() + file)
return True
else:
#erase all files, no conexion con thesa module
for file in listSysFiles:
print("moviendo", file)
shutil.move(DIR_QML_SYS + QDir.separator() + file,
DIR_QML_SYS_LOST + QDir.separator() + file)
self.m_qjsonnetwork.signalResponse.emit("systemnet", 34,
{"error": ""})
return False
def action_record_stop_button(self):
# check if the session name & video path file fields are filled
if not self.session_name.text() or not self.video_file_path.text():
self.error_dialog(
'Please inform both the Session Name and the Video/Audio Path!'
)
return
# check if the directory exists
if not QDir(self.video_file_path.text()).exists():
self.error_dialog('The directory {} does not exist!'.format(
self.video_file_path.text()))
return
# check if the directory is writable
if not os.access(self.video_file_path.text(), os.W_OK):
self.error_dialog('The directory {} is not writable!'.format(
self.video_file_path.text()))
return
if self.recording:
# it is already recording
# we will stop the session
self.recording_label.setPixmap(cfg.ASSETS_IMAGES_FOLDER +
'gray_rec.png')
self.record_stop_button.setText('Record session')
# enable fields
self.session_name.setEnabled(True)
self.video_file_path.setEnabled(True)
self.list_cameras.setEnabled(True)
self.list_audio_devices.setEnabled(True)
self.list_backing_tracks.setEnabled(True)
self.volume_slider.setEnabled(True)
# stop session
self.record_session.stop()
# restart camera
self.wait_for_video_process()
else:
# it is not yet recording
# we will start the session
# on MacOs it is possible to keep showing the camera
# on GUI while it is recording the SAME camera.
# Unfortunately, it is not possible neither on Linux
# nor on Windows. This is the reason why we are
# stopping the camera here and restarting it
# after the recording is finished
self.camera.stop()
self.recording_label.setPixmap(cfg.ASSETS_IMAGES_FOLDER +
'red_rec.png')
self.record_stop_button.setText('Recording… Press here to stop')
# disable fields
self.session_name.setEnabled(False)
self.video_file_path.setEnabled(False)
self.list_cameras.setEnabled(False)
self.list_audio_devices.setEnabled(False)
self.list_backing_tracks.setEnabled(False)
self.volume_slider.setEnabled(False)
# start session
if self.backing_track_player.state(
) == QMediaPlayer.State.PlayingState:
self.backing_track_player.stop()
self.record_session.start_recording(
self.session_name.text(), self.video_file_path.text(),
self.list_cameras.currentData().description(),
self.list_audio_devices.currentData(),
self.list_backing_tracks.currentText(),
int(self.volume_slider.value()))
self.recording = not self.recording
def organize_files():
separator = window.cmb_separator.currentText()
target_dir = QDir(window.edit_target_dir.text())
list_target_dirs = target_dir.entryList()
progress = progress_window()
progress.set_max(window.list_files.count())
for index in range(window.list_files.count()):
progress.set_value(index)
#
# STEP 1: Create target directory if necessary
#
# Get folder name for file
fn_src = window.list_files.item(index).text()
progress.set_text("Processing \"{0}\"".format(fn_src))
md = pyexiv2.ImageMetadata(fn_src)
image_ts = datetime.date
try:
md.read()
image_ts = md['Exif.Photo.DateTimeOriginal'].value
except:
print("Cannot open file \"{0}\"".format(fn_src))
continue
# Makes sure the day and month are always two digits
def correct_format(number):
if number < 10:
return "0" + str(number)
else:
return str(number)
folder_name_trg = str(image_ts.year) + separator + correct_format(
image_ts.month) + separator + correct_format(image_ts.day)
dir_name_trg = target_dir.absolutePath() + QDir.separator(
) + folder_name_trg
# Create folder for day if necessary
target_folder = QDir(dir_name_trg)
if not target_folder.exists():
QDir.mkdir(target_dir, dir_name_trg)
print("Created directory \"{0}\"".format(dir_name_trg))
#
# STEP 2: Move file
#
# absolute file name of the new file
fn_trg_abs = dir_name_trg + QDir.separator() + fn_src.split(
QDir.separator())[-1]
file_trg = QFile(fn_trg_abs)
# Don't overwrite existing files
if file_trg.exists():
print("Skipping file \"{0}\"".format(file_trg.fileName()))
continue
QFile.copy(fn_src, fn_trg_abs)
print("Copied file from \"{0}\" to \"{1}\"".format(fn_src, fn_trg_abs))
print("Finished!")
