class App(QWidget):
def __init__(self):
super().__init__()
self.title = 'Intrusion Detection System'
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.button = QPushButton('Send command', self)
self.button.move(1400, 950)
self.button.resize(300, 50)
self.button.clicked.connect(self.on_click)
self.tabs = QTabWidget(self)
self.tab_real_time = QWidget()
self.tab_ip_host = QWidget()
self.tabs.resize(1600, 890)
self.tabs.addTab(self.tab_real_time, "Real time")
self.tabs.addTab(self.tab_ip_host, "Hosts")
self.tabs.move(300, 30)
self.tab_real_time.layout = QVBoxLayout(self)
self.messedge_box = QTextEdit(self)
self.tab_real_time.layout.addWidget(self.messedge_box)
self.tab_real_time.setLayout(self.tab_real_time.layout)
self.showMaximized()
def add_text_real_time(self, messedge_text):
self.messedge_box.append(messedge_text)
@pyqtSlot()
def on_click(self):
sys.exit(app.exec_())
def Create_Tabs(self, collection, xposition, yposition, xresize, yresize,
cssline, parentwindow):
tabs = QTabWidget(parentwindow)
tabs.resize(xresize, yresize)
for i in range(0, len(collection)):
tabs.addTab(collection[i].get_widget(),
collection[i].get_widget_text())
tabs.move(xposition, yposition)
tabs.setStyleSheet(cssline)
return tabs
class MyTableWidget(QWidget):
def __init__(self, parent):
super().__init__(parent)
# Initialize tab screen
self.label = QLabel(self)
self.label.setText("Нет событий")
self.tabs = QTabWidget(self)
self.tab1 = FirstTab(self)
self.tab2 = SecondTab(self)
self.tabs.resize(300, 200)
self.tabs.move(0, 20)
# Add tabs
self.tabs.addTab(self.tab1, "Tab 1")
self.tabs.addTab(self.tab2, "Tab 2")
def infoFromTab(self, info):
self.label.setText(info)
self.label.adjustSize()
def setupUI(self):
button = QPushButton('import text file', self)
button.move(0, MARGIN)
button.clicked.connect(lambda: self.openFile())
self.linesLabel = self.initLabel("Lines: 0",
button.pos().x() + MARGIN,
button.pos().y() + MARGIN * 2,
button.width(), button.height())
self.wordsLabel = self.initLabel("Words: 0",
button.pos().x() + MARGIN,
button.pos().y() + MARGIN * 3,
button.width(), button.height())
self.sentencesLabel = self.initLabel("Sentences: 0",
button.pos().x() + MARGIN,
button.pos().y() + MARGIN * 4,
button.width(), button.height())
self.textBox = QTextEdit(self)
self.textBox.setAlignment(QtCore.Qt.AlignTop)
self.textBox.resize(self.width() - button.width() * 3.8,
self.height() - MARGIN * 2)
self.textBox.move(button.width() + MARGIN * 1.5, MARGIN)
self.textBox.setReadOnly(True)
tabView = QTabWidget(self)
tabView.move(self.textBox.pos().x() + self.textBox.width() + MARGIN,
MARGIN)
tableSizeX = self.width() - self.textBox.width() - button.width(
) - MARGIN * 3
tableSizeY = self.height() - MARGIN * 6
charTab, self.charTable = self.createTabWithTable(
"Characters Frequancy Table:", ["Character", "Occurrences"],
tableSizeX, tableSizeY)
wordTab, self.wordTable = self.createTabWithTable(
"Words Frequancy Table:", ["Word", "Occurrences"], tableSizeX,
tableSizeY)
tabView.addTab(charTab, "Characters")
tabView.addTab(wordTab, "Words")
tabView.resize(tableSizeX, tableSizeY + MARGIN * 4)
def createSection(self, name, attrs, tabname, parent): if (name == "tabs"): p = QTabWidget(parent) elif isinstance(parent, QTabWidget): p = QFrame() parent.addTab(p, tabname) self.contentPanels.append(p) p.setAutoFillBackground(True) else: p = QFrame(parent) self.contentPanels.append(p) p.setVisible(self.defaultsSection.getWithDefault(attrs, "visible") == "yes") p.setAutoFillBackground(True) p.move(int(self.defaultsSection.getWithDefault(attrs, "left")), int(self.defaultsSection.getWithDefault(attrs, "top"))) p.resize(int(self.defaultsSection.getWithDefault(attrs, "width")), int(self.defaultsSection.getWithDefault(attrs, "height"))) p.Tag = tabname setControlColors(p, bg=self.defaultsSection.getWithDefault(attrs, "bgcolor")) return p
class instanceWindow(QDialog):
widgets = []
repoWidgets = []
cacheTabWidgets = []
installModpack = utils.installModpack()
getModpackFS = utils.getModpackFS()
getModpackURL = utils.getModpackURL()
getModpackRepo = utils.getModpackRepo()
# Same drill. Does background things.
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowModality(Qt.ApplicationModal)
self.progressWin = installWindow(self)
self.getModpackRepo.result.connect(self.updateRepo)
optionWindow.launcherConfig = utils.loadSettings(self)
screen_resolution = app.desktop().screenGeometry()
self.title = config.NAME + " " + config.VER + " Instance Manager"
self.setWindowIcon(QIcon(config.ICON))
self.left = screen_resolution.width() / 2 - 290
self.top = screen_resolution.height() / 2 - 170
self.initUI()
self.getModpackRepo.start()
# Same drill. Does showy things.
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, 580, 340)
self.setFixedSize(self.size())
self.createTabs()
self.createButtons()
self.createStatus()
self.createInput()
self.show()
def updateRepo(self, result, modpacks):
for widget in self.repoWidgets:
try:
widget.deleteLater()
except:
pass
self.repoWidgets = []
if result == True:
for key, modpack in modpacks["modpacks"].items():
vbox = QVBoxLayout()
group = QGroupBox(modpack["name"] + " version " + modpack["modpackver"])
widget = QPushButton(self, text="Install " + modpack["name"] + " version " + modpack["modpackver"] + ".")
widget1 = QTextEdit(self)
widget2 = QPushButton(self, text="View on pymcl.net")
widget1.setText(modpack["smalldesc"])
widget1.setReadOnly(True)
widget.clicked.connect(functools.partial(self.getModpackURLWrapper, modpack["zipurl"]))
widget2.clicked.connect(functools.partial(utils.openModpackInBrowser, key))
vbox.addWidget(widget)
vbox.addWidget(widget1)
vbox.addWidget(widget2)
group.setLayout(vbox)
self.modpackRepoLayout.addWidget(group)
self.repoWidgets.append(widget)
self.repoWidgets.append(widget1)
self.repoWidgets.append(widget2)
self.repoWidgets.append(group)
# I sorta figured this out. Still hella bad. Will be sorted sometime in the future.
def createTabs(self):
for widget in self.widgets:
try:
widget.deleteLater()
except:
pass
self.widgets = []
self.tab = QTabWidget(self)
self.tab.move(1, 0)
self.tab.resize(self.size())
self.tab.resize(self.tab.width(), self.tab.height()-20)
self.removeInstanceContainer = QVBoxLayout(self)
self.cacheTabContainer = QVBoxLayout(self)
self.modpackRepoContainer = QVBoxLayout(self)
self.addInstanceTab = QWidget()
self.removeInstanceTab = QWidget()
self.cacheTab = QWidget()
self.modpackRepoTab = QWidget()
self.tab.addTab(self.addInstanceTab, "Create an Instance")
self.tab.addTab(self.modpackRepoTab, "Modpack Repo")
self.tab.addTab(self.removeInstanceTab, "Delete Instances")
self.tab.addTab(self.cacheTab, "Manage Cached Modpacks")
self.removeInstanceTab.setLayout(self.removeInstanceContainer)
self.cacheTab.setLayout(self.cacheTabContainer)
self.modpackRepoTab.setLayout(self.modpackRepoContainer)
scroll = QScrollArea(self)
self.removeInstanceContainer.addWidget(scroll)
scroll.setWidgetResizable(True)
scroll.resize(scroll.width(), scroll.height()-20)
scrollContent = QWidget(scroll)
self.removeInstanceLayout = QVBoxLayout(scrollContent)
scrollContent.setLayout(self.removeInstanceLayout)
scroll.setWidget(scrollContent)
scroll = QScrollArea(self)
self.cacheTabContainer.addWidget(scroll)
scroll.setWidgetResizable(True)
scrollContent = QWidget(scroll)
self.cacheTabLayout = QVBoxLayout(scrollContent)
scrollContent.setLayout(self.cacheTabLayout)
scroll.setWidget(scrollContent)
scroll = QScrollArea(self)
self.modpackRepoContainer.addWidget(scroll)
scroll.setWidgetResizable(True)
scrollContent = QWidget(scroll)
self.modpackRepoLayout = QVBoxLayout(scrollContent)
scrollContent.setLayout(self.modpackRepoLayout)
scroll.setWidget(scrollContent)
self.refreshButton = QPushButton(self.modpackRepoTab)
self.refreshButton.move(8, 8)
self.refreshButton.resize(20, 20)
icon = QIcon(utils.resourcePath("refresh.png"))
self.refreshButton.setIcon(icon)
self.refreshButton.clicked.connect(self.getModpackRepo.start)
self.updateInstanceList()
self.updateCacheList()
def updateInstanceList(self):
utils.areYouThere(config.MC_DIR + "/instances")
for widget in self.widgets:
widget.deleteLater()
self.widgets = []
instances = [f for f in os.listdir(config.MC_DIR + "/instances") if not os.path.isfile(config.MC_DIR + "/instances/" + f)]
for instance in instances:
widget = QPushButton(self, text="Delete " + instance + ".")
widget.clicked.connect(functools.partial(utils.rmInstance, instance, self))
self.removeInstanceLayout.addWidget(widget)
self.widgets.append(widget)
def updateCacheList(self):
utils.areYouThere(config.MC_DIR + "/modpackzips")
modpacks = [f for f in os.listdir(config.MC_DIR + "/modpackzips") if os.path.isfile(config.MC_DIR + "/modpackzips/" + f)]
for widget in self.cacheTabWidgets:
try:
widget.deleteLater()
except:
pass
self.repoWidgets = []
for modpack in modpacks:
vbox = QVBoxLayout()
group = QGroupBox(modpack)
widget = QPushButton(self, text="Install " + modpack + ".")
widget1 = QPushButton(self, text="Delete " + modpack + ".")
widget2 = QTextEdit(self)
widget2.setText("A generic ZIP modpack.")
widget2.setReadOnly(True)
widget.clicked.connect(functools.partial(self.installModpackWrapper, config.MC_DIR + "/modpackzips/" + modpack))
widget1.clicked.connect(functools.partial(self.removeModpack, config.MC_DIR + "/modpackzips/" + modpack, modpack))
vbox.addWidget(widget)
vbox.addWidget(widget1)
vbox.addWidget(widget2)
group.setLayout(vbox)
self.cacheTabLayout.addWidget(group)
self.cacheTabWidgets.append(widget)
self.cacheTabWidgets.append(widget1)
self.cacheTabWidgets.append(widget2)
self.cacheTabWidgets.append(group)
def createButtons(self):
# Local filesystem crap
self.installModpackButton = QPushButton("Install Local Modpack", self.addInstanceTab)
self.installModpackButton.resize(150, 22)
self.installModpackButton.move(5, 5)
self.installModpackButton.clicked.connect(lambda: self.getModpackFSWrapper(self.modpackZipDir.text()))
self.getDirButton = QPushButton("...", self.addInstanceTab)
self.getDirButton.resize(24, 22)
self.getDirButton.move(545, 5)
self.getDirButton.clicked.connect(self.getDir)
self.openDirButton = QPushButton("Open " + config.NAME + " Install Dir", self.addInstanceTab)
self.openDirButton.resize(150, 22)
self.openDirButton.move(5, self.height()-70)
self.openDirButton.clicked.connect(self.openDir)
# Url crap
self.installModpackUrlButton = QPushButton("Install Modpack from URL", self.addInstanceTab)
self.installModpackUrlButton.resize(150, 22)
self.installModpackUrlButton.move(5, 34)
self.installModpackUrlButton.clicked.connect(lambda: self.getModpackURLWrapper(self.modpackURL.text()))
self.instanceVersionButton = QPushButton(self.addInstanceTab, text="Create Blank Instance")
self.instanceVersionButton.resize(150, 22)
self.instanceVersionButton.move(5, 63)
self.instanceVersionButton.clicked.connect(lambda: self.installModpackWrapper(self.instanceName.text(), True, self.instanceVersion.currentText()))
def createStatus(self):
self.status = QLabel(self)
self.status.resize(self.width(), 20)
self.status.move(0, self.height()-20)
self.updateStatus()
def createInput(self):
self.modpackZipDir = QLineEdit(self.addInstanceTab)
self.modpackZipDir.setPlaceholderText("Paste the path to your modpack ZIP file here!")
self.modpackZipDir.resize(390, 22)
self.modpackZipDir.move(155, 5)
self.modpackURL = QLineEdit(self.addInstanceTab)
self.modpackURL.setPlaceholderText("Paste the URL to download your modpack ZIP from here!")
self.modpackURL.resize(390, 22)
self.modpackURL.move(155, 34)
self.instanceName = QLineEdit(self.addInstanceTab)
self.instanceName.setPlaceholderText("Instance name")
self.instanceName.resize(194, 22)
self.instanceName.move(155, 63)
self.instanceVersion = QComboBox(self.addInstanceTab)
self.instanceVersion.addItems(utils.getMCVersions().keys())
self.instanceVersion.resize(194, 22)
self.instanceVersion.move(351, 63)
def progressWinWrapper(self):
if self.progressWin.iWantToDie == True:
self.progressWin.iWantToDie = False
self.progressWin.exec_()
def modpackInstallDone(self):
self.progressWin.iWantToDie = True
self.progressWin.close()
self.updateInstanceList()
def installModpackWrapper(self, modpackName, isVanilla=False, mcVer=""):
self.installModpack.stop()
self.installModpack = utils.installModpack(modpackName, isVanilla, mcVer)
self.installModpack.done.connect(self.modpackInstallDone)
self.installModpack.starting.connect(self.progressWinWrapper)
self.installModpack.updateIStatus.connect(self.updateIStatus)
self.installModpack.updateStatus.connect(self.updateStatus)
self.installModpack.start()
def getModpackURLWrapper(self, modpackURL):
self.getModpackURL.stop()
self.getModpackURL = utils.getModpackURL(modpackURL)
self.getModpackURL.starting.connect(self.progressWinWrapper)
self.getModpackURL.installModpack.connect(self.installModpackWrapper)
self.getModpackURL.updateIStatus.connect(self.updateIStatus)
self.getModpackURL.start()
def getModpackFSWrapper(self, modpackDir):
self.getModpackFS.stop()
self.getModpackFS = utils.getModpackFS(modpackDir)
self.getModpackFS.starting.connect(self.progressWinWrapper)
self.getModpackFS.installModpack.connect(self.installModpackWrapper)
self.getModpackFS.start()
def removeModpack(self, dir, name="this"):
result = QMessageBox.question(self, "Are you sure?", "Are you sure you want to delete " + name + "?", QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if result == QMessageBox.Yes:
os.unlink(dir)
self.updateCacheList()
@staticmethod
def openDir():
if platform.system() == "Windows":
os.startfile(config.MC_DIR)
elif platform.system() == "Darwin":
subprocess.Popen(["open", config.MC_DIR])
else:
subprocess.Popen(["xdg-open", config.MC_DIR])
def getDir(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Select a Modpack ZIP File", os.path.expanduser("~"), "Modpack ZIP Archive (*.zip)")
if fileName:
self.modpackZipDir.setText(fileName)
# Cause we need an error box thingy without too much copypasta.
def error(self, err):
QMessageBox.warning(self, "Warning", err, QMessageBox.Ok, QMessageBox.Ok)
def updateStatus(self, text="", color="black", bgcolor="lightgrey"):
self.status.setText(text)
self.status.setStyleSheet("color: " + color + "; background-color: " + bgcolor + ";")
def updateIStatus(self, text):
utils.logger.info(text)
try:
if text.startswith("[") and self.progressWin.status.toPlainText().split("\n")[len(self.progressWin.status.toPlainText().split("\n"))-2].startswith("["):
newtext = self.progressWin.status.toPlainText().split("\n")
newtext = "\n".join(newtext[:len(newtext)-2])
newtext = newtext + "\n" + text + "\n"
else:
newtext = self.progressWin.status.toPlainText() + text + "\n"
self.progressWin.status.setText(newtext)
self.progressWin.status.verticalScrollBar().setValue(self.progressWin.status.verticalScrollBar().maximum())
except:
pass
# Fires when the instance select window closes.
def closeEvent(self, event, *args, **kwargs):
global mainWin
# Wouldnt want to try and launch a non-existant instance now, do we?
if not os.path.exists(config.MC_DIR + "/instances/" + mainWin.currentInstance):
try:
mainWin.currentInstance = os.listdir(config.MC_DIR + "/instances")[1]
except:
mainWin.currentInstance = ""
mainWin.createDropdowns()
mainWin.setInstance(mainWin.currentInstance)
class optionWindow(QDialog):
widgets = []
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowModality(Qt.ApplicationModal)
screen_resolution = app.desktop().screenGeometry()
self.title = config.NAME + " " + config.VER + " Instance Configuration"
self.setWindowIcon(QIcon(config.ICON))
self.left = screen_resolution.width() / 2 - 290
self.top = screen_resolution.height() / 2 - 170
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, 580, 340)
self.setFixedSize(self.size())
self.createTabs()
self.createInstallTab()
self.createConfigTab()
self.createModsTab()
self.createSavesTab()
def createTabs(self):
for widget in self.widgets:
try:
widget.deleteLater()
except:
pass
self.widgets = []
self.tab = QTabWidget(self)
self.tab.move(1, 0)
self.tab.resize(self.size())
self.tab.resize(self.tab.width(), self.tab.height()-20)
self.modsContainer = QVBoxLayout(self)
self.savesContainer = QVBoxLayout(self)
self.installTab = QWidget()
self.savesTab = QWidget()
self.configTab = QWidget()
self.modsTab = QWidget()
self.tab.addTab(self.configTab, "Config")
self.tab.addTab(self.modsTab, "Mods")
self.tab.addTab(self.savesTab, "Saves")
self.tab.addTab(self.installTab, "Install")
self.modsTab.setLayout(self.modsContainer)
self.savesTab.setLayout(self.savesContainer)
scroll = QScrollArea(self)
self.modsContainer.addWidget(scroll)
scroll.setWidgetResizable(True)
scrollContent = QWidget(scroll)
self.modsLayout = QVBoxLayout(scrollContent)
scrollContent.setLayout(self.modsLayout)
scroll.setWidget(scrollContent)
scroll = QScrollArea(self)
self.savesContainer.addWidget(scroll)
scroll.setWidgetResizable(True)
scrollContent = QWidget(scroll)
self.savesLayout = QVBoxLayout(scrollContent)
scrollContent.setLayout(self.savesLayout)
scroll.setWidget(scrollContent)
def createInstallTab(self):
self.installModButton = QPushButton("Add Local Mod to Jar", self.installTab)
self.installModButton.resize(150, 22)
self.installModButton.move(5, 5)
self.installModButton.clicked.connect(lambda: utils.addToJar(mainWin.currentInstance, self.modZipDir.text()))
self.modZipDir = QLineEdit(self.installTab)
self.modZipDir.setPlaceholderText("Paste the path to your mod ZIP file here!")
self.modZipDir.resize(390, 22)
self.modZipDir.move(155, 5)
self.getDirButton = QPushButton("...", self.installTab)
self.getDirButton.resize(24, 22)
self.getDirButton.move(545, 5)
self.getDirButton.clicked.connect(self.getDir)
def createSavesTab(self):
messageLabel = QLabel("Save management comming soon(tm)!", self.savesTab)
messageLabel.move(185, 120)
messageLabel.resize(255, messageLabel.height())
def createModsTab(self):
messageLabel = QLabel("Mod management comming soon(tm)!", self.modsTab)
messageLabel.move(185, 120)
messageLabel.resize(255, messageLabel.height())
# Same drill. Creates things.
def createConfigTab(self):
global launcherConfig
# Inputs
self.javaArgs = QLineEdit(self.configTab, text=mainWin.instanceConfig["javaargs"])
self.javaArgs.resize(310, 24)
self.javaArgs.move(150, 20)
self.maxRamAllocation = QLineEdit(self.configTab, text=mainWin.instanceConfig["maxram"])
self.maxRamAllocation.resize(100, 24)
self.maxRamAllocation.move(205, 48)
self.minRamAllocation = QLineEdit(self.configTab, text=mainWin.instanceConfig["minram"])
self.minRamAllocation.resize(100, 24)
self.minRamAllocation.move(360, 48)
self.enableAutoProxySkin = QCheckBox(self.configTab)
self.enableAutoProxySkin.setChecked(mainWin.instanceConfig["proxyskin"])
self.enableAutoProxySkin.move(150, 81)
self.enableAutoProxySound = QCheckBox(self.configTab)
self.enableAutoProxySound.setChecked(mainWin.instanceConfig["proxysound"])
self.enableAutoProxySound.move(150, 109)
self.enableAutoProxyCape = QCheckBox(self.configTab)
self.enableAutoProxyCape.setChecked(mainWin.instanceConfig["proxycape"])
self.enableAutoProxyCape.move(150, 137)
self.javaLoc = QLineEdit(self.configTab, text=mainWin.instanceConfig["javaargs"])
self.javaLoc.resize(310, 24)
self.javaLoc.move(150, 160)
try:
mainWin.instanceConfig["javaloc"]
except:
mainWin.instanceConfig["javaloc"] = ""
self.javaLoc = QLineEdit(self.configTab, text=mainWin.instanceConfig["javaloc"])
self.javaLoc.resize(310, 24)
self.javaLoc.move(150, 160)
self.getJavDirButton = QPushButton("...", self.configTab)
self.getJavDirButton.resize(24, 22)
self.getJavDirButton.move(465, 160)
self.getJavDirButton.clicked.connect(self.getJavDir)
# Labelz
self.javaArgsLabel = QLabel(self.configTab, text="Java arguments:")
self.javaArgsLabel.resize(100, 20)
self.javaArgsLabel.move(20, 22)
self.ramAllocationLabel = QLabel(self.configTab, text="RAM Allocation:")
self.ramAllocationLabel.resize(100, 20)
self.ramAllocationLabel.move(20, 50)
self.maxRamAllocationLabel = QLabel(self.configTab, text="Maximum:")
self.maxRamAllocationLabel.move(150, 50)
self.maxRamAllocationLabel.resize(100, 20)
self.minRamAllocationLabel = QLabel(self.configTab, text="Minimum:")
self.minRamAllocationLabel.move(310, 50)
self.minRamAllocationLabel.resize(100, 20)
self.enableAutoProxySkinLabel = QLabel(self.configTab, text="Enable skin proxy:")
self.enableAutoProxySkinLabel.resize(100, 20)
self.enableAutoProxySkinLabel.move(20, 76)
self.enableAutoProxySoundLabel = QLabel(self.configTab, text="Enable sound proxy:")
self.enableAutoProxySoundLabel.resize(100, 20)
self.enableAutoProxySoundLabel.move(20, 104)
self.enableAutoProxyCapeLabel = QLabel(self.configTab, text="Enable cape proxy:")
self.enableAutoProxyCapeLabel.resize(100, 20)
self.enableAutoProxyCapeLabel.move(20, 132)
self.enableAutoProxySkinLabel2 = QLabel(self.configTab, text="(Breaks sounds if skinfix is installed!)")
self.enableAutoProxySkinLabel2.resize(250, 20)
self.enableAutoProxySkinLabel2.move(170, 76)
self.enableAutoProxySoundLabel2 = QLabel(self.configTab, text="(Backup your resources folder if using custom sounds!)")
self.enableAutoProxySoundLabel2.resize(300, 20)
self.enableAutoProxySoundLabel2.move(170, 104)
self.enableAutoProxyCapeLabel2 = QLabel(self.configTab, text="(Breaks sounds if skinfix is installed!)")
self.enableAutoProxyCapeLabel2.resize(250, 20)
self.enableAutoProxyCapeLabel2.move(170, 132)
self.javaArgsLabel = QLabel(self.configTab, text="Java location:")
self.javaArgsLabel.resize(100, 20)
self.javaArgsLabel.move(20, 160)
def getDir(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Select a Mod ZIP File", os.path.expanduser("~"), "Mod Archive (*.zip;*.jar)")
if fileName:
self.modZipDir.setText(fileName)
def getJavDir(self):
fileName, _ = QFileDialog.getOpenFileName(self, "Select a JRE", os.path.expanduser("~"), "JRE (*)")
if fileName:
self.javaLoc.setText(fileName)
# Fires when options window is closed.
def closeEvent(self, event, *args, **kwargs):
# Saves config to file.
mainWin.instanceConfig["javaargs"] = self.javaArgs.text()
mainWin.instanceConfig["minram"] = self.minRamAllocation.text()
mainWin.instanceConfig["maxram"] = self.maxRamAllocation.text()
mainWin.instanceConfig["proxyskin"] = self.enableAutoProxySkin.isChecked()
mainWin.instanceConfig["proxysound"] = self.enableAutoProxySound.isChecked()
mainWin.instanceConfig["proxycape"] = self.enableAutoProxyCape.isChecked()
mainWin.instanceConfig["javaloc"] = self.javaLoc.text()
utils.saveInstanceSettings(mainWin.instanceConfig, mainWin.currentInstance)
class MainGui(QWidget):
"""
The gui
"""
def __init__(self):
super().__init__()
self.thread = ServerThread(app)
self.thread.start()
self.initUi()
def initUi(self):
"""Initializes the ui"""
self.command_text_edit = QLineEdit()
self.response_text_edit = QLineEdit()
insert_button = QPushButton("Insert")
insert_button.clicked.connect(self.on_click)
form_layout = QFormLayout()
form_layout.addRow(QLabel("Regex trigger"), self.command_text_edit)
form_layout.addRow(QLabel("Response"), self.response_text_edit)
form_layout.addRow(QLabel("Add to database"), insert_button)
form_group_box = QGroupBox("Add a new bot trigger")
form_group_box.setLayout(form_layout)
self.trigger_table = None
self.create_table()
self.delete_table_button = QPushButton("Delete Row")
self.delete_table_button.clicked.connect(self.delete_table)
self.info_label = QLabel("")
self.token_info = QLabel("")
self.slack_token = QLineEdit()
self.bot_token = QLineEdit()
self.token_insert = QPushButton("Insert")
self.token_insert.clicked.connect(self.insert_tokens)
self.token_items_layout = QFormLayout()
self.token_items_layout.addRow(QLabel("OAuth access token"),
self.slack_token)
self.token_items_layout.addRow(QLabel("Bot user OAuth access token"),
self.bot_token)
self.token_items_layout.addRow(QLabel("Add to database"),
self.token_insert)
self.token_group = QGroupBox("Add OAuth tokens")
self.token_group.setLayout(self.token_items_layout)
self.token_layout = QVBoxLayout()
self.token_layout.addWidget(self.token_group)
self.token_layout.addWidget(self.token_info)
self.token_tab = QWidget()
self.token_tab.setLayout(self.token_layout)
self.tabs = QTabWidget()
self.triggers_layout = QVBoxLayout()
self.triggers_layout.addWidget(form_group_box)
self.triggers_layout.addWidget(self.info_label)
self.triggers_tab = QWidget()
self.triggers_tab.setLayout(self.triggers_layout)
self.list_layout = QVBoxLayout(self)
self.list_layout.addWidget(self.trigger_table)
self.list_layout.addWidget(self.delete_table_button)
self.list_tab = QWidget()
self.list_tab.setLayout(self.list_layout)
self.tabs.addTab(self.token_tab, "Set OAuth tokens")
self.tabs.addTab(self.triggers_tab, "Set bot triggers")
self.tabs.addTab(self.list_tab, "List bot triggers")
self.tabs.move(0, 0)
vbox = QVBoxLayout()
vbox.addWidget(self.tabs)
self.setLayout(vbox)
self.setGeometry(0, 0, 500, 800)
self.setWindowTitle('Slack Bot')
self.show()
@QtCore.pyqtSlot()
def create_table(self):
"""
Creates a table and fetches all rows from the database
"""
trigger_table = QTableWidget()
trigger_table.setColumnCount(2)
trigger_table.setRowCount(
len(database.fetch_all_command_pairs().items()))
for y_index, row in enumerate(
database.fetch_all_command_pairs().items()):
for x_index in range(0, 2):
trigger_table.setItem(y_index, x_index,
QTableWidgetItem(row[x_index]))
trigger_table.setHorizontalHeaderLabels(["Regex Trigger", "Response"])
self.trigger_table = trigger_table
@QtCore.pyqtSlot()
def delete_table(self):
"""Deletes a currently selected row from the database"""
current_row = self.trigger_table.currentRow()
current_item = self.trigger_table.item(current_row, 0).text()
database.delete_command(current_item)
self.update_table()
@QtCore.pyqtSlot()
def update_table(self):
"""Updates all the items in the table"""
y_index = self.trigger_table.columnCount()
x_index = self.trigger_table.rowCount()
self.trigger_table.setColumnCount(2)
self.trigger_table.setRowCount(
len(database.fetch_all_command_pairs().items()))
for y_index, row in enumerate(
database.fetch_all_command_pairs().items()):
for x_index in range(0, 2):
self.trigger_table.setItem(y_index, x_index,
QTableWidgetItem(row[x_index]))
self.trigger_table.setHorizontalHeaderLabels(
["Regex Trigger", "Response"])
@QtCore.pyqtSlot()
def on_click(self):
"""Adds command and response to the database"""
command_text = self.command_text_edit.text()
response_text = self.response_text_edit.text()
print("{} -> {}".format(command_text, response_text))
if database.insert_command(command_text, response_text):
self.info_label.setText(
"Added trigger {} to database".format(command_text))
else:
self.info_label.setText(
"That trigger already exists in the database")
self.command_text_edit.clear()
self.response_text_edit.clear()
self.update_table()
@QtCore.pyqtSlot()
def insert_tokens(self):
"""Adds tokens to the database"""
slack_token = self.slack_token.text()
bot_token = self.bot_token.text()
print("{}\n{}".format(slack_token, bot_token))
database.insert_token(slack_token, bot_token)
self.slack_token.clear()
self.bot_token.clear()
self.token_info.clear()
self.token_info.setText("Added token to the database")
class Atlas(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
#On startup, check whether variable databases exist. If not, build databases.
#Check Variable Database
if os.path.exists("./Variables/Variables.sqlite3") == False:
#Create Variables Database
conn = sqlite3.connect("./Variables/Variables.sqlite3")
c = conn.cursor()
#Create Antibiotics Table
c.execute(
"CREATE TABLE Antibiotics(id INTEGER PRIMARY KEY, name TEXT)")
ant = "Carbenicillin"
c.execute("INSERT INTO Antibiotics(name) VALUES (?)", (ant, ))
ant = "Kanamycin"
c.execute("INSERT INTO Antibiotics(name) VALUES (?)", (ant, ))
ant = "Chloramphenicol"
c.execute("INSERT INTO Antibiotics(name) VALUES (?)", (ant, ))
# Create Plasmids Table
c.execute(
"CREATE TABLE Plasmids(id INTEGER PRIMARY KEY, name TEXT)")
# Create Primers Table
c.execute(
"CREATE TABLE Primers(id INTEGER PRIMARY KEY, name TEXT)")
conn.commit()
conn.close()
#Insert Menu Bar
self.openFile = QAction('&Open', self)
self.openFile.setShortcut('Ctrl+O')
self.openFile.setStatusTip('Open new File')
self.openFile.triggered.connect(self.showDialog)
menubar = self.menuBar()
self.fileMenu = menubar.addMenu('&File')
self.fileMenu.addAction(self.openFile)
#Center Window
self.resize(1200, 600)
qtRectangle = self.frameGeometry()
centerPoint = QDesktopWidget().availableGeometry().center()
qtRectangle.moveCenter(centerPoint)
self.move(qtRectangle.topLeft())
self.setWindowTitle('ATLAS')
#Insert Status Bar
self.statusBar().showMessage('Ready')
self.show()
#Experiment Selection Frame
self.ExpFrame = QFrame(self)
self.ExpFrame.move(5, 25)
self.ExpFrame.resize(450, 200)
self.ExpFrame.setFrameShape(QFrame.StyledPanel)
self.ExpFrame.show()
#Experiment Frame Label
self.ExpLabel = QLabel(self.ExpFrame)
self.ExpLabel.setText("Experiment Tables")
self.ExpLabel.move(5, 1)
newfont = QFont("Times", 8, QFont.Bold)
self.ExpLabel.setFont(newfont)
self.ExpLabel.show()
#Experiment Table Generation Button
self.ExpButton = QPushButton(self.ExpFrame)
self.ExpButton.resize(120, 30)
self.ExpButton.move(320, 20)
self.ExpButton.setText("Generate")
self.ExpButton.clicked.connect(self.GenExpList)
self.ExpButton.show()
#Experiment Check Buttons
self.ExpCheck1 = QCheckBox(self.ExpFrame)
self.ExpCheck1.move(15, 30)
self.ExpCheck1.setText("Include Complete Experiments")
self.ExpCheck1.show()
#Experiment Table
self.ExpTable = QTableView(self.ExpFrame)
self.ExpTable.move(10, 60)
self.ExpTable.resize(430, 130)
self.ExpTableModel = QStandardItemModel(self)
self.ExpTable.setModel(self.ExpTableModel)
self.ExpTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
row = []
cell = QStandardItem("#")
row.append(cell)
cell = QStandardItem("Name")
row.append(cell)
self.ExpTable.horizontalHeader().hide()
self.ExpTable.verticalHeader().hide()
self.ExpTableModel.appendRow(row)
self.ExpTable.horizontalHeader().setStretchLastSection(True)
self.ExpTable.setColumnWidth(0, 12)
self.ExpTable.resizeRowsToContents()
self.ExpTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.ExpTable.show()
#Modification Frame
self.ModFrame = QFrame(self)
self.ModFrame.move(5, 230)
self.ModFrame.resize(450, 350)
self.ModFrame.setFrameShape(QFrame.StyledPanel)
self.ModFrame.show()
#Modification Label
self.ModLabel = QLabel(self.ModFrame)
self.ModLabel.setText("Section Viewer")
self.ModLabel.move(5, 1)
newfont = QFont("Times", 8, QFont.Bold)
self.ModLabel.setFont(newfont)
self.ModLabel.show()
#Modification Table
self.ModTable = QTableView(self.ModFrame)
self.ModTable.move(10, 20)
self.ModTable.resize(430, 320)
self.ModTableModel = QStandardItemModel(self)
self.ModTable.setModel(self.ModTableModel)
self.ModTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
row = []
cell = QStandardItem("Date")
row.append(cell)
cell = QStandardItem("Name")
row.append(cell)
self.ModTable.horizontalHeader().hide()
self.ModTable.verticalHeader().hide()
self.ModTableModel.appendRow(row)
self.ModTable.horizontalHeader().setStretchLastSection(True)
self.ModTable.setColumnWidth(0, 80)
self.ModTable.resizeRowsToContents()
self.ModTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.ModTable.clicked.connect(self.openExp)
self.ModTable.show()
#Detailed Tabs
self.DetTabs = QTabWidget(self)
self.DetTab1 = QWidget(self)
self.DetTab1.setAutoFillBackground(True)
self.DetTab2 = QWidget(self)
self.DetTab2.setAutoFillBackground(True)
self.DetTab3 = QWidget(self)
self.DetTab3.setAutoFillBackground(True)
self.DetTabs.move(460, 25)
self.DetTabs.resize(735, 556)
self.DetTabs.addTab(self.DetTab1, "DetTab1")
self.DetTabs.addTab(self.DetTab2, "DetTab2")
self.DetTabs.addTab(self.DetTab3, "New Protocol")
self.DetTabs.show()
self.DetTabs.currentChanged.connect(self.TabChange)
#New Protocol Tab Setup
self.DTNew_Cat_Title = QLabel(self.DetTab3)
self.DTNew_Cat_Title.setText("Protocol Location")
self.DTNew_Cat_Title.move(5, 2)
newfont = QFont("Times", 8, QFont.Bold)
self.DTNew_Cat_Title.setFont(newfont)
self.DTNew_Cat_Title.show()
self.DTNew_CatText_Title = QLineEdit(self.DetTab3)
self.DTNew_CatText_Title.setText("./Protocols/General/")
self.DTNew_CatText_Title.move(3, 22)
self.DTNew_CatText_Title.resize(723, 17)
self.DTNew_CatText_Title.show()
self.CatButton = QPushButton(self.DetTab3)
self.CatButton.resize(120, 22)
self.CatButton.move(2, 40)
self.CatButton.setText("Change Location...")
self.CatButton.clicked.connect(self.showDialogDir)
self.CatButton.show()
self.DTNew_Lab_Title = QLabel(self.DetTab3)
self.DTNew_Lab_Title.setText("Title")
self.DTNew_Lab_Title.move(5, 65)
newfont = QFont("Times", 8, QFont.Bold)
self.DTNew_Lab_Title.setFont(newfont)
self.DTNew_Lab_Title.show()
self.DTNew_Text_Title = QLineEdit(self.DetTab3)
self.DTNew_Text_Title.setText("Protocol Title")
self.DTNew_Text_Title.move(3, 83)
self.DTNew_Text_Title.resize(723, 17)
self.DTNew_Text_Title.show()
self.DTNew_Lab_Title = QLabel(self.DetTab3)
self.DTNew_Lab_Title.setText("Select Section")
self.DTNew_Lab_Title.move(5, 105)
newfont = QFont("Times", 8, QFont.Bold)
self.DTNew_Lab_Title.setFont(newfont)
self.DTNew_Lab_Title.show()
self.DTNew_Text_Title = QComboBox(self.DetTab3)
self.DTNew_Text_Title.move(3, 123)
self.DTNew_Text_Title.resize(723, 17)
self.DTNew_Text_Title.show()
self.DTNew_Sec_Name = QLabel(self.DetTab3)
self.DTNew_Sec_Name.setText("Section Name")
self.DTNew_Sec_Name.move(5, 147)
newfont = QFont("Times", 8, QFont.Bold)
self.DTNew_Sec_Name.setFont(newfont)
self.DTNew_Sec_Name.show()
self.DTNew_Sec_Text = QLineEdit(self.DetTab3)
self.DTNew_Sec_Text.setText("Section Name")
self.DTNew_Sec_Text.move(3, 168)
self.DTNew_Sec_Text.resize(723, 17)
self.DTNew_Sec_Text.show()
# self.DTNew_Lab_Date = QLabel(self.DetTab3)
# self.DTNew_Lab_Date.setText("Date")
# self.DTNew_Lab_Date.move(5, 107)
# newfont = QFont("Times", 8, QFont.Bold)
# self.DTNew_Lab_Date.setFont(newfont)
# self.DTNew_Lab_Date.show()
#
# self.DTNew_But_Date = QDateEdit(self.DetTab3)
# self.DTNew_But_Date.move(3,128)
# self.DTNew_But_Date.resize(80,19)
# self.DTNew_But_Date.setCalendarPopup(True)
# self.DTNew_But_Date.show()
self.DTNew_Lab_Section = QLabel(self.DetTab3)
self.DTNew_Lab_Section.setText("Section Text")
self.DTNew_Lab_Section.move(5, 194)
newfont = QFont("Times", 8, QFont.Bold)
self.DTNew_Lab_Section.setFont(newfont)
self.DTNew_Lab_Section.show()
self.DTNew_Text_Section = QPlainTextEdit(self.DetTab3)
self.DTNew_Text_Section.appendPlainText("Section Text")
self.DTNew_Text_Section.move(3, 216)
self.DTNew_Text_Section.resize(723, 200)
self.DTNew_Text_Section.show()
self.DTNew_Var_Lab = QLabel(self.DetTab3)
self.DTNew_Var_Lab.setText("Insert Variable")
self.DTNew_Var_Lab.move(5, 426)
newfont = QFont("Times", 8, QFont.Bold)
self.DTNew_Var_Lab.setFont(newfont)
self.DTNew_Var_Lab.show()
self.DTNew_Var_Comb = QComboBox(self.DetTab3)
self.DTNew_Var_Comb.move(3, 446)
self.DTNew_Var_Comb.resize(100, 30)
self.DTNew_Var_Comb.currentTextChanged.connect(self.VarChange)
self.DTNew_Var_Comb.show()
self.DTNew_Var_Lab2 = QLabel(self.DetTab3)
self.DTNew_Var_Lab2.setText("Default Value")
self.DTNew_Var_Lab2.move(130, 426)
newfont = QFont("Times", 8, QFont.Bold)
self.DTNew_Var_Lab2.setFont(newfont)
self.DTNew_Var_Lab2.show()
self.DTNew_Var_Comb2 = QComboBox(self.DetTab3)
self.DTNew_Var_Comb2.move(130, 446)
self.DTNew_Var_Comb2.resize(100, 30)
self.DTNew_Var_Comb2.show()
self.DTNew_VarIns_But = QPushButton(self.DetTab3)
self.DTNew_VarIns_But.setText("Insert")
self.DTNew_VarIns_But.move(257, 446)
self.DTNew_VarIns_But.resize(100, 30)
self.DTNew_VarIns_But.clicked.connect(self.InsVar)
self.DTNew_VarIns_But.show()
self.DTNew_AddSec_Button = QPushButton(self.DetTab3)
self.DTNew_AddSec_Button.move(3, 486)
self.DTNew_AddSec_Button.resize(300, 30)
self.DTNew_AddSec_Button.setText("Add Section")
self.DTNew_AddSec_Button.show()
#Read Variable List when New Protocol tab is opened
def TabChange(self, i):
if i == 2:
print("yes")
conn = sqlite3.connect("./Variables/Variables.sqlite3")
tables = conn.execute(
"SELECT name FROM sqlite_master WHERE type='table';")
templist = []
for name in tables:
templist.append(name[0])
self.DTNew_Var_Comb.addItems(templist)
conn.close()
#Open file when experiment is clicked in list - temporary function
def openExp(self, clickedIndex):
Exp = clickedIndex.sibling(clickedIndex.row(), 0).data()
print(Exp)
os.startfile(Experiments[Exp])
#Test function for opening file dialog box - temporary function
def showDialog(self):
fname = QFileDialog.getOpenFileName(self, 'Open file', '.')
print(fname[0])
#Open dialog box and select a folder
def showDialogDir(self):
dname = str(QFileDialog.getExistingDirectory(self, 'Select Directory'))
self.DTNew_CatText_Title.setText(dname)
#Search Experiments folder and build list of Experiments present on computer
def GenExpList(self):
self.ExpTableModel.setRowCount(0)
for root, dirs, files in os.walk(".\Experiments"):
for file in files:
if file.startswith("Experiment"):
if "." in file.split()[1]:
doc = docx.Document(root + "\\" + file)
if doc.core_properties.subject != "Complete" or self.ExpCheck1.isChecked(
):
row = []
row.append(
QStandardItem(file.split()[1]
[:file.split()[1].index(".")]))
row.append(QStandardItem(
doc.core_properties.title))
self.ExpTableModel.appendRow(row)
self.ExpTable.resizeRowsToContents()
Experiments[file.split()[1][:file.split(
)[1].index(".")]] = root + "\\" + file
else:
doc = docx.Document(root + "\\" + file)
if doc.core_properties.subject != "Complete" or self.ExpCheck1.isChecked(
):
row = []
row.append(QStandardItem(file.split()[1]))
row.append(QStandardItem(
doc.core_properties.title))
self.ExpTableModel.appendRow(row)
self.ExpTable.resizeRowsToContents()
Experiments[file.split()[1]] = root + "\\" + file
doc = docx.Document(os.path.realpath(".\demo 1.docx"))
print(doc.paragraphs[1].text)
print(Experiments)
#Open calendar function
def OpenCal(self):
print("hello")
self.DTNew_Cal.show()
def AddSection(self):
print("hello")
#When the Variable Category ComboBox is changed, update the second combobox
def VarChange(self, s):
self.DTNew_Var_Comb2.clear()
print(s)
var = s
conn = sqlite3.connect("./Variables/Variables.sqlite3")
rows = conn.execute("SELECT name FROM {0};".format(var))
templist = []
for name in rows:
templist.append(name[0])
self.DTNew_Var_Comb2.addItems(templist)
conn.close()
def InsVar(self):
print(self.DTNew_Var_Comb.currentText(),
self.DTNew_Var_Comb2.currentText())
class App(QMainWindow):
# -------------- main window initialization ---------------
def __init__(self):
super().__init__()
self.left = 10
self.top = 10
self.title = 'XRD data processing'
self.width = 720
self.height = 540
self.layout = QVBoxLayout(self)
self.button1 = QPushButton('Open file', self)
self.label1 = QLabel('', self)
self.tabs = QTabWidget(self)
self.tab1 = QWidget()
self.label2 = QLabel('Specify theta', self)
self.kanal = QLineEdit('', self)
self.button2 = QPushButton('Next', self)
self.m = PlotCanvas(self, 710, 450)
self.m.move(15, 40)
self.tools = NavigationToolbar(self.m, self)
self.tools.move(15, 500)
self.tools.resize(400, 30)
self.setStyleSheet(
"QMainWindow { background-color: rgb(253, 253, 253) }")
self.initUI()
# ------------ main tab & window configuration -------------
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.setMaximumSize(720, 540)
self.button1.setToolTip('Click to open data file')
self.button1.move(5, 7)
self.button1.resize(90, 26)
self.button1.clicked.connect(self.file_fcn)
self.button2.move(630, 501)
self.button2.resize(75, 27)
self.button2.clicked.connect(self.btn_fcn)
self.button2.clicked.connect(self.newTab_fcn)
self.label1.move(100, 6)
self.label1.setText(" Current file: None ")
self.label1.setMinimumWidth(600)
self.label1.setMaximumHeight(27)
self.tabs.resize(710, 500)
self.tabs.move(5, 38)
self.tabs.addTab(self.tab1, "Main window")
self.label2.move(430, 500)
self.label2.resize = (48, 27)
self.kanal.setToolTip('Enter theta value')
self.kanal.move(525, 500)
self.kanal.resize(100, 30)
self.buttons = QWidget(self)
self.buttons_layout = QHBoxLayout()
self.buttons.setLayout(self.buttons_layout)
self.buttons_layout.addWidget(self.tools)
self.buttons_layout.addWidget(self.label2)
self.buttons_layout.addWidget(self.kanal)
self.buttons_layout.addWidget(self.button2)
self.tab1.layout = QVBoxLayout()
self.tab1.layout.addWidget(self.m)
self.tab1.layout.addWidget(self.buttons)
self.tab1.setLayout(self.tab1.layout)
self.layout.addWidget(self.tabs)
self.setLayout(self.layout)
self.tabs.tabCloseRequested.connect(self.closeTab)
self.show()
# --------- load data from file (open file button) ------------
def file_fcn(self):
options = QFileDialog.Options()
self.fileName, _ = QFileDialog.getOpenFileName(
self,
"Open data file - XDR data processing",
"",
"Data Files (*.dat);;All Files (*)",
options=options)
if self.fileName:
self.data = np.genfromtxt(self.fileName)
self.label1.setText(" Current file: " + str(self.fileName))
self.show()
self.m.threedee_plt(self.data)
else:
print("Error: File not selected")
# -------------- channel ---------------
def btn_fcn(self):
try:
k = int(self.kanal.text())
except ValueError:
print("Not a number")
self.my_channel = k
# -------------- New tab configuration ---------------
def newTab_fcn(self, i):
k = self.my_channel
self.position1 = 21
self.position2 = -99
self.tab = QWidget()
self.tabs.addTab(self.tab, "Theta: " + str(k) + " °")
self.tabs.setCurrentIndex(i)
self.tabs.setTabsClosable(True)
self.tabs.setMovable(True)
self.m2 = NewTabCanvas(self, 710, 450)
self.m2.move(15, 40)
self.tabtools = NavigationToolbar(self.m2, self)
self.label0 = QLabel('Select data filter and its parameters', self)
self.label0.resize(250, 26)
self.label0.setFont(QFont("Sans Serif", 11))
self.labelx = QLabel('Export to file', self)
self.labelx.resize(150, 26)
self.labelx.setFont(QFont("Sans Serif", 11))
self.rad1 = QRadioButton("&Zero-phase")
self.rad1.setChecked(False)
self.rad1.toggled.connect(
lambda: self.m2.rad1click(self.data, self.my_channel))
self.rad2 = QRadioButton("&Savitzky-Golay")
self.rad2.setChecked(False)
self.rad2.toggled.connect(
lambda: self.m2.rad2click(self.data, self.my_channel))
self.rad3 = QRadioButton("&Median")
self.rad3.setChecked(False)
self.rad3.toggled.connect(lambda: self.m2.rad3click(
self.data, self.my_channel, self.position1))
self.rad4 = QRadioButton("&Exponential smoothing")
self.rad4.setChecked(False)
self.rad4.toggled.connect(lambda: self.m2.rad4click(
self.data, self.my_channel, self.position2))
self.slide1 = QSlider(Qt.Horizontal, self)
self.slide1.setMaximumWidth(110)
self.slide1.setMinimum(11)
self.slide1.setMaximum(501)
self.slide1.setToolTip('Win length: ' + str(self.position1))
self.slide1.setSingleStep(20)
self.slide1.setTickInterval(50)
self.slide1.setTickPosition(QSlider.TicksBelow)
self.slide1.setFocusPolicy(Qt.StrongFocus)
self.slide1.valueChanged[int].connect(lambda: self.slide1_fcn(self.data, self.my_channel, \
self.position1))
self.slide2 = QSlider(Qt.Horizontal)
self.slide2.move(300, 472)
self.slide2.setMaximumWidth(110)
self.slide2.setMinimum(-99)
self.slide2.setMaximum(-1)
self.slide2.setSingleStep(1)
self.slide2.setTickInterval(10)
self.slide2.setTickPosition(QSlider.TicksBelow)
self.slide2.setFocusPolicy(Qt.StrongFocus)
self.slide2.setValue(self.position2)
self.slide2.setToolTip('Alpha: ' + str(-(self.position2 / 800)))
self.slide2.valueChanged[int].connect(lambda: self.slide2_fcn(self.data, self.my_channel, \
self.position2))
self.b1 = QPushButton('Export data', self)
self.b1.setToolTip('Click to save data to a text file')
self.b1.move(510, 450)
self.b1.resize(120, 54)
self.b1.clicked.connect(lambda: self.b1_fcn(self.m2.dat))
self.b3 = QPushButton('Save chart', self)
self.b3.setToolTip('Click to save chart as an image')
self.b3.move(510, 508)
self.b3.resize(120, 54)
self.b3.clicked.connect(lambda: self.b3_fcn(self.m2.figure))
self.layout1 = QHBoxLayout()
self.layout2 = QHBoxLayout()
self.layout3 = QVBoxLayout()
self.layout4 = QHBoxLayout()
self.widget1 = QWidget(self)
self.widget2 = QWidget(self)
self.widget3 = QWidget(self)
self.widget4 = QWidget(self)
self.widget1.setLayout(self.layout1)
self.widget2.setLayout(self.layout2)
self.widget3.setLayout(self.layout3)
self.widget4.setLayout(self.layout4)
self.layout1.addWidget(self.rad1)
self.layout2.addWidget(self.rad2)
self.layout1.addWidget(self.rad3)
self.layout2.addWidget(self.rad4)
self.layout1.addWidget(self.slide1)
self.layout2.addWidget(self.slide2)
self.layout3.addWidget(self.labelx)
self.layout3.addWidget(self.b1)
self.layout3.addWidget(self.b3)
self.layout4.addWidget(self.label0)
self.group = QButtonGroup(self)
self.group.addButton(self.rad1)
self.group.addButton(self.rad2)
self.group.addButton(self.rad3)
self.group.addButton(self.rad4)
self.tab.layout = QGridLayout(self)
self.tab.layout.setSpacing(5)
self.tab.layout.addWidget(self.m2, 1, 0, 4, 2)
self.tab.layout.addWidget(self.widget1, 6, 0)
self.tab.layout.addWidget(self.widget2, 7, 0)
self.tab.layout.addWidget(self.widget4, 5, 0)
self.tab.layout.addWidget(self.widget3, 5, 1, 3, 1)
self.tab.layout.addWidget(self.tabtools, 8, 0, 1, 2)
self.tab.setLayout(self.tab.layout)
self.m2.twodee_plt(self.data, self.my_channel)
# -------------- export data to files functions ---------------
def b1_fcn(self, cisla):
try:
self.m2.dat
except NameError:
print("Process data first")
except ValueError:
print("")
else:
self.m2.dat = cisla
fileName, _ = QFileDialog.getSaveFileName(
self, "QFileDialog.getSaveFileName()", "",
"Data Files (*.csv);;All files (*)")
if fileName:
d = cisla.shape[0]
x = np.arange(0, d, 1)
data = np.column_stack((x, cisla))
head = "Time (s), Intensity ()"
np.savetxt(fileName, data, header=head, delimiter=',')
else:
print("Error: File not saved")
def b3_fcn(self, fig):
self.m2.figure = fig
fileName, _ = QFileDialog.getSaveFileName(
self, "QFileDialog.getSaveFileName()", "",
"Image files (*.jpg);;Portable Graphics (*.png)"
";;Vector Graphics (*.svg);;PDF files (*.pdf);;All Files (*)")
suffix = fileName[-3:]
if not fileName:
print("Error: File not saved")
if fileName:
fig.savefig(fname=fileName, format=suffix)
# -------------- median filter slider ---------------
def slide1_fcn(self, data, channel, position):
self.position1 = position
self.data = data
self.my_channel = channel
position = self.slide1.value()
self.position1 = position
self.m2.rad3click(self.data, self.my_channel, self.position1)
self.slide1.setToolTip('Win length: ' + str(self.position1))
# -------------- exponential smoothing slider ---------------
def slide2_fcn(self, data, channel, position):
self.position2 = position
self.data = data
self.my_channel = channel
position = self.slide2.value()
self.position2 = position
self.m2.rad4click(self.data, self.my_channel, self.position2)
self.slide2.setToolTip('Alpha: ' + str(-(position / 800)))
def closeTab(self, i):
if self.tabs.count() < 2:
return
self.tabs.removeTab(i)
from app import fixed
from amazon.dynamo import Tweet, Entity, ProfileTwitter
from twitter import twitter_keys
from app import keys
from instagram import instagram_keys
main_widget = QWidget()
main_widget.resize(1024, 768)
main_widget.setWindowTitle('Social Finder')
main_widget.setStyleSheet("background-color:black;")
main_widget.show()
tab_widget = QTabWidget(main_widget)
tab_widget.resize(1014, 200)
tab_widget.move(5, 5)
tab_widget.show()
instagram_tab = QWidget()
tab_widget.resize(1014, 200)
instagram_tab.setStyleSheet("background-color:black;")
twitter_label_html_fmt = """
<html>
<link rel="stylesheet" type="text/css" href="http://yui.yahooapis.com/3.18.1/build/cssreset/cssreset-min.css">
<link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet">
<style>
div.tw {
margin-bottom:2px;
}
div.prefix::before {
class GUI(QMainWindow):
def __init__(self):
super().__init__()
self.thread()
self.initGui()
def initGui(self):
self.resize(800, 500)
self.setMinimumSize(800, 500)
self.setMaximumSize(800, 500)
self.layout = QHBoxLayout(self, spacing=0)
self.layout.setContentsMargins(0, 0, 0, 0)
self.setWindowIcon(QIcon('./static/logo.ico'))
self.move_center()
self.font()
self.lable()
self.log()
self.tab()
self.radiobutton()
# self.win.show()
self.statusBar().showMessage("Go for your son")
self.setWindowFlags(Qt.FramelessWindowHint)
self.button()
def thread(self):
#start thread
self.thread_start = start.START()
def move_center(self):
screen = QDesktopWidget().screenGeometry()
form = self.geometry()
x_move_step = (screen.width() - form.width()) / 2
y_move_step = (screen.height() - form.height()) / 2
self.move(int(x_move_step), int(y_move_step))
def font(self):
self.font_bigbutton = QFont()
self.font_bigbutton.setBold(True)
self.font_bigbutton.setPointSize(20)
self.font_bigbutton.setWeight(25)
# radio button fot
self.font_rbt = QFont()
self.font_rbt.setBold(True)
self.font_rbt.setPointSize(15)
self.font_rbt.setWeight(15)
def button(self):
self.btn_start = QPushButton("初始化", self.tab_one)
self.btn_start.resize(150, 50)
self.btn_start.setFont(self.font_bigbutton)
self.btn_start.setIcon(QIcon("./static/start.png"))
self.btn_start.setIconSize(QSize(25, 25))
self.btn_start.clicked.connect(self.start_server)
self.btn_start.move(350, 350)
def tab(self):
self.tab_panel = QTabWidget(self)
self.tab_one = QWidget(self)
self.tab_two = QWidget(self)
self.tab_panel.addTab(self.tab_one, "开始")
self.tab_panel.addTab(self.tab_two, "设置")
self.tab_panel.resize(520, 440)
self.tab_panel.move(10, 30)
def log(self):
self.log_panel = QTextBrowser(self)
self.log_panel.resize(250, 415)
self.log_panel.move(540, 55)
def lable(self):
# logo picture
self.label_icon = QLabel(self)
self.label_icon.setPixmap(QPixmap("./static/logo.png"))
self.label_icon.resize(30, 30)
self.label_icon.move(0, 0)
# title label
self.label_title = QLabel(self)
self.label_title.setText("TFDS-OneKey")
self.label_title.move(30, 0)
# close label button
self.label_close = MyLabel(self)
self.label_close.setPixmap(QPixmap("./static/close.png"))
self.label_close.resize(30, 30)
self.label_close.move(770, 0)
self.label_close.click_fun(self.close)
# clear log label
self.label_clearlog = MyLabel(self)
self.label_clearlog.setPixmap(QPixmap("./static/clear.png"))
self.label_clearlog.resize(30, 30)
self.label_clearlog.move(540, 20)
self.label_clearlog.click_fun(self.log_clear)
# minisize label button
self.label_mini = MyLabel(self)
self.label_mini.setPixmap(QPixmap("./static/mini.png"))
self.label_mini.resize(30, 30)
self.label_mini.move(740, 0)
self.label_mini.click_fun(self.showMinimized)
# steamcmd save dir
#self.label_steamcmd = QLabel(self.tab_one)
# self.label_steamcmd.setText("Steamcmd:")
# self.label_steamcmd.move(300,100)
def radiobutton(self):
# use pre setting
self.rbt_preset = QRadioButton("预设", self.tab_one)
self.rbt_preset.setFont(self.font_rbt)
self.rbt_preset.setChecked(True)
self.rbt_preset.move(250, 370)
# uses setting
self.rbt_customset = QRadioButton("自定义", self.tab_one)
self.rbt_customset.setFont(self.font_rbt)
self.rbt_customset.setCheckable(False)
self.rbt_customset.move(130, 370)
def closeEvent(self, event):
result = QMessageBox.question(self, "注意：", "您真的要关闭TFDS吗？",
QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if result == QMessageBox.Yes:
event.accept()
else:
event.ignore()
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.m_flag = True
self.m_Position = event.globalPos() - self.pos() # 获取鼠标相对窗口的位置
event.accept()
self.setCursor(QCursor(Qt.OpenHandCursor)) # 更改鼠标图标
def mouseMoveEvent(self, QMouseEvent):
if Qt.LeftButton and self.m_flag:
self.move(QMouseEvent.globalPos() - self.m_Position) # 更改窗口位置
QMouseEvent.accept()
def mouseReleaseEvent(self, QMouseEvent):
self.m_flag = False
self.setCursor(QCursor(Qt.ArrowCursor))
def log_add(self, data):
self.log_panel.append(data)
def log_clear(self):
self.log_panel.clear()
def start_server(self):
self.thread_start.start()
self.thread_start.trg.connect(self.log_add)
class App(QWidget):
def __init__(self):
DATA.CREATE()
super().__init__()
self.title = 'Intrusion Detection System'
self.initUI()
def initUI(self):
"""Buttron bind server"""
self.setWindowTitle(self.title)
self.button_bind_server = QPushButton('Bind server', self)
self.button_bind_server.move(1800, 950)
self.button_bind_server.resize(80, 30)
self.button_bind_server.clicked.connect(self.on_click_bind_server)
"""Button close IDS"""
self.button_exit = QPushButton('Close', self)
self.button_exit.move(1800, 990)
self.button_exit.resize(80, 30)
self.button_exit.clicked.connect(self.on_click_exit)
"""DEBUG box"""
self.messege_box = QTextEdit(self)
self.messege_box.move(10, 870)
self.messege_box.resize(1750, 150)
"""List widget"""
self.ip_list = QListWidget(self)
self.ip_list.move(10, 10)
self.ip_list.resize(280, 850)
self.ip_list.itemClicked.connect(self.on_click_list_widget_item)
"""Tab Widget
-DEBUG
-Real time"""
self.tabs = QTabWidget(self)
self.tab_real_time = QWidget()
self.tabs.resize(1460, 850)
self.tabs.addTab(self.tab_real_time, "Real time")
self.tabs.move(300, 10)
"""Real time widgets
-TextEdit
-TableView"""
self.messege_box_real_time = QTextEdit(self.tab_real_time)
self.param_table = QTableView(self.tab_real_time)
self.messege_box_real_time.resize(1000, 821)
self.param_table.move(1002, 0)
self.param_table.resize(454, 821)
self.model_for_table_view = QStandardItemModel(self.param_table)
self.model_for_table_view.setHorizontalHeaderLabels(
["Value", "Comments"])
self.model_for_table_view.setVerticalHeaderLabels([
"100", "101", "102", "103", "104", "105", "106", "107", "108",
"109", "110", "111", "112", "113", "114", "115", "116", "117",
"118", "119", "120", "121", "122", "123", "124", "125", "126",
"127", "128", "129", "130"
])
self.param_table.setModel(self.model_for_table_view)
self.param_table.setAlternatingRowColors(True)
self.param_table.setAutoScroll(True)
for index_new_data_table in range(100, 131):
self.model_for_table_view.setItem(index_new_data_table - 100, 0,
QStandardItem("0"))
self.model_for_table_view.setItem(
index_new_data_table - 100, 1,
QStandardItem(print_mess_warning[index_new_data_table]))
self.showMaximized()
time_time = threading.Thread(target=self.update_data_while)
time_time.daemon = True
time_time.start()
def update_data_while(self):
while True:
time.sleep(10)
update_data = DATA.GET_ALL_DATA()
for index_update_data in update_data:
self.model_for_table_view.setItem(
index_update_data[1] - 100, 0,
QStandardItem(str(index_update_data[2])))
def add_text_real_time(self, messege_text):
self.messege_box_real_time.append(messege_text)
def add_text_debug(self, messege_text):
self.messege_box.append(messege_text)
def add_item_on_list_widget(self, ip_mac_table):
for index_list_widget in ip_mac_table:
self.ip_list.addItem(index_list_widget[1])
def data_socket_GUI(self):
GUI_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
GUI_socket.bind(("127.0.0.1", 55555))
GUI_socket.listen(1)
GUI_conn, GUI_address = GUI_socket.accept()
if GUI_conn != False and GUI_address != False:
while (True):
text_data = GUI_conn.recv(1024)
text_data = text_data.decode('utf-8')
if text_data[0:5] == "DEBUG":
ex.add_text_debug(text_data[5:])
elif text_data[0:5] == "REALT":
ex.add_text_real_time(text_data[5:])
elif text_data[0:5] == "LISTW":
ip_mac_table = DATA.GET_ALL_DATA_ARP_HOST()
ex.add_item_on_list_widget(ip_mac_table)
@pyqtSlot()
def on_click_bind_server(self):
server = Server(server_name,
9000) ### ИНИЦИАЛИАЦИЯ СЕРВЕРА class Server
try:
threading.Thread(target=server.start,
name="Server_thread").start() ### ЗАПУСК СЕРВЕРА
threading.Thread(target=ex.data_socket_GUI,
name="GUI_print_data_thread").start()
except:
ex.add_text_debug("{0} {1} Unexpected exception".format(
time.ctime(), ERROR))
# finally:
# ex.add_text_real_time("{} Shutting down".format(INFO))
def on_click_exit(self):
try:
for process in multiprocessing.active_children(
): ### ЗАКРЫТИЕ ВСЕХ СОЕДИНЕНИЙ
ex.add_text_debug("{0} {1} Shutting down process {2}".format(
time.ctime(), INFO, process))
process.terminate()
process.join()
finally:
sys.exit()
def on_click_close_tab(self):
self.tabs.removeTab(self.tabs.currentIndex())
def on_click_push_update(self):
self.messege_box_real_time_to_host.clear()
for index_new_data_table in range(100, 131):
self.model_for_table_view_tab.setItem(index_new_data_table - 100,
0, QStandardItem("0"))
data_print = DATA.GET_ALL_DATA_SIGNAL()
for index_print in data_print:
ip_src_dst = re.findall(r'(\d+\.\d+\.\d+\.\d+)', index_print[3])
if ip_src_dst[0] == self.ip_tab.text(
) or ip_src_dst[1] == self.ip_tab.text():
self.messege_box_real_time_to_host.append(index_print[3][5:])
self.model_for_table_view_tab.setItem(
index_print[2] - 100, 0,
QStandardItem(
str(
int(
self.model_for_table_view_tab.data(
self.model_for_table_view_tab.index(
index_print[2] - 100, 0))) + 1)))
def on_click_list_widget_item(self, item):
global print_mess_warning
self.tab_to_host = QWidget()
self.ip_tab = item
self.tabs.addTab(self.tab_to_host, item.text())
button_close = QPushButton("Close tab", self.tab_to_host)
button_push = QPushButton("Update", self.tab_to_host)
self.messege_box_real_time_to_host = QTextEdit(self.tab_to_host)
self.param_table_to_host = QTableView(self.tab_to_host)
self.messege_box_real_time_to_host.resize(1000, 821)
self.param_table_to_host.move(1002, 0)
button_close.move(1280, 780)
button_push.move(1080, 780)
self.param_table_to_host.resize(454, 750)
self.model_for_table_view_tab = QStandardItemModel(
self.param_table_to_host)
self.model_for_table_view_tab.setHorizontalHeaderLabels(["Value"])
self.model_for_table_view_tab.setVerticalHeaderLabels([
"100", "101", "102", "103", "104", "105", "106", "107", "108",
"109", "110", "111", "112", "113", "114", "115", "116", "117",
"118", "119", "120", "121", "122", "123", "124", "125", "126",
"127", "128", "129", "130"
])
self.param_table_to_host.setModel(self.model_for_table_view_tab)
self.param_table_to_host.setAlternatingRowColors(True)
self.param_table_to_host.setAutoScroll(True)
button_close.clicked.connect(self.on_click_close_tab)
button_push.clicked.connect(self.on_click_push_update)
for index_new_data_table in range(100, 131):
self.model_for_table_view_tab.setItem(index_new_data_table - 100,
0, QStandardItem("0"))
self.model_for_table_view_tab.setItem(
index_new_data_table - 100, 1,
QStandardItem(print_mess_warning[index_new_data_table]))
data_print = DATA.GET_ALL_DATA_SIGNAL()
for index_print in data_print:
ip_src_dst = re.findall(r'(\d+\.\d+\.\d+\.\d+)', index_print[3])
if ip_src_dst[0] == item.text() or ip_src_dst[1] == item.text():
self.messege_box_real_time_to_host.append(index_print[3][5:])
self.model_for_table_view_tab.setItem(
index_print[2] - 100, 0,
QStandardItem(
str(
int(
self.model_for_table_view_tab.data(
self.model_for_table_view_tab.index(
index_print[2] - 100, 0))) + 1)))
class App(QWidget):
changeQImage = pyqtSignal(QImage) #Creating a signal
changeLog = pyqtSignal(Log) #Creating a signal
changeBatteryBar = pyqtSignal(
CommonCommonStateBatteryStateChanged) #Creating a siganl
checkHz = pyqtSignal(list)
def __init__(self):
super(QWidget, self).__init__()
self.velocityPub = rospy.Publisher("/bebop/cmd_vel",
Twist,
queue_size=10)
self.takeoffPub = rospy.Publisher('/bebop/takeoff',
Empty,
queue_size=10)
self.landPub = rospy.Publisher('/bebop/land', Empty, queue_size=10)
self.goFwrd_vel = Twist()
self.goBwrd_vel = Twist()
self.recording = False #creating variable that keeps record if we're recording
self.logCount = 0 #count for adding right amount of rows to Log
self.count5 = 0 #count so we only print one ready/error takeoff msg per takeoff
#subscriber to battery, Image, Log and LaserScan
self.batterySub = rospy.Subscriber(
"/bebop/states/common/CommonState/BatteryStateChanged",
CommonCommonStateBatteryStateChanged,
self.batteryCallback,
queue_size=10)
self.imgSub = rospy.Subscriber("/bebop/image_raw",
Image,
self.imageCallback,
queue_size=10)
self.logSub = rospy.Subscriber("/rosout_agg",
Log,
self.logCallback,
queue_size=10)
self.recording = False
threading.Timer(0.1, self.hzFunk).start()
self.initUI()
##-------------------------------------------------------------------------------------------------------
@pyqtSlot(QImage)
def setImage(self, image):
self.imageLabel.setPixmap(
QPixmap.fromImage(image)) #Setting QImage in imageLabel
@pyqtSlot(Log)
def setLog(self, log):
#Setting table
self.logger.setItem(self.logCount, 0,
QTableWidgetItem(log.msg)) #printing msg to table
self.logger.setItem(self.logCount, 1, QTableWidgetItem(str(
log.level))) #printing error lever table
self.logger.setItem(self.logCount, 2, QTableWidgetItem(
log.name)) #printing node-name to table
self.logger.setItem(
self.logCount, 3, QTableWidgetItem(str(
log.header.stamp))) #printing timestamp to table
self.logger.setRowCount(4 + self.logCount) #adding new row
self.logCount += 1
@pyqtSlot(CommonCommonStateBatteryStateChanged)
def setBatteyBar(self, status):
self.batteryBar.setValue(status.percent) # setting battery percent
@pyqtSlot(list)
def getHz(self, list):
self.hzLogger.setItem(0, 0, QTableWidgetItem(str(list[0])))
self.hzLogger.setItem(1, 0, QTableWidgetItem(str(list[1])))
self.hzLogger.setItem(2, 0, QTableWidgetItem(str(list[2])))
try:
if float(self.hzLogger.item(0, 0).text()) < float(
self.hzLogger.item(0, 1).text()):
self.hzLogger.item(0, 0).setBackground(QColor(250, 0, 0))
except:
pass
try:
if float(self.hzLogger.item(1, 0).text()) < float(
self.hzLogger.item(1, 1).text()):
self.hzLogger.item(1, 0).setBackground(QColor(250, 0, 0))
except:
pass
try:
if float(self.hzLogger.item(2, 0).text()) < float(
self.hzLogger.item(2, 1).text()):
self.hzLogger.item(2, 0).setBackground(QColor(250, 0, 0))
except:
pass
#Callback for QImage
def imageCallback(self, data):
bridge = CvBridge()
rgbImage = bridge.imgmsg_to_cv2(
data,
desired_encoding="passthrough") #converting rosimage to cvimage
h, w, ch = rgbImage.shape
bytesPerLine = ch * w
convertToQtFormat = QImage(
rgbImage.data, w, h, bytesPerLine,
QImage.Format_RGB888) #converting cvimage to QImage
p = convertToQtFormat.scaled(640, 480, Qt.KeepAspectRatio)
self.changeQImage.emit(
p) #emitting QImage through changeQImage-signal to setImage
#Callback for Log
def logCallback(self, log):
self.changeLog.emit(
log) #emitting rosout_agg-info through changeLog-signal to setLog
#Callback for battery
def batteryCallback(self, status):
self.changeBatteryBar.emit(
status
) #emitting battarystatus through changeBatteryBar-signal to setBatteyBar
##------------------------------------------------------------------------------------------------------
def takeOff(self):
ret = self.checkRecStatus()
if ret == 1048576 or ret == None: #number for ignore-action
self.takeoffPub.publish()
else:
pass
def land(self):
self.landPub.publish()
def goFwrd(self):
self.goFwrd_vel.linear.x = +1
self.velocityPub.publish(self.goFwrd_vel)
def goBwrd(self):
self.goBwrd_vel.linear.x = -1
self.velocityPub.publish(self.goBwrd_vel)
def turnRight(self):
self.turnRight = Twist()
self.turnRight.angular.z = -0.5
self.velocityPub.publish(self.turnRight)
def turnLeft(self):
self.turnLeft = Twist()
self.turnLeft.angular.z = +0.5
self.velocityPub.publish(self.turnLeft)
def hover(self):
self.hover = Twist()
self.hover.linear.x = 0
self.hover.linear.y = 0
self.hover.linear.z = 0
self.hover.angular.z = 0
self.velocityPub.publish(self.hover)
def hzFunk(self):
a = rostopic.ROSTopicHz(-1)
b = rostopic.ROSTopicHz(-1)
c = rostopic.ROSTopicHz(-1)
rospy.Subscriber("/bebop/cmd_vel", Twist, a.callback_hz)
rospy.Subscriber("/bebop/odom", Odometry, b.callback_hz)
rospy.Subscriber("/bebop/image_raw", Image, c.callback_hz)
time.sleep(1.0)
list = []
try:
list.append(a.get_hz()[0])
except:
list.append("No message")
try:
list.append(b.get_hz()[0])
except:
list.append("No message")
try:
list.append(c.get_hz()[0])
except:
list.append("No message")
self.checkHz.emit(list)
def checkRecStatus(self):
if self.recording == False:
ret = self.recMessageBox("You are not recording!")
return ret
else:
pass
##------------------------------------------------------------------------------------------------------------
#FUNCTIONS FOR RECORDING
def rec_funk(self):
#if we're not already recording--> changing look of rec btn, setting rec to true and
#setting selected topics to list of all selected topics in topicLogger.
#Else --> end recording
if self.recording == False:
self.rec_btn.setStyleSheet(
"border-radius :40; background-color: green; border : 2px solid darkgreen;font-size: 30px;font-family: Arial"
)
self.recording = True
selectedTopics = self.topicLogger.selectedItems()
# if at least one topic is selected--> record trem. Else --> record all topics.
if len(selectedTopics) > 0:
command = ""
for i in selectedTopics:
command = command + " " + i.text()
command = shlex.split("rosbag record " + command)
self.rosbag_record = subprocess.Popen(command)
else:
command = shlex.split("rosbag record -a")
self.rosbag_record = subprocess.Popen(command)
else:
list_cmd = subprocess.Popen("rosnode list",
shell=True,
stdout=subprocess.PIPE)
list_output = list_cmd.stdout.read()
retcode = list_cmd.wait()
assert retcode == 0, "List command returned %d" % retcode
for string in list_output.split("\n"):
if (string.startswith("/record")):
os.system("rosnode kill " + string)
self.rec_btn.setStyleSheet(
"border-radius :40; background-color: red; border : 2px solid darkred;font-size: 30px;font-family: Arial"
)
self.topicLogger.clearSelection()
self.recording = False
##-----------------------------------------------------------------------------------------------------------
def initUI(self):
#create mainwindow
self.setWindowTitle("ROS usb_cam")
self.setGeometry(250, 100, 1100, 687)
#creating edge label2
self.edgeLabel = QLabel(self)
self.edgeLabel.setStyleSheet(
"border: 1px solid grey; background-color: #CCCCCC")
self.edgeLabel.move(650, 65)
self.edgeLabel.resize(445, 358)
#create a Image Label
self.imageLabel = QLabel(self)
self.imageLabel.move(4, 4)
self.imageLabel.resize(640, 480)
#create QTableWidget for logger
self.logger = QTableWidget(self)
self.logger.resize(780, 180)
self.logger.setRowCount(6)
self.logger.setColumnCount(4)
self.logger.setColumnWidth(0, 400)
self.logger.setColumnWidth(1, 80)
self.logger.setColumnWidth(2, 158)
self.logger.setHorizontalHeaderLabels(
("Message;Severity;Node;Timestamp").split(";"))
#create QTableWidget for topics
self.topicLogger = QTableWidget(self)
self.topicLogger.resize(780, 180)
self.topicLogger.setRowCount(45)
self.topicLogger.setColumnCount(2)
self.topicLogger.setColumnWidth(0, 400)
self.topicLogger.setColumnWidth(1, 380)
self.topicLogger.setHorizontalHeaderLabels(("Topic;Msgs").split(";"))
self.topicLogger.setSelectionMode(QAbstractItemView.MultiSelection)
topics = rospy.get_published_topics(namespace='/')
count2 = 0
for i in topics:
self.topicLogger.setItem(count2, 0, QTableWidgetItem(i[0]))
self.topicLogger.setItem(count2, 1, QTableWidgetItem(i[1]))
count2 += 1
#creating hz-sensor logger
self.hzLogger = QTableWidget(self)
self.hzLogger.resize(780, 180)
self.hzLogger.setRowCount(3)
self.hzLogger.setColumnCount(2)
self.hzLogger.setColumnWidth(0, 500)
self.hzLogger.setVerticalHeaderLabels(
("Velocity commands;Odometry;Image").split(";"))
self.hzLogger.setHorizontalHeaderLabels(
("Frequencies;Preferd min").split(";"))
#creating tabWidget to insert logger osv
self.tabWidget = QTabWidget(self)
self.tabWidget.move(310, 440)
self.tabWidget.resize(780, 240)
self.tabWidget.addTab(self.logger, "rosout_agg info")
self.tabWidget.addTab(self.topicLogger, "Topics")
self.tabWidget.addTab(self.hzLogger, "Topic frequencies")
#create push button - deactivate
self.takeoff_btn = QPushButton('Takeoff', self)
self.takeoff_btn.move(700, 100)
self.takeoff_btn.clicked.connect(self.takeOff)
#create push button - activate
self.land_btn = QPushButton('Land', self)
self.land_btn.move(800, 100)
self.land_btn.clicked.connect(self.land)
#create push button - go forward
self.goFwrd_btn = QPushButton('Go forward', self)
self.goFwrd_btn.move(830, 200)
self.goFwrd_btn.clicked.connect(self.goFwrd)
#create push button - go backward
self.goBwrd_btn = QPushButton('Go backward', self)
self.goBwrd_btn.move(830, 300)
self.goBwrd_btn.clicked.connect(self.goBwrd)
#create push button - turn right
self.turnRight_btn = QPushButton('Turn right', self)
self.turnRight_btn.move(910, 250)
self.turnRight_btn.clicked.connect(self.turnRight)
#create push button - turn left
self.turnLeft_btn = QPushButton('Turn left', self)
self.turnLeft_btn.move(750, 250)
self.turnLeft_btn.clicked.connect(self.turnLeft)
#create push button - hover
self.hover_btn = QPushButton('HOVER', self)
self.hover_btn.move(700, 140)
self.hover_btn.clicked.connect(self.hover)
#create push button - recording
self.rec_btn = QPushButton('REC', self)
self.rec_btn.setGeometry(1000, 85, 80, 80)
self.rec_btn.setStyleSheet(
"border-radius :40; background-color: red; border : 2px solid darkred;font-size: 30px;font-family: Arial"
)
self.rec_btn.clicked.connect(self.rec_funk)
#creating LTU logo label
self.label_ltu_image = QLabel(self)
pixmap_ltu_image = QPixmap("./image/LTU.png")
pixmap_ltu_image = pixmap_ltu_image.scaled(200, 200,
Qt.KeepAspectRatio,
Qt.FastTransformation)
self.label_ltu_image.setPixmap(pixmap_ltu_image)
self.label_ltu_image.move(4, 450)
#creating robotics team logo label
self.robteamImage = QLabel(self)
robteamPixmap = QPixmap("./image/robteam.png")
robteamPixmap = robteamPixmap.scaled(300, 300, Qt.KeepAspectRatio,
Qt.FastTransformation)
self.robteamImage.setPixmap(robteamPixmap)
self.robteamImage.move(4, 600)
# #Creating battery label and bar
self.batteryLabel = QLabel("Battery", self)
self.batteryLabel.move(5, 0)
self.batteryLabel.resize(50, 20)
self.batteryBar = QProgressBar(self)
self.batteryBar.move(5, 25)
self.batteryBar.resize(150, 30)
self.batteryBar.setMaximum(100)
self.show() #showing GUI
#creating different keybord shortcuts
self.shortcut_fwrd = QShortcut(QKeySequence("w"), self)
self.shortcut_fwrd.activated.connect(self.goFwrd)
self.shortcut_bwrd = QShortcut(QKeySequence("s"), self)
self.shortcut_bwrd.activated.connect(self.goBwrd)
self.shortcut_turnRight = QShortcut(QKeySequence("d"), self)
self.shortcut_turnRight.activated.connect(self.turnRight)
self.shortcut_turnLeft = QShortcut(QKeySequence("a"), self)
self.shortcut_turnLeft.activated.connect(self.turnLeft)
self.shortcut_takeoff = QShortcut(QKeySequence("k"), self)
self.shortcut_takeoff.activated.connect(self.takeOff)
self.shortcut_land = QShortcut(QKeySequence("l"), self)
self.shortcut_land.activated.connect(self.land)
self.changeQImage.connect(self.setImage) #connecting signal to slot
self.changeLog.connect(self.setLog) #connecting signal to slot
self.checkHz.connect(self.getHz) #connecting signal to slot
self.changeBatteryBar.connect(
self.setBatteyBar) #connecting signal to slot
#creating warning-messagebox
def messageBox(self, text):
self.rec_msgBox = QMessageBox()
self.rec_msgBox.setWindowModality(False)
self.rec_msgBox.setIcon(QMessageBox.Warning)
self.rec_msgBox.setWindowTitle("Warning")
self.rec_msgBox.setText(text)
self.rec_msgBox.show()
#creating warning-message for recording
def recMessageBox(self, text):
self.rec_msgBox = QMessageBox()
self.rec_msgBox.setIcon(QMessageBox.Warning)
self.rec_msgBox.setWindowTitle("Warning")
self.rec_msgBox.setText(text)
self.rec_msgBox.setStandardButtons(QMessageBox.Ignore
| QMessageBox.Abort)
ret = self.rec_msgBox.exec_()
if ret == QMessageBox.Abort:
return ret
else:
return ret
class Window(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.setFixedSize(QSize(WIND_HEIGHT, WIND_WIDTH))
self.setWindowTitle('HeadHunter')
self.setWindowIcon(QIcon('sources/hh.png'))
self.color = '#cfebfd'
self.second_color = '#87cefa'
self.third_color = '#0000cc'
self.start_sal = MIN_SALARY
self.data = work_with_data.get_prepocess_data(False)
self.categorical_columns = ['Area', 'Employment', 'Experience']
self.binary_columns = list(LANGUAGES) + list(SIZE_COMPANY.keys())
self.model = model.get_forest_model(self.data,
self.categorical_columns,
self.binary_columns)
# 1 Widget
self.tabs_lang = QTabWidget(self)
self.tabs_lang1 = QWidget()
self.tabs_lang2 = QWidget()
self.tabs_lang.resize(WIND_HEIGHT, WIND_WIDTH - BUTTON_MENU_WIDTH - 5)
self.tabs_lang.move(0, BUTTON_MENU_WIDTH + 5)
self.tabs_lang.addTab(self.tabs_lang1,
'Статистика по средней зарплате')
self.tabs_lang.addTab(self.tabs_lang2,
'Статистика по количеству вакансий')
# 2 Widget
self.tabs_city = QTabWidget(self)
self.tabs_city1 = QWidget()
self.tabs_city2 = QWidget()
self.tabs_city.resize(WIND_HEIGHT, WIND_WIDTH - BUTTON_MENU_WIDTH - 5)
self.tabs_city.move(0, BUTTON_MENU_WIDTH + 5)
self.tabs_city.addTab(self.tabs_city1,
'Статистика по средней зарплате')
self.tabs_city.addTab(self.tabs_city2,
'Статистика по количеству вакансий')
# 3 Widget
self.tabs_map = QTabWidget(self)
self.tab_map1 = QWidget()
self.tabs_map.resize(WIND_HEIGHT, WIND_WIDTH - BUTTON_MENU_WIDTH - 25)
self.tabs_map.move(0, BUTTON_MENU_WIDTH + 25)
self.tabs_map.addTab(self.tab_map1, '')
# 4 Widget
self.tabs_model = QTabWidget(self)
self.tab_model1 = QWidget()
self.tabs_model.resize(WIND_HEIGHT,
WIND_WIDTH - BUTTON_MENU_WIDTH - 25)
self.tabs_model.move(0, BUTTON_MENU_WIDTH + 25)
self.tabs_model.addTab(self.tab_model1, '')
# 1,2 plot
self.plot_lang1 = MatPlot(WIND_HEIGHT * 0.25, 0, self.tabs_lang1,
self.second_color)
self.plot_lang2 = MatPlot(WIND_HEIGHT * 0.25, 0, self.tabs_lang2,
self.second_color)
# 3,4 plot
self.plot_city1 = MatPlot(WIND_HEIGHT * 0.25, 0, self.tabs_city1,
self.second_color)
self.plot_city2 = MatPlot(WIND_HEIGHT * 0.25, 0, self.tabs_city2,
self.second_color)
# map
self.plot_map1 = MatPlot(0, 0, self.tab_map1, self.color,
self.third_color)
# button
self.button_lang = QPushButton('Статистика\nпо языкам', self)
self.button_lang.clicked.connect(lambda: self.show_tab(self.tabs_lang))
self.button_lang.resize(BUTTON_MENU_HEIGHT, BUTTON_MENU_WIDTH)
self.button_lang.move(BUTTON_MENU_HEIGHT * 0, 0)
self.button_city = QPushButton('Статистика\nпо городам', self)
self.button_city.clicked.connect(lambda: self.show_tab(self.tabs_city))
self.button_city.resize(BUTTON_MENU_HEIGHT, BUTTON_MENU_WIDTH)
self.button_city.move(BUTTON_MENU_HEIGHT * 1, 0)
self.button_map = QPushButton('Востребованность\nв городах', self)
self.button_map.clicked.connect(lambda: self.show_tab(self.tabs_map))
self.button_map.resize(BUTTON_MENU_HEIGHT, BUTTON_MENU_WIDTH)
self.button_map.move(BUTTON_MENU_HEIGHT * 2, 0)
self.button_model = QPushButton('Заработная\nплата', self)
self.button_model.clicked.connect(
lambda: self.show_tab(self.tabs_model))
self.button_model.resize(BUTTON_MENU_HEIGHT, BUTTON_MENU_WIDTH)
self.button_model.move(BUTTON_MENU_HEIGHT * 3, 0)
self.button_update = QPushButton('Обновить', self)
self.button_update.clicked.connect(self.update_data)
self.button_update.resize(BUTTON_MENU_HEIGHT / 3,
BUTTON_MENU_WIDTH / 3)
self.button_update.move(
BUTTON_MENU_HEIGHT * 3 + 2 * BUTTON_MENU_HEIGHT / 3,
BUTTON_MENU_WIDTH + 2)
# 1-2 filter
self.all_filters = {}
self.filters_city1 = QFrame(self.tabs_city1)
self.filters_city1.resize(FRAME_WIDTH, FRAME_HEIGHT - 50)
self.filters_city1.move(10, 10)
self.all_filters['City1'] = (self.create_filters(self.filters_city1,
'City1',
lang=True,
sal=False))
self.filters_city2 = QFrame(self.tabs_city2)
self.filters_city2.resize(FRAME_WIDTH, FRAME_HEIGHT)
self.filters_city2.move(10, 10)
self.all_filters['City2'] = (self.create_filters(self.filters_city2,
'City2',
lang=True))
# 3-4 filter
self.filters_lang1 = QFrame(self.tabs_lang1)
self.filters_lang1.resize(FRAME_WIDTH, FRAME_HEIGHT - 50)
self.filters_lang1.move(10, 10)
self.all_filters['Lang1'] = (self.create_filters(self.filters_lang1,
'Lang1',
area=True,
sal=False))
self.filters_lang2 = QFrame(self.tabs_lang2)
self.filters_lang2.resize(FRAME_WIDTH, FRAME_HEIGHT)
self.filters_lang2.move(10, 10)
self.all_filters['Lang2'] = (self.create_filters(self.filters_lang2,
'Lang2',
area=True))
# model
self.filter_model = {}
self.create_filters_model(self.tab_model1)
self.button_forecast = QPushButton('Расчет', self.tab_model1)
self.button_forecast.clicked.connect(self.create_forecast)
self.button_forecast.resize(BUTTON_MENU_HEIGHT, BUTTON_MENU_WIDTH)
self.button_forecast.move(WIND_HEIGHT / 2 - BUTTON_MENU_HEIGHT / 2,
300)
self.button_forecast.setEnabled(False)
self.label_forecast = QLabel(self.tab_model1)
self.label_forecast.setAlignment(Qt.AlignCenter)
self.label_forecast.resize(WIND_HEIGHT, BUTTON_MENU_WIDTH)
self.label_forecast.move(0, 400)
self.plot_all()
self.show_tab(self.tabs_lang)
self.set_style()
def show_tab(self, item_view):
self.tabs_lang.hide()
self.tabs_map.hide()
self.tabs_city.hide()
self.tabs_model.hide()
item_view.show()
def create_filters(self, parent, code, lang=False, area=False, sal=True):
if sal:
label_sal = QLabel(parent)
label_sal.setText('Зарплата от')
label_sal.resize(100, 15)
label_sal.move(5, 125)
label_sal_val = QLabel(parent)
label_sal_val.move(FRAME_WIDTH - 50, 125)
label_sal_val.resize(45, 15)
label_sal_val.setAlignment(Qt.AlignRight)
label_sal_val.setText(str(self.start_sal))
sld_sal = QSlider(Qt.Horizontal, parent)
sld_sal.setMinimum(int(self.start_sal / 5000))
sld_sal.setMaximum(40)
sld_sal.setPageStep(1)
sld_sal.move(5, 145)
sld_sal.resize(FRAME_WIDTH - 10, 20)
sld_sal.valueChanged[int].connect(
lambda val, tab=code: self.sld_action(val, tab))
else:
label_sal_val = None
sld_sal = None
if lang:
combo_lang = QComboBox(parent)
combo_lang.setMaxVisibleItems(20)
combo_lang.addItem("Все языки")
combo_lang.resize(FRAME_WIDTH - 10, 20)
combo_lang.move(5, 10)
combo_lang.addItems(LANGUAGES)
combo_lang.activated.connect(
lambda val, tab=code: self.refresh_plot(tab))
else:
combo_lang = None
if area:
combo_area = QComboBox(parent)
combo_area.setMaxVisibleItems(20)
combo_area.addItem("Все города")
combo_area.resize(FRAME_WIDTH - 10, 20)
combo_area.move(5, 10)
combo_area.addItems(
[work_with_data.decode_param(val) for val in AREA])
combo_area.activated.connect(
lambda val, tab=code: self.refresh_plot(tab))
else:
combo_area = None
combo_sizecomp = QComboBox(parent)
combo_sizecomp.setMaxVisibleItems(5)
combo_sizecomp.addItem("Все компании")
combo_sizecomp.resize(FRAME_WIDTH - 10, 20)
combo_sizecomp.move(5, 40)
combo_sizecomp.addItems([
work_with_data.decode_param(size_comp)
for size_comp in SIZE_COMPANY
])
combo_sizecomp.activated.connect(
lambda val, tab=code: self.refresh_plot(tab))
combo_exp = QComboBox(parent)
combo_exp.setMaxVisibleItems(10)
combo_exp.addItem("Любой опыт")
combo_exp.resize(FRAME_WIDTH - 10, 20)
combo_exp.move(5, 70)
combo_exp.addItems([
work_with_data.decode_param(experience)
for experience in EXPERIENCE
])
combo_exp.activated.connect(
lambda val, tab=code: self.refresh_plot(tab))
combo_empl = QComboBox(parent)
combo_empl.setMaxVisibleItems(10)
combo_empl.addItem("Любой график")
combo_empl.resize(FRAME_WIDTH - 10, 20)
combo_empl.move(5, 100)
combo_empl.addItems([
work_with_data.decode_param(employment)
for employment in EMPLOYMENT
])
combo_empl.activated.connect(
lambda val, tab=code: self.refresh_plot(tab))
items = {
'Lang': combo_lang,
'Area': combo_area,
'MinSal': sld_sal,
'SizeComp': combo_sizecomp,
'Employment': combo_empl,
'Experience': combo_exp,
'lbl_min': label_sal_val
}
return items
def create_filters_model(self, parent):
checks = {}
for i, lang in enumerate(LANGUAGES):
check = QCheckBox(parent)
check.setText(lang)
check.stateChanged.connect(self.check_action)
check.move(250 * (i % 4) + 80, 25 * (i // 4) + 25)
checks[lang] = check
combo_area = QComboBox(parent)
combo_area.setMaxVisibleItems(20)
combo_area.resize(WIND_HEIGHT / 2 - 80 - 20, 20)
combo_area.move(80, 200)
combo_area.addItems([work_with_data.decode_param(val) for val in AREA])
combo_empl = QComboBox(parent)
combo_empl.setMaxVisibleItems(10)
combo_empl.resize(WIND_HEIGHT / 2 - 80 - 20, 20)
combo_empl.move(WIND_HEIGHT / 2, 200)
combo_empl.addItems([
work_with_data.decode_param(employment)
for employment in EMPLOYMENT
])
combo_exp = QComboBox(parent)
combo_exp.setMaxVisibleItems(10)
combo_exp.resize(WIND_HEIGHT / 2 - 80 - 20, 20)
combo_exp.move(80, 240)
combo_exp.addItems([
work_with_data.decode_param(experience)
for experience in EXPERIENCE
])
combo_sizecomp = QComboBox(parent)
combo_sizecomp.setMaxVisibleItems(5)
combo_sizecomp.resize(WIND_HEIGHT / 2 - 80 - 20, 20)
combo_sizecomp.move(WIND_HEIGHT / 2, 240)
combo_sizecomp.addItems([
work_with_data.decode_param(size_comp)
for size_comp in SIZE_COMPANY
])
self.filter_model = {
'Lang': checks,
'Area': combo_area,
'Employment': combo_empl,
'Experience': combo_exp,
'SizeComp': combo_sizecomp
}
def set_style(self):
main_style = 'background: #ffffff;'
style_combobox = """
QComboBox{{
font-weight: 600;
background: {};
border: none;
}}
QComboBox QAbstractItemView {{
selection-color: #000000;
selection-background-color: {};
}}
QComboBox::drop-down{{
border: 1px;
}}
QComboBox::hover{{
background: {};
}}
""".format(self.color, self.color, self.second_color)
style_slider = """
QSlider::groove:horizontal {{
height: 3px;
background: #B0AEB1;
}}
QSlider::handle:horizontal {{
background: {};
border: 1px solid {};
width: 10px;
margin: -10px 0;
}}
QSlider::sub-page:qlineargradient {{
background: {};
}}
""".format(self.color, self.color, self.third_color)
style_filters = '''
background-color: #ffffff
'''
style_button = '''
QPushButton {{
background-color: {};
font: bold 12px;
border: 1px solid #ffffff;
}}
QPushButton:hover {{
background-color: {};
color: #ffffff;
}}
'''.format(self.color, self.third_color)
style_tabs = '''
QTabBar::tab {height: 0px; width: 0px;};
'''
style_checkbox = """
QCheckBox::indicator:checked {
image: url(sources//hh_enabled.png);
}
QCheckBox::indicator:unchecked {
image: url(sources//hh_notenabled.png);
}
"""
for key in self.all_filters:
for name_item in ('Area', 'Lang', 'SizeComp', 'Experience',
'Employment'):
if self.all_filters[key][name_item] is not None:
self.all_filters[key][name_item].setStyleSheet(
style_combobox)
# for name_item in ('SizeComp', 'Experience', 'Employment'):
# self.all_filters[key][name_item].setStyleSheet(style_combobox)
if self.all_filters[key]['MinSal'] is not None:
self.all_filters[key]['MinSal'].setStyleSheet(style_slider)
for key in self.filter_model:
if key in ('Area', 'SizeComp', 'Experience', 'Employment'):
self.filter_model[key].setStyleSheet(style_combobox)
if key in ('Lang', ):
for check in self.filter_model[key].values():
check.setStyleSheet(style_checkbox)
self.setStyleSheet(main_style)
self.filters_city1.setStyleSheet(style_filters)
self.filters_city2.setStyleSheet(style_filters)
self.filters_lang1.setStyleSheet(style_filters)
self.filters_lang2.setStyleSheet(style_filters)
self.button_lang.setStyleSheet(style_button)
self.button_city.setStyleSheet(style_button)
self.button_map.setStyleSheet(style_button)
self.button_model.setStyleSheet(style_button)
self.button_update.setStyleSheet(style_button)
self.tabs_map.setStyleSheet(style_tabs)
self.tabs_model.setStyleSheet(style_tabs)
self.button_forecast.setStyleSheet(style_button)
self.label_forecast.setStyleSheet("""
QLabel {{
font: bold 24px;
border: 1px solid #ffffff;
color: {};
}}
""".format(self.second_color))
# self.label_forecast.setFont(QFont("Times", 8, QFont.Bold))
def plot_all(self):
for nametab in ('Lang1', 'Lang2', 'City1', 'City2'):
self.refresh_plot(nametab)
self.draw_plot_map1()
def sld_action(self, value, nametab):
self.all_filters[nametab]['lbl_min'].setText(str(value * 5000))
self.refresh_plot(nametab)
def check_action(self):
active_checks = []
for lang, checkbox in self.filter_model['Lang'].items():
if checkbox.isChecked():
active_checks.append(lang)
if len(active_checks) >= MAX_LANG_MODEL:
for checkbox in self.filter_model['Lang'].values():
if not checkbox.isChecked():
checkbox.setEnabled(False)
else:
for checkbox in self.filter_model['Lang'].values():
checkbox.setEnabled(True)
self.button_forecast.setEnabled(bool(len(active_checks)))
def refresh_plot(self, tabname):
df_t = self.data
sal = self.all_filters[tabname]['MinSal']
if sal is not None:
min_sal = sal.value() * 5000
df_t = self.data[self.data['Salary'] > min_sal]
area = self.all_filters[tabname]['Area']
if area is not None and area.currentIndex():
area = work_with_data.encode_param(area.currentText())
df_t = df_t[df_t['Area'] == area]
lang = self.all_filters[tabname]['Lang']
if lang is not None and lang.currentIndex():
lang = lang.currentText()
df_t = df_t[df_t[lang] == 1]
if self.all_filters[tabname]['SizeComp'].currentIndex():
size_comp = work_with_data.encode_param(
self.all_filters[tabname]['SizeComp'].currentText())
df_t = df_t[df_t[size_comp] == 1]
if self.all_filters[tabname]['Experience'].currentIndex():
exp = work_with_data.encode_param(
self.all_filters[tabname]['Experience'].currentText())
df_t = df_t[df_t['Experience'] == exp]
if self.all_filters[tabname]['Employment'].currentIndex():
empl = work_with_data.encode_param(
self.all_filters[tabname]['Employment'].currentText())
df_t = df_t[df_t['Employment'] == empl]
if tabname == 'Lang1':
self.draw_plot_lang1(df_t)
elif tabname == 'Lang2':
self.draw_plot_lang2(df_t)
elif tabname == 'City1':
self.draw_plot_city1(df_t)
elif tabname == 'City2':
self.draw_plot_city2(df_t)
def draw_plot_lang1(self, data=None):
if data is None:
data = self.data
mass_sal = [(lang, data[data[lang] == 1]['Salary'].mean())
for lang in LANGUAGES]
mass_sal = [val for val in mass_sal if str(val[1]) != 'nan']
mass_sal.sort(key=lambda x: -x[1])
temp = list(zip(*mass_sal))
if not temp:
temp = [[], []]
self.plot_lang1.plot_bar(*temp, 'Средняя зарплата по языкам')
def draw_plot_lang2(self, data=None):
if data is None:
data = self.data
count_vac = [(lang, data[data[lang] == 1].shape[0])
for lang in LANGUAGES]
count_vac.sort(key=lambda x: -x[1])
count_vac = filter(lambda x: x[1] > 0, count_vac)
temp = list(zip(*count_vac))
if not temp:
temp = [[], []]
self.plot_lang2.plot_bar(*temp, 'Количество вакансий по языкам')
def draw_plot_city1(self, data=None):
if data is None:
data = self.data
mass_sal = [(area, data[data['Area'] == area]['Salary'].mean())
for area in AREA.keys()]
mass_sal = [val for val in mass_sal if str(val[1]) != 'nan']
mass_sal.sort(key=lambda x: -x[1])
temp = list(zip(*mass_sal))
if not temp:
temp = [[], []]
else:
temp[0] = [work_with_data.decode_param(city) for city in temp[0]]
self.plot_city1.plot_bar(*temp, 'Средняя зарплата по городам')
def draw_plot_city2(self, data=None):
if data is None:
data = self.data
count_vac = [(area, data[data['Area'] == area].shape[0])
for area in AREA.keys()]
count_vac.sort(key=lambda x: -x[1])
count_vac = filter(lambda x: x[1] > 0, count_vac)
temp = list(zip(*count_vac))
if not temp:
temp = [[], []]
else:
temp[0] = [work_with_data.decode_param(city) for city in temp[0]]
self.plot_city2.plot_bar(*temp, 'Количество вакансий по городам')
def draw_plot_map1(self, data=None):
if data is None:
data = self.data
mass_sal = [(area, data[data['Area'] == area].shape[0])
for area in AREA.keys()]
mass_sal = filter(lambda x: x[1] > 0, mass_sal)
temp = list(zip(*mass_sal))
min_vac = min(temp[1])
temp[1] = [vac / min_vac for vac in temp[1]]
self.plot_map1.plot_map(*temp, 'Количество вакансий по городам')
def create_forecast(self):
vacancy = []
for key in self.categorical_columns:
vacancy.append(
work_with_data.encode_param(
self.filter_model[key].currentText()))
for checkbox in self.filter_model['Lang'].values():
vacancy.append(int(checkbox.isChecked()))
for size_comp in SIZE_COMPANY:
vacancy.append(
int(
work_with_data.encode_param(self.filter_model['SizeComp'].
currentText()) == size_comp))
df = pd.DataFrame([vacancy],
columns=self.categorical_columns +
self.binary_columns)
self.label_forecast.setText('Возможная зарплата: {:.0f} руб'.format(
self.model.get_predict(df)[0]))
def update_data(self):
answer = QMessageBox.question(self, 'Обновление данных',
'Вы хотите обновить данные?',
QMessageBox.Ok | QMessageBox.Cancel,
QMessageBox.Cancel)
if answer == QMessageBox.Ok:
self.data = work_with_data.get_prepocess_data(True)
self.model = model.get_forest_model(self.data,
self.categorical_columns,
self.binary_columns)
self.plot_all()
