class RecordWall(QWidget):
def __init__(self, parent=None, session=None, token=None):
QWidget.__init__(self, parent)
self.pixmap = QtGui.QPixmap()
self.sizeMonitor = QApplication.desktop().availableGeometry()
self.setGeometry(0, 0, (2 * self.sizeMonitor.width()) / 3,
self.sizeMonitor.height())
self.session = session
self.token = token
self.post_id = 0
self.ui()
self.delButton.clicked.connect(self.deletePost)
def ui(self):
self.nameLayout = QHBoxLayout()
self.icon = QLabel()
self.textName = QLabel()
self.postSource = QLabel()
self.delButton = QPushButton('Del')
self.nameLayout.addWidget(self.icon, 0, Qt.AlignLeft)
self.nameLayout.addWidget(self.textName, 1, Qt.AlignLeft)
self.nameLayout.addWidget(self.postSource, 2, Qt.AlignLeft)
self.nameLayout.addWidget(self.delButton, 3, Qt.AlignRight)
self.dateLayout = QHBoxLayout()
self.date = QLabel()
self.dateLayout.addWidget(self.date)
self.textLayout = QHBoxLayout()
self.text = QLabel()
self.textLayout.addWidget(self.text)
self.attachmentsLayout = QHBoxLayout()
self.repostLayout = QVBoxLayout()
self.line = QFrame()
self.line.setFrameShape(QFrame.HLine)
self.line.setFrameShadow(QFrame.Sunken)
self.infoWidget = QWidget()
self.infoLayout = QHBoxLayout()
self.like = QLabel()
self.pixmap.load(MyData.CWD + '/src/like.png')
myPixmap = self.pixmap.scaled(20, 20, Qt.KeepAspectRatio,
Qt.FastTransformation)
self.like.setPixmap(myPixmap)
self.countLike = QLabel()
self.repost = QLabel()
self.pixmap.load(MyData.CWD + '/src/repost.png')
myPixmap = self.pixmap.scaled(16, 16, Qt.KeepAspectRatio,
Qt.FastTransformation)
self.repost.setPixmap(myPixmap)
self.countRepost = QLabel()
self.views = QLabel()
self.pixmap.load(MyData.CWD + '/src/eye.png')
myPixmap = self.pixmap.scaled(20, 20, Qt.KeepAspectRatio,
Qt.FastTransformation)
self.views.setPixmap(myPixmap)
self.countViews = QLabel()
self.infoLayout.addWidget(self.like, alignment=Qt.AlignLeft)
self.infoLayout.addWidget(self.countLike, alignment=Qt.AlignRight)
self.infoLayout.addWidget(self.repost, alignment=Qt.AlignLeft)
self.infoLayout.addWidget(self.countRepost, alignment=Qt.AlignLeft)
self.infoLayout.addWidget(self.views, alignment=Qt.AlignRight)
self.infoLayout.addWidget(self.countViews, alignment=Qt.AlignRight)
self.infoWidget.setLayout(self.infoLayout)
self.infoWidget.setMaximumWidth(
self.infoLayout.totalSizeHint().width() + 50)
self.allQVBoxLayout = QVBoxLayout()
self.allQVBoxLayout.addLayout(self.nameLayout)
self.allQVBoxLayout.addLayout(self.dateLayout)
self.allQVBoxLayout.addLayout(self.textLayout)
self.allQVBoxLayout.addLayout(self.attachmentsLayout)
self.allQVBoxLayout.addLayout(self.repostLayout)
self.allQVBoxLayout.addWidget(self.line)
self.allQVBoxLayout.addWidget(self.infoWidget)
self.frame = QFrame()
self.frame.setFrameShape(QFrame.Panel)
self.frame.setFrameShadow(QFrame.Raised)
self.frame.setLayout(self.allQVBoxLayout)
self.mainLayout = QVBoxLayout()
self.mainLayout.addWidget(self.frame)
self.setLayout(self.mainLayout)
self.textName.setStyleSheet('''color: rgb(60, 50, 130);''')
self.postSource.setStyleSheet('''color: rgb(170, 170, 170);''')
self.date.setStyleSheet('''color: rgb(130, 130, 130);''')
self.frame.setStyleSheet('''background-color:rgb(255, 255, 255);''')
def setNameLayout(self, name, lastName, image):
self.textName.setText(name + ' ' + lastName)
if type(image) == str:
self.pixmap.load(image)
myPixmap = self.pixmap.scaled(32, 32, Qt.KeepAspectRatio,
Qt.FastTransformation)
self.icon.setPixmap(myPixmap)
elif type(image) == bytes:
self.pixmap.loadFromData(image)
myPixmap = self.pixmap.scaled(32, 32, Qt.KeepAspectRatio,
Qt.FastTransformation)
self.icon.setPixmap(myPixmap)
def setPostSource(self, postSource):
if postSource == 'profile_photo':
self.postSource.setText('Обновил фотографию на странице')
elif postSource == 'profile_activity':
self.postSource.setText('Изменен статус')
elif postSource == 'pinned':
self.postSource.setText('Запись закреплена')
def setDateLayout(self, date):
value = datetime.datetime.fromtimestamp(date)
if value.month == 1:
self.date.setText(value.strftime('%d янв %Y'))
if value.month == 2:
self.date.setText(value.strftime('%d фев %Y'))
if value.month == 3:
self.date.setText(value.strftime('%d март %Y'))
if value.month == 4:
self.date.setText(value.strftime('%d апр %Y'))
if value.month == 5:
self.date.setText(value.strftime('%d май %Y'))
if value.month == 6:
self.date.setText(value.strftime('%d июнь %Y'))
if value.month == 7:
self.date.setText(value.strftime('%d июль %Y'))
if value.month == 8:
self.date.setText(value.strftime('%d авг %Y'))
if value.month == 9:
self.date.setText(value.strftime('%d сен %Y'))
if value.month == 10:
self.date.setText(value.strftime('%d окт %Y'))
if value.month == 11:
self.date.setText(value.strftime('%d ноя %Y'))
if value.month == 12:
self.date.setText(value.strftime('%d дек %Y'))
def setText(self, text):
split = re.split('\n', text)
retext = ''
for mas in split:
sp = re.findall('.', mas)
if len(sp) > 30:
retext += ''.join(sp[0:len(sp) // 2])
retext += '\n'
retext += ''.join(sp[len(sp) // 2:len(sp)])
retext += ('\n')
else:
retext += mas + '\n'
self.text.setText(retext)
def setAttachments(self, imgata):
attachment = QLabel()
self.attachmentsLayout.addWidget(attachment, Qt.AlignLeft)
self.pixmap.loadFromData(imgata)
myPixmap = self.pixmap.scaled(300, 300, Qt.KeepAspectRatio,
Qt.FastTransformation)
attachment.setPixmap(myPixmap)
def setInfo(self, likes, reposts, views=None):
self.countLike.setText(str(likes))
self.countRepost.setText(str(reposts))
if views != None:
self.countViews.setText(str(views))
def deleteInformation(self):
self.line.deleteLater()
self.infoLayout.deleteLater()
self.like.deleteLater()
self.countLike.deleteLater()
self.repost.deleteLater()
self.countRepost.deleteLater()
self.views.deleteLater()
self.countViews.deleteLater()
def deletePost(self):
api = API(self.session, self.token)
response = api.wall.delete(post_id=self.post_id)
if response['response'] == 1:
self.deleteLater()
print('Response by delete post', response)
def mouseDoubleClickEvent(self, QMouseEvent):
api = API(self.session, self.token)
response = api.wall.delete(post_id=self.post_id)
if response['response'] == 1:
self.deleteLater()
print('Response by delete post', response)
class DropSiteWindow(QWidget):
def __init__(self, pageNumber, driver):
super().__init__()
"""
QUICK START IN OPTIONS
HANDLE EXCEPTIONS WERES ARE BLOCKED OR NETWORK DOESNT WORK ETC -> WHEN GOING BACK ONLINE LOAD IMAGE
REOPNING TAB DOESNT SAVE PAGE STATE
REOPNING TAB OPENS IN DIFFERENT BROWSER
BETTER WAY TO CHECK WHETHER ITS A STANDLONE EXEC OR LOCALLY RUN
HAVE A LOOK AT QSETTINGS TO REMEMBER WINDOW SIZES AND SESSION STATE ETC..
FUTURE FEATURES:
- MORE FREEDOM WITH REARRANGING TABS
- SUPPORT OTHER DATA TYPES E.G. PDF FILE ETC..
- FAVOURITE TABS -> MOVES THEM HIGHER
- ANIMATE CLOSE BUTTON FADE IN/OUT
- IMPLEMENT THEMES (ONLY DARK MODE RIGHT NOW)
"""
# SETUP THUMBNAIL FOLDER
if not (os.path.isdir(tabsettings.absImageFolderPath())):
os.mkdir(tabsettings.absImageFolderPath())
self.clearingTabs = False
self.acceptDrops = True
self.options = tabsettings.TabSettings()
self.pageNumber = pageNumber
self.pageName = 'Page ' + str(self.pageNumber)
self.driver = driver
self.setPageName()
# SETUP LAYOUTS
self.mainLayout = QVBoxLayout()
self.scroll = QScrollArea()
self.scrollWidget = QWidget()
self.scrollWidgetLayout = QVBoxLayout()
self.scroll.setWidgetResizable(True)
self.scroll.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.scroll.setFrameStyle(QFrame.NoFrame)
self.scrollWidgetLayout.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.scrollWidgetLayout.setContentsMargins(3, 3, 3, 3)
self.scrollWidgetLayout.setSpacing(3)
self.mainLayout.setContentsMargins(0, 0, 0, 0)
self.scrollWidget.setLayout(self.scrollWidgetLayout)
self.scroll.setWidget(self.scrollWidget)
self.mainLayout.addWidget(self.scroll)
self.setLayout(self.mainLayout)
# IF TAB FILE EXISTS REMAKE TABS
self.tabFilePath = os.path.join(os.getcwd(),
tabsettings.tabFileName(self))
self.tabFileName = tabsettings.tabFileName(self)
self.archiveTabFileName = tabsettings.archiveTabFileName(self)
exists = os.path.isfile(self.tabFilePath)
size = 0
if exists: size = os.path.getsize(self.tabFilePath)
if size > 0 and exists:
self.loadTabs(self.tabFilePath)
else:
self.newTab()
self.updatePageNames()
self.checkArchiveTabFileSize()
# LOAD TABS FROM CURRENT PAGE TAB FILE -> CREATE NEW TAB -> LOAD TAB WITH CONTENT OF TAB FILE ENTRY
def loadTabs(self, path):
with open(path, 'r') as f:
data = f.readlines()
for index, line in enumerate(data):
l = line.split('\n')[0]
currentItems = l.split(' ')
url = currentItems[0]
imagePath = currentItems[1]
tabNumber = currentItems[2]
tab = self.newTab()
self.loadTabData(tab, url, imagePath)
# IF ITS LAST TAB ADD EMPTY TAB AFTER
if index == len(data) - 1:
self.newTab()
# CREATE NEW TAB -> IF TABCOUNT > ALLOWED -> CREATE NEW ROW THEN ADD TAB
def newTab(self):
if (self.options.tabCount % self.options.tabsPerRow) == 0:
self.currentRow = QHBoxLayout()
self.currentRow.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.currentRow.setSpacing(3)
self.currentRow.setSizeConstraint(QLayout.SetMinimumSize)
self.scrollWidgetLayout.insertLayout(
self.scrollWidgetLayout.layout().count(), self.currentRow)
self.options.tabRows.append(self.currentRow)
self.options.tabCount += 1
drp = DropArea(self.options, self.options.tabCount, self.driver,
tabsettings.MIN_TAB_WIDTH, tabsettings.MIN_TAB_HEIGHT,
tabsettings.ASPECT_RATIO,
tabsettings.absImageFolderPath(), self.tabFileName,
self.archiveTabFileName)
drp.imageLoaded.connect(self.newTab)
drp.tabDeleted.connect(lambda: self.deleteTab(drp))
drp.tabAdded.connect(self.addTabToList)
drp.tabReordered.connect(self.reorderTab)
drp.destroyed.connect(self.reorganizeTabFile)
self.options.emptyTab = drp
self.currentRow.addWidget(drp)
return drp
# SHORTCUT METHOD TO LOAD TAB
def loadTabData(self, tab, url, imagePath):
tab.load(url, imagePath)
# DELETE TAB -> SET PARENT NONE -> REMOVE FROM TAB LIST -> DELETE ENTRY IN TAB FILE -> ARCHIVE IF NOT DUPLICATE
def deleteTab(self, tab):
if tab.taken:
self.options.tabCount -= 1
self.options.loadedTabCount -= 1
self.options.tabList.remove(tab)
tab.setParent(None)
tab.deleteLater()
# REMOVE ENTRY FROM SAVED TABS FILE
fileData = open(self.tabFileName, 'r').readlines()
with open(self.tabFileName, 'w') as out:
# FILE LAYOUT EACH LINE -> (URL IMAGE_PATH TAB_NUMBER)
for line in fileData:
currentItems = line.split(' ')
tabNum = int(currentItems[2])
# IF CURRENT LINE IS NOT TAB TO BE DELETED WRITE LINE
if not (tabNum == tab.tabNumber): out.write(line)
# CHECK IF THERE IS DUPLICATE TAB IF SO DON'T ARCHIVE
dontArchiveImage = tab.checkDuplicateTab(tab.url, self.tabFileName)
if not dontArchiveImage: self.archiveTab(tab.url, tab.imagePath)
# ARCHIVE TAB IN ARCHIVE TAB FILE NAME OF CURRENT PAGE -> RENAME IMAGE TO .IMAGE IF ITS AVAILABLE
def archiveTab(self, url, imagePath):
try:
os.rename(
os.path.normpath(
os.path.join(tabsettings.IMAGE_FOLDER_PATH, imagePath)),
os.path.normpath(
os.path.join(tabsettings.IMAGE_FOLDER_PATH,
'.' + imagePath)))
except FileNotFoundError:
pass
with open(self.archiveTabFileName, 'a+') as f:
f.seek(0)
lines = f.readlines()
duplicate = False
for line in lines:
if line.split(' ')[0] == url:
duplicate = True
if not duplicate: f.write(url + ' ' + '.' + imagePath + '\n')
# ADD TAB TO TABLIST -> IF NUMBER GREATER THEN LIST SIZE -> APPEND -> ELSE REPLACE TAB IN LIST
def addTabToList(self, tab, tabNum):
if len(self.options.tabList) <= tabNum:
self.options.tabList.append(tab)
else:
self.options.tabList[tabNum] = tab
# REORDER TAB IN TABLIST AND MOVE WIDGET -> REORGANIZE TAB FILE TO SHOW CHANGES MADE
def reorderTab(self, tab, swapValue):
# GET INDEX OF TAB IN TAB LIST
index = self.options.tabList.index(tab)
# SWAP VALUE = SHIFT IN TABS E.G. -1 FOR ONE LEFT
newIndex = index + swapValue
self.options.tabList.remove(tab)
self.options.tabList.insert(newIndex, tab)
self.reorganizeTabFile()
# REORGANIZE TAB FILE -> FROM DELETED TAB (TAB NUMBERS WRONG) -> OR FROM REORGANIZING TAB
def reorganizeTabFile(self):
if os.path.isfile(
self.tabFilePath) and os.path.getsize(self.tabFilePath) > 0:
if not self.clearingTabs:
for index, tab in enumerate(self.options.tabList):
tab.tabNumber = index + 1
self.options.emptyTab.tabNumber = len(self.options.tabList) + 1
# REORDER TABS IN THE SAVED TABS FILE SO THEY HAVE CORRECT TAB NUMBER
with open(self.tabFileName, 'r+') as f:
lines = f.readlines()
currentTab = 1
finalStringData = ''
for line in lines:
currentItems = line.split('\n')[0].split(' ')
# REORGANIZING AFTER DELETING A TAB
if (currentTab != int(currentItems[2])):
finalStringData += currentItems[
0] + ' ' + self.options.tabList[
currentTab -
1].imagePath + ' ' + str(currentTab) + '\n'
# REORGANIZING AFTER REORDERING A TAB
elif (currentItems[0] !=
self.options.tabList[currentTab - 1].url):
current = self.options.tabList[currentTab - 1]
finalStringData += current.url + ' ' + current.imagePath + ' ' + str(
current.tabNumber) + '\n'
else:
finalStringData += line
currentTab += 1
# SEEK BEGINNING -> CLEAR FILE -> WRITE DATA (TRUNCATE SETS FILE SIZE TO MAX (0))
f.seek(0)
f.truncate(0)
f.write(finalStringData)
self.checkLayouts()
# CHECK IF ANY LAYOUTS HAVE < 3 CHILDREN APART FROM LAST -> MOVE WIDGETS TO PREVIOUS LAYOUT/ROW ::: IF CURRENT ROW EMPTY -> SET TO PREVIOUS ROW
def checkLayouts(self):
# IF ANY LAYOUTS HAVE < 3 CHILDREN REORGANIZE THE WIDGETS
complete = False
while not complete:
for i in range(0, len(self.options.tabRows) - 1):
if self.options.tabRows[i].count() < 3:
child = self.options.tabRows[i + 1].itemAt(0)
self.options.tabRows[i + 1].removeItem(child)
self.options.tabRows[i].addItem(child)
complete = True
# IF CURRENT ROW HAS NO CHILDREN REMOVE IT AND SET IT TO PREVIOUS ROW
if self.currentRow.count() == 0:
self.options.tabRows.remove(self.currentRow)
self.currentRow.deleteLater()
self.currentRow = self.options.tabRows[len(self.options.tabRows) -
1]
# CLEAR ALL TABS IN CURRENT PAGE -> EMPTY TABLIST AND TABROWS -> ARCHIVE ALL DELETED TABS
def clear(self):
self.clearingTabs = True
# REMOVE ENTRY FROM SAVED TABS FILE
fileData = []
with open(self.tabFileName, 'r') as inp:
fileData += inp.readlines()
for line in fileData:
currentItems = line.split(' ')
self.archiveTab(currentItems[0], currentItems[1])
for i in range(len(self.options.tabList) - 1, -1, -1):
self.options.tabList[i].setParent(None)
self.options.tabList[i].deleteLater()
self.options.tabList.remove(self.options.tabList[i])
os.remove(self.tabFilePath)
self.options.tabCount = 0
# REMOVE ALL ROWS FROM LIST EXCEPT FIRST AND CLEAR TABS
for x in range(len(self.options.tabRows) - 1, -1, -1):
if self.options.tabRows[x].count() > 0:
self.options.tabRows[x].itemAt(0).widget().deleteLater()
if x == 0: self.options.tabRows[x].destroyed.connect(self.newTab)
self.options.tabRows[x].deleteLater()
self.options.tabRows.remove(self.options.tabRows[x])
self.clearingTabs = False
# CLEARS ALL TABS BUT DOES NOT REMOVE THEM OR ARCHIVE THEM AND RESETS VARIABLES
def cleanClear(self):
for i in reversed(range(len(self.options.tabRows))):
for j in reversed(range(self.options.tabRows[i].count())):
self.options.tabRows[i].itemAt(j).widget().setParent(None)
self.options.tabRows.clear()
self.options.tabList.clear()
self.options.emptyTab = None
self.options.tabCount = 0
self.options.loadedTabCount = 0
# RUN AFTER CLEAN CLEAR JUST RELOADS ALL TABS INTO WINDOW
def cleanLoad(self):
with open(self.tabFileName, 'r') as f:
for line in f:
current = line.split('\n')[0].split(' ')
url = current[0]
imagePath = current[1]
tabNumber = current[2]
drp = self.newTab()
drp.load(url, imagePath)
self.newTab()
# CHANGE TABS PER ROW IN CURRENT PAGE OPTIONS -> CHANGE MIN WIDTH/HEIGHT -> RELOAD ALL TABS
def changeTabsPerRow(self, number):
self.clearingTabs = True
tabsettings.MIN_TAB_WIDTH *= (self.options.tabsPerRow / number)
tabsettings.MIN_TAB_HEIGHT *= (self.options.tabsPerRow / number)
self.options.tabsPerRow = number
self.cleanClear()
self.cleanLoad()
self.clearingTabs = False
# SET PAGE NAME FROM ENTRY IN PAGENAMES.TXT BY PAGENUMBER
def setPageName(self):
if os.path.exists(os.path.join(os.getcwd(), 'pagenames.txt')):
with open('pagenames.txt', 'r+') as f:
for index, line in enumerate(f.readlines()):
if index + 1 == self.pageNumber:
self.pageName = line.split('\n')[0]
# UPDATE PAGENAMES.TXT -> IF DOESN'T EXIST -> WRITE PAGENAME -> ELSE REWRITE ENTRY TO PAGENAME -> OR IF NEW PAGE WRITE NEW LINE
def updatePageNames(self):
if not os.path.exists(os.path.join(os.getcwd(), 'pagenames.txt')):
with open('pagenames.txt', 'a+') as f:
f.write(self.pageName + '\n')
else:
data = open('pagenames.txt', 'r').readlines()
# IF NUMBER OF LINES >= NUMBER THEN NAME WILL BE IN FILE
if len(data) >= self.pageNumber:
with open('pagenames.txt', 'w') as f:
for index, line in enumerate(data):
if index + 1 == self.pageNumber:
f.write(self.pageName + '\n')
else:
f.write(line)
# NAME IS NOT IN FILE SO MUST APPEND IT TO FILE
else:
with open('pagenames.txt', 'a') as f:
f.write(self.pageName + '\n')
# SET PAGENAME AND UPDATE PAGENAMES.TXT WITH NEW NAME
def rename(self, string):
self.pageName = string
self.updatePageNames()
# CHECK IF ARCHIVE TAB FILE SIZE IS GREATER THEN VALUE -> REWRITE OUT FIRST LINES UNTIL ITS DESIRED SIZE
def checkArchiveTabFileSize(self):
if os.path.isfile(os.path.join(os.getcwd(), self.archiveTabFileName)):
data = open(self.archiveTabFileName, 'r').readlines()
if len(data) > tabsettings.ARCHIVE_TAB_FILE_MAX_SIZE:
with open(self.archiveTabFileName, 'w') as f:
for index, line in enumerate(data):
if index != 0 and index <= tabsettings.ARCHIVE_TAB_FILE_MAX_SIZE:
f.write(line)
def close(self):
self.driver.close()
self.driver.quit()
print('Exited')
sys.exit(0)
class MacroLine(QObject):
changed = pyqtSignal()
types = ["Text", "Down", "Up", "Tap"]
type_to_cls = [ActionTextUI, ActionDownUI, ActionUpUI, ActionTapUI]
def __init__(self, parent, action):
super().__init__()
self.parent = parent
self.container = parent.container
if self.parent.parent.keyboard.vial_protocol >= 2:
self.types = self.types[:] + ["Delay (ms)"]
self.type_to_cls = self.type_to_cls[:] + [ActionDelayUI]
self.arrows = QHBoxLayout()
self.btn_up = QToolButton()
self.btn_up.setText("▲")
self.btn_up.setToolButtonStyle(Qt.ToolButtonTextOnly)
self.btn_up.clicked.connect(self.on_move_up)
self.btn_down = QToolButton()
self.btn_down.setText("▼")
self.btn_down.clicked.connect(self.on_move_down)
self.btn_down.setToolButtonStyle(Qt.ToolButtonTextOnly)
self.arrows.addWidget(self.btn_up)
self.arrows.addWidget(self.btn_down)
self.arrows.setSpacing(0)
self.select_type = QComboBox()
self.select_type.addItems(self.types)
self.select_type.setCurrentIndex(self.type_to_cls.index(type(action)))
self.select_type.currentIndexChanged.connect(self.on_change_type)
self.action = action
self.action.changed.connect(self.on_change)
self.row = -1
self.btn_remove = QToolButton()
self.btn_remove.setText("×")
self.btn_remove.setToolButtonStyle(Qt.ToolButtonTextOnly)
self.btn_remove.clicked.connect(self.on_remove_clicked)
def insert(self, row):
self.row = row
self.container.addLayout(self.arrows, row, 0)
self.container.addWidget(self.select_type, row, 1)
self.container.addWidget(self.btn_remove, row, 3)
self.action.insert(row)
def remove(self):
self.container.removeItem(self.arrows)
self.container.removeWidget(self.select_type)
self.container.removeWidget(self.btn_remove)
self.action.remove()
def delete(self):
self.action.delete()
self.btn_remove.deleteLater()
self.select_type.deleteLater()
self.arrows.deleteLater()
self.btn_up.deleteLater()
self.btn_down.deleteLater()
def on_change_type(self):
self.action.remove()
self.action.delete()
self.action = self.type_to_cls[self.select_type.currentIndex()](
self.container)
self.action.changed.connect(self.on_change)
self.action.insert(self.row)
self.changed.emit()
def on_remove_clicked(self):
self.parent.on_remove(self)
def on_move_up(self):
self.parent.on_move(self, -1)
def on_move_down(self):
self.parent.on_move(self, 1)
def on_change(self):
self.changed.emit()
class Sensor:
def __init__(self, db_bridge, app):
self.db_bridge = db_bridge
self.app = app
self.layout = None
self.label = None
self.checkbox = None
self.checkbox_callback = None
self.img_processor = ImageProcessor()
self.start_time = None
self.stop_time = None
self.meas_list = None
def set_sensor_values(self,
sensor_type,
sensor_id=None,
file_name=None,
data=None):
self.sensor_type = sensor_type
self.meas_list = data
self.file_name = file_name
self.sensor_id = sensor_id
def checkbox_activate(self):
self.checkbox_callback(self)
def create_ui(self, callback):
self.layout = QHBoxLayout()
self.label = QLabel(
f'{self.sensor_type}: {self.sensor_id if self.sensor_id is not None else self.file_name}'
)
self.checkbox = QCheckBox()
self.layout.addWidget(self.label)
self.layout.addWidget(self.checkbox)
self.checkbox_callback = callback
self.checkbox.stateChanged.connect(self.checkbox_activate)
return self.layout
def delete_ui(self):
self.layout.deleteLater()
self.label.deleteLater()
self.checkbox.deleteLater()
def data_loaded(self):
return self.meas_list is not None
def reload(self):
if self.meas_list is not None:
self.load_data()
def is_active(self):
return self.checkbox.isChecked()
def get_data(self):
if self.meas_list is None:
print("WARNING attempting to load data that is not loaded")
return self.meas_list
def load_data(self):
"""
This function takes a source and then looks at its type to find the function to get that data
:param source: A dict containing all the information to load the data
:return: list of measurements
"""
if self.sensor_type == 'csv':
self.meas_list = load_csv(self.file_name)
elif self.sensor_type == 'sensor':
self.meas_list = self.load_sensor()
else:
raise Exception('Source type was not recognized')
self.start_time = self.meas_list[0].timestamp
self.stop_time = self.meas_list[-1].timestamp
for index, meas in enumerate(self.meas_list):
meas.set_or_index(index)
meas.set_sensor(self)
meas.convert_to_numpy()
def load_sensor(self):
"""
Uses a database query to get measurements from the sensor with id == sensor_id
Explanation for converting to different class is written in the data_model_helper.py
:param sensor_id:
:return:
"""
param = self.app.get_query_param()
db_values = self.db_bridge.get_values(self.sensor_id, param)
sens_values = [Measurement(meas) for meas in db_values]
return sens_values
def get_default_vis(self, index):
thermal_data = self.meas_list[index].data
self.img_processor.set_thermal_data(thermal_data)
imgs_batch_1 = self.img_processor.get_imgs()
print(
f'diff in thermal_data: {np.max(thermal_data) - np.min(thermal_data)}'
)
return imgs_batch_1
def get_multi_processing(self, index):
hist_amount = self.img_processor.get_hist_length()
start_index = max(0, index - hist_amount)
prev_frames = [meas.data for meas in self.meas_list[start_index:index]]
cur_frame = self.meas_list[index].data
self.img_processor.set_current_frame(cur_frame)
self.img_processor.set_history(prev_frames)
return self.img_processor.subtract_history()
def get_closest_meas(self, time):
cur_time = timedelta(seconds=time)
min_diff = float('inf')
min_index = 0
for meas, index in enumerate(self.meas_list):
if abs_diff(meas.timestamp, cur_time) < min_diff:
min_diff = abs_diff(meas.timestamp, cur_time)
min_index = index
return min_index
