def init_gui():
app = QtWidgets.QApplication(sys.argv)
MainWindow = QtWidgets.QMainWindow()
ui = Ui_MainWindow()
ui.setupUi(MainWindow)
MainWindow.show()
sys.exit(app.exec_())
class Authorization(QtWidgets.QMainWindow):
def enter(self):
login = self.ui.loginEdit.text()
password = self.ui.passworEdit.text()
if get_password(login) is None:
QMessageBox.question(self, 'Error', 'Error', QMessageBox.Ok,
QMessageBox.Ok)
elif get_password(login).lower() == password.lower():
self.user_window = User(login)
self.user_window.show()
elif get_password(login).lower() == (password.lower() + '~1'):
self.w3 = Administrator(login)
self.w3.show()
else:
QMessageBox.question(self, 'Error', 'Error', QMessageBox.Ok,
QMessageBox.Ok)
def exit(self):
self.close()
def registration(self):
self.w2 = Account()
self.w2.show()
def __init__(self):
super(Authorization, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.enter.clicked.connect(self.enter)
self.ui.exit.clicked.connect(self.exit)
self.ui.reg.clicked.connect(self.registration)
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.comboBox.currentIndexChanged.connect(self.updateLabel)
self.ui.comboBox_2.currentIndexChanged.connect(self.updateLabel)
self.ui.comboBox_3.currentIndexChanged.connect(self.updateLabel)
self.ui.comboBox_4.currentIndexChanged.connect(self.updateLabel)
self.ui.comboBox_5.currentIndexChanged.connect(self.updateLabel)
self.ui.comboBox_6.currentIndexChanged.connect(self.updateLabel)
def updateLabel(self):
currentDataArr = [
str(determineValue(self.ui.comboBox.currentText())),
str(determineValue(self.ui.comboBox_2.currentText())),
str(determineValue(self.ui.comboBox_3.currentText())),
str(determineValue(self.ui.comboBox_4.currentText())),
str(determineValue(self.ui.comboBox_5.currentText())),
str(determineValue(self.ui.comboBox_6.currentText()))
]
result = ''
for i in range(len(currentDataArr)):
if currentDataArr[i] == '-1':
continue
result = result + currentDataArr[i]
self.ui.label.setText(result + " ohms")
class MyWindow(QtWidgets.QMainWindow):
def __init__(self):
super(MyWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.download_btn.clicked.connect(self.download)
self.ui.get_lex.clicked.connect(self.analysis)
def download(self):
path = self.ui.pathfile.text()
with open(path) as file:
data = file.readlines()
self.ui.listWidget.addItems(data)
def analysis(self):
lex_list = []
for index in range(self.ui.listWidget.count()):
for item_pair in lex_analysis(
self.ui.listWidget.item(index).text()):
lex_list.append(item_pair)
self.ui.tableWidget.setRowCount(len(lex_list))
row = 1
for lexem, lexem_type in lex_list:
self.ui.tableWidget.setItem(row, 0,
QtWidgets.QTableWidgetItem(lexem))
self.ui.tableWidget.setItem(row, 1,
QtWidgets.QTableWidgetItem(lexem_type))
row += 1
class MatplotlibWidget(QMainWindow):
def __init__(self):
super().__init__()
#loadUi("design.ui", self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowTitle("yet another title (im bad at names)")
self.ui.MplWidget.canvas.axes.format_coord = lambda x, y: ""
self.addToolBar(2, NavigationToolbar2QT(self.ui.MplWidget.canvas,
self))
self.ui.MplWidget.canvas.mpl_connect("motion_notify_event",
self.handle_mouse_moved)
self.draw_graph()
def handle_mouse_moved(self, event):
if event.xdata is not None and event.ydata is not None:
#print(f"x: {event.xdata:.2f}, y: {event.ydata:.2f}")
self.ui.statusbar.showMessage(
f"x: {event.xdata:.2f}, y: {event.ydata:.2f}")
def draw_graph(self):
fq = randint(1, 100)
ln = 100
t = np.linspace(0, 1, ln)
wave = np.cos(2 * np.pi * fq * t)
self.ui.MplWidget.canvas.axes.clear()
self.ui.MplWidget.canvas.axes.plot(wave)
self.ui.MplWidget.canvas.draw()
class eitMain(QMainWindow):
def __init__(self):
super(eitMain, self).__init__()
self.ui = Ui_MainWindow() #Opens the main window.
self.ui.setupUi(self)
self.ui.searchBtn.clicked.connect(
self.charSearch) #this is the search button.
self.ui.actionExit.triggered.connect(
QApplication.quit) #This is the quit option in the menu bar.
def charSearch(
self
): #this passes the text from the search box to the later thing that actually searches.
self.charName = self.ui.charSearch.text()
esiFunction.charIntelSearch(self, eitMain)
def noResults(
self
): #this is displayed if your search has no results, otherwise it would crash.
noResults = QMessageBox()
noResults.setIcon(QMessageBox.Information)
noResults.setText("No Results Found.")
noResults.setInformativeText(
"Search must be exact.\n\nCase Sensitive.")
noResults.setStandardButtons(QMessageBox.Ok)
noResults.setWindowTitle("Error")
noResults.exec_()
self.ui.searchBtn.clicked.connect(self.charSearch)
class sayiTahmin (QMainWindow):
pc_sayi = random.randint(1, 100)
flag = False
kalan_hak = 4
def __init__(self):
super().__init__()
self.ui=Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowIcon(QIcon(":\icons/num.jpg"))
self.ui.txt_kalanhak.setText(str(self.kalan_hak + 1))
self.ui.txt_tahmin.returnPressed.connect(self.tahminet)
self.ui.btn_yenioyun.clicked.connect(self.yeniOyun)
def yeniOyun(self):
self.kalan_hak=4
self.flag=False
self.ui.txt_sonuc.setText("Yeni Oyun Başladı")
self.ui.txt_tahmin.setText("")
self.ui.txt_kalanhak.setText(str(self.kalan_hak + 1))
self.pc_sayi = random.randint(1, 100)
def tahminet(self):
try:
girilenSayi = int(self.ui.txt_tahmin.text())
if self.pc_sayi == int(girilenSayi):
self.ui.txt_sonuc.setText("Tebrikler doğru bildiniz.. " + str(self.pc_sayi))
self.flag = True
self.ui.txt_tahmin.setText("")
#self.yeniOyun()
elif self.kalan_hak == 0:
self.ui.txt_sonuc.setText(
"Son hakkında da bilemedin ve hakkın bitti.. Başka bir oyunda tekrar deneyin. \n Doğru sayi: " + str(
self.pc_sayi))
self.ui.txt_tahmin.setText("")
self.ui.txt_kalanhak.setText(str(self.kalan_hak))
elif int(girilenSayi) > self.pc_sayi:
self.ui.txt_sonuc.setText(
"Tekrar Deneyin.. İpucu: Daha küçük sayi girin.. ")
# Kalan hakkınız: " + str(self.kalan_hak))
self.kalan_hak -= 1
self.ui.txt_kalanhak.setText(str(self.kalan_hak + 1))
self.ui.txt_tahmin.setText("")
else:
self.ui.txt_sonuc.setText(
"Tekrar Deneyin.. İpucu: Daha büyük bir sayi girin..")
# Kalan hakkınız: " + str(self.kalan_hak))
self.kalan_hak -= 1
self.ui.txt_kalanhak.setText(str(self.kalan_hak + 1))
self.ui.txt_tahmin.setText("")
except ValueError:
self.ui.txt_sonuc.setText("Sayi giriniz..")
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.label.setText('Hello4!')
self.ui.label.setFont(QtGui.QFont('SansSerif', 25))
self.ui.label.setFixedHeight(50)
class interface(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.text=None
self.scroll = QScrollArea()
self.scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.ui.setupUi(self)
self.grid = QGridLayout()
self.ui.label.setLayout(self.grid)
self.list_img=[]
self.ui.pushButton.clicked.connect(self.search)
#self.create_labels(self.list_img)
def search(self):
self.text=self.ui.textEdit.toPlainText()
self.get_img_database(self.text)
if (len(self.text)!=0):
self.list_img = self.get_img_database(self.text)
if (len(self.list_img)==0):
QMessageBox.warning(self, 'Error', 'There is no image about search key')
else:
self.create_labels(self.list_img)
else:
QMessageBox.warning(self, 'Error', 'There is no search key')
def location(self,i):
y=int(i/4)
x=int(i%4)
return x,y
def create_labels(self,list):
for i in reversed(range(self.grid.count())):
self.grid.itemAt(i).widget().setParent(None)
for i in range(0,len(list)):
label1=QLabel()
label1.setAlignment(Qt.AlignCenter)
req = Request(list[i],headers={'User-Agent': 'Mozilla/5.0'})
url_data = urllib2.urlopen(req).read()
self.pm = QPixmap() #.scaled(250, 250, Qt.KeepAspectRatio,Qt.SmoothTransformation)
self.pm.loadFromData(url_data)
label1.setPixmap(self.pm)
x,y=self.location(i)
self.grid.addWidget(label1, y, x)
def get_img_database(self,key):
cluster = MongoClient("mongodb+srv://muho:84437**[email protected]/muho?retryWrites=true&w=majority")
db = cluster["muho"]
collection = db["images"]
regx = re.compile("{}".format(key), re.IGNORECASE)
collections = collection.find({"caption": regx})
url_list=[]
for x in collections:
if "https" in x["url"]:
if (len(url_list)<20):
url_list.append(x['url'])
return url_list
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.progressBar.setRange(0, 100)
self.ui.progressBar.setValue(10)
self.ui.horizontalSlider.setValue(35)
self.ui.calendarWidget.setSelectedDate(QtCore.QDate(1993, 5, 5))
self.ui.pushButton.clicked.connect(self.btn_click)
def btn_click(self):
self.ui.textEdit.setText("Button was clicked")
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.label.setFont(QtGui.QFont('SansSerif', 30))
self.ui.label.setGeometry(QtCore.QRect(
10, 10, 200, 200)) # изменить геометрию ярлыка
self.ui.pushButton.clicked.connect(self.move_label)
def _move_second_label(self):
while True:
x = self.ui.label.x()
y = self.ui.label.y()
rand_x = random.randint(-4, 4)
rand_y = random.randint(-4, 4)
self.ui.label.move(x + rand_x, y + rand_y)
time.sleep(0.1)
def _move_first_label(self):
while True:
x = self.ui.label_2.x()
y = self.ui.label_2.y()
rand_x = random.randint(-8, 8)
rand_y = random.randint(-8, 8)
self.ui.label_2.move(x + rand_x, y + rand_y)
time.sleep(0.1)
def _move_third_label(self):
while True:
x = self.ui.label_2.x()
y = self.ui.label_2.y()
rand_x = random.randint(-10, 10)
rand_y = random.randint(-10, 10)
self.ui.label_3.move(x + rand_x, y + rand_y)
time.sleep(0.1)
def move_label(self):
threading.Thread(target=(self._move_first_label)).start()
threading.Thread(target=(self._move_second_label)).start()
threading.Thread(target=(self._move_third_label)).start()
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.mosStyleLable.setText("")
self.ui.petStyleLabe.setText("")
self.ui.splitBtn.clicked.connect(self.splitBtn_clicked)
def splitBtn_clicked(self):
self.ui.mosStyleLable.setText(
MoscowSpliter(self.ui.inputTextField.toPlainText()))
self.ui.petStyleLabe.setText(
PeterSpliter(self.ui.inputTextField.toPlainText()))
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.mutex = threading.Lock()
self.semaphore = threading.Semaphore()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.pushButton.clicked.connect(self.start_threads)
def set_mutext_color(self, color):
self.mutex.acquire()
try:
self.ui.mutex_label.setStyleSheet(f"background-color:{color};")
time.sleep(0.1)
finally:
self.mutex.release()
def set_semaphor_color(self, color):
self.semaphore.acquire()
try:
self.ui.semaphor_label.setStyleSheet(f"background-color:{color};")
time.sleep(0.1)
finally:
self.semaphore.release()
def start_mutext(self, color):
while True:
self.set_mutext_color(color)
time.sleep(0.2)
def start_semaphor(self, color):
while True:
self.set_semaphor_color(color)
time.sleep(0.1)
def start_threads(self):
threading.Thread(target=self.start_mutext, args=('#0000FF', )).start()
threading.Thread(target=self.start_mutext, args=('#ffff00',)).start()
threading.Thread(target=self.start_mutext, args=('#000000', )).start()
threading.Thread(target=self.start_semaphor, args=('#ffff00', )).start()
threading.Thread(target=self.start_semaphor, args=('#0000FF', )).start()
threading.Thread(target=self.start_semaphor, args=('#000000', )).start()
class Calculator(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.number_string = '0'
# falta-me criar o grupo dos botões no designer
for button in self.ui.digits.buttons():
button.clicked.connect(self.add_digit)
self.show()
def add_digit(self):
number = self.sender()
self.ui.LCD.display(self.number_string)
class ApplicationWindow(QtWidgets.QMainWindow):
signal = list()
cur = 0
flag = 1
ran = 50
def __init__(self):
super(ApplicationWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.timer = QtCore.QTimer()
self.timer.setInterval(10)
self.timer.timeout.connect(self.pan)
self.timer.start()
def open_dialog_box(self):
print("heelll")
filename = QFileDialog.getOpenFileName()
path = filename[0]
signal = np.genfromtxt(path, delimiter=',')
self.ui.plotWindow.plot(list(range(len(signal))), signal)
self.ui.plotWindow.setXRange(self.cur, self.cur + self.ran)
def pan(self):
if not self.flag:
self.ui.plotWindow.setXRange(self.cur, self.cur + self.ran)
self.cur = self.cur + 0.1
def play(self):
self.flag = 0
def pause(self):
self.flag = 1
def zoomin(self):
self.ran = max(5, self.ran - 5)
self.ui.plotWindow.setXRange(self.cur, self.cur + self.ran)
def zoomout(self):
self.ran = min(100, self.ran + 5)
self.ui.plotWindow.setXRange(self.cur, self.cur + self.ran)
import pyqrcode
from PIL import Image
from PySide2.QtGui import QPixmap
from PySide2.QtWidgets import *
from pyzbar.pyzbar import decode
from design import Ui_MainWindow
# create app
app = QApplication()
# init
Window = QMainWindow(None)
ui = Ui_MainWindow()
ui.setupUi(Window)
Window.show()
# hook logic
def error():
return ('H', 'Q', 'M', 'L')[ui.correction_level.currentIndex()]
def version():
return ui.version.value()
def scale():
return 177 / (21 + 4 * (version() - 1)) * 1.66
import os
class MainWindow(QMainWindow):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent=parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.figure = Figure()
self.figureCanvas = FigureCanvas(self.figure)
self.plotToolbar = NavigationToolbar(self.figureCanvas, self)
self.data = StiffnessData()
def setup_ui(self):
self.ui.plotLayout.addWidget(self.figureCanvas)
self.ui.plotLayout.addWidget(self.plotToolbar)
self.setup_handlers()
def setup_handlers(self):
self.ui.setupBraketParametersBtn.clicked.connect(
self.bracket_parameters_setup)
self.ui.meshGenerateBtn.clicked.connect(self.mesh_parameters_setup)
self.ui.setupLFparametersBtn.clicked.connect(
self.load_fix_parameters_setup)
self.ui.loadTypeBox.currentIndexChanged.connect(
self.load_fix_box_type_changed)
self.ui.fixTypeBox.currentIndexChanged.connect(
self.load_fix_box_type_changed)
def draw_plot(self):
axis = self.figure.add_subplot(121) if len(
self.figure.get_axes()) == 0 else self.figure.get_axes()[0]
bracket = default_bracket.copy()
bracket.append(bracket[0])
bracket = np.array(bracket)
axis.plot(bracket[:, 0], bracket[:, 1], c="blue")
def draw_mesh(self):
x = self.data.get_tri_x()
y = self.data.get_tri_y()
if x is not None and y is not None:
axis = self.figure.get_axes()[0] if len(
self.figure.get_axes()) > 0 else self.figure.add_subplot(121)
axis.triplot(x, y, self.data.tri.simplices, c="lime")
axis.plot(x, y, 'o')
self.figure.canvas.draw()
def calculate(self, p):
if self.data.is_prepared():
self.data.set_fixing(Node(default_bracket[0]))
self.data.set_fixing(Node(default_bracket[1]))
self.data.set_load(Node(default_bracket[2]), p)
fg = Finite2DGenerator(self.data)
moving = fg.calculate_moving()
self.ui.resultText.setText(f"0 - {min(moving)}")
fg.draw_displaced(
self.figure.add_subplot(122) if len(self.figure.get_axes()) < 2
else self.figure.get_axes()[1])
self.figure.canvas.draw()
else:
self.show_popup("Ошибка", "Не введены необходимые данные")
def bracket_parameters_setup(self):
try:
y = float(self.ui.youngaParameter.text())
m = float(self.ui.poissonParameter.text())
h = float(self.ui.thicknessParameter.text())
self.ui.bracketParametersText.setText(f"""Параметры кронштейна:
Коэффициент Юнга: {y}
Коэффициент Пуассона: {m}
Толщина кронштейна: {h} мм""")
self.data.poisson, self.data.young, self.data.thickness = m, y, float(
h) / 1000.0
self.draw_plot()
self.ui.pageMesh.setEnabled(True)
except ValueError:
self.show_popup("Ошибка ввода", "Неккоректное число")
def mesh_parameters_setup(self):
try:
size = float(self.ui.meshSizeInput.text())
self.data.define_nodes_mesh(default_bracket.copy(), size)
self.draw_mesh()
self.setup_node_fix_load_info()
self.set_checkable_boxes()
val = float(self.ui.powerValue.text())
self.calculate(val)
except ValueError as e:
self.show_popup("Ошибка ввода", "Неккоректное число",
QMessageBox.Critical, None, f"{e}\n{e}")
def load_fix_parameters_setup(self):
fix = self.ui.fixParametersBox.findChildren(QtWidgets.QCheckBox)
load = self.ui.loadParametersBox.findChildren(QtWidgets.QCheckBox)
fix_indexes = []
load_indexes = []
i = 0
for f, l in zip(fix, load):
if f.isEnabled() and f.isChecked():
fix_indexes.append(self.define_node_edge(f.text(), i))
if l.isEnabled() and l.isChecked():
load_indexes.append(self.define_node_edge(l.text(), i))
i += 1
if self.check_fix_load_validate(fix_indexes, load_indexes):
print(fix_indexes, load_indexes)
@staticmethod
def define_node_edge(text, default_value):
for i in default_bracket:
if text == f"{i}":
return i
return default_value
def check_fix_load_validate(self, fix, load):
valid = True
if len(fix) == 0 or len(load) == 0:
self.show_popup("Неверные данные",
"Не заданы закрепления или фиксация",
QMessageBox.Warning)
valid = False
elif len(fix) + len(load) > 3:
self.show_popup("Неверные данные",
"Закрепления и фиксация заданны не корректно",
QMessageBox.Warning)
valid = False
elif len([e for e in fix if e in load]) > 0:
self.show_popup("Неверные данные",
"Закрепления и фиксация совпадают",
QMessageBox.Warning)
valid = False
return valid
def load_fix_box_type_changed(self):
self.set_checkable_boxes()
def set_checkable_boxes(self):
if self.ui.fixTypeBox.currentIndex() == 0:
self.enable_fix_node_checkboxes()
else:
self.enable_fix_node_checkboxes(False)
if self.ui.loadTypeBox.currentIndex() == 0:
self.enable_load_node_checkboxes()
else:
self.enable_load_node_checkboxes(False)
def setup_node_fix_load_info(self):
fix = self.ui.fixParametersBox.findChildren(QtWidgets.QCheckBox)[0:3]
load = self.ui.loadParametersBox.findChildren(QtWidgets.QCheckBox)[0:3]
index = 0
for f, l in zip(fix, load):
f.setText(f"{default_bracket[index]}")
l.setText(f"{default_bracket[index]}")
index += 1
self.ui.bottomFixNodeCheckBox.setChecked(True)
self.ui.leftFixNodeCheckBox.setChecked(True)
self.ui.rightLoadNodeCheckBox.setChecked(True)
def enable_fix_node_checkboxes(self, enable=True):
self.enable_checkboxes(self.ui.fixParametersBox, 0, 3, enable)
self.enable_checkboxes(self.ui.fixParametersBox, 3, 6, not enable)
def enable_load_node_checkboxes(self, enable=True):
self.enable_checkboxes(self.ui.loadParametersBox, 0, 3, enable)
self.enable_checkboxes(self.ui.loadParametersBox, 3, 6, not enable)
@staticmethod
def enable_checkboxes(widget, i, j, enable):
for w in widget.findChildren(QtWidgets.QCheckBox)[i:j]:
w.setCheckable(enable)
w.setEnabled(enable)
@staticmethod
def show_popup(title,
text,
icon=QMessageBox.Critical,
info=None,
details=None):
msg = QMessageBox()
msg.setWindowTitle(title)
msg.setText(text)
msg.setIcon(icon)
if info is not None:
msg.setInformativeText(info)
if details is not None:
msg.setDetailedText(details)
return msg.exec_()
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.label_UserInf_Status.setText(get_YesNo(admin.pravchange))
self.user = admin
self.ui.pushButton_GenPass.clicked.connect(self.btnGenPass)
self.ui.pushButton_SaveFile_Pass.clicked.connect(self.btnSaveFile_Pass)
self.ui.pushButton_Shifr.clicked.connect(self.btnShifr)
self.ui.pushButton_DeShifr.clicked.connect(self.btnDeShifr)
self.ui.pushButton_SaveFile_Shifr.clicked.connect(
self.btnSaveFile_Shifr)
self.ui.lineEdit_Fraza.textChanged.connect(self.updateAllTwoChange)
self.ui.lineEdit_Poradak_Stolb.textChanged.connect(
self.updatePoradak_Stolb)
self.ui.lineEdit_Poradak_Strok.textChanged.connect(
self.updatePoradak_Strok)
self.ui.checkBox_FilePravEdit_Ban.clicked.connect(
lambda: self.btnCheckBox_StatusChange('ban'))
self.ui.checkBox_FilePravEdit_Write.clicked.connect(
lambda: self.btnCheckBox_StatusChange('write'))
self.ui.checkBox_FilePravEdit_Read.clicked.connect(
lambda: self.btnCheckBox_StatusChange('read'))
self.ui.checkBox_FilePravEdit_Full.clicked.connect(
lambda: self.btnCheckBox_StatusChange('full'))
self.ui.checkBox_FilePravEdit_SendPrav.clicked.connect(
lambda: self.btnCheckBox_StatusChange('sendprav'))
self.ui.comboBox_UserInf_User.view().pressed.connect(
self.updateSelectUser)
self.ui.comboBox_ChangePrav_User.view().pressed.connect(
self.updatePravSelectUser)
self.ui.comboBox_ChangePrav_Type.view().pressed.connect(
self.updatePravUser)
self.ui.comboBox_FileLook_File.view().pressed.connect(
self.updateListPrav)
self.ui.comboBox_FilePravEdit_File.view().pressed.connect(
self.updateSelectPravChangeFile)
self.ui.comboBox_FilePravEdit_User.view().pressed.connect(
self.updateSelectPravChangeUser)
self.ui.label_FileLook_Ban.setText(get_YesNo(self.user.file1.ban))
self.ui.label_FileLook_Write.setText(get_YesNo(self.user.file1.write))
self.ui.label_FileLook_Read.setText(get_YesNo(self.user.file1.read))
self.ui.label_FileLook_Full.setText(get_YesNo(self.user.file1.full))
self.ui.label_FileLook_SendPrav.setText(
get_YesNo(self.user.file1.sendprav))
self.ui.comboBox_FilePravEdit_File.clear()
if self.user.file1.sendprav or self.user.file1.full:
self.ui.comboBox_FilePravEdit_File.addItem('File1')
if self.user.file2.sendprav or self.user.file1.full:
self.ui.comboBox_FilePravEdit_File.addItem('File2')
if self.user.file3.sendprav or self.user.file1.full:
self.ui.comboBox_FilePravEdit_File.addItem('File3')
if self.user.file4.sendprav or self.user.file1.full:
self.ui.comboBox_FilePravEdit_File.addItem('File4')
self.ui.comboBox_FilePravEdit_User.setCurrentIndex(0)
self.ui.comboBox_FilePravEdit_File.setCurrentIndex(0)
filename = self.ui.comboBox_FilePravEdit_File.currentText()
user = self.ui.comboBox_FilePravEdit_User.currentText()
self.change_LookPravFile(self.get_FileName(user, filename))
# self.ui.lineEdit_Fraza.setInputMask('XXXXXXXXXXXXXXXXXXXXXXXXX')
self.ui.lineEdit_Poradak_Stolb.setInputMask('99999')
self.ui.lineEdit_Poradak_Strok.setInputMask('99999')
self.updateTableUserPrav()
self.ui.tableWidget_Osn.setColumnWidth(0, 20)
self.ui.tableWidget_Osn.setColumnWidth(1, 20)
self.ui.tableWidget_Osn.setColumnWidth(2, 20)
self.ui.tableWidget_Osn.setColumnWidth(3, 20)
self.ui.tableWidget_Osn.setColumnWidth(4, 20)
self.ui.tableWidget_Stolb.setColumnWidth(0, 20)
self.ui.tableWidget_Stolb.setColumnWidth(1, 20)
self.ui.tableWidget_Stolb.setColumnWidth(2, 20)
self.ui.tableWidget_Stolb.setColumnWidth(3, 20)
self.ui.tableWidget_Stolb.setColumnWidth(4, 20)
self.ui.tableWidget_Strok.setColumnWidth(0, 20)
self.ui.tableWidget_Strok.setColumnWidth(1, 20)
self.ui.tableWidget_Strok.setColumnWidth(2, 20)
self.ui.tableWidget_Strok.setColumnWidth(3, 20)
self.ui.tableWidget_Strok.setColumnWidth(4, 20)
def updatePoradak_Stolb(self):
poradok_text_stolb = self.ui.lineEdit_Poradak_Stolb.text()
if len(poradok_text_stolb) == 5:
symbol_list = ['6', '7', '8', '9', '0']
status = True
for i, text in enumerate(symbol_list):
if not poradok_text_stolb.find(text) == -1:
status = False
if status:
self.updateAllTwoChange()
else:
self.ui.lineEdit_Poradak_Stolb.setText('12345')
error(
'Введите числа для задания порадка в диапазоне от 1 до 5!')
else:
self.ui.lineEdit_Poradak_Stolb.setText('12345')
error('Заполните порядок столбцов!')
def updatePoradak_Strok(self):
poradok_text_stolb = self.ui.lineEdit_Poradak_Stolb.text()
poradok_text_line = self.ui.lineEdit_Poradak_Strok.text()
if len(poradok_text_line) == 5:
symbol_list = ['6', '7', '8', '9', '0']
status = True
for i, text in enumerate(symbol_list):
if not poradok_text_line.find(text) == -1:
status = False
if status:
self.updateAllTwoChange()
else:
self.ui.lineEdit_Poradak_Strok.setText('12345')
error(
'Введите числа для задания порадка в диапазоне от 1 до 5!')
else:
self.ui.lineEdit_Poradak_Strok.setText('12345')
error('Заполните порядок строк!')
def updateAllTwoChange(self):
poradok_text_stolb = self.ui.lineEdit_Poradak_Stolb.text()
poradok_text_line = self.ui.lineEdit_Poradak_Strok.text()
old_text = self.ui.lineEdit_Fraza.text().ljust(25, " ")
twochange.list_text = []
for i in range(5):
twochange.list_text.append(old_text[i * 5:i * 5 + 5])
for i, text in enumerate(twochange.list_text):
j = 0
for j in range(5):
self.ui.tableWidget_Osn.setItem(
i, j, QTableWidgetItem(text[j:j + 1]))
j += 1
twochange.list_stolb = []
for i, text in enumerate(twochange.list_text):
new_text = ''
for j in range(5):
count = int(poradok_text_stolb[j:j + 1])
new_text += text[count - 1:count]
twochange.list_stolb.append(new_text)
for i, text in enumerate(twochange.list_stolb):
for j in range(5):
self.ui.tableWidget_Stolb.setItem(
i, j, QTableWidgetItem(text[j:j + 1]))
j += 1
twochange.list_line = ['', '', '', '', '']
for i in range(5):
stroka_text = ''
count = int(poradok_text_line[i:i + 1])
for j, text in enumerate(twochange.list_stolb):
stroka_text += text[count - 1:count]
twochange.list_line[i] = stroka_text
for i, text in enumerate(twochange.list_line):
for j in range(5):
self.ui.tableWidget_Strok.setItem(
i, j, QTableWidgetItem(text[j:j + 1]))
j += 1
def updateSelectPravChangeFile(self, index):
item = self.ui.comboBox_FilePravEdit_File.model().itemFromIndex(
index).row()
self.ui.comboBox_FilePravEdit_File.setCurrentIndex(item)
filename = self.ui.comboBox_FilePravEdit_File.currentText()
user = self.ui.comboBox_FilePravEdit_User.currentText()
self.change_LookPravFile(self.get_FileName(user, filename))
def updateSelectPravChangeUser(self, index):
self.ui.comboBox_FilePravEdit_File.clear()
if self.user.file1.sendprav or self.user.file1.full:
self.ui.comboBox_FilePravEdit_File.addItem('File1')
if self.user.file2.sendprav or self.user.file2.full:
self.ui.comboBox_FilePravEdit_File.addItem('File2')
if self.user.file3.sendprav or self.user.file3.full:
self.ui.comboBox_FilePravEdit_File.addItem('File3')
if self.user.file4.sendprav or self.user.file4.full:
self.ui.comboBox_FilePravEdit_File.addItem('File4')
item = self.ui.comboBox_FilePravEdit_User.model().itemFromIndex(
index).row()
self.ui.comboBox_FilePravEdit_User.setCurrentIndex(item)
filename = self.ui.comboBox_FilePravEdit_File.currentText()
user = self.ui.comboBox_FilePravEdit_User.currentText()
self.change_LookPravFile(self.get_FileName(user, filename))
def updateSelectUser(self, index):
item = self.ui.comboBox_UserInf_User.model().itemFromIndex(index).row()
self.ui.comboBox_UserInf_User.setCurrentIndex(item)
self.user = self.get_UserName(
self.ui.comboBox_UserInf_User.currentText())
self.ui.comboBox_FileLook_File.setCurrentIndex(0)
self.ui.label_FileLook_Ban.setText(get_YesNo(self.user.file1.ban))
self.ui.label_FileLook_Write.setText(get_YesNo(self.user.file1.write))
self.ui.label_FileLook_Read.setText(get_YesNo(self.user.file1.read))
self.ui.label_FileLook_Full.setText(get_YesNo(self.user.file1.full))
self.ui.label_FileLook_SendPrav.setText(
get_YesNo(self.user.file1.sendprav))
self.ui.comboBox_FilePravEdit_User.setCurrentIndex(0)
self.ui.comboBox_FilePravEdit_File.setCurrentIndex(0)
if self.user.pravchange == True:
self.ui.groupBox_ChangePrav.setVisible(True)
self.ui.comboBox_ChangePrav_User.setCurrentIndex(0)
self.ui.label_UserInf_Status.setText(
get_YesNo(self.user.pravchange))
self.ui.comboBox_ChangePrav_Type.setCurrentIndex(
get_UserPrav(user1))
else:
self.ui.groupBox_ChangePrav.setVisible(False)
self.ui.label_UserInf_Status.setText(
get_YesNo(self.user.pravchange))
self.ui.comboBox_FilePravEdit_File.setEnabled(True)
self.ui.comboBox_FilePravEdit_User.setEnabled(True)
self.ui.checkBox_FilePravEdit_Ban.setEnabled(True)
self.ui.checkBox_FilePravEdit_Write.setEnabled(True)
self.ui.checkBox_FilePravEdit_Read.setEnabled(True)
self.ui.checkBox_FilePravEdit_Full.setEnabled(True)
self.ui.checkBox_FilePravEdit_SendPrav.setEnabled(True)
self.ui.comboBox_FilePravEdit_File.clear()
if self.user.file1.sendprav or self.user.file1.full:
self.ui.comboBox_FilePravEdit_File.addItem('File1')
if self.user.file2.sendprav or self.user.file2.full:
self.ui.comboBox_FilePravEdit_File.addItem('File2')
if self.user.file3.sendprav or self.user.file3.full:
self.ui.comboBox_FilePravEdit_File.addItem('File3')
if self.user.file4.sendprav or self.user.file4.full:
self.ui.comboBox_FilePravEdit_File.addItem('File4')
if self.ui.comboBox_FilePravEdit_File.currentText(
) and self.ui.comboBox_FilePravEdit_User.currentText():
filename = self.ui.comboBox_FilePravEdit_File.currentText()
user = self.ui.comboBox_FilePravEdit_User.currentText()
self.change_LookPravFile(self.get_FileName(user, filename))
else:
self.ui.comboBox_FilePravEdit_File.setEnabled(False)
self.ui.comboBox_FilePravEdit_User.setEnabled(False)
self.ui.checkBox_FilePravEdit_Ban.setEnabled(False)
self.ui.checkBox_FilePravEdit_Write.setEnabled(False)
self.ui.checkBox_FilePravEdit_Read.setEnabled(False)
self.ui.checkBox_FilePravEdit_Full.setEnabled(False)
self.ui.checkBox_FilePravEdit_SendPrav.setEnabled(False)
def updatePravSelectUser(self, index):
# item = self.ui.comboBox_ChangePrav_User.model().itemFromIndex(index).row()
# if item == 0:
# self.ui.comboBox_ChangePrav_Type.setCurrentIndex(get_UserPrav(user1))
# elif item == 1:
# self.ui.comboBox_ChangePrav_Type.setCurrentIndex(get_UserPrav(user2))
# elif item == 2:
# self.ui.comboBox_ChangePrav_Type.setCurrentIndex(get_UserPrav(user3))
# elif item == 3:
# self.ui.comboBox_ChangePrav_Type.setCurrentIndex(get_UserPrav(user4))
item = self.ui.comboBox_ChangePrav_User.model().itemFromIndex(
index).row()
self.ui.comboBox_ChangePrav_User.setCurrentIndex(item)
self.ui.comboBox_ChangePrav_Type.setCurrentIndex(
get_UserPrav(
self.get_UserName(
self.ui.comboBox_ChangePrav_User.currentText())))
def updatePravUser(self, index):
def update_UserPrav(user, type):
if type == 0:
user.pravchange = True
else:
user.pravchange = False
user = self.ui.comboBox_ChangePrav_User.currentText()
item = self.ui.comboBox_ChangePrav_Type.model().itemFromIndex(
index).row()
if self.user.pravchange == True:
update_UserPrav(self.get_UserName(user), item)
self.ui.comboBox_ChangePrav_Type.setCurrentIndex(item)
if self.user.user == user:
self.ui.label_UserInf_Status.setText(
get_YesNo(self.user.pravchange))
self.ui.groupBox_ChangePrav.setVisible(False)
error(
f'Права пользователя {user} на редактирование прав других пользователей изменены!'
)
else:
error(f'Вы не можете изменять права!')
def updateListPrav(self, index):
item = self.ui.comboBox_FileLook_File.model().itemFromIndex(
index).row()
self.ui.comboBox_FileLook_File.setCurrentIndex(item)
file = self.get_FileName(self.user,
self.ui.comboBox_FileLook_File.currentText())
self.ui.label_FileLook_Ban.setText(get_YesNo(file.ban))
self.ui.label_FileLook_Write.setText(get_YesNo(file.write))
self.ui.label_FileLook_Read.setText(get_YesNo(file.read))
self.ui.label_FileLook_Full.setText(get_YesNo(file.full))
self.ui.label_FileLook_SendPrav.setText(get_YesNo(file.sendprav))
def btnCheckBox_StatusChange(self, param):
def cheakPravForFile(file):
if not file.ban and not file.full and not file.read and not file.write and not file.sendprav:
file.ban = True
self.ui.checkBox_FilePravEdit_Ban.setChecked(True)
file.write = False
self.ui.checkBox_FilePravEdit_Write.setChecked(False)
file.read = False
self.ui.checkBox_FilePravEdit_Read.setChecked(False)
file.sendprav = False
self.ui.checkBox_FilePravEdit_SendPrav.setChecked(False)
file.full = False
self.ui.checkBox_FilePravEdit_Full.setChecked(False)
def get_PravStatusUser(file, param):
if param == 'ban':
return file.ban
elif param == 'write':
return file.write
elif param == 'read':
return file.read
elif param == 'full':
return file.full
elif param == 'sendprav':
return file.sendprav
file = self.get_FileName(
self.ui.comboBox_FilePravEdit_User.currentText(),
self.ui.comboBox_FilePravEdit_File.currentText())
status = get_PravStatusUser(file, param)
if param == 'ban':
if status:
self.change_PravFile(file, False, True, True, True, True)
else:
self.change_PravFile(file, True, False, False, False, False)
elif param == 'full':
if status:
self.change_PravFile(file, False, None, None, None, False)
else:
self.change_PravFile(file, False, True, True, True, True)
elif param == 'write':
if status:
self.change_PravFile(file, False, False, None, None, None)
else:
self.change_PravFile(file, False, True, None, None, None)
elif param == 'read':
if status:
self.change_PravFile(file, False, None, False, None, None)
else:
self.change_PravFile(file, False, None, True, None, None)
elif param == 'sendprav':
if status:
self.change_PravFile(file, False, None, None, False, None)
else:
self.change_PravFile(file, False, None, None, True, None)
cheakPravForFile(file)
self.change_LookPicFile(self.user,
self.ui.comboBox_FileLook_File.currentText())
self.updateTableUserPrav()
# def cheakPravForFile(self, file):
# if not file.ban and not file.full and not file.read and not file.write and not file.sendprav:
# file.ban = True
# self.ui.checkBox_FilePravEdit_Ban.setChecked(True)
# file.write = False
# self.ui.checkBox_FilePravEdit_Write.setChecked(False)
# file.read = False
# self.ui.checkBox_FilePravEdit_Read.setChecked(False)
# file.sendprav = False
# self.ui.checkBox_FilePravEdit_SendPrav.setChecked(False)
# file.full = False
# self.ui.checkBox_FilePravEdit_Full.setChecked(False)
def get_UserPravText(self, file):
text = ''
if file.ban:
text = 'Полный запрет'
elif file.full:
text = 'Полный доступ'
else:
if file.read:
text += 'Чтение'
if file.write:
if text != '':
text += ', '
text += 'Запись'
if file.sendprav:
if text != '':
text += ', '
text += 'Передача прав'
if text == '':
return 'Нет прав!'
return text
def updateTableUserPrav(self):
i = 0
userlist = [admin, user1, user2, user3, user4]
for user in userlist:
j = 0
filelist = [user.file1, user.file2, user.file3, user.file4]
for file in filelist:
self.ui.tableWidget.setItem(
i, j, QTableWidgetItem(self.get_UserPravText(file)))
j += 1
i += 1
def change_lookCheakBoxStatus(self, ban_status, write_status, read_status,
full_status, sendprav_status):
self.ui.checkBox_FilePravEdit_Ban.setChecked(ban_status)
self.ui.checkBox_FilePravEdit_Write.setChecked(write_status)
self.ui.checkBox_FilePravEdit_Read.setChecked(read_status)
self.ui.checkBox_FilePravEdit_Full.setChecked(full_status)
self.ui.checkBox_FilePravEdit_SendPrav.setChecked(sendprav_status)
def btnChange(self):
self.ui.pushButton_GenPass.clicked.connect(self.btnGenPass)
self.ui.pushButton_SaveFile_Pass.clicked.connect(self.btnSaveFile_Pass)
self.ui.pushButton_Shifr.clicked.connect(self.btnShifr)
self.ui.pushButton_DeShifr.clicked.connect(self.btnDeShifr)
self.ui.pushButton_SaveFile_Shifr.clicked.connect(
self.btnSaveFile_Shifr)
def btnGenPass(self):
PassType = False
if self.ui.comboBox_PassType.currentText() == 'Да':
PassType = True
passlist = genpassword(self.ui.spinBox.value(), PassType)
self.ui.textEdit_PassList.setText(passlist)
self.ui.pushButton_SaveFile_Pass.setEnabled(True)
def btnSaveFile_Pass(self):
if self.ui.textEdit_PassList.toPlainText() == '':
error('Пароли не сгенерированны!')
else:
self.savefile_window = mywindow_savefile()
if self.savefile_window.filename:
with open(self.savefile_window.filename, 'w') as file:
file.write('{}'.format(
self.ui.textEdit_PassList.toPlainText()))
def btnShifr(self):
if self.ui.lineEdit_Key.text(
) == '' or self.ui.textEdit_Text.toPlainText() == '':
error('Данные не заполнены!')
else:
print(self.ui.comboBox_shifrLang.currentText())
print(self.ui.lineEdit_Key.text()[:1])
text = self.ui.textEdit_Text.toPlainText().lower()
key = self.ui.lineEdit_Key.text().lower()
if self.ui.comboBox_shifrLang.currentText() == 'en':
if cheaktext(text, tabula_recta_en) and cheaktext(
key, tabula_recta_en):
code = encrypt(key, text, tabula_recta_en)
self.ui.textEdit_Shifr.setText(code)
self.ui.pushButton_SaveFile_Shifr.setEnabled(True)
else:
error('Неверно выбран язык!')
elif self.ui.comboBox_shifrLang.currentText() == 'rus':
if cheaktext(text, tabula_recta_rus) and cheaktext(
key, tabula_recta_rus):
code = encrypt(key, text, tabula_recta_rus)
self.ui.textEdit_Shifr.setText(code)
self.ui.pushButton_SaveFile_Shifr.setEnabled(True)
else:
error('Неверно выбран язык!')
def btnDeShifr(self):
if self.ui.lineEdit_Key.text(
) == '' or self.ui.textEdit_Text.toPlainText() == '':
error('Данные не заполнены!')
else:
print(self.ui.lineEdit_Key.text()[:1])
text = self.ui.textEdit_Text.toPlainText().lower()
key = self.ui.lineEdit_Key.text().lower()
if self.ui.comboBox_shifrLang.currentText() == 'en':
if cheaktext(text, tabula_recta_en) and cheaktext(
key, tabula_recta_en):
code = decrypt(key, text, tabula_recta_en)
self.ui.textEdit_Shifr.setText(code)
self.ui.pushButton_SaveFile_Shifr.setEnabled(True)
else:
error('Неверно выбран язык!')
elif self.ui.comboBox_shifrLang.currentText() == 'rus':
if cheaktext(text, tabula_recta_rus) and cheaktext(
key, tabula_recta_rus):
code = decrypt(key, text, tabula_recta_rus)
self.ui.textEdit_Shifr.setText(code)
self.ui.pushButton_SaveFile_Shifr.setEnabled(True)
else:
error('Неверно выбран язык!')
def btnSaveFile_Shifr(self):
if self.ui.textEdit_PassList.toPlainText() == '':
error('Шифр не сгенерирован!')
else:
self.savefile_window = mywindow_savefile()
if self.savefile_window.filename:
with open(self.savefile_window.filename, 'w') as file:
file.write('{}'.format(
self.ui.textEdit_Shifr.toPlainText()))
def get_UserName(self, user):
if user == 'Admin':
return admin
elif user == 'User1':
return user1
elif user == 'User2':
return user2
elif user == 'User3':
return user3
elif user == 'User4':
return user4
else:
return self.user
def get_FileName(self, username, filename):
if filename == 'File1':
return self.get_UserName(username).file1
elif filename == 'File2':
return self.get_UserName(username).file2
elif filename == 'File3':
return self.get_UserName(username).file3
elif filename == 'File4':
return self.get_UserName(username).file4
def get_PravStatusUser(self, file, param):
if param == 'ban':
return file.ban
elif param == 'write':
return file.write
elif param == 'read':
return file.read
elif param == 'full':
return file.full
elif param == 'sendprav':
return file.sendprav
def change_LookPravFile(self, user):
self.ui.checkBox_FilePravEdit_Ban.setChecked(user.ban)
self.ui.checkBox_FilePravEdit_Write.setChecked(user.write)
self.ui.checkBox_FilePravEdit_Read.setChecked(user.read)
self.ui.checkBox_FilePravEdit_Full.setChecked(user.full)
self.ui.checkBox_FilePravEdit_SendPrav.setChecked(user.sendprav)
def change_LookPicFile(self, user, filename):
file = self.get_FileName(user, filename)
self.ui.label_FileLook_Ban.setText(get_YesNo(file.ban))
self.ui.label_FileLook_Write.setText(get_YesNo(file.write))
self.ui.label_FileLook_Read.setText(get_YesNo(file.read))
self.ui.label_FileLook_Full.setText(get_YesNo(file.full))
self.ui.label_FileLook_SendPrav.setText(get_YesNo(file.sendprav))
def change_PravFile(self, user, ban, write, read, sendprav, full):
if ban is not None:
user.ban = ban
self.ui.checkBox_FilePravEdit_Ban.setChecked(ban)
if write is not None:
user.write = write
self.ui.checkBox_FilePravEdit_Write.setChecked(write)
if read is not None:
user.read = read
self.ui.checkBox_FilePravEdit_Read.setChecked(read)
if sendprav is not None:
user.sendprav = sendprav
self.ui.checkBox_FilePravEdit_SendPrav.setChecked(sendprav)
if full is not None:
user.full = full
self.ui.checkBox_FilePravEdit_Full.setChecked(full)
class parser(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setFixedSize(852, 671)
self.setWindowTitle("LALR Parser")
self.init()
QtCore.QObject.connect(self.ui.action_Open,
QtCore.SIGNAL("triggered()"), self.open_file)
self.ui.action_Exit.triggered.connect(self.exit_app)
self.ui.display.clicked.connect(self.disp)
self.ui.first.clicked.connect(self.disp_first)
self.ui.lr1.clicked.connect(self.disp_lr1_states)
self.ui.lalr.clicked.connect(self.disp_lalr_states)
self.ui.parse_table.clicked.connect(self.disp_parse_table)
self.ui.plainTextEdit.textChanged.connect(self.check_changed)
self.ui.parse.clicked.connect(self.disp_parsing)
self.ui.actionAuthor.triggered.connect(self.disp_author)
def init(self):
self.grammar = []
self.augment_grammar = []
self.first = {}
self.term = []
self.non_term = []
self.states = []
self.lalr_states = []
self.parse_table = []
State.state_count = -1
lalrState.state_count = 0
def check_changed(self):
self.changed = True
def open_file(self):
file = QtGui.QFileDialog.getOpenFileName(self, 'Open Grammar file')
if file != '':
file = open(file, 'r')
self.ui.plainTextEdit.setPlainText(file.read())
file.close()
self.ui.lineEdit.clear()
self.ui.textBrowser.clear()
def read_input(self):
self.init()
lines = self.ui.plainTextEdit.toPlainText() #string
lines_list = lines.split('\n') #converting into list of lines
try:
for line in lines_list:
line = line.replace(' ', '')
if line != '':
line_list = line.split('->')
if line_list[0].isupper() and line_list[1] != '':
if '|' in line_list[1]:
prod_list = line_list[1].split('|')
for prod in prod_list:
self.grammar.append([line_list[0], prod])
else:
self.grammar.append(line_list)
else:
self.ui.textBrowser.clear()
self.ui.textBrowser.setText("Invalid grammar")
self.grammar = []
if self.grammar != []:
term_and_nonterm(self.grammar, self.term, self.non_term)
calculate_first(self.grammar, self.first, self.term,
self.non_term)
get_augmented(self.grammar, self.augment_grammar)
find_states(self.states, self.augment_grammar, self.first,
self.term, self.non_term)
combine_states(self.lalr_states, self.states)
get_parse_table(self.parse_table, self.lalr_states,
self.augment_grammar)
self.changed = False
except (KeyError, IndexError):
self.ui.textBrowser.clear()
self.ui.textBrowser.setText("Invalid grammar")
self.init()
############################ DISPLAY ################################
def disp(self):
self.ui.textBrowser.clear()
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
for prod in self.grammar:
s = prod[0] + ' -> ' + prod[1] + '\n'
self.ui.textBrowser.append(s)
self.ui.textBrowser.append("\nNon Terminals : " +
' '.join(self.non_term) +
"\nTerminals : " + ' '.join(self.term))
def disp_first(self):
if self.first == {} or self.changed:
self.read_input()
if self.first != {}:
self.ui.textBrowser.clear()
for nonterm in self.non_term:
self.ui.textBrowser.append('First(' + nonterm + ') : ' +
' '.join(self.first[nonterm]) +
'\n')
def disp_lr1_states(self):
if self.states == [] or self.changed:
self.read_input()
if self.states != []:
self.ui.textBrowser.clear()
self.ui.textBrowser.append(
"Number of LR(1) states : " +
str(self.states[len(self.states) - 1].state_num + 1))
for state in self.states:
self.ui.textBrowser.append(
'----------------------------------------------------------------'
)
if state.state_num == 0:
self.ui.textBrowser.append("\nI" + str(state.state_num) +
' : ' + '\n')
else:
self.ui.textBrowser.append("\nI" + str(state.state_num) +
' : ' + ' goto ( I' +
str(state.parent[0]) + " -> '" +
str(state.parent[1]) + "' )\n")
for item in state.state:
self.ui.textBrowser.append(item[0] + ' -> ' + item[1] +
' , [ ' + ' '.join(item[2]) +
' ]')
if state.actions != {}:
self.ui.textBrowser.append('\nActions : ')
for k, v in state.actions.items():
self.ui.textBrowser.insertPlainText(
str(k) + ' -> ' + str(abs(v)) + '\t')
def disp_lalr_states(self):
if self.lalr_states == [] or self.changed:
self.read_input()
if self.lalr_states != []:
self.ui.textBrowser.clear()
self.ui.textBrowser.append("Number of LALR states : " +
str(lalrState.state_count))
for state in self.lalr_states:
self.ui.textBrowser.append(
'----------------------------------------------------------------'
)
if state.state_num == 0:
self.ui.textBrowser.append("\nI" + str(state.state_num) +
' : ' + '\tGot by -> ' +
str(state.parent_list) + '\n')
else:
self.ui.textBrowser.append("\nI" + str(state.state_num) +
' : ' + ' goto ( I' +
str(state.parent[0]) + " -> '" +
str(state.parent[1]) + "' )" +
'\tGot by -> ' +
str(state.parent_list) + '\n')
for item in state.state:
self.ui.textBrowser.append(item[0] + ' -> ' + item[1] +
' , [ ' + ' '.join(item[2]) +
' ]')
if state.actions != {}:
self.ui.textBrowser.append('\nActions : ')
for k, v in state.actions.items():
self.ui.textBrowser.insertPlainText(
str(k) + ' -> ' + str(abs(v)) + '\t')
def disp_parse_table(self):
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
self.ui.textBrowser.clear()
all_symb = []
all_symb.extend(self.term)
all_symb.append('$')
all_symb.extend(self.non_term)
if 'e' in all_symb:
all_symb.remove('e')
head = '{0:12}'.format(' ')
for X in all_symb:
head = head + '{0:12}'.format(X)
self.ui.textBrowser.setText(head + '\n')
s = '------------' * len(all_symb)
self.ui.textBrowser.append(s)
for index, state in enumerate(self.parse_table):
line = '{0:<12}'.format(index)
for X in all_symb:
if X in state.keys():
if X in self.non_term:
action = state[X]
else:
if state[X] > 0:
action = 's' + str(state[X])
elif state[X] < 0:
action = 'r' + str(abs(state[X]))
elif state[X] == 0:
action = 'accept'
line = line + '{0:<12}'.format(action)
else:
line = line + '{0:<12}'.format("")
self.ui.textBrowser.append(line)
self.ui.textBrowser.append(s)
def disp_parsing(self):
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
self.ui.textBrowser.clear()
line_input = self.ui.lineEdit.text()
self.parse(self.parse_table, self.augment_grammar, line_input)
def parse(self, parse_table, augment_grammar, inpt):
inpt = list(inpt + '$')
stack = [0]
a = inpt[0]
try:
head = '{0:40} {1:40} {2:40}'.format("Stack", "Input", "Actions")
self.ui.textBrowser.setText(head)
while True:
string = '\n{0:<40} {1:<40} '.format(stack, ''.join(inpt))
s = stack[len(stack) - 1]
action = parse_table[s][a]
if action > 0:
inpt.pop(0)
stack.append(action)
self.ui.textBrowser.append(string + 'Shift ' + a + '\n')
a = inpt[0]
elif action < 0:
prod = augment_grammar[-action]
if prod[1] != 'e':
for i in prod[1]:
stack.pop()
t = stack[len(stack) - 1]
stack.append(parse_table[t][prod[0]])
self.ui.textBrowser.append(string + 'Reduce ' + prod[0] +
' -> ' + prod[1] + '\n')
elif action == 0:
self.ui.textBrowser.append('ACCEPT\n')
break
except KeyError:
self.ui.textBrowser.append('\n\nERROR\n')
def exit_app(self):
QtGui.QApplication.quit()
def disp_author(self):
QtGui.QMessageBox.information(
self, "About", "LALR PARSER\n\nAuthor:\n Akshay Hebbar Y S\t",
QtGui.QMessageBox.Ok)
class ControlWindow:
def __init__(self):
self.app = QtWidgets.QApplication(sys.argv)
self.MainWindow = QtWidgets.QMainWindow()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.MainWindow)
self.cv_images = {}
self.load_images()
self.video_thread = VideoThread()
self.video_thread.changePixmap.connect(lambda p: self.setVideoImage(p))
self.video_thread.change_video_state.connect(
lambda s: self.update_video_state(s))
self.ui.video_play_button.clicked.connect(self.play_video)
#self.ui.video_pause_button.clicked.connect(self.pause_video)
self.ui.load_video_button.clicked.connect(
lambda s: self.load_video("File"))
self.ui.video_stop_button.clicked.connect(self.stop_video)
self.ui.load_web_cam_button.clicked.connect(
lambda s: self.load_video("Camera"))
self.ui.image_feed.itemClicked.connect(self.listwidgetclicked)
def listwidgetclicked(self, item):
idx = id(item)
print('video class member', self.video_thread.shirt_img)
print('click {}'.format(idx), self.cv_images[idx].image)
self.video_thread.shirt_img = self.cv_images[idx].image
def load_images(self):
path = "tshirt/"
included_extensions = ['jpg', 'jpeg', 'bmp', 'png', 'gif']
file_names = [
fn for fn in os.listdir(path) if any(
fn.endswith(ext) for ext in included_extensions)
]
# shirt_img = self.load_shirt("tshirt/shirt1.png")
self.cv_images = {}
for i in file_names:
image = self.load_shirt(path + i)
item = QListWidgetItem()
icon = QtGui.QIcon()
# icon.addPixmap(QtGui.QPixmap(_fromUtf8(path+i)), QtGui.QIcon.Normal, QtGui.QIcon.Off)
icon.addPixmap(QtGui.QPixmap(path + i), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
item.setIcon(icon)
self.cv_images[id(item)] = CvImages(path + i, image)
self.ui.image_feed.addItem(item)
#print('cv', self.cv_images)
def load_shirt(self, img_path):
img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
assert img.shape[
2] == 4, "shirt image : {} doesn't have alpha channel".format(
img_path)
alpha_channel = img[:, :, -1]
# calculate extreme points of shirt
x, y, w, h = cv2.boundingRect(alpha_channel)
return img[y:y + h, x:x + w]
def setVideoImage(self, p):
p = QPixmap.fromImage(p)
p = p.scaled(1200, 1200, Qt.KeepAspectRatio)
self.ui.video_feed1.setPixmap(p)
def setVideoOutput(self, p):
p = QPixmap.fromImage(p)
p = p.scaled(1000, 1000, Qt.KeepAspectRatio)
self.ui.video_feed2.setPixmap(p)
def load_video(self, video_source):
global g_video_source
if video_source == "Camera":
g_video_source[0] = "Camera"
self.ui.video_path_label.setText('')
self.video_thread.start()
else:
g_video_source[0] = "File"
options = QFileDialog.Options()
fileName, _ = QFileDialog.getOpenFileName(
self.MainWindow,
"QFileDialog.getOpenFileName()",
os.getcwd(),
"All Files (*);;Avi Files (*.avi)",
options=options)
if fileName:
self.ui.video_path_label.setText(fileName)
self.video_thread.vid_path = fileName
self.play_video()
def run(self):
self.MainWindow.show()
sys.exit(self.app.exec_())
def play_video(self):
self.video_thread.vid_path = self.ui.video_path_label.text()
self.video_thread.start()
self.ui.video_play_button.setEnabled(False)
def pause_video(self):
global g_video_state
if g_video_state[0] == "Paused":
g_video_state[0] = "Playing"
else:
g_video_state[0] = "Paused"
def stop_video(self):
g_video_state[0] = "Stop"
self.video_thread.video_state = "Stop"
self.ui.video_play_button.setEnabled(True)
def update_video_state(self, state):
#print ("Update state", state)
if state == "Stop":
self.stop_video()
class MyWindow(QMainWindow):
########инициализация окна######
def __init__(self):
super(MyWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.initUI1()
self.update()
###############################
###########настройка сигналов#####################
def initUI1(self):
self.ui.audit_month.clicked.connect(lambda: self.graf_tadjyk1(y1))
self.ui.audit_week.clicked.connect(lambda: self.graf_tadjyk2(y2))
self.ui.teach_week.clicked.connect(lambda: self.graf_tadjyk3())
self.ui.teach_month.clicked.connect(lambda: self.graf_tadjyk4())
###############################
#########функции создания графиков########################
def graf_tadjyk1(self, y1):
x1 = [i for i in range(1, 27)]
y1 = np.array(y1)
x1 = np.array(x1)
plt.title("Процентные данные загруженности аудиторий на каждые 4 недели")
plt.plot(x1, y1)
plt.scatter(x1, y1)
plt.grid()
# plt.savefig("tadjyk1.png")
plt.show()
def graf_tadjyk2(self, y2):
x2 = [i for i in range(1, 54)]
y2 = np.array(y2)
x2 = np.array(x2)
plt.title("Процентные данные загруженности аудиторий на каждую неделю")
plt.plot(x2, y2)
plt.scatter(x2, y2)
plt.grid()
# plt.savefig("tadjyk2.png")
plt.show()
def graf_tadjyk3(self):
lines = []
labels = []
number_of_colors = len(teacher_time)
color = ["#" + ''.join([choice('0123456789ABCDEF') for j in range(6)])
for i in range(number_of_colors)]
plt.title("Количество преподавателей в каждую неделю")
for j, i in enumerate(teacher_time):
x3 = teacher_time[i].keys()
y3 = teacher_time[i].values()
labels.append(i)
a, = plt.plot(x3, y3, color=color[j])
lines.append(a)
plt.legend(lines, labels)
plt.grid()
# plt.savefig("tadjyk3.png")
plt.show()
def graf_tadjyk4(self):
x4 = [l for l in range(1, 14)]
y4 = []
k = 0
for i in range(1, 54):
if i % 4 != 0:
for j in teacher_time:
if i in teacher_time[j]:
k += teacher_time[j][i]
else:
y4.append(k)
k = 0
y4 = np.array(y4)
x4 = np.array(x4)
plt.title("Количество пар у преподавателей в месяц")
plt.plot(x4, y4)
plt.grid()
plt.scatter(x4, y4)
plt.show()
class parser(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setFixedSize(857, 716)
self.setWindowTitle("LALR Parser")
self.init()
QtCore.QObject.connect(self.ui.action_Open, QtCore.SIGNAL("triggered()"), self.open_file)
self.ui.action_Exit.triggered.connect(self.exit_app)
self.ui.display.clicked.connect(self.disp)
self.ui.first.clicked.connect(self.disp_first)
self.ui.lr1.clicked.connect(self.disp_lr1_states)
self.ui.lalr.clicked.connect(self.disp_lalr_states)
self.ui.parse_table.clicked.connect(self.disp_parse_table)
self.ui.plainTextEdit.textChanged.connect(self.check_changed)
self.ui.parse.clicked.connect(self.disp_parsing)
self.ui.actionAuthor.triggered.connect(self.disp_author)
def init(self):
self.grammar = []
self.augment_grammar = []
self.first = {}
self.term = []
self.non_term = []
self.states = []
self.lalr_states = []
self.parse_table = []
State.state_count = -1
lalrState.state_count = 0
def check_changed(self):
self.changed = True
def open_file(self):
file = QtGui.QFileDialog.getOpenFileName(self, "Open Grammar file")
file = open(file, "r")
self.ui.plainTextEdit.setPlainText(file.read())
file.close()
self.ui.lineEdit.clear()
self.ui.textBrowser.clear()
def read_input(self):
self.init()
lines = self.ui.plainTextEdit.toPlainText() # string
lines_list = lines.split("\n") # converting into list of lines
try:
for line in lines_list:
line = line.replace(" ", "")
if line != "":
line_list = line.split("->")
if line_list[0].isupper() and line_list[1] != "":
if "|" in line_list[1]:
prod_list = line_list[1].split("|")
for prod in prod_list:
self.grammar.append([line_list[0], prod])
else:
self.grammar.append(line_list)
else:
self.ui.textBrowser.clear()
self.ui.textBrowser.setText("Invalid grammar")
self.grammar = []
if self.grammar != []:
term_and_nonterm(self.grammar, self.term, self.non_term)
calculate_first(self.grammar, self.first, self.term, self.non_term)
get_augmented(self.grammar, self.augment_grammar)
find_states(self.states, self.augment_grammar, self.first, self.term, self.non_term)
combine_states(self.lalr_states, self.states)
get_parse_table(self.parse_table, self.lalr_states, self.augment_grammar)
self.changed = False
except (KeyError, IndexError):
self.ui.textBrowser.clear()
self.ui.textBrowser.setText("Invalid grammar")
self.init()
############################ DISPLAY ################################
def disp(self):
self.ui.textBrowser.clear()
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
for prod in self.grammar:
s = prod[0] + " -> " + prod[1] + "\n"
self.ui.textBrowser.append(s)
self.ui.textBrowser.append(
"\nNon Terminals : " + " ".join(self.non_term) + "\nTerminals : " + " ".join(self.term)
)
def disp_first(self):
if self.first == {} or self.changed:
self.read_input()
if self.first != {}:
self.ui.textBrowser.clear()
for key, value in self.first.items():
if key in self.non_term:
self.ui.textBrowser.append("First(" + key + ") : " + " ".join(value) + "\n")
def disp_lr1_states(self):
if self.states == [] or self.changed:
self.read_input()
if self.states != []:
self.ui.textBrowser.clear()
self.ui.textBrowser.append(
"Number of LR(1) states : " + str(self.states[len(self.states) - 1].state_num + 1)
)
for state in self.states:
self.ui.textBrowser.append("----------------------------------------------------------------")
if state.state_num == 0:
self.ui.textBrowser.append("\nI" + str(state.state_num) + " : " + "\n")
else:
self.ui.textBrowser.append(
"\nI"
+ str(state.state_num)
+ " : "
+ " goto ( I"
+ str(state.parent[0])
+ " -> '"
+ str(state.parent[1])
+ "' )\n"
)
for item in state.state:
self.ui.textBrowser.append(item[0] + " -> " + item[1] + " , [ " + " ".join(item[2]) + " ]")
if state.actions != {}:
self.ui.textBrowser.append("\nActions : ")
for k, v in state.actions.items():
self.ui.textBrowser.insertPlainText(str(k) + " -> " + str(abs(v)) + "\t")
def disp_lalr_states(self):
if self.lalr_states == [] or self.changed:
self.read_input()
if self.lalr_states != []:
self.ui.textBrowser.clear()
self.ui.textBrowser.append("Number of LALR states : " + str(lalrState.state_count))
for state in self.lalr_states:
self.ui.textBrowser.append("----------------------------------------------------------------")
if state.state_num == 0:
self.ui.textBrowser.append(
"\nI" + str(state.state_num) + " : " + "\tGot by -> " + str(state.parent_list) + "\n"
)
else:
self.ui.textBrowser.append(
"\nI"
+ str(state.state_num)
+ " : "
+ " goto ( I"
+ str(state.parent[0])
+ " -> '"
+ str(state.parent[1])
+ "' )"
+ "\tGot by -> "
+ str(state.parent_list)
+ "\n"
)
for item in state.state:
self.ui.textBrowser.append(item[0] + " -> " + item[1] + " , [ " + " ".join(item[2]) + " ]")
if state.actions != {}:
self.ui.textBrowser.append("\nActions : ")
for k, v in state.actions.items():
self.ui.textBrowser.insertPlainText(str(k) + " -> " + str(abs(v)) + "\t")
def disp_parse_table(self):
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
self.ui.textBrowser.clear()
all_symb = []
all_symb.extend(self.term)
all_symb.append("$")
all_symb.extend(self.non_term)
if "e" in all_symb:
all_symb.remove("e")
head = "{0:12}".format(" ")
for X in all_symb:
head = head + "{0:12}".format(X)
self.ui.textBrowser.setText(head + "\n")
s = "------------" * len(all_symb)
self.ui.textBrowser.append(s)
for index, state in enumerate(self.parse_table):
line = "{0:<12}".format(index)
for X in all_symb:
if X in state.keys():
if X in self.non_term:
action = state[X]
else:
if state[X] > 0:
action = "s" + str(state[X])
elif state[X] < 0:
action = "r" + str(abs(state[X]))
elif state[X] == 0:
action = "accept"
line = line + "{0:<12}".format(action)
else:
line = line + "{0:<12}".format("")
self.ui.textBrowser.append(line)
self.ui.textBrowser.append(s)
def disp_parsing(self):
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
self.ui.textBrowser.clear()
line_input = self.ui.lineEdit.text()
self.parse(self.parse_table, self.augment_grammar, line_input)
def parse(self, parse_table, augment_grammar, inpt):
inpt = list(inpt + "$")
stack = [0]
a = inpt[0]
try:
head = "{0:40} {1:40} {2:40}".format("Stack", "Input", "Actions")
self.ui.textBrowser.setText(head)
while True:
string = "\n{0:<40} {1:<40} ".format(stack, "".join(inpt))
s = stack[len(stack) - 1]
action = parse_table[s][a]
if action > 0:
inpt.pop(0)
stack.append(action)
self.ui.textBrowser.append(string + "Shift " + a + "\n")
a = inpt[0]
elif action < 0:
prod = augment_grammar[-action]
if prod[1] != "e":
for i in range(len(prod[1])):
stack.pop()
t = stack[len(stack) - 1]
stack.append(parse_table[t][prod[0]])
self.ui.textBrowser.append(string + "Reduce " + prod[0] + " -> " + prod[1] + "\n")
elif action == 0:
self.ui.textBrowser.append("ACCEPT\n")
break
except KeyError:
self.ui.textBrowser.append("\n\nERROR\n")
def exit_app(self):
QtGui.QApplication.quit()
def disp_author(self):
QtGui.QMessageBox.information(
self,
"About",
"LALR PARSER\n\nAuthors:\n Akshay Hebbar Y S\t\n Bharath Kumar N B\t\n Nikil Upadhyaya\t\n Alok S\t",
QtGui.QMessageBox.Ok,
)
class parser(QtGui.QMainWindow):
def __init__(self, parent = None):
QtGui.QWidget.__init__(self,parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.setFixedSize(852, 671)
self.setWindowTitle("LALR Parser")
self.init()
QtCore.QObject.connect(self.ui.action_Open,QtCore.SIGNAL("triggered()"),self.open_file)
self.ui.action_Exit.triggered.connect(self.exit_app)
self.ui.display.clicked.connect(self.disp)
self.ui.first.clicked.connect(self.disp_first)
self.ui.lr1.clicked.connect(self.disp_lr1_states)
self.ui.lalr.clicked.connect(self.disp_lalr_states)
self.ui.parse_table.clicked.connect(self.disp_parse_table)
self.ui.plainTextEdit.textChanged.connect(self.check_changed)
self.ui.parse.clicked.connect(self.disp_parsing)
self.ui.actionAuthor.triggered.connect(self.disp_author)
def init(self):
self.grammar = []
self.augment_grammar = []
self.first = {}
self.term = []
self.non_term = []
self.states = []
self.lalr_states = []
self.parse_table = []
State.state_count = -1
lalrState.state_count = 0
def check_changed(self):
self.changed = True
def open_file(self):
file = QtGui.QFileDialog.getOpenFileName(self,'Open Grammar file')
if file != '':
file = open(file,'r')
self.ui.plainTextEdit.setPlainText(file.read())
file.close()
self.ui.lineEdit.clear()
self.ui.textBrowser.clear()
def read_input(self):
self.init()
lines = self.ui.plainTextEdit.toPlainText() #string
lines_list = lines.split('\n') #converting into list of lines
try:
for line in lines_list:
line = line.replace(' ' ,'')
if line != '':
line_list = line.split('->')
if line_list[0].isupper() and line_list[1] != '':
if '|' in line_list[1]:
prod_list = line_list[1].split('|')
for prod in prod_list:
self.grammar.append([line_list[0],prod])
else:
self.grammar.append(line_list)
else:
self.ui.textBrowser.clear()
self.ui.textBrowser.setText("Invalid grammar")
self.grammar = []
if self.grammar != []:
term_and_nonterm(self.grammar,self.term,self.non_term)
calculate_first(self.grammar,self.first,self.term,self.non_term)
get_augmented(self.grammar,self.augment_grammar)
find_states(self.states,self.augment_grammar,self.first,self.term,self.non_term)
combine_states(self.lalr_states, self.states)
get_parse_table(self.parse_table,self.lalr_states,self.augment_grammar)
self.changed = False
except (KeyError, IndexError):
self.ui.textBrowser.clear()
self.ui.textBrowser.setText("Invalid grammar")
self.init()
############################ DISPLAY ################################
def disp(self):
self.ui.textBrowser.clear()
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
for prod in self.grammar:
s = prod[0]+ ' -> ' + prod[1]+'\n'
self.ui.textBrowser.append(s)
self.ui.textBrowser.append("\nNon Terminals : "+' '.join(self.non_term)+"\nTerminals : "+' '.join(self.term))
def disp_first(self):
if self.first == {} or self.changed:
self.read_input()
if self.first != {}:
self.ui.textBrowser.clear()
for nonterm in self.non_term:
self.ui.textBrowser.append('First('+nonterm+') : '+' '.join(self.first[nonterm])+'\n')
def disp_lr1_states(self):
if self.states == [] or self.changed:
self.read_input()
if self.states != []:
self.ui.textBrowser.clear()
self.ui.textBrowser.append("Number of LR(1) states : "+ str(self.states[len(self.states)-1].state_num + 1))
for state in self.states:
self.ui.textBrowser.append('----------------------------------------------------------------')
if state.state_num == 0:
self.ui.textBrowser.append("\nI"+str(state.state_num)+' : '+'\n')
else:
self.ui.textBrowser.append("\nI"+str(state.state_num)+' : '+' goto ( I'+str(state.parent[0])+" -> '"+ str(state.parent[1]) +"' )\n")
for item in state.state:
self.ui.textBrowser.append(item[0]+ ' -> ' + item[1]+' , [ '+ ' '.join(item[2])+' ]')
if state.actions != {}:
self.ui.textBrowser.append('\nActions : ')
for k,v in state.actions.items():
self.ui.textBrowser.insertPlainText(str(k)+' -> '+str(abs(v))+'\t')
def disp_lalr_states(self):
if self.lalr_states == [] or self.changed:
self.read_input()
if self.lalr_states != []:
self.ui.textBrowser.clear()
self.ui.textBrowser.append("Number of LALR states : " + str(lalrState.state_count))
for state in self.lalr_states:
self.ui.textBrowser.append('----------------------------------------------------------------')
if state.state_num == 0:
self.ui.textBrowser.append("\nI"+str(state.state_num)+' : '+'\tGot by -> '+str(state.parent_list)+'\n')
else:
self.ui.textBrowser.append("\nI"+str(state.state_num)+' : '+' goto ( I'+str(state.parent[0])+" -> '"+ str(state.parent[1]) +"' )"+'\tGot by -> '+str(state.parent_list)+'\n')
for item in state.state:
self.ui.textBrowser.append(item[0]+ ' -> ' + item[1]+' , [ '+ ' '.join(item[2])+' ]')
if state.actions != {}:
self.ui.textBrowser.append('\nActions : ')
for k,v in state.actions.items():
self.ui.textBrowser.insertPlainText(str(k)+' -> '+str(abs(v))+'\t')
def disp_parse_table(self):
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
self.ui.textBrowser.clear()
all_symb = []
all_symb.extend(self.term)
all_symb.append('$')
all_symb.extend(self.non_term)
if 'e' in all_symb:
all_symb.remove('e')
head = '{0:12}'.format(' ')
for X in all_symb:
head = head + '{0:12}'.format(X)
self.ui.textBrowser.setText(head+'\n')
s = '------------'*len(all_symb)
self.ui.textBrowser.append(s)
for index, state in enumerate(self.parse_table):
line = '{0:<12}'.format(index)
for X in all_symb:
if X in state.keys():
if X in self.non_term:
action = state[X]
else:
if state[X] > 0:
action = 's' + str(state[X])
elif state[X] < 0:
action = 'r' + str(abs(state[X]))
elif state[X] == 0:
action = 'accept'
line = line + '{0:<12}'.format(action)
else:
line = line + '{0:<12}'.format("")
self.ui.textBrowser.append(line)
self.ui.textBrowser.append(s)
def disp_parsing(self):
if self.grammar == [] or self.changed:
self.read_input()
if self.grammar != []:
self.ui.textBrowser.clear()
line_input = self.ui.lineEdit.text()
self.parse(self.parse_table, self.augment_grammar, line_input)
def parse(self,parse_table,augment_grammar,inpt):
inpt = list(inpt+'$')
stack = [0]
a = inpt[0]
try:
head = '{0:40} {1:40} {2:40}'.format("Stack","Input", "Actions")
self.ui.textBrowser.setText(head)
while True:
string = '\n{0:<40} {1:<40} '.format(stack, ''.join(inpt))
s = stack[len(stack)-1]
action = parse_table[s][a]
if action > 0:
inpt.pop(0)
stack.append(action)
self.ui.textBrowser.append(string + 'Shift ' + a+ '\n')
a = inpt[0]
elif action < 0:
prod = augment_grammar[-action]
if prod[1] != 'e':
for i in prod[1]:
stack.pop()
t = stack[len(stack)-1]
stack.append(parse_table[t][prod[0]])
self.ui.textBrowser.append(string + 'Reduce ' + prod[0] + ' -> '+ prod[1] + '\n')
elif action == 0:
self.ui.textBrowser.append('ACCEPT\n')
break
except KeyError:
self.ui.textBrowser.append('\n\nERROR\n')
def exit_app(self):
QtGui.QApplication.quit()
def disp_author(self):
QtGui.QMessageBox.information(self, "About", "LALR PARSER\n\nAuthor:\n Akshay Hebbar Y S\t", QtGui.QMessageBox.Ok)
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.lineEdit.setPlaceholderText("Search By Room Name, City or Country")
scroll_area = self.ui.GridScrolarea
scrollAreaWidgetContents = QtWidgets.QWidget()
scroll_area.setWidgetResizable(True)
self.grid = QtWidgets.QGridLayout(scrollAreaWidgetContents)
scroll_area.setWidget(scrollAreaWidgetContents)
self.ui.verticalLayout_2.addWidget(scroll_area)
self.data = list()
self.read_excel_file('input.xlsx')
self.add_items(self.data)
self.ui.pushButton.clicked.connect(self.search_click)
self.ui.pushButton_2.clicked.connect(partial(self.add_items, self.data))
self.ui.pushButton_3.clicked.connect(partial(self.run_combo_click))
def run_combo_click(self):
t = self.ui.comboBox.currentText()
print(t)
koi_b_phase2(t)
def read_excel_file(self, file):
wb = load_workbook(file)
s = wb[wb.sheetnames[0]]
max = s.max_row
for row in range(2, max + 1):
obj = ButtonData()
obj.id = s['A' + str(row)].value
obj.url = s['B' + str(row)].value
obj.avg = s['C' + str(row)].value
obj.room_name = s['D' + str(row)].value
obj.city = s['E' + str(row)].value
obj.country = s['F' + str(row)].value
self.data.append(obj)
wb.close()
def clear_all(self):
for i in range(self.grid.count()):
self.grid.itemAt(i).widget().close()
def add_items(self, data):
self.clear_all()
rows = int(len(data) / 5) + 1
count = 0
for i in range(rows):
for j in range(5):
if count == len(data):
break
btn = QtWidgets.QPushButton(data[count].room_name)
btn.setFixedHeight(30)
btn.setFixedWidth(150)
btn.clicked.connect(partial(self.button_clicked, data[count]))
self.grid.addWidget(btn, i, j)
count = count + 1
def button_clicked(self, data):
print(data.id)
koi_b(data)
def search_click(self):
self.clear_all()
key = str(self.ui.lineEdit.text()).lower().strip()
subData = list()
for d in self.data:
if key in str(d.city).lower().strip() or key in str(d.room_name).lower().strip() or key in str(
d.country).lower().strip():
subData.append(d)
if len(subData) == 0:
lbl = QtWidgets.QLabel("No Result Found")
font = QtGui.QFont()
font.setPointSize(20)
lbl.setFont(font)
self.grid.addWidget(lbl, 0, 0)
else:
self.add_items(subData)
class MainWindow(QtWidgets.QMainWindow):
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.LoginButton.clicked.connect(self.login)
self.ui.imagedetectbtn.clicked.connect(self.DetectImage)
self.ui.openFilebtn.clicked.connect(self.openFile)
self.ui.setPathbtn.clicked.connect(self.outputFile)
self.ui.detectimage.clicked.connect(self.switchImageWidget)
self.ui.detectvideo.clicked.connect(self.switchVideoWidget)
self.ui.webcamDetect.clicked.connect(self.switchWebcamWidget)
self.ui.usernotifications.clicked.connect(
self.switchNotificationsWidget)
self.ui.userSettings.clicked.connect(self.switchSettingsWidget)
self.ui.logout.clicked.connect(self.switchLoginWidget)
self.ui.signbtn.clicked.connect(self.switchSignupWidget)
self.ui.createAccountbtn.clicked.connect(self.signup)
self.ui.changeUserInfobtn.clicked.connect(self.switchUserInfoWidget)
self.ui.Changepasswordbtn.clicked.connect(self.switchPasswordWidget)
self.ui.saveuserinfobtn.clicked.connect(self.saveUserInfo)
self.ui.savenewpasswordbtn.clicked.connect(self.saveNewPassword)
self.ui.detectCamera.clicked.connect(self.detectCameraIP)
self.ui.backToNotification.clicked.connect(
self.switchNotificationsWidget)
self.ui.filterbtn.clicked.connect(self.filterValues)
self.ui.detectCamera_2.clicked.connect(self.detectVideo)
self.ui.openFilebtn_2.clicked.connect(self.openVideoFile)
self.ui.homebutton.clicked.connect(self.switchHomeWidget)
#Create event for notification so user can delete or save
self.ui.listWidget_2.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.ui.listWidget_2.customContextMenuRequested.connect(
self.rightClickFunction)
self.customMenu = QtWidgets.QMenu('Menu', self.ui.listWidget_2)
self.customMenu.addAction(QtGui.QIcon('images/resize.png'), "Enlarge",
self.enlargeImage)
self.customMenu.addAction(QtGui.QIcon('images/save.png'), "Save",
self.saveFunction)
self.customMenu.addAction(QtGui.QIcon('images/delete.png'), "Delete",
self.deleteFunction)
#Filter
def filterValues(self):
#Array containing checkbox values
Detection_type = []
if self.ui.checkBox.isChecked():
Detection_type.append("image")
if self.ui.checkBox_2.isChecked():
Detection_type.append("video")
if self.ui.checkBox_3.isChecked():
Detection_type.append("webcam")
#Get date from user input and rearrange format
date1 = datetime.datetime.strptime(
str(self.ui.dateEdit_2.date().toPyDate()),
'%Y-%m-%d').strftime('%d-%m-%Y')
date2 = datetime.datetime.strptime(
str(self.ui.dateEdit_3.date().toPyDate()),
'%Y-%m-%d').strftime('%d-%m-%Y')
#Go through each widget and filter it depending on what the user has picked
for row in range(self.ui.listWidget_2.count()):
index = self.ui.listWidget_2.item(row)
widget = self.ui.listWidget_2.itemWidget(index)
if self.filter(Detection_type, date1, date2, 5, 5, widget):
index.setHidden(False)
else:
index.setHidden(True)
#Filter if statements checks certain conditiions
def filter(self, detection_types, date1, date2, time1, time2, widget):
date_check = widget.customWidgetDate.text().replace("Date: ", "")
type_check = widget.customWidgetType.text().replace("Detection: ", "")
myDate = datetime.datetime.strptime(date_check, '%d-%m-%Y')
userDate1 = datetime.datetime.strptime(date1, '%d-%m-%Y')
userDate2 = datetime.datetime.strptime(date2, '%d-%m-%Y')
default_date = datetime.datetime.strptime("01-01-2000", '%d-%m-%Y')
#Order date so it doesnt matter which way user enters date
if userDate1 != default_date and userDate2 != default_date:
if userDate1 > userDate2:
temp = userDate1
userDate1 = userDate2
userDate2 = temp
#Filter
#
#Simple filter with IF statements to check if widget has the thing we are looking for if so filter accordingly
#
if len(detection_types) == 0:
if default_date == userDate1 and default_date != userDate2:
if userDate2 == myDate:
return True
else:
return False
elif default_date != userDate1 and default_date == userDate2:
if userDate1 == myDate:
return True
else:
return False
elif userDate1 != default_date and userDate2 != default_date:
if userDate1 <= myDate and userDate2 >= myDate:
return True
else:
return False
else:
if default_date == userDate1 and default_date != userDate2:
if userDate2 == myDate and type_check in detection_types:
return True
else:
return False
elif default_date != userDate1 and default_date == userDate2:
if userDate1 == myDate and type_check in detection_types:
return True
else:
return False
elif userDate1 != default_date and userDate2 != default_date:
if userDate1 <= myDate and userDate2 >= myDate and type_check in detection_types:
return True
else:
return False
elif userDate1 == default_date and userDate2 == default_date:
if type_check in detection_types:
return True
else:
return False
return True
#Enlarges image for detection image in notification
def enlargeImage(self):
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
self.ui.stackedWidget_2.setCurrentWidget(self.ui.largeImage)
#Takes image and breaks the file name apart so it can be stored correctly
widget = self.ui.listWidget_2.itemWidget(
self.ui.listWidget_2.currentItem())
date = widget.customWidgetDate.text().replace("Date: ", "")
time = widget.customWidgetScore.text().replace("Time: ", "")
time = time.replace(":", "-")
type = widget.customWidgetType.text().replace("Detection: ", "")
value = str(date + " " + time + " " + type + ".jpg")
#Get the user images and downloads them and displays it to the notifications
imageBlob = bucket.blob(current_user + "/" + value)
with urllib.request.urlopen(imageBlob.public_url) as url:
s = url.read()
pixmap1 = QtGui.QPixmap()
pixmap1.loadFromData(s)
pixmap = QtGui.QPixmap(pixmap1)
self.ui.enlargeImagelabel.setPixmap(QtGui.QPixmap(pixmap))
self.ui.enlargeImagelabel.setScaledContents(True)
self.ui.enlargeImagelabel.setSizePolicy(
QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Ignored)
self.ui.label_6.setText(widget.customWidgetDate.text())
self.ui.label_32.setText(widget.customWidgetScore.text())
self.ui.label_33.setText(widget.customWidgetType.text())
#Allows you to save the images in notifications
def saveFunction(self):
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
file = str(QFileDialog.getExistingDirectory(self, "Select Directory"))
if file != "":
widget = self.ui.listWidget_2.itemWidget(
self.ui.listWidget_2.currentItem())
date = widget.customWidgetDate.text().replace("Date: ", "")
time = widget.customWidgetScore.text().replace("Time: ", "")
time = time.replace(":", "-")
type = widget.customWidgetType.text().replace("Detection: ", "")
value = str(date + " " + time + " " + type + ".jpg")
print(file + "/" + value)
imageBlob = bucket.blob(
current_user + "/" +
value) #Get the users folder from database, and their images
urllib.request.urlretrieve(imageBlob.public_url,
file + "/" + value)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
#Allows you to delete notifications from your database
def deleteFunction(self):
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
global item
global firebase
widget = self.ui.listWidget_2.itemWidget(
self.ui.listWidget_2.currentItem())
date = widget.customWidgetDate.text().replace("Date: ", "")
time = widget.customWidgetScore.text().replace("Time: ", "")
time = time.replace(":", "-")
type = widget.customWidgetType.text().replace("Detection: ", "")
value = str(date + " " + time + " " + type + ".jpg")
self.ui.listWidget_2.removeItemWidget(
self.ui.listWidget_2.currentItem())
self.ui.listWidget_2.takeItem(
self.ui.listWidget_2.row(self.ui.listWidget_2.currentItem()))
widget.deleteLater()
key = None
for k, v in answer["imagePaths"].items():
if v == value:
break
firebase.delete("/users/" + userID + "/imagePaths/" + k, None)
print("delete")
#Creates right click options with enlarge, save, delete
def rightClickFunction(self, event):
global item
index = self.ui.listWidget_2.indexAt(event)
if not index.isValid():
return
item = self.ui.listWidget_2.indexAt(event)
self.customMenu.popup(QtGui.QCursor.pos())
#Saves new password
def saveNewPassword(self):
if self.ui.lineEdit_6.text() == answer["password"]:
value = self.passwordValidation(self.ui.lineEdit_7.text())
if "perfect" == value:
if self.ui.lineEdit_7.text() == self.ui.lineEdit_8.text():
firebase.put('/users/' + userID, "password",
self.ui.lineEdit_7.text())
self.ui.errorlabel.setText("Updated password")
else:
self.ui.errorlabel.setText("Passwords not the same")
else:
self.ui.errorlabel.setText(value)
else:
self.ui.errorlabel.setText("Current password is incorrect")
#Saves user info
def saveUserInfo(self):
firebase.put('/users/' + userID, "firstName",
self.ui.lineEdit_3.text())
firebase.put('/users/' + userID, "lastName", self.ui.lineEdit_4.text())
firebase.put('/users/' + userID, "email", self.ui.lineEdit_5.text())
#These set up the switches between the different pages for the application
def switchUserInfoWidget(self):
self.ui.stackedWidget_3.setCurrentWidget(self.ui.page)
if answer is not None:
self.ui.lineEdit_3.setText(answer["firstName"])
self.ui.lineEdit_4.setText(answer["lastName"])
self.ui.lineEdit_5.setText(answer["email"])
def switchHomeWidget(self):
self.ui.stackedWidget_2.setCurrentWidget(self.ui.page_6)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
def switchPasswordWidget(self):
self.ui.stackedWidget_3.setCurrentWidget(self.ui.page_2)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
def switchImageWidget(self):
self.ui.label_21.setText("")
self.ui.fileLabel.setText("Open file path")
self.ui.pathLabel.setText("set file path")
self.ui.stackedWidget_2.setCurrentWidget(self.ui.detect_image_page)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
def switchWebcamWidget(self):
self.ui.label_9.setText("")
self.ui.cameraIP.setText("")
self.ui.locationCamera.setText("")
self.ui.stackedWidget_2.setCurrentWidget(self.ui.detect_webcam_page)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
def switchVideoWidget(self):
self.ui.errorvideo.setText("")
self.ui.fileLabel_2.setText("Open file path")
self.ui.stackedWidget_2.setCurrentWidget(self.ui.detect_video_page)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
def switchSettingsWidget(self):
self.ui.stackedWidget_2.setCurrentWidget(self.ui.setting_page)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_4)
def switchNotificationsWidget(self):
self.ui.stackedWidget_2.setCurrentWidget(self.ui.notification_page)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_5)
def switchLoginWidget(self):
self.ui.stackedWidget.setCurrentWidget(self.ui.login_page)
self.ui.stackedWidget_2.setCurrentWidget(self.ui.page_6)
self.ui.stackedWidget_4.setCurrentWidget(self.ui.page_5)
self.ui.lineEdit_2.setText("")
self.ui.listWidget_2.clear()
self.ui.cameraIP.setText("")
self.ui.label_17.setText("")
self.ui.locationCamera.setText("")
self.ui.fileLabel_2.setText("Open file path")
self.ui.fileLabel.setText("Open file path")
self.ui.pathLabel.setText("set file path")
item = None
userID = None
current_user = None
answer = None
fname = None
f1 = None
flag = True
fvideoname = None
#creates a thread which is consistenly checking users input and seeing if they have entered everything correctly
def newFunc(self):
global flag
global firebase
result = firebase.get('/users', None)
time.sleep(2)
while flag:
#Check username field
answer = None
if self.ui.usernamelabel.text():
if len(self.ui.usernamelabel.text()) >= 4:
answer = next(
(item for item in result.values()
if item["username"] == self.ui.usernamelabel.text()),
None)
if answer is None:
self.ui.UsernameImg.setPixmap(
QtGui.QPixmap("./images/greentick.png"))
self.ui.usernameBtn.setText("Perfect!")
else:
self.badUsernameField()
self.ui.usernameBtn.setText("Username already exists")
else:
self.badUsernameField()
self.ui.usernameBtn.setText(
"Username must be at least 4 characters")
else:
self.badUsernameField()
self.ui.usernameBtn.setText("Username must be unique")
#Check email fields
if self.ui.emaillabel.text():
if validate_email(self.ui.emaillabel.text()):
self.goodEmailField()
self.ui.emailBtn.setText("Perfect!")
else:
self.badEmailField()
self.ui.emailBtn.setText("Email must be valid")
else:
self.badEmailField()
self.ui.emailBtn.setText("Email must be valid")
#Check password fields
if self.ui.passwordlabel.text():
vald1 = self.passwordLengthValidation(
self.ui.passwordlabel.text())
vald3 = self.passwordNumberValidation(
self.ui.passwordlabel.text())
vald2 = self.passwordCapitalValidation(
self.ui.passwordlabel.text())
if vald1 == "perfect":
self.goodPasswordLengthField()
self.ui.passwordBtn.setText("Perfect!")
else:
self.badPasswordLengthField()
self.ui.passwordBtn.setText(
"Password must be longer than 4 characters")
if vald2 == "perfect":
self.goodPasswordCapitalField()
self.ui.passwordBtn_2.setText("Perfect!")
else:
self.badPasswordCapitalField()
self.ui.passwordBtn_2.setText(
"Password must have a capital letter")
if vald3 == "perfect":
self.goodPasswordNumberField()
self.ui.passwordBtn_3.setText("Perfect!")
else:
self.badPasswordNumberField()
self.ui.passwordBtn_3.setText(
"Password must have a number")
if self.ui.passwordlabel.text() == self.ui.passwordlabel2.text(
):
self.goodPasswordSameField()
self.ui.passwordBtn_4.setText("Perfect!")
else:
self.badPasswordSameField()
self.ui.passwordBtn_4.setText("Passwords must be the same")
else:
self.badPasswordNumberField()
self.badPasswordCapitalField()
self.badPasswordLengthField()
self.badPasswordSameField()
self.ui.passwordBtn_3.setText("Password must have a number")
self.ui.passwordBtn_2.setText(
"Password must have a capital letter")
self.ui.passwordBtn.setText(
"Password must be longer than 4 characters")
self.ui.passwordBtn_4.setText("Passwords must be the same")
# value = self.passwordValidation(self.ui.passwordlabel.text())
# if value == "perfect":
# if self.ui.passwordlabel2.text():
# if self.ui.passwordlabel.text() == self.ui.passwordlabel2.text():
# self.goodPasswordField()
# self.ui.passwordBtn.setText("Password is perfect!")
# else:
# self.badPasswordField()
# self.ui.passwordBtn.setText("Passwords must be the same")
# else:
# self.badPasswordField()
# self.ui.passwordBtn.setText("re-password field is empty!")
# else:
# self.badPasswordField()
# self.ui.passwordBtn.setText(value)
# else:
# self.badPasswordField()
# self.ui.passwordBtn.setText("password field is empty!")
def switchSignupWidget(self):
self.ui.stackedWidget.setCurrentWidget(self.ui.page_3)
self.ui.label_17.setText("")
threading.Thread(target=self.newFunc, daemon=True).start()
def passwordLengthValidation(self, password):
if len(password) <= 4:
return "Make sure your password is at least 5 letters"
else:
return "perfect"
def passwordNumberValidation(self, password):
if re.search('[0-9]', password) is None:
return "Make sure your password has a number in it"
else:
return "perfect"
def passwordCapitalValidation(self, password):
if re.search('[A-Z]', password) is None:
return "Make sure your password has a capital letter in it"
else:
return "perfect"
def goodUsernameField(self):
self.ui.UsernameImg.setPixmap(QtGui.QPixmap("./images/greentick.png"))
def badUsernameField(self):
self.ui.UsernameImg.setPixmap(QtGui.QPixmap("./images/wrongcross.png"))
def goodEmailField(self):
self.ui.emailImg.setPixmap(QtGui.QPixmap("./images/greentick.png"))
def badEmailField(self):
self.ui.emailImg.setPixmap(QtGui.QPixmap("./images/wrongcross.png"))
def goodPasswordLengthField(self):
self.ui.passwordImg.setPixmap(QtGui.QPixmap("./images/greentick.png"))
def badPasswordLengthField(self):
self.ui.passwordImg.setPixmap(QtGui.QPixmap("./images/wrongcross.png"))
def goodPasswordCapitalField(self):
self.ui.passwordImg_2.setPixmap(
QtGui.QPixmap("./images/greentick.png"))
def badPasswordCapitalField(self):
self.ui.passwordImg_2.setPixmap(
QtGui.QPixmap("./images/wrongcross.png"))
def goodPasswordNumberField(self):
self.ui.passwordImg_3.setPixmap(
QtGui.QPixmap("./images/greentick.png"))
def badPasswordNumberField(self):
self.ui.passwordImg_3.setPixmap(
QtGui.QPixmap("./images/wrongcross.png"))
def goodPasswordSameField(self):
self.ui.passwordImg_4.setPixmap(
QtGui.QPixmap("./images/greentick.png"))
def badPasswordSameField(self):
self.ui.passwordImg_4.setPixmap(
QtGui.QPixmap("./images/wrongcross.png"))
def signup(self):
global firebase
global flag
result = firebase.get('/users', None)
firstname = self.ui.firstnamelabel.text()
surname = self.ui.surnamelabel.text()
email = self.ui.emaillabel.text()
username = self.ui.usernamelabel.text()
password = self.ui.passwordlabel.text()
repassword = self.ui.passwordlabel2.text()
#Quickly check which button is checked
if "Perfect" in self.ui.emailBtn.text(
) and "Perfect" in self.ui.passwordBtn.text(
) and "Perfect" in self.ui.usernameBtn.text(
) and "Perfect" in self.ui.passwordBtn_2.text(
) and "Perfect" in self.ui.passwordBtn_3.text(
) and "Perfect" in self.ui.passwordBtn_4.text():
flag = False
user = User(firstname, surname, email, username, "Not specified",
5, password, [])
result = firebase.post('/users', user.__dict__)
self.ui.stackedWidget.setCurrentWidget(self.ui.login_page)
else:
print("fix errors")
#LETS THE USER Login
def login(self):
global answer
global firebase
global current_user
global userID
result = firebase.get('/users', None)
username = self.ui.lineEdit.text()
password = self.ui.lineEdit_2.text()
userID = next(
(item for item in result if result[item]["username"] == username),
None) #Get user ID
answer = next(
(item for item in result.values() if item["username"] == username),
None) #Get user DATA
if answer is None:
self.ui.label_17.setText("User doesn't exist")
else:
if answer["password"] == password:
current_user = answer["username"]
#firebase.post('/users/'+ userID + '/imagePaths','C:/Users/abdsaam/Desktop/pythonapp/designs/images/greentick.png')
self.ui.stackedWidget.setCurrentIndex(0)
qApp.processEvents()
if "imagePaths" in answer:
for x in answer["imagePaths"].values():
print(x)
imageBlob = bucket.blob(
current_user + "/" + x
) #Get the users folder from database, and their images
print(imageBlob.public_url)
with urllib.request.urlopen(
imageBlob.public_url) as url:
s = url.read()
wid = test_widget()
wid.setImage(s)
values = x.split()
wid.setLabelDate(str("Date: " + values[0]))
wid.setLabelTime(
str("Time: " + values[1].replace("-", ":")))
wid.setLabelType(
str("Detection: " +
values[2].replace(".jpg", "")))
widgetItem = QtWidgets.QListWidgetItem(
self.ui.listWidget_2)
widgetItem.setSizeHint(wid.sizeHint())
self.ui.listWidget_2.addItem(widgetItem)
self.ui.listWidget_2.setItemWidget(widgetItem, wid)
#imageBlob.upload_from_filename('C:/Users/abdsaam/Desktop/pythonapp/designs/images/greentick.png')
# imageBlob = bucket.blob(self.ui.lineEdit.text()+"/")
#print(imageBlob)
else:
self.ui.label_17.setText("Incorrect password")
def DetectImage(self):
self.ui.label_21.setText("Loading.... Application might freeze....")
qApp.processEvents()
global f1, fname
image = cv2.imread(fname[0]) #get filename
image_expanded = np.expand_dims(image, axis=0) #convert to numpy array
#Saves model output into 4 values
(boxes, scores, classes, num) = sess.run(
[
detection_boxes, detection_scores, detection_classes,
num_detections
],
feed_dict={image_tensor: image_expanded}
) #uses model that was loaded in and feeds it a np array of the image we wish to have detected
#Detect image
vis_util.visualize_boxes_and_labels_on_image_array(
image,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores), {1: {
'name': 'smoker',
'id': 1
}},
use_normalized_coordinates=True,
line_thickness=8,
min_score_thresh=0.90)
# selected_indices = tf.image.non_max_suppression(boxes[0], scores[0], 5, 0.5)
# print(scores[0])
# print(selected_indices)
# print(selected_indices.get_shape().as_list())
# selected_boxes = tf.gather(boxes, selected_indices)
# print(selected_boxes)
# print(selected_boxes.get_shape().as_list())
# threshold = 0.5
# height, width = image.shape[:2] #gets height and width of image
# for x in selected_indices.get_shape().as_list():
# if x is None:
# ymin = boxes[0][0][0]*height
# xmin = boxes[0][0][1]*width
# ymax = boxes[0][0][2]*height
# xmax = boxes[0][0][3]*width
# else:
# ymin = boxes[0][x][0]*height
# xmin = boxes[0][x][1]*width
# ymax = boxes[0][x][2]*height
# xmax = boxes[0][x][3]*width
# cv2.rectangle(image, (int(xmin),int(ymin)), (int(xmax),int(ymax)),(0,255,0),5)
#Get the date time and save it
datetimevalue = strftime("%d-%m-%Y %H-%M-%S", gmtime())
cv2.imwrite(f1 + "/" + datetimevalue + " " + "image" + ".jpg", image)
pixmap = QtGui.QPixmap(f1 + "/" + datetimevalue + " " + "image" +
".jpg")
scaled_pixmap = pixmap.scaled(500, 500, QtCore.Qt.KeepAspectRatio)
#Post the image to the database with the date and time
self.ui.label_11.setPixmap(QtGui.QPixmap(scaled_pixmap))
if self.ui.saveNotificationsImage.isChecked():
value = datetimevalue + " " + "image" + ".jpg"
firebase.post('/users/' + userID + '/imagePaths', value)
imageBlob = bucket.blob(current_user + "/" + value)
path = f1 + "/" + datetimevalue + " " + "image" + ".jpg"
imageBlob.upload_from_filename(path)
self.newNotification(f1 + "/" + value, value)
self.ui.label_21.setText("Done!")
def newNotification(self, path, s):
wid = test_widget()
wid.setImage1(path)
values = s.split()
wid.setLabelDate(str("Date: " + values[0]))
wid.setLabelTime(str("Time: " + values[1].replace("-", ":")))
wid.setLabelType(str("Detection: " + values[2].replace(".jpg", "")))
widgetItem = QtWidgets.QListWidgetItem(self.ui.listWidget_2)
widgetItem.setSizeHint(wid.sizeHint())
self.ui.listWidget_2.insertItem(0, widgetItem)
self.ui.listWidget_2.setItemWidget(widgetItem, wid)
def outputFile(self):
global f1
f1 = QFileDialog.getExistingDirectory(None, "Select Output Folder")
self.ui.pathLabel.setText(f1)
def openFile(self):
global fname
fname = QFileDialog.getOpenFileName(None, 'Open file', 'c:\\',
'Image files (*.jpg *.png)')
pixmap = QtGui.QPixmap(fname[0])
scaled_pixmap = pixmap.scaled(500, 500, QtCore.Qt.KeepAspectRatio)
self.ui.label_11.setPixmap(QtGui.QPixmap(scaled_pixmap))
self.ui.fileLabel.setText(fname[0])
def openVideoFile(self):
global fvideoname
fvideoname = QFileDialog.getOpenFileName(None, 'Open file', 'c:\\',
'Video files (*.mp4 *.mov)')
self.ui.fileLabel_2.setText(fvideoname[0])
def detectVideo(self):
global fvideoname
self.ui.errorvideo.setText("Loading.... Application might freeze....")
qApp.processEvents()
video = cv2.VideoCapture(fvideoname[0])
if video.isOpened():
self.ui.errorvideo.setText("Done!")
current_time = time.time()
while (video.isOpened()):
#Get frame and expand it so it can fed to tensorflow
ret, frame = video.read()
frame_expanded = np.expand_dims(frame, axis=0)
# Perform the actual detection by running the model with the image as input
(boxes, scores, classes,
num) = sess.run([
detection_boxes, detection_scores, detection_classes,
num_detections
],
feed_dict={image_tensor: frame_expanded})
#Draws bounding box around the detected part of the image #Helper code
vis_util.visualize_boxes_and_labels_on_image_array(
frame,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores), {1: {
'name': 'smoker',
'id': 1
}},
use_normalized_coordinates=True,
line_thickness=8,
min_score_thresh=0.90)
#Show the detected image on the window
cv2.imshow("video", frame)
if scores[0][0] * 100 > 90:
if self.thirty_timer(current_time):
current_time = time.time()
datetimevalue = strftime("%d-%m-%Y %H-%M-%S", gmtime())
cv2.imwrite(
"./videoimages" + "/" + datetimevalue + " " +
"video" + ".jpg", frame)
if self.ui.saveNotificationsImage_3.isChecked():
value = datetimevalue + " " + "video" + ".jpg"
firebase.post('/users/' + userID + '/imagePaths',
value)
imageBlob = bucket.blob(current_user + "/" + value)
path = "./videoimages" + "/" + datetimevalue + " " + "video" + ".jpg"
imageBlob.upload_from_filename(path)
self.newNotification("./videoimages" + "/" + value,
value)
#Q or Esc to quit detecting webcam
k = cv2.waitKey(1)
if k == ord('q') or k == 27:
break
if cv2.getWindowProperty("video", 1) == -1:
break
# Clean up
video.release()
cv2.destroyAllWindows()
else:
self.ui.errorvideo.setText("Error with video file")
def thirty_timer(self, oldtime):
return time.time() - oldtime >= 30
def detectCameraIP(self):
self.ui.label_9.setText("Loading.... Application might freeze....")
qApp.processEvents()
#Check if user is connecting to USB webcam or trying to connect to cameraIP address
if self.ui.cameraIP.text().isdigit():
cameraIPvalue = int(self.ui.cameraIP.text())
else:
cameraIPvalue = self.ui.cameraIP.text()
video = cv2.VideoCapture(cameraIPvalue)
video.set(3, 1024)
video.set(4, 768)
if video.isOpened():
self.ui.label_9.setText("Done!")
current_time = time.time()
while (True):
#Get frame and expand it so it can fed to tensorflow
ret, frame = video.read()
frame_expanded = np.expand_dims(frame, axis=0)
# Perform the actual detection by running the model with the image as input
(boxes, scores, classes,
num) = sess.run([
detection_boxes, detection_scores, detection_classes,
num_detections
],
feed_dict={image_tensor: frame_expanded})
#Draws bounding box around the detected part of the image #Helper code
vis_util.visualize_boxes_and_labels_on_image_array(
frame,
np.squeeze(boxes),
np.squeeze(classes).astype(np.int32),
np.squeeze(scores), {1: {
'name': 'smoker',
'id': 1
}},
use_normalized_coordinates=True,
line_thickness=8,
min_score_thresh=0.90)
#Show the detected image on the window
cv2.imshow(self.ui.locationCamera.text(), frame)
if scores[0][0] * 100 > 90:
if self.thirty_timer(current_time):
current_time = time.time()
datetimevalue = strftime("%d-%m-%Y %H-%M-%S", gmtime())
cv2.imwrite(
"./webcamimages" + "/" + datetimevalue + " " +
"webcam" + ".jpg", frame)
if self.ui.saveNotificationsImage_2.isChecked():
value = datetimevalue + " " + "webcam" + ".jpg"
firebase.post('/users/' + userID + '/imagePaths',
value)
imageBlob = bucket.blob(current_user + "/" + value)
path = "./webcamimages" + "/" + datetimevalue + " " + "webcam" + ".jpg"
imageBlob.upload_from_filename(path)
self.newNotification(
"./webcamimages" + "/" + value, value)
#Q or Esc to quit detecting webcam
k = cv2.waitKey(1)
if k == ord('q') or k == 27:
break
if cv2.getWindowProperty(self.ui.locationCamera.text(),
1) == -1:
break
# Clean up
video.release()
cv2.destroyAllWindows()
else:
self.ui.label_9.setText("Cannot find camera")
class MainView(QMainWindow):
def __init__(self, model: MainModel, controller: MainController):
super().__init__()
self.controller = controller
self.model = model
self.currentBlock = ""
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.saveControls()
self.setupButtons()
self.model.subscribe_update_function(self.updateFilenames)
def saveControls(self):
self.controls = {
"radioButtons": self.ui.centralwidget.findChildren(QRadioButton),
"dateEdits": self.ui.centralwidget.findChildren(QDateTimeEdit),
"selects": self.ui.centralwidget.findChildren(QComboBox),
"textEdits": self.ui.centralwidget.findChildren(QLineEdit),
"checkboxes": self.ui.centralwidget.findChildren(QCheckBox),
"counters": self.ui.centralwidget.findChildren(QSpinBox)
}
def setupButtons(self):
self.ui.Btn_Delete.clicked.connect(self.deleteFiles)
self.ui.Btn_Confirm.clicked.connect(self.runRename)
self.ui.Btn_AddBlock.clicked.connect(self.addBlockToBlocksArea)
self.ui.Table_FilesList.filesdropped.connect(self.addFile)
self.ui.listW_New_Pattern.newdrop.connect(self.updatePattern)
self.ui.listW_New_Pattern.model().rowsRemoved.connect(
self.updatePattern)
# Connect controls to onChange function
self.ui.Toolbox_BlockSettings.currentChanged.connect(self.onChange)
for rb in self.controls["radioButtons"]:
rb.clicked.connect(self.onChange)
for de in self.controls["dateEdits"]:
de.setDateTime(QDateTime.currentDateTime())
de.editingFinished.connect(self.onChange)
for sel in self.controls["selects"]:
sel.currentIndexChanged.connect(self.onChange)
for ed in self.controls["textEdits"]:
ed.textChanged.connect(self.onChange)
for cb in self.controls["checkboxes"]:
cb.stateChanged.connect(self.onChange)
for c in self.controls["counters"]:
c.valueChanged.connect(self.onChange)
def resetButtons(self):
for de in self.controls["dateEdits"]:
de.setDateTime(QDateTime.currentDateTime())
for sel in self.controls["selects"]:
sel.currentIndex = 0
for ed in self.controls["textEdits"]:
ed.clear()
for c in self.controls["counters"]:
c.blockSignals(True)
c.setValue(c.minimum())
c.blockSignals(False)
for cb in self.controls["checkboxes"] + self.controls["radioButtons"]:
cb.blockSignals(True)
if cb.autoExclusive():
cb.setAutoExclusive(False)
cb.setChecked(False)
cb.setAutoExclusive(True)
else:
cb.setChecked(False)
cb.blockSignals(False)
self.currentBlock = None
self.ui.Btn_AddBlock.setEnabled(False)
@pyqtSlot()
def onChange(self):
# Toggle active/inactive fields according radiobuttons/checkboxes
if type(self.sender()) == QCheckBox or type(
self.sender()) == QRadioButton:
parentLayout = self.sender().parentWidget().findChildren(
QGridLayout)[0]
for row in range(parentLayout.rowCount()):
item = parentLayout.itemAtPosition(row, 0)
dependentsInRow = findItemsInLayout(parentLayout, row, row + 1,
1,
parentLayout.columnCount())
if item and item.widget() and item.widget().isChecked():
[w.setEnabled(True) for w in dependentsInRow]
else:
[w.setEnabled(False) for w in dependentsInRow]
# Create new block value
block = self.createBlock()
self.currentBlock = block
if self.currentBlock and len(self.currentBlock) > 0:
self.ui.Btn_AddBlock.setEnabled(True)
self.currentBlock = block
self.displayPreview()
else:
self.ui.Btn_AddBlock.setEnabled(False)
@pyqtSlot()
def updatePattern(self):
pattern = self.ui.listW_New_Pattern
modelP = pattern.model()
modelP.rowCount()
patternList = []
for i in range(pattern.count()):
patternList.append(pattern.item(i).data(Qt.UserRole))
self.controller.updatePattern(patternList)
def displayPreview(self):
block = self.currentBlock
previewArea = self.ui.Lbl_PreviewBlock
if block:
previewArea.setText(block["prettyValue"])
else:
previewArea.setText("")
def addBlockToBlocksArea(self):
if self.currentBlock:
self.ui.listW_BlocksArea.addBlock(self.currentBlock)
self.resetButtons()
def createBlock(self):
if self.ui.Toolbox_BlockSettings.currentIndex() == 0:
return self.createTextBlock()
elif self.ui.Toolbox_BlockSettings.currentIndex() == 1:
return self.createNumberBlock()
else:
pass
def createTextBlock(self):
if self.ui.RB_Text_exactText.isChecked():
data = self.ui.Inp_Text_exactText.text()
if len(data) > 0:
block = {
"value": data,
"case": self.resolveCase(),
"separator": self.resolveSeparator()
}
block["prettyValue"] = self.createPrettyValue(block)
return block
elif self.ui.RB_Text_Date.isChecked():
data = self.ui.Inp_Text_Date.date()
dateformat = self.ui.Sel_Text_DateFormat.currentText()
block = {
"value": data.toString(dateformat),
"case": self.resolveCase(),
"separator": self.resolveSeparator()
}
block["prettyValue"] = self.createPrettyValue(block)
return block
elif self.ui.RB_Text_ParentFolder.isChecked():
block = {
"value": "ParentDir",
"case": self.resolveCase(),
"separator": self.resolveSeparator()
}
block["prettyValue"] = self.createPrettyValue(block)
return block
elif self.ui.RB_Text_OriginalName.isChecked():
block = {
"value": "OriginalName",
"case": self.resolveCase(),
"separator": self.resolveSeparator()
}
block["prettyValue"] = self.createPrettyValue(block)
return block
elif self.ui.RB_Text_Word.isChecked():
wordIndex = self.ui.Inp_Word_index.value()
separators = (self.ui.Inp_Word_Separators.text()
) if self.ui.Inp_Word_Separators.text() else ""
block = {
"value": "Word:" + str(wordIndex) + ":" + separators,
"case": self.resolveCase(),
"separator": self.resolveSeparator()
}
block["prettyValue"] = self.createPrettyValue(block)
return block
else:
pass
def createNumberBlock(self):
if self.ui.RB_Number_Counter.isChecked():
count = self.ui.Inp_Numbering_StartFrom.value()
zeroes = self.ui.Inp_Numbering_LeadingZeroes.value() + len(
str(count))
block = {
"value": "Nr:" + str(count).zfill(zeroes),
"case": None,
"separator": self.resolveSeparator()
}
block["prettyValue"] = self.createPrettyValue(block)
return block
elif self.ui.RB_Number_Folder.isChecked():
block = {
"value": "Nr:Folder",
"case": None,
"separator": self.resolveSeparator()
}
block["prettyValue"] = self.createPrettyValue(block)
return block
elif self.ui.RB_Number_Items.isChecked():
block = {
"value": "Nr:All",
"case": None,
"separator": self.resolveSeparator()
}
block["prettyValue"] = self.createPrettyValue(block)
return block
else:
pass
def resolveCase(self):
if self.ui.CB_Case_change.isChecked():
sel = self.ui.Sel_Case
if sel.currentText() == "lowercase":
return "L"
elif sel.currentText() == "UPPERCASE":
return "U"
elif sel.currentText() == "rEVERSE":
return "R"
else:
return None
else:
return None
def resolveSeparator(self):
if self.ui.CB_Separators_include.isChecked():
return self.ui.Inp_Separator.text()
else:
return None
def createPrettyValue(self, block):
previewString = block["value"]
if block["separator"]:
previewString += block["separator"]
if block["case"]:
if block["case"] == "L":
previewString += u"\u2193"
elif block["case"] == "U":
previewString += u"\u2191"
elif block["case"] == "R":
previewString += u"\u2191\u2193"
else:
pass
return previewString
def updateFilenames(self):
self.controller.updateFilenames()
self.ui.Table_FilesList.updateFilenames(self.model.files)
@pyqtSlot(str)
def addFile(self, filepath):
if os.path.isfile(filepath):
if filepath not in self.model.files:
file = createFileData(filepath)
self.controller.addFile({filepath: file})
self.ui.Table_FilesList.addFile(file)
def deleteFiles(self):
files = self.ui.Table_FilesList.checked.copy()
for file in files:
self.deleteFile(file)
def deleteFile(self, filepath):
if filepath in self.model.files:
self.controller.deleteFile(filepath)
self.ui.Table_FilesList.deleteFile(filepath)
self.ui.Table_FilesList.checked.discard(filepath)
def runRename(self):
files = self.ui.Table_FilesList.checked.copy()
if not files:
self.ui.Lbl_Status.setText("No files selected")
self.ui.Lbl_Status.setStyleSheet("color:red;")
else:
filesNameExists = 0
filesNameNotDefined = 0
for file in files:
if self.model.files[file]["out"] and len(
self.model.files[file]["out"]) > 0:
try:
newPath = os.path.join(
os.path.dirname(file),
self.model.files[file]["out"] +
self.model.files[file]["ext"])
os.rename(file, newPath)
self.deleteFile(file)
except FileExistsError:
filesNameExists += 1
else:
filesNameNotDefined += 1
if filesNameExists:
self.ui.Lbl_Status.setText(
"%d files were not renamed, because another file with same name exists"
% (filesNameExists))
self.ui.Lbl_Status.setStyleSheet("color:red;")
elif filesNameNotDefined:
self.ui.Lbl_Status.setText(
"%d files were not renamed, because new name not defined" %
(filesNameNotDefined))
self.ui.Lbl_Status.setStyleSheet("color:red;")
else:
self.ui.Lbl_Status.setText("All files renamed successfully!")
self.ui.Lbl_Status.setStyleSheet("color:green;")
self.ui.listW_New_Pattern.removeAllBlocks()
self.controller.resetPattern()
class MainFrame(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self, loop, config):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.config = config
self.ui.txt_log.insertPlainText('Файл настроек загружен.')
self.prefs_window = None
self.ui.menu_exit.triggered.connect(self._exit)
self.ui.menu_preferences.triggered.connect(self.prefs_open)
self.ui.menu_open.triggered.connect(self.open_dialog)
self.ui.menu_save.triggered.connect(self.save)
self.ui.menu_save_as.triggered.connect(self.save_as)
self.ui.menu_create.triggered.connect(self.clear_numbers)
self.ui.btn_exit.clicked.connect(self._exit)
self.ui.btn_send.clicked.connect(self.send)
self.loop = loop
def _exit(self):
sys.exit()
def open_dialog(self):
file_name = QtGui.QFileDialog.getOpenFileName(self, "Открыть файл списка номеров", "", "text file (*.txt)")
if os.path.exists(file_name):
self.ui.txt_sms_num.clear()
with open(file_name, 'r') as f:
self.ui.txt_sms_num.insertPlainText(f.read())
self.response_decode((5, file_name))
def save(self):
file_name = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + '.txt'
cat = os.path.split(os.path.abspath(__file__))[0]
full_path = os.path.join(cat, file_name)
with open(full_path, 'w') as f:
f.write(self.ui.txt_sms_num.toPlainText())
self.response_decode((6, file_name))
def save_as(self):
file_name = QtGui.QFileDialog.getSaveFileName(self, "Сохранить файл с номерами как", "", "text file (*.txt)")
cat = os.path.split(os.path.abspath(__file__))[0]
full_path = os.path.join(cat, file_name)
with open(full_path, 'w') as f:
f.write(self.ui.txt_sms_num.toPlainText())
self.response_decode((6, file_name))
def clear_numbers(self):
self.ui.txt_sms_num.clear()
def prefs_open(self):
if self.prefs_window is None:
self.prefs = Preferences(self.config)
self.connect(self.prefs, QtCore.SIGNAL('config(PyQt_PyObject)'), self.reload_config)
self.connect(self.prefs, QtCore.SIGNAL("response(PyQt_PyObject)"), self.response_decode)
self.prefs.show()
def reload_config(self, config):
self.config = config
def sanitarize_numbers(self):
pattern = re.compile(r'\d+', flags=re.IGNORECASE)
numbers = list(self.ui.txt_sms_num.toPlainText().split('\n'))
phone_numbers = []
for number in numbers:
digits = re.findall(pattern, number)
fixed_number = ''
if len(digits) > 1:
for digit in digits:
fixed_number += digit
phone_numbers.append(fixed_number)
elif len(digits) == 1:
phone_numbers.append(digits[0])
return phone_numbers
def sanitarize_text(self):
text = self.ui.txt_sms_text.toPlainText()
pattern = re.compile(r'([\"\'])', flags=re.IGNORECASE)
r_pattern = re.compile(r'[\"\']', flags=re.IGNORECASE)
index = re.findall(pattern, text)
if len(index) != 0:
for i in range(1, len(index)+1):
print(i%2)
if i % 2 == 1:
text = re.sub(r_pattern, "<<", text, 1)
elif i % 2 == 0:
text = re.sub(r_pattern, ">>", text, 1)
return text
def send(self):
# Следующие аргументы должны быть загружены из файла в момент инициализации!!!
numbers = list(self.ui.txt_sms_num.toPlainText().split('\n'))
sms_text = self.ui.txt_sms_text.toPlainText()
if self.config['sanitarize'] == 'true':
numbers = self.sanitarize_numbers()
sms_text = self.sanitarize_text()
if numbers[0] == '':
self.ui.txt_log.insertPlainText('Не указано ни одного номера телефона для отправки!\n')
else:
print(sms_text)
self.GSM = GSMGateway(self.loop,(self.config['username'], self.config['password']),
self.config['gateway'], SIMSlot=self.config['simslot'],
numbers_list=numbers, text=sms_text)
self.connect(self.GSM, QtCore.SIGNAL("response(PyQt_PyObject)"), self.response_decode)
self.GSM.start()
def response_decode(self, response):
stage, data = response
if stage == 0:
if data == 'Connection established':
self.ui.txt_log.insertPlainText('\nСоединение с шлюзом установлено успешно.')
else:
self.ui.txt_log.insertPlainText('\nНевозможно установить соединение со шлюзом.')
elif stage == 1:
if 'Success' in data:
self.ui.txt_log.insertPlainText('\nДанные авторизации приняты')
else:
self.ui.txt_log.insertPlainText('\nШлюз отверг запрос авторизации')
elif stage == 2:
pattern = re.compile(r"\w+:\s?(\d+)", flags=re.IGNORECASE)
if 'failed' in data:
number = re.findall(pattern, data)[0]
self.ui.txt_log.insertPlainText('\nОшибка отправки СМС на номер: %s' % number)
elif 'Response: Follows' in data:
number = re.findall(pattern, data)[0]
self.ui.txt_log.insertPlainText('\nСМС отправлена на номер: %s' % number)
#-------------------------------------------------------------------------------------
elif stage == 5:
self.ui.txt_log.insertPlainText('\nЗагружен файл списка номеров: %s' % data)
elif stage == 6:
self.ui.txt_log.insertPlainText('\nСохранен файл списка номеров: %s' % data)
elif stage == 7:
self.ui.txt_log.insertPlainText('\nФайл настроек изменен: %s' % data)
class MainFrame(QtGui.QMainWindow, Ui_MainWindow):
def __init__(self, loop, config):
super().__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.config = config
self.ui.txt_log.insertPlainText('Файл настроек загружен.')
self.prefs_window = None
self.ui.menu_exit.triggered.connect(self._exit)
self.ui.menu_preferences.triggered.connect(self.prefs_open)
self.ui.menu_open.triggered.connect(self.open_dialog)
self.ui.menu_save.triggered.connect(self.save)
self.ui.menu_save_as.triggered.connect(self.save_as)
self.ui.menu_create.triggered.connect(self.clear_numbers)
self.ui.btn_exit.clicked.connect(self._exit)
self.ui.btn_send.clicked.connect(self.send)
self.loop = loop
def _exit(self):
sys.exit()
def open_dialog(self):
file_name = QtGui.QFileDialog.getOpenFileName(
self, "Открыть файл списка номеров", "", "text file (*.txt)")
if os.path.exists(file_name):
self.ui.txt_sms_num.clear()
with open(file_name, 'r') as f:
self.ui.txt_sms_num.insertPlainText(f.read())
self.response_decode((5, file_name))
def save(self):
file_name = datetime.datetime.now().strftime(
"%Y-%m-%d_%H-%M-%S") + '.txt'
cat = os.path.split(os.path.abspath(__file__))[0]
full_path = os.path.join(cat, file_name)
with open(full_path, 'w') as f:
f.write(self.ui.txt_sms_num.toPlainText())
self.response_decode((6, file_name))
def save_as(self):
file_name = QtGui.QFileDialog.getSaveFileName(
self, "Сохранить файл с номерами как", "", "text file (*.txt)")
cat = os.path.split(os.path.abspath(__file__))[0]
full_path = os.path.join(cat, file_name)
with open(full_path, 'w') as f:
f.write(self.ui.txt_sms_num.toPlainText())
self.response_decode((6, file_name))
def clear_numbers(self):
self.ui.txt_sms_num.clear()
def prefs_open(self):
if self.prefs_window is None:
self.prefs = Preferences(self.config)
self.connect(self.prefs, QtCore.SIGNAL('config(PyQt_PyObject)'),
self.reload_config)
self.connect(self.prefs, QtCore.SIGNAL("response(PyQt_PyObject)"),
self.response_decode)
self.prefs.show()
def reload_config(self, config):
self.config = config
def sanitarize_numbers(self):
pattern = re.compile(r'\d+', flags=re.IGNORECASE)
numbers = list(self.ui.txt_sms_num.toPlainText().split('\n'))
phone_numbers = []
for number in numbers:
digits = re.findall(pattern, number)
fixed_number = ''
if len(digits) > 1:
for digit in digits:
fixed_number += digit
phone_numbers.append(fixed_number)
elif len(digits) == 1:
phone_numbers.append(digits[0])
return phone_numbers
def sanitarize_text(self):
text = self.ui.txt_sms_text.toPlainText()
pattern = re.compile(r'([\"\'])', flags=re.IGNORECASE)
r_pattern = re.compile(r'[\"\']', flags=re.IGNORECASE)
index = re.findall(pattern, text)
if len(index) != 0:
for i in range(1, len(index) + 1):
print(i % 2)
if i % 2 == 1:
text = re.sub(r_pattern, "<<", text, 1)
elif i % 2 == 0:
text = re.sub(r_pattern, ">>", text, 1)
return text
def send(self):
# Следующие аргументы должны быть загружены из файла в момент инициализации!!!
numbers = list(self.ui.txt_sms_num.toPlainText().split('\n'))
sms_text = self.ui.txt_sms_text.toPlainText()
if self.config['sanitarize'] == 'true':
numbers = self.sanitarize_numbers()
sms_text = self.sanitarize_text()
if numbers[0] == '':
self.ui.txt_log.insertPlainText(
'Не указано ни одного номера телефона для отправки!\n')
else:
print(sms_text)
self.GSM = GSMGateway(
self.loop, (self.config['username'], self.config['password']),
self.config['gateway'],
SIMSlot=self.config['simslot'],
numbers_list=numbers,
text=sms_text)
self.connect(self.GSM, QtCore.SIGNAL("response(PyQt_PyObject)"),
self.response_decode)
self.GSM.start()
def response_decode(self, response):
stage, data = response
if stage == 0:
if data == 'Connection established':
self.ui.txt_log.insertPlainText(
'\nСоединение с шлюзом установлено успешно.')
else:
self.ui.txt_log.insertPlainText(
'\nНевозможно установить соединение со шлюзом.')
elif stage == 1:
if 'Success' in data:
self.ui.txt_log.insertPlainText('\nДанные авторизации приняты')
else:
self.ui.txt_log.insertPlainText(
'\nШлюз отверг запрос авторизации')
elif stage == 2:
pattern = re.compile(r"\w+:\s?(\d+)", flags=re.IGNORECASE)
if 'failed' in data:
number = re.findall(pattern, data)[0]
self.ui.txt_log.insertPlainText(
'\nОшибка отправки СМС на номер: %s' % number)
elif 'Response: Follows' in data:
number = re.findall(pattern, data)[0]
self.ui.txt_log.insertPlainText(
'\nСМС отправлена на номер: %s' % number)
#-------------------------------------------------------------------------------------
elif stage == 5:
self.ui.txt_log.insertPlainText(
'\nЗагружен файл списка номеров: %s' % data)
elif stage == 6:
self.ui.txt_log.insertPlainText(
'\nСохранен файл списка номеров: %s' % data)
elif stage == 7:
self.ui.txt_log.insertPlainText('\nФайл настроек изменен: %s' %
data)
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.last_row = 0
# signal connections
self.ui.cb_p.currentTextChanged.connect(self.set_S)
self.ui.cb_S.currentTextChanged.connect(self.set_N)
self.ui.cb_S.currentTextChanged.connect(self.set_m)
self.ui.cb_m.currentTextChanged.connect(self.set_n)
self.ui.pushButton.clicked.connect(self.fill_r_col)
self.ui.table.cellClicked.connect(self.fill_c_col)
self.ui.saveButton.clicked.connect(self.saveTable)
self.set_p()
self.setup_table()
def set_p(self):
for i in [2, 3, 5, 7, 11, 13]:
self.ui.cb_p.addItem(str(i))
def set_S(self, p):
S_arr = get_S(int(p))
self.ui.cb_S.clear()
for S in S_arr:
self.ui.cb_S.addItem(str(S))
def set_N(self, S):
if not S:
return
N = get_N(int(self.ui.cb_p.currentText()), int(S))
self.ui.N_placeholder.setText(str(N))
def set_m(self, S):
if not S:
return
m_arr = get_m(int(S))
self.ui.cb_m.clear()
for m in m_arr:
self.ui.cb_m.addItem(str(m))
def set_n(self, m):
if not m:
return
n = int(self.ui.cb_S.currentText()) // int(m)
self.ui.n_placeholder.setText(str(n))
def setup_table(self):
self.ui.table.setColumnCount(8)
self.ui.table.setHorizontalHeaderLabels([
'r',
'r в p-ичной',
'g(r)',
'C1',
# 'C1 в p-ичной',
'g(C1)',
'C2',
'C3',
'C3 в p-ичной'
])
self.ui.table.verticalHeader().setVisible(False)
self.ui.table.setSelectionMode(
QtWidgets.QAbstractItemView.SingleSelection)
self.ui.table.setEditTriggers(
QtWidgets.QAbstractItemView.NoEditTriggers)
def calculateButtonClick(self):
self.ui.pushButton.setText('Идет расчет данных')
self.fill_r_col()
def fill_r_col(self):
if not self.ui.cb_m.currentText():
return
self.ui.table.clearContents()
self.ui.table.setRowCount(0)
m = int(self.ui.cb_m.currentText())
p = int(self.ui.cb_p.currentText())
r_arr = get_r(p, m)
i = -1
for i, (r, r_p, g_r_p) in enumerate(r_arr):
self.ui.table.setRowCount(i + 1)
self.ui.table.setItem(i, 0, QtWidgets.QTableWidgetItem(str(r)))
self.ui.table.setItem(i, 1, QtWidgets.QTableWidgetItem(str(r_p)))
self.ui.table.setItem(i, 2, QtWidgets.QTableWidgetItem(str(g_r_p)))
if i > -1:
self.last_row = max(i, self.last_row)
self.ui.pushButton.setText('Рассчитать значения')
def fill_c_col(self, x, y):
gray_color = QtGui.QColor("#f0fcf2")
if y != 0:
print(x, y)
return
self.ui.table.removeColumn(7)
self.ui.table.removeColumn(6)
self.ui.table.removeColumn(5)
self.ui.table.removeColumn(4)
self.ui.table.removeColumn(3)
self.ui.table.setRowCount(self.last_row + 1)
self.ui.table.insertColumn(3)
self.ui.table.insertColumn(4)
self.ui.table.insertColumn(5)
self.ui.table.insertColumn(6)
self.ui.table.insertColumn(7)
# self.ui.table.insertColumn(7)
self.ui.table.setHorizontalHeaderItem(3,
QtWidgets.QTableWidgetItem('C1'))
# self.ui.table.setHorizontalHeaderItem(4, QtWidgets.QTableWidgetItem('C1 в p-ичной'))
self.ui.table.setHorizontalHeaderItem(
4, QtWidgets.QTableWidgetItem('g(C1)'))
self.ui.table.setHorizontalHeaderItem(5,
QtWidgets.QTableWidgetItem('C2'))
self.ui.table.setHorizontalHeaderItem(6,
QtWidgets.QTableWidgetItem('C3'))
self.ui.table.setHorizontalHeaderItem(
7, QtWidgets.QTableWidgetItem('C3 в p-ичной'))
try:
r = int(self.ui.table.item(x, y).text())
except AttributeError:
return
p = int(self.ui.cb_p.currentText())
s = int(self.ui.cb_S.currentText())
m = int(self.ui.cb_m.currentText())
c_arr = get_C1(r, p, s, m)
i = -1
for i, (c, c_p, g_c_p, c2) in enumerate(c_arr):
if self.ui.table.rowCount() < i + 1:
self.ui.table.setRowCount(i + 1)
item = QtWidgets.QTableWidgetItem(str(c))
self.ui.table.setItem(i, 3, item)
# item = QtWidgets.QTableWidgetItem(str(c_p))
# item.setBackground(gray_color)
# self.ui.table.setItem(i, 4, item)
item = QtWidgets.QTableWidgetItem(str(g_c_p))
self.ui.table.setItem(i, 4, item)
item = QtWidgets.QTableWidgetItem(str(c2))
self.ui.table.setItem(i, 5, item)
self.last_row = max(i, self.last_row)
for i, val in enumerate(sorted(set(c2 for _, _, _, c2 in c_arr))):
item = QtWidgets.QTableWidgetItem(str(val))
item_p = QtWidgets.QTableWidgetItem(str(to_base(val, p)))
self.ui.table.setItem(i, 6, item)
self.ui.table.setItem(i, 7, item_p)
self.ui.M_placeholder.setText(str(i + 1))
def saveTable(self):
self.ui.saveButton.setText('Идет сохранение таблицы')
workbook = xlsxwriter.Workbook('table.xlsx')
worksheet = workbook.add_worksheet('Table')
bold = workbook.add_format({'bold': True})
for col in range(self.ui.table.columnCount()):
worksheet.write(0, col,
self.ui.table.horizontalHeaderItem(col).text(),
bold)
for row in range(self.ui.table.rowCount()):
for col in range(self.ui.table.columnCount()):
if self.ui.table.item(row, col):
worksheet.write(row + 1, col,
int(self.ui.table.item(row, col).text()))
else:
worksheet.write(row + 1, col, '-')
workbook.close()
self.ui.saveButton.setText('Сохранить таблицу в table.xlsx')
class ApplicationWindow(QtWidgets.QMainWindow):
sampleRate = 44100
length = 1
def __init__(self):
super(ApplicationWindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
def Csound(self):
self.frequency = 430.81
self.PianoSound(self.frequency)
def Dsound(self):
self.frequency = 546.83
self.PianoSound(self.frequency)
def Esound(self):
self.frequency = 664.81
self.PianoSound(self.frequency)
def Fsound(self):
self.frequency = 694.61
self.PianoSound(self.frequency)
def Gsound(self):
self.frequency = 736
self.PianoSound(self.frequency)
def Asound(self):
self.frequency = 780
self.PianoSound(self.frequency)
def Bsound(self):
self.frequency = 846.93
self.PianoSound(self.frequency)
def C1sound(self):
self.frequency = 891.63
self.PianoSound(self.frequency)
def D1sound(self):
self.frequency = 953.66
self.PianoSound(self.frequency)
def E1sound(self):
self.frequency = 1000.63
self.PianoSound(self.frequency)
def F1sound(self):
self.frequency = 1049.23
self.PianoSound(self.frequency)
def G1sound(self):
self.frequency = 1100
self.PianoSound(self.frequency)
def A1sound(self):
self.frequency = 1160
self.PianoSound(self.frequency)
def B1sound(self):
self.frequency = 1233.88
self.PianoSound(self.frequency)
def PianoSound(self, frequency):
time = np.linspace(0, self.length, self.sampleRate * self.length)
Y = np.sin(2 * np.pi * self.frequency * time) * np.exp(
-0.0004 * 2 * np.pi * self.frequency * time)
Y += np.sin(2 * 2 * np.pi * self.frequency * time) * np.exp(
-0.0004 * 2 * np.pi * self.frequency * time) / 2
Y += np.sin(3 * 2 * np.pi * self.frequency * time) * np.exp(
-0.0004 * 2 * np.pi * self.frequency * time) / 4
Y += np.sin(4 * 2 * np.pi * self.frequency * time) * np.exp(
-0.0004 * 2 * np.pi * self.frequency * time) / 8
Y += np.sin(5 * 2 * np.pi * self.frequency * time) * np.exp(
-0.0004 * 2 * np.pi * self.frequency * time) / 16
Y += np.sin(6 * 2 * np.pi * self.frequency * time) * np.exp(
-0.0004 * 2 * np.pi * self.frequency * time) / 32
Y += Y * Y * Y
Y *= 1 + 16 * time * np.exp(-6 * time)
wavfile.write('Piano.wav', self.sampleRate, Y)
playsound('Piano.wav')
def Eguitar(self):
self.frequency = 329.63
self.GuitarSound(self.frequency)
def Bguitar(self):
self.frequency = 246.94
self.GuitarSound(self.frequency)
def Gguitar(self):
self.frequency = 196
self.GuitarSound(self.frequency)
def Dguitar(self):
self.frequency = 146.83
self.GuitarSound(self.frequency)
def Aguitar(self):
self.frequency = 110
self.GuitarSound(self.frequency)
def E2guitar(self):
self.frequency = 82.41
self.GuitarSound(self.frequency)
def GuitarSound(self, frequency):
samples = []
current_sample = 0
previous_value = 0
wavetable_size = self.sampleRate // int(self.frequency)
wavetable = (2 * np.random.randint(0, 2, wavetable_size) - 1).astype(
np.float)
n_samples = self.sampleRate * 2
while len(samples) < n_samples:
wavetable[current_sample] = 0.5 * (wavetable[current_sample] +
previous_value)
samples.append(wavetable[current_sample])
previous_value = samples[-1]
current_sample += 1
current_sample = current_sample % wavetable.size
data = np.array(samples)
wavfile.write('guitar.wav', self.sampleRate, data)
playsound('guitar.wav')
class mywindow(QtWidgets.QMainWindow):
def __init__(self):
super(mywindow, self).__init__()
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# connected run_alg to btn
self.ui.pushButton.clicked.connect(self.run_alg)
def run_alg(self):
#сохраняем все введенные данные
try:
global alphabet
alphabet = funcs.get_set_of_alphabet(
self.ui.alphabetText.toPlainText())
global input_word
input_word = self.ui.inputText.toPlainText()
global scheme
scheme = funcs.get_dict_scheme(self.ui.schemeText.toPlainText())
#проверяем соответствует ли схема и вход. слово алфавиту
if self.check_all_input_data():
self.clear_styles()
resText = ""
words = funcs.do_scheme(scheme, input_word)
for word in words:
resText += word + "\n"
self.ui.resultText.setText(resText)
except funcs.NoArrowException as exc:
self.ui.resultText.setText("У подстановки нет стрелки перехода!")
self.ui.schemeText.setStyleSheet(
"border: 2px solid red; color: red;")
except funcs.InvalidSubException as exc:
self.ui.resultText.setText("Подстановка имеет неверный формат!")
self.ui.schemeText.setStyleSheet(
"border: 2px solid red; color: red;")
def check_all_input_data(self) -> bool:
isInputWordCorrect = True
isSchemeCorrect = True
for ch in input_word:
if not (ch in alphabet):
self.ui.inputText.setStyleSheet(
"border: 2px solid red; color: red;")
self.ui.resultText.setText(
"Входное слово имеет неверный формат!")
isInputWordCorrect = False
for key, value in scheme.items():
for ch in key:
if not (ch in alphabet):
self.ui.schemeText.setStyleSheet(
"border: 2px solid red; color: red;")
self.ui.resultText.setText("Схема имеет неверный формат!")
isSchemeCorrect = False
for ch in value:
if not (ch in alphabet) and ch != '.':
self.ui.schemeText.setStyleSheet(
"border: 2px solid red; color: red;")
self.ui.resultText.setText("Схема имеет неверный формат!")
isSchemeCorrect = False
return isInputWordCorrect and isSchemeCorrect
def clear_styles(self):
self.ui.schemeText.setStyleSheet("")
self.ui.inputText.setStyleSheet("")
class Mywindow(QtWidgets.QMainWindow):
def __init__(self, parent=None):
super(Mywindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.ui.pushButton_Encrypt.clicked.connect(self.encryption)
self.ui.pushButton_Decrypt.clicked.connect(self.decryption)
self.ui.pushButton_SavetoFile.clicked.connect(self.writeFile)
self.ui.pushButton_ReadfromFile.clicked.connect(self.readFile)
self.ui.action_AboutDev.triggered.connect(self.openAboutDev)
self.ui.action_Help.triggered.connect(self.openHelp)
def openMenu(position):
menu = QMenu()
quitAction = menu.addAction("Quit")
action = menu.exec_(tableWidget.mapToGlobal(position))
if action == quitAction:
qApp.quit()
def encryption(self):
print("begin - encr")
text = str(self.ui.plainTextEdit_Encr.toPlainText())
print(text)
text = re.sub(r'\W+', '', text)
if (text.__len__() % 6 != 0):
trashVal = math.ceil(text.__len__() / 6) * 6 - text.__len__()
print(trashVal)
for x in range(trashVal):
text += random.choice(string.ascii_letters)
print(text)
encrypt = ""
for x in range(6):
encrypt += text[x::6]
print(encrypt)
self.ui.textBrowser_Encrypt.setText(encrypt)
def decryption(self):
print("begin - decr")
text = self.ui.plainTextEdit_Decr.toPlainText()
decrypt = ""
for x in range(math.ceil(text.__len__() / 6)):
decrypt += text[x::math.ceil(text.__len__() / 6)]
print(decrypt)
self.ui.textBrowser_Decrypt.setText(decrypt)
def openAboutDev(self):
self.application1 = AboutDevWindow()
self.application1.show()
def openHelp(self):
self.application1 = HelpWindow()
self.application1.show()
def writeFile(self):
with open("savedFile.txt", "w") as file:
file.write(self.ui.textBrowser_Decrypt.toPlainText())
def readFile(self):
with open("readFile.txt", "r") as file:
text = str(file.readlines())
text = re.sub(r'\W+', '', text)
print(text)
if (text.__len__() % 6 != 0):
trashVal = math.ceil(text.__len__() / 6) * 6 - text.__len__()
for x in range(trashVal):
text += random.choice(string.ascii_letters)
encrypt = ""
for x in range(6):
encrypt += text[x::6]
self.ui.textBrowser_Encrypt.setText(encrypt)
