-
Destiny Kuehn authored
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
mseedpeek.py 57.39 KiB
"""
!/usr/bin/env python
# gui for viewing mseed headers
# author: bcb
#
##########################
# 2004.141
# Modification
# Author: bcb
# beautified help page
#
# NOTE: next change to have drop down for blockette notebook
# and actually describe each field for given blockette
##########################
# 2004.301
# Modification
# Author: bcb
#
# utilize LibTrace calcrate function rather than local
##########################
# 2005.027
# Modification
# Author: bcb
#
# added try/except for directory & file open in self.FindTrace to
# reflect changes in LibTrace.py
# incorporated mseedInfo.py - file containing mseed header information
# added dropdown menus for blockettes and labeled display
# added Blockette Information window
# re-disorganized routines and added a few additional code comments
# optimized FindTrace
##########################
# 2005.040
# Modification
# Author: bcb
#
# added infobox indicating endianess
# correctly handles mseed files that are corrupt
##########################
# 2005.132
# Modification
# Author: bcb
#
# removed routine GetBlockette and replaced with 2 lines of code
##########################
# 2005.143
# Modification
# Author: bcb
#
# added main window button "Flush Dictionaries". Allows user view changes to
# mseed
# files without rebuilding db
##########################
# 2005.281
# Modification
# Author: bcb
#
# added a station selection box to window on station name
# added a -f option to allow user to give filenames on commandline
# using getopt for cmdline parsing
##########################
# 2005.307
# Modification
# Author: bcb
#
# added feature if only one trace on commandline input then fill fields on
# startup
##########################
# 2005.335
# bug fix
# Author: bcb
#
# blockettes 100, 201 and 400 were not being handled correctly in ReadHdrs
##########################
# 2007.040
# modification
# Author: bcb
#
# added capability to select viewed sta:chan:loc:net:samp in Unique view
#
# new methods: buildUniqueSelectBox, SelectKeys
################################################################
#
# modification
# version: 2008.180
# author: Bruce Beaudoin
#
# modified to take advantage of LibTrace optimization
################################################################
#
# modification
# version: 2018.129
# author: Derick Hess
#
# Python 3 compatibility
# setup.py
################################################################
#
# modification
# version: 2020.204
# author: Maeva Pourpoint
#
# Updates to work under Python 3.
# Unit tests to ensure basic functionality.
# Code cleanup to conform to the PEP8 style guide.
# Directory cleanup (remove unused files introduced by Cookiecutter).
# Packaged with conda.
################################################################
#
# modification
# version: 2022.1.0.0
# author: Maeva Pourpoint
#
# Update versioning scheme
################################################################
#
# modification
# version: 2023.1.0.0
# author: Destiny Kuehn
#
# GUI updated to PySide2
# Pmw dependency dropped
# Version number updated
"""
import sys
import os
import itertools
from getopt import getopt
from glob import glob
from operator import mod
from PySide2 import QtCore, QtGui, QtWidgets
from mseedpeek.libtrace import *
from mseedpeek.mseedInfo import *
VERSION = "2023.1.0.0"
SPACE = " "
def main():
"""
Main class for mseedpeek
"""
# return version number if -# command line option
file_list = []
try:
opts, pargs = getopt(sys.argv[1:], 'f#')
for flag, arg in opts:
if flag == "-f":
InFiles = pargs
for fl in InFiles:
for f in glob(fl):
file_list.append(f)
if flag == "-#":
print(VERSION)
sys.exit(0)
except Exception:
print("\nInvalid command line usage\n")
print("Usage:\nmseedpeek\nmseedpeek -#\nmseedpeek -f file(s)\n")
sys.exit(1)
print("\n", os.path.basename(sys.argv[0]), VERSION)
app = QtWidgets.QApplication(sys.argv)
# mc = main class
if file_list:
mc = MainWindow("mseedpeek %s" % VERSION, file_list)
else:
mc = MainWindow("mseedpeek %s" % VERSION, file_list=None)
mc.show()
sys.exit(app.exec_())
class MainWindow(QtWidgets.QWidget):
"""
Main class for mseedpeek
"""
def __init__(self, title, file_list):
"""
Init everything for startup
"""
super().__init__()
# window settings
self.resize(self.minimumSize())
self.setWindowTitle(title)
# init vars
self.data_init()
# set up main window
self.create_main_window()
self.build_blockettes()
self.build_help()
self.hide_show("hide")
# if files entered on commandline call build trace
if file_list:
self.dd_text.setText(':'.join(str(file) for file in file_list))
self.build_trace_list(self.dd_text.text())
def data_init(self):
"""
Init starting vars
"""
self.verb_var = 0
self.blk_size = 0
self.num_blocks = 0
self.dir_list = []
self.stat_sel_list = []
self.old_mseed_file = ""
self.standard_vars = [
"Station Name:",
"Location Code:",
"Channel:",
"Net Code:",
"Sps (nominal):",
]
self.v_vars = [
"Year:",
"Day:",
"Hour:",
"Min:",
"Sec:",
"0.0001s:"
]
self.first_vv_vars = [
"Sequence Number:",
"Data Hdr/Qaul:",
"Reserved:"
]
self.vv_vars = [
"Number Samples:",
"Sample Factor:",
"Sample Multiplier:",
"Activity Flags:",
"I/O & Clk Flags:",
"Data Qaul Flags:",
"Number Blockettes:",
"Time Corr:",
"Offet Data:",
"Offset Blockette:"
]
def create_main_window(self):
"""
Build tabs and info bar for root window
"""
# tab widget
self.tabwidget = QtWidgets.QTabWidget()
self.trace_headers_tab = QtWidgets.QWidget()
self.blockettes_tab = QtWidgets.QWidget()
self.help_tab = QtWidgets.QWidget()
self.tabwidget.addTab(self.trace_headers_tab, "Trace Headers")
self.tabwidget.addTab(self.blockettes_tab, "Blockettes")
self.tabwidget.addTab(self.help_tab, "Help")
# info bar widget
self.infobar = QtWidgets.QLineEdit()
self.infobar.setStyleSheet("background-color:yellow")
self.infobar.setReadOnly(True)
self.infobar.setAlignment(QtGui.Qt.AlignCenter)
# main window layout
self.window_layout = QtWidgets.QVBoxLayout()
self.setLayout(self.window_layout)
# add tab widget and info bar to main window layout
self.window_layout.addWidget(self.tabwidget)
self.build_trace_headers() # build widgets for Trace Headers tab
self.window_layout.addWidget(self.infobar)
self.window_layout.setMargin(0) # set spacing
def build_help(self):
"""
Build Help tab
"""
# init tab layout
layout = QtWidgets.QVBoxLayout(self.help_tab)
# Help textbox
Blue = QtGui.QColor(0, 0, 153)
Green = QtGui.QColor(0, 100, 0)
Red = QtGui.QColor(136, 8, 8)
Black = QtGui.QColor(0, 0, 0)
help_text = QtWidgets.QTextEdit()
layout.addWidget(help_text)
help_text.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
help_text.setAcceptRichText(False)
# Name
help_text.setTextColor(Blue)
text = "NAME"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = "\n" + SPACE + "mseedpeek - \
GUI for displaying mseed file headers.\n\n"
help_text.insertPlainText(text)
# Version
help_text.setTextColor(Blue)
text = "VERSION"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = "\n" + SPACE + str(VERSION) + "\n\n"
help_text.insertPlainText(text)
# Synopsis
help_text.setTextColor(Blue)
text = "SYNOPSIS"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = "\n" + SPACE + "mseedpeek\n" + SPACE + "\
mseedpeek -#\n" + SPACE + "mseedpeek -f file_names\n\n"
help_text.insertPlainText(text)
# Options
help_text.setTextColor(Blue)
text = "OPTIONS"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = "\n" + SPACE + "-# returns version number\n" + \
SPACE + "-f file_name(s) - accepts command line \
input for files to inspect (wildcards accepted)\n\n"
help_text.insertPlainText(text)
# Description
help_text.setTextColor(Blue)
text = "DESCRIPTION"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = "\n" + SPACE + "mseedpeek has three notebooks: "
help_text.insertPlainText(text)
help_text.setTextColor(Green)
text = "[Trace Headers][Blockettes]"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ", and "
help_text.insertPlainText(text)
help_text.setTextColor(Green)
text = "[Help]"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ". The "
help_text.insertPlainText(text)
help_text.setTextColor(Green)
text = "[Trace Headers]\n"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = SPACE + "notebook displays various the fixed \
header in four levels of verbosity. The "
help_text.insertPlainText(text)
help_text.setTextColor(Green)
text = "[Blockettes]\n"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = SPACE + "notebook displays blockette information.\n\n"
help_text.insertPlainText(text)
help_text.setTextColor(Green)
text = SPACE + "[Trace Headers]\n"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = SPACE + "General:\n" + SPACE + " \
>> specify/load directories for building trace db\n" + SPACE + "\
>> select trace for header display\n" + SPACE + "\
>> select level of verbosity for \
display\n\n" + SPACE + "\
Buttons:\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + " <Build Trace db>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": Searchs the directories listed in the \"Data-Directories\" \
entry box \n" + SPACE + " (a colon separated list) and builds a \
list of mseed files found indexing them on unique values of\n\
" + SPACE + " <dir>:<file_name>. It then creates a \
dropdown menu with entries for each data \
directory\n" + SPACE + " found.\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + " <Find>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": Launches a file browser allowing the user to add directories to \
the \"Data Directories\" entry\n" + SPACE + " box. \
Double clicking selects the new directory.\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + " <Clear>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": Clears the \"Data Directories\" entry box.\n\n"
help_text.insertPlainText(text)
text = SPACE + " By selecting a data directory a dropdown \
menu is created for trace selection. Selecting a trace from\n" \
+ SPACE + " this menu will create a header display.\n\n"
help_text.insertPlainText(text)
text = SPACE + "Radio Buttons:\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + " <Standard>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": This is the default. It displays Station, Channel, \
Location Code, Net Code, and the\n" + SPACE + "\
nominal Sample Rate.\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + " <Verbose>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": Standard display plus time of block.\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + " <Very Verbose>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": Verbose plus the rest of the mseed fixed header fields.\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + " <Unique>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": This displays changes in the Standard fields within a mseed\
file.\n\n"
help_text.insertPlainText(text)
text = SPACE + "Slider Scale and "
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = "<Jump To Block #> "
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = "Button:\n" + SPACE + " At the bottom of the page \
is a scale bar showing block numbers. Sliding the bar \
scans through all\n\
" + SPACE + " fixed headers for the selected \
mseed file.\n\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + "<Flush Directories>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": Clears cached trace header data. As you view \
mseed headers, mseedpeek\n\
" + SPACE + " maintains a cache of previously \
viewed headers for quick, future access. If \
you wish to monitor\n\
" + SPACE + " changes to mseed files you \
need to flush the dictionaries so that the \
new changes will be displayed.\n\n"
help_text.insertPlainText(text)
help_text.setTextColor(Green)
text = SPACE + "[Blockettes]"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ":\n"
help_text.insertPlainText(text)
text = SPACE + " The 'Blockettes' notebook displays all blockettes \
found for the select mseed file in a dropdown menu.\n\
" + SPACE + " By selecting a blockette from the \
dropdown menu, the contents \
of the blockette will be\n" + SPACE + " displayed.\n"
help_text.insertPlainText(text)
help_text.setTextColor(Red)
text = SPACE + " <Blockette Info>"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = ": Displays a pop-up window with a definition of the \
SEED Blockette.\n\n"
help_text.insertPlainText(text)
text = SPACE + " At the bottom of the page is a scale bar showing \
block numbers and sliding the bar scans through all\n\
" + SPACE + " blockettes for the selected mseed file.\n\n"
help_text.insertPlainText(text)
help_text.setTextColor(Blue)
text = "KEYWORDS\n"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = SPACE + "mseed; header information\n\n"
help_text.insertPlainText(text)
help_text.setTextColor(Blue)
text = "SEE ALSO\n"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = SPACE + "SEED manual (pdf), fixhdr, mseedhdr\n\n"
help_text.insertPlainText(text)
help_text.setTextColor(Blue)
text = "AUTHOR\n"
help_text.insertPlainText(text)
help_text.setTextColor(Black)
text = SPACE + "Bruce Beaudoin <bruce@passcal.nmt.edu>"
help_text.insertPlainText(text)
def build_blockettes(self):
"""
Create initial widgets for Blockettes tab
"""
# data boxes
self.blktype_box = QtWidgets.QGroupBox()
self.blktype_box.setObjectName("Box1")
self.blkinfo_box = QtWidgets.QGroupBox()
self.blkinfo_box.setLayout(QtWidgets.QHBoxLayout())
self.blkinfo_box.setObjectName("Box2")
self.blk_vars_box = QtWidgets.QGroupBox()
self.blk_vars_box.setLayout(QtWidgets.QVBoxLayout())
self.blk_vars_box.setObjectName("Box3")
# widgets
blk_label = QtWidgets.QLabel("Blockette:")
blk_menu = QtWidgets.QComboBox()
blk_menu.setObjectName("type_menu")
self.blkinfo_btn = QtWidgets.QPushButton("Blockette Info")
self.blkinfo_btn.setStyleSheet("QPushButton{background-color:lightblue;}\
QPushButton::hover{background-color:green;}")
self.blkinfo_btn.clicked.connect(self.blkinfo_window)
# box layouts
l1 = QtWidgets.QHBoxLayout(self.blktype_box)
l1.addWidget(blk_label)
l1.addWidget(blk_menu)
l1.addStretch()
# add to tab's main layout
main_layout = QtWidgets.QVBoxLayout()
main_layout.addWidget(self.blktype_box)
main_layout.addWidget(self.blkinfo_box)
main_layout.addWidget(self.blk_vars_box)
main_layout.addStretch()
self.blockettes_tab.setLayout(main_layout)
def build_trace_headers(self):
"""
Build widgets for Trace Headers tab
"""
# tab layout
self.trace_headers_layout = QtWidgets.QVBoxLayout(
self.trace_headers_tab)
# groupboxes for data fields
self.datadir_box = QtWidgets.QGroupBox()
self.datadir_box.setCheckable(False)
sp = self.datadir_box.sizePolicy()
sp.setVerticalPolicy(QtWidgets.QSizePolicy.Fixed)
self.datadir_box.setSizePolicy(sp)
self.stations_box = QtWidgets.QGroupBox()
self.stations_box.setCheckable(False)
sp = self.stations_box.sizePolicy()
sp.setVerticalPolicy(QtWidgets.QSizePolicy.Fixed)
self.stations_box.setSizePolicy(sp)
self.radio_box = QtWidgets.QGroupBox()
self.radio_box.setCheckable(False)
sp = self.radio_box.sizePolicy()
sp.setVerticalPolicy(QtWidgets.QSizePolicy.Fixed)
self.radio_box.setSizePolicy(sp)
self.dir_trace_box = QtWidgets.QGroupBox()
self.dir_trace_box.setCheckable(False)
sp = self.dir_trace_box.sizePolicy()
sp.setVerticalPolicy(QtWidgets.QSizePolicy.Fixed)
self.dir_trace_box.setSizePolicy(sp)
self.flush_exit_box = QtWidgets.QGroupBox()
self.flush_exit_box.setCheckable(False)
sp = self.flush_exit_box.sizePolicy()
sp.setVerticalPolicy(QtWidgets.QSizePolicy.Fixed)
self.flush_exit_box.setSizePolicy(sp)
self.window_layout.addWidget(self.flush_exit_box)
# layouts for groupboxes
datadir_layout = QtWidgets.QHBoxLayout(self.datadir_box)
stations_layout = QtWidgets.QHBoxLayout(self.stations_box)
rbuttons_layout = QtWidgets.QHBoxLayout(self.radio_box)
flush_exit_layout = QtWidgets.QHBoxLayout(self.flush_exit_box)
flush_exit_layout.setMargin(0)
flush_exit_layout.setSpacing(450)
dir_trace_layout = QtWidgets.QFormLayout(self.dir_trace_box)
# fill flush / exit groubpx
self.exit_btn = QtWidgets.QPushButton("Exit")
self.exit_btn.setStyleSheet(
"QPushButton::hover{background-color:darkred;}")
self.exit_btn.clicked.connect(lambda: quit())
self.flush_btn = QtWidgets.QPushButton("Flush Directories")
self.flush_btn.clicked.connect(self.flush_dict)
self.flush_btn.setStyleSheet(
"QPushButton::hover{background-color:orange;}")
flush_exit_layout.addWidget(self.flush_btn)
flush_exit_layout.addWidget(self.exit_btn)
# fill data dir groupbox
self.dd_label = QtWidgets.QLabel("Data Directories:")
self.dd_text = QtWidgets.QLineEdit()
self.build_trace_btn = QtWidgets.QPushButton("Build Trace db")
self.build_trace_btn.setStyleSheet("QPushButton{background-color:lightblue;} \
QPushButton::hover\
{background-color:green;}")
self.build_trace_btn.clicked.connect(self.clicked_build_trace)
self.find_btn = QtWidgets.QPushButton("Find")
self.find_btn.clicked.connect(self.clicked_find)
self.clear_btn = QtWidgets.QPushButton("Clear")
self.clear_btn.clicked.connect(lambda: self.dd_text.clear())
datadir_layout.addWidget(self.dd_label)
datadir_layout.addWidget(self.dd_text)
datadir_layout.addWidget(self.build_trace_btn)
datadir_layout.addWidget(self.find_btn)
datadir_layout.addWidget(self.clear_btn)
# stations widgets
self.stations_label = QtWidgets.QLabel(
"Find only stations (colon separated list):")
self.stations_text = QtWidgets.QLineEdit()
self.stations_clear_btn = QtWidgets.QPushButton("Clear")
self.stations_clear_btn.clicked.connect(
lambda: self.stations_text.clear())
stations_layout.addWidget(self.stations_label)
stations_layout.addWidget(self.stations_text)
stations_layout.addWidget(self.stations_clear_btn)
# fill stations groupbox
self.standard_rbtn = QtWidgets.QRadioButton("Standard")
self.standard_rbtn.setChecked(True)
self.standard_rbtn.clicked.connect(lambda: self.clicked_scan_type(0))
self.verbose_rbtn = QtWidgets.QRadioButton("Verbose")
self.verbose_rbtn.setChecked(False)
self.verbose_rbtn.clicked.connect(lambda: self.clicked_scan_type(1))
self.vv_rbtn = QtWidgets.QRadioButton("Very Verbose")
self.vv_rbtn.setChecked(False)
self.vv_rbtn.clicked.connect(lambda: self.clicked_scan_type(2))
self.unique_rbtn = QtWidgets.QRadioButton("Unique")
self.unique_rbtn.setChecked(False)
self.unique_rbtn.clicked.connect(lambda: self.clicked_scan_type(3))
# spacer item
# adds distance between rbuttons and "Header Endianess"
spacerItem = QtWidgets.QSpacerItem(250, 0,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.header_endianess_label = QtWidgets.QLabel("Header Endianess")
self.header_endianess_text = QtWidgets.QLineEdit()
self.header_endianess_text.setStyleSheet("background-color:yellow")
rbuttons_layout.addWidget(self.standard_rbtn)
rbuttons_layout.addWidget(self.verbose_rbtn)
rbuttons_layout.addWidget(self.vv_rbtn)
rbuttons_layout.addWidget(self.unique_rbtn)
rbuttons_layout.addItem(spacerItem)
rbuttons_layout.addWidget(self.header_endianess_label)
rbuttons_layout.addWidget(self.header_endianess_text)
# fill dir / trace groupbox
self.dir_label = QtWidgets.QLabel("Directory:")
self.dir_menu = QtWidgets.QComboBox()
self.dir_menu.activated.connect(lambda: self.select_dir_trace("dir"))
self.trace_label = QtWidgets.QLabel("Trace:")
self.trace_menu = QtWidgets.QComboBox()
self.trace_menu.activated.connect(
lambda: self.select_dir_trace("trace"))
dir_trace_layout.addRow(self.dir_label, self.dir_menu)
dir_trace_layout.addRow(self.trace_label, self.trace_menu)
self.dir_trace_box.hide()
self.trace_label.hide()
self.trace_menu.hide()
# stacked widget (jump box)
self.standard_box = StandardBox(self.standard_vars)
self.verbose_box = VerboseBox(self.standard_vars, self.v_vars)
self.vv_box = VVBox(
self.first_vv_vars, self.standard_vars, self.v_vars, self.vv_vars)
self.unique_box = UniqueBox()
self.jump_box = QtWidgets.QStackedWidget()
self.jump_box.setStyleSheet("QGroupBox{border:0;}")
self.jump_box.setMinimumSize(0, 200)
self.jump_box.addWidget(self.standard_box)
self.jump_box.addWidget(self.verbose_box)
self.jump_box.addWidget(self.vv_box)
self.jump_box.addWidget(self.unique_box)
# slider
self.slider_box = SliderBox()
self.slider_box.slider.valueChanged.connect(
lambda: self.update_slider("slider"))
self.slider_box.jump_menu.currentTextChanged.connect(
lambda: self.update_slider("menu"))
self.unique_box.unique_jump.currentIndexChanged.connect(
lambda: self.update_slider("unique"))
# add everything to trace headers layout
self.trace_headers_layout.addWidget(self.datadir_box)
self.trace_headers_layout.addWidget(self.stations_box)
self.trace_headers_layout.addWidget(self.radio_box)
self.trace_headers_layout.addWidget(self.dir_trace_box)
self.trace_headers_layout.addWidget(self.jump_box)
self.trace_headers_layout.addWidget(self.slider_box)
# set data directory widget to display cwd
default_dir = os.getcwd()
self.dd_text.setText(default_dir)
def clicked_scan_type(self, index):
"""
Show data related to selected scan type
"""
self.verb_var = index
self.jump_box.setCurrentIndex(self.verb_var)
if self.trace_menu.isHidden():
self.jump_box.hide()
self.maybe_read_hdrs()
def clicked_find(self):
"""
Open file dialogue to search for mseed files
"""
search = QtWidgets.QFileDialog.getExistingDirectory()
directories = self.dd_text.text()
if search:
if directories:
self.dd_text.insert(":" + search)
else:
self.dd_text.insert(search)
def clicked_build_trace(self):
"""
Check directories have been provided before building trace list
"""
directories = self.dd_text.text()
if directories:
self.dir_list.clear()
self.build_trace_list(directories)
self.hide_show("hide")
else:
error_msg = QtWidgets.QMessageBox()
error_msg.setIcon(QtWidgets.QMessageBox.Critical)
error_msg.setText("Error")
error_msg.setInformativeText("No directories listed.")
error_msg.setWindowTitle("Error")
error_msg.exec_()
def build_trace_list(self, directories):
"""
Build trace list from given directories
"""
for dir in str(directories).split(":"):
if not os.path.isdir(dir):
err = "***WARNING*** Directory " + dir + " not found."
self.infobar(err, "red")
QtWidgets.QApplication.beep()
else:
self.dir_list.append(dir)
stat_sel = self.stations_text.text()
if stat_sel:
for stat in str(stat_sel).split(":"):
statsel = stat.strip()
self.stat_sel_list.append(statsel)
if self.dir_list:
(num_files, err_files) = self.find_trace()
text = "Done. " + str(num_files) + " mseed files found. ***\
" + str(err_files) + " files with errors."
self.update_infobar(text, "green")
def hide_show(self, action):
"""
Hide/show widgets between scans
"""
if action == "hide":
widget = self.jump_box.currentWidget()
for child in widget.findChildren(QtWidgets.QWidget):
if not child.isHidden():
child.hide()
for child in self.slider_box.findChildren(QtWidgets.QWidget):
if not child.isHidden():
child.hide()
widgets = self.blockettes_tab.findChildren(QtWidgets.QGroupBox)
for widget in widgets:
if not widget.isHidden():
widget.hide()
self.trace_label.hide()
self.trace_menu.hide()
self.blktype_box.hide()
self.blkinfo_box.hide()
self.blk_vars_box.hide()
else:
widget = self.jump_box.currentWidget()
for child in widget.findChildren(QtWidgets.QWidget):
if child.isHidden():
child.show()
for child in self.slider_box.findChildren(QtWidgets.QWidget):
if child.isHidden():
child.show()
widgets = self.blockettes_tab.findChildren(QtWidgets.QGroupBox)
for widget in widgets:
if widget.isHidden():
widget.show()
self.blktype_box.show()
self.blkinfo_box.show()
self.blk_vars_box.show()
def find_trace(self):
"""
based on traverse routine in "python standard library", Lundh pg 34
"""
stack = []
for k in range(len(self.dir_list)):
stack.append(self.dir_list[k])
file_list = {}
num_mseed_files = 0
rw_error = 0
cnt = 1
while stack:
directory = stack.pop()
try:
listfiles = os.listdir(directory)
except Exception as e:
print("Directory Read Error: %s" % e)
for file in listfiles:
if mod(cnt, 25):
pass
else:
self.wait("Examining File: ", cnt)
fullname = os.path.join(directory, file)
if os.path.isfile(fullname):
if not os.access(fullname, 6):
err = "ERROR: Read/Write permission denied."
err1 = "\t File: " + fullname
print(err)
print(err1)
rw_error += 1
continue
try:
msfile = Mseed(fullname)
if msfile.isMseed():
num_mseed_files += 1
if directory in file_list:
file_list[directory].append(file)
else:
file_list[directory] = []
file_list[directory].append(file)
try:
# simple test to determine if correct size file
filesize = msfile.filesize
blksize = msfile.blksize
(numblocks, odd_size) = divmod(
filesize, blksize)
if odd_size:
warn = ("ERROR: File size is not an "
" integer number of block size (" +
str(blksize) + "). \n\t File: " +
fullname)
print(warn)
rw_error += 1
continue
except Exception:
err = ("ERROR: Cannot determine file and "
"block sizes. \n\t File:" + fullname)
print(err)
rw_error += 1
continue
msfile.close()
except Exception as e:
rw_error += 1
print("File Open Error: %s" % fullname, e)
cnt += 1
if (os.path.isdir(fullname) or (os.path.islink(fullname) and
not os.path.isfile(fullname))):
stack.append(fullname)
self.dir_trace_dict = {}
self.dir_trace_dict = file_list
self.update_dir_list()
return num_mseed_files, rw_error
def select_dir_trace(self, menu):
"""
If directory menu selected, show trace menu
If trace menu selected, read hdrs
"""
if menu == "dir":
dir = self.dir_menu.currentText()
if dir:
self.update_trace_list(dir)
self.trace_label.show()
self.trace_menu.show()
else:
self.trace_label.hide()
self.trace_menu.hide()
else:
trace = self.trace_menu.currentText()
if trace:
dir = self.dir_menu.currentText()
self.next_scan(dir, trace)
def next_scan(self, dir, trace):
"""
Prepare for next scan, i.e. reset/clear/hide some widgets
"""
self.clear_slider()
self.read_hdrs(dir, trace, 0)
self.fill_slider()
self.hide_show("show")
self.header_endianess_text.setText(self.byte_order)
self.jump_box.setCurrentIndex(self.verb_var)
self.update_infobar("", "yellow")
# hack, widget was behaving weird for some reason
# after showing it
self.slider_box.jump_menu.setEnabled(False)
self.slider_box.jump_menu.setEnabled(True)
def read_hdrs(self, dir, trace, blk):
"""
Read headers of a given file, build dictionary for quick access
"""
file_absolute_path = os.path.join(dir, trace)
rdfile = Mseed(file_absolute_path)
if rdfile.isMseed():
try:
filesize = rdfile.filesize
blksize = rdfile.blksize
except Exception:
err = "Cannot determine file and block sizes. File: " + trace
self.update_infobar(err, "red")
rdfile.close()
return
self.blk_size = blksize
(numblocks, self.odd_size) = divmod(filesize, blksize)
self.num_blocks = numblocks
verbose = self.verb_var
self.fixed_hdr_dict = {}
self.rate_dict = {}
self.blockettes_dict = {}
self.key_list = []
self.unique_list = []
self.unique_select_list = []
n = 0
# now build a dictionary of all fixed header info keyed to block
# number looping over total number of blocks in files
lastkey = -1
while n < numblocks:
hdrs = rdfile.fixedhdr(n * blksize)
self.fixed_hdr_dict[n] = hdrs
self.rate_dict[n] = rdfile.rate
# if unique selected build unique list
(SeqNum, DHQual, res, Stat, Loc, Chan, Net) = hdrs[0]
Rate = str(self.rate_dict[n])
Stat = Stat.strip().decode()
Chan = Chan.strip().decode()
Loc = Loc.strip().decode()
Net = Net.strip().decode()
key = ":".join([Stat, Chan, Loc, Net, Rate])
# if key in self.keyList:
if key == lastkey:
pass
else:
lastkey = key
if key not in self.unique_select_list:
self.unique_select_list.append(key)
key = str(blk) + ":" + key
self.unique_list.append(key)
# build Blockette dictionary keyed to block number
numblk = hdrs[3][3]
addseek = hdrs[3][6]
b = 0
# loop over number of blockettes following fixed header at
# block n
while b < numblk:
seekval = (n * blksize) + addseek
(blktype, next) = rdfile.typenxt(seekval)
# builds command to read specific blockette
blklist = eval("rdfile.blk" + str(blktype) + "\
(" + str(seekval) + ")")
if blklist:
# handle awkward lists w/ muli-byte reserve, array, or
# calib fields
if blklist[0] == 100:
tmplist = blklist[:4]
tup = blklist[4:]
tmplist.append(tup)
blklist = tmplist
if blklist[0] == 201:
tmplist = blklist[:8]
tup = blklist[8:13]
for new in (tup, blklist[14], blklist[15],
blklist[16]):
tmplist.append(new)
blklist = tmplist
if blklist[0] == 400:
tmplist = blklist[:5]
tup = blklist[5:]
tmplist.append(tup)
blklist = tmplist
# build Blockettes
if n in self.blockettes_dict:
self.blockettes_dict[n].append(blklist)
else:
self.blockettes_dict[n] = []
self.blockettes_dict[n].append(blklist)
addseek = next
b += 1
n += 1
# get endianess before closing
self.byte_order = rdfile.byteorder
rdfile.close()
self.set_blockettes(0)
if not verbose:
self.fill_standard(int(blk))
elif verbose == 1:
self.fill_verbose(int(blk))
elif verbose == 2:
self.fill_vv(int(blk))
else:
self.fill_unique()
def clear_slider(self):
"""
Reset blk slider between scans
"""
# block/unblock widget signals
self.slider_box.slider.blockSignals(True)
self.slider_box.jump_menu.blockSignals(True)
self.slider_box.slider.setValue(0)
self.slider_box.jump_menu.clear()
self.slider_box.jump_menu.insertItem(0, "0")
self.slider_box.jump_menu.setCurrentIndex(0)
self.slider_box.jump_menu.blockSignals(False)
self.slider_box.slider.blockSignals(False)
def fill_slider(self):
"""
Set slider range for chosen trace
"""
# block/unblock widget signals
self.slider_box.slider.blockSignals(True)
self.slider_box.jump_menu.blockSignals(True)
self.slider_box.slider.setTickPosition(
self.slider_box.slider.TicksBelow)
self.slider_box.slider.setRange(0, self.num_blocks - 1)
i = 0
self.slider_box.jump_menu.clear()
while i < self.num_blocks:
self.slider_box.jump_menu.insertItem(i, str(i))
i += 1
self.slider_box.slider.setTickInterval(
self.slider_box.slider.maximum() / 5)
self.slider_box.jump_menu.blockSignals(False)
self.slider_box.slider.blockSignals(False)
def set_blockettes(self, key):
"""
Setup blockette frames for new key entry
"""
self.blockettes_list = []
for blk in self.blockettes_dict[key]:
self.blockettes_list.append(blk[0])
self.blockettes_list.sort()
# fill blockette info for first blockette found
self.fill_blockettes_tab(key, self.blockettes_list[0])
def fill_blockettes_tab(self, key, blktype):
"""
clears/initializes entry fields in Blockettes tab
"""
for block in self.blockettes_dict[key]:
if block[0] == blktype:
blocktuple = block
for key, values in BlkVars.items():
if blktype == key:
boxes = self.blockettes_tab.findChildren(QtWidgets.QGroupBox)
for box in boxes:
if box.objectName() == "Box1":
menu = box.findChild(QtWidgets.QComboBox, "type_menu")
menu.clear()
menu.insertItem(0, str(blktype))
elif box.objectName() == "Box2":
layout = box.layout()
# delete previous labels if they exist
if layout is not None:
while layout.count():
item = layout.takeAt(0)
widget = item.widget()
if widget is not None:
widget.setParent(None)
# create new labels
label = QtWidgets.QLabel()
label.setText(str(values[0]))
layout.addWidget(label)
layout.addWidget(self.blkinfo_btn)
layout.addStretch()
else:
layout = box.layout()
# delete previous labels if they exist
if layout is not None:
while layout.count():
item = layout.takeAt(0)
widget = item.widget()
if widget is not None:
widget.setParent(None)
# create new labels
for x in range(1, len(values)):
label = QtWidgets.QLabel()
label.setText(str(values[x]) + " " +
str(blocktuple[x - 1]))
layout.addWidget(label)
def blkinfo_window(self):
"""
Popup window for blk info button
"""
self.info_window = QtWidgets.QWidget()
self.info_window.resize(650, 400)
self.info_window.setWindowTitle("Blockette Information")
# widgets
blk_label = QtWidgets.QLabel("Blockette:")
blk_menu = QtWidgets.QComboBox()
blk_menu.activated.connect(
lambda: info_box.setText(BlkInfoDict[int(blk_menu.currentText())])
if blk_menu.currentText().isdigit()
else info_box.setText(BlkInfoDict[blk_menu.currentText()]))
info_box = QtWidgets.QTextEdit()
done_btn = QtWidgets.QPushButton("Done")
done_btn.setStyleSheet("QPushButton{background-color:lightblue;}\
QPushButton::hover{background-color:red;}")
done_btn.clicked.connect(lambda: self.info_window.close())
top_layout = QtWidgets.QHBoxLayout()
top_layout.addWidget(blk_label)
top_layout.addWidget(blk_menu)
top_layout.addStretch()
main_layout = QtWidgets.QVBoxLayout(self.info_window)
main_layout.addLayout(top_layout)
main_layout.addWidget(info_box)
main_layout.addWidget(done_btn)
for key in BlkInfoDict.keys():
blk_menu.addItem(str(key))
blk_menu.setCurrentText(str(self.blockettes_list[0]))
info_box.setText(BlkInfoDict[self.blockettes_list[0]])
self.info_window.show()
def fill_standard(self, key):
"""
Fills standard info on HdrDisplay
"""
try:
standard_widgets = self.standard_box.findChildren(
QtWidgets.QLineEdit)
rate = self.rate_dict[key]
vars = []
# SeqNum, DHQual, res, Stat, Loc, Chan, Net
vars.append(self.fixed_hdr_dict[key][0])
vars = list(itertools.chain.from_iterable(vars))
vars = vars[3:] # remove SeqNum, DHQual, res
vars.append(rate)
for x in range(len(vars)):
widget = standard_widgets[x]
var = vars[x]
try:
var = var.strip().decode()
except Exception:
pass
widget.setText(str(var))
# if user inputs invalid blk num
except Exception:
return
def fill_verbose(self, key):
"""
Fills verbose info on HdrDisplay
"""
try:
verbose_widgets = self.verbose_box.findChildren(
QtWidgets.QLineEdit)
rate = self.rate_dict[key]
vars = []
# SeqNum, DHQual, res, Stat, Loc, Chan, Net
vars.append(self.fixed_hdr_dict[key][0])
vars.append([str(rate)])
# Year, Day, Hour, Min, Sec, junk, Micro
vars.append(self.fixed_hdr_dict[key][1])
vars = list(itertools.chain.from_iterable(vars))
vars = vars[3:] # remove SeqNum, DHQual, res
del vars[-2] # remove junk
for x in range(len(vars)):
widget = verbose_widgets[x]
var = vars[x]
try:
var = var.strip().decode()
except Exception:
pass
widget.setText(str(var))
# if user inputs invalid blk num
except Exception:
return
def fill_vv(self, key):
"""
Fills very verbose info on HdrDisplay
"""
try:
vv_widgets = self.vv_box.findChildren(QtWidgets.QLineEdit)
rate = self.rate_dict[key]
vars = []
# SeqNum, DHQual, res, Stat, Loc, Chan, Net
vars.append(self.fixed_hdr_dict[key][0])
vars.append([str(rate)])
# Year, Day, Hour, Min, Sec, junk, Micro
vars.append(self.fixed_hdr_dict[key][1])
# NumSamp, SampFact, SampMult
vars.append(self.fixed_hdr_dict[key][2])
# act, io, DQual, numblk, timcorr, bdata, bblock
vars.append(self.fixed_hdr_dict[key][3])
vars = list(itertools.chain.from_iterable(vars))
del vars[-12] # remove junk
for x in range(len(vars)):
widget = vv_widgets[x]
var = vars[x]
try:
var = var.strip().decode()
except Exception:
pass
widget.setText(str(var))
# if user inputs invalid blk num
except Exception:
return
def fill_unique(self):
"""
Fills unique info on HdrDisplay
"""
# text colors
Blue = QtGui.QColor(0, 0, 153)
Black = QtGui.QColor(0, 0, 0)
# fill drop down menus
self.unique_box.keys_menu.clear()
self.unique_box.keys_menu.addItem("*")
self.unique_box.keys_menu.addItem(f'{self.unique_select_list[0]}')
self.unique_box.unique_jump.blockSignals(True)
i = 0
while i < self.num_blocks:
self.unique_box.unique_jump.addItem(str(i))
i += 1
self.unique_box.unique_jump.blockSignals(False)
# fill text box
text = "Block\tStat\tChan\tLoc\tNet\tRate"
self.unique_box.unique_infobox.setTextColor(Blue)
self.unique_box.unique_infobox.setText(text)
self.unique_box.unique_infobox.setTextColor(Black)
data = []
data.append(self.unique_list[0].split(":"))
data = list(itertools.chain.from_iterable(data))
data = '\t'.join(str(i) for i in data)
self.unique_box.unique_infobox.append(data)
def wait(self, words, cnt):
"""
routine to put words on info bar, used to count traces
being examined
"""
text = words + str(cnt)
self.update_infobar(text, "lightblue")
def update_dir_list(self):
"""
Update directory list for each scan
"""
self.dir_menu.clear()
self.dir_menu.insertItem(0, "")
for key in self.dir_trace_dict:
self.dir_menu.addItem(key)
self.dir_trace_box.show()
def update_trace_list(self, dir):
"""
Update trace list for each scan
"""
self.trace_menu.clear()
self.trace_menu.insertItem(0, "")
for key, values in self.dir_trace_dict.items():
if dir == key:
values.sort()
for trace in values:
self.trace_menu.addItem(trace)
def update_infobar(self, text, color):
"""
Update info bar when certain actions happen
"""
self.infobar.setText(text)
self.infobar.setStyleSheet("background-color:" + color)
QtWidgets.QApplication.beep()
def update_slider(self, widget):
"""
Get new blk number if any of the slider related widgets
are toggled, and update hdr info
"""
try:
if widget == "slider":
value = self.slider_box.slider.value()
self.slider_box.jump_menu.setCurrentText(str(value))
self.unique_box.unique_jump.setCurrentText(str(value))
elif widget == "menu":
value = self.slider_box.jump_menu.currentText()
self.slider_box.slider.setValue(int(value))
self.unique_box.unique_jump.setCurrentText(str(value))
else:
value = self.unique_box.unique_jump.currentText()
self.slider_box.slider.setValue(int(value))
self.slider_box.jump_menu.setCurrentText(str(value))
self.vv_rbtn.setChecked(True)
self.verb_var = 2
self.jump_box.setCurrentIndex(2)
# update hdr info & info bar
self.maybe_read_hdrs()
byte_offset = int(value) * int(self.blk_size)
text = "Byte Offset: " + str(byte_offset)
self.update_infobar(text, "yellow")
# if user inputs invalid blk num
except Exception:
return
def maybe_read_hdrs(self):
"""
If certain conditions are met, call read hdrs
"""
if not self.dir_menu.isHidden():
dir = self.dir_menu.currentText()
if dir:
if not self.trace_menu.isHidden():
trace = self.trace_menu.currentText()
if trace:
blk = self.slider_box.jump_menu.currentText()
self.read_hdrs(dir, trace, blk)
def flush_dict(self):
"""
clears dictionaries. Allows user to apply a reset and
dynamically monitor changes to mseed files.
"""
self.fixed_hdr_dict = {}
self.rate_dict = {}
self.blockettes_dict = {}
self.key_list = []
self.unique_list = []
self.clear_slider()
self.header_endianess_text.clear()
self.hide_show("hide")
QtWidgets.QApplication.beep()
class SliderBox(QtWidgets.QGroupBox):
"""
Box that holds all the blockette slider widgets
"""
def __init__(self):
"""
Init widgets for blockette parsing
"""
super().__init__()
self.setStyleSheet("QGroupBox{border:0;}")
# widgets
label1 = QtWidgets.QLabel("Jump To Block #:")
self.jump_menu = QtWidgets.QComboBox()
self.jump_menu.setMinimumWidth(100)
self.jump_menu.setEditable(True)
self.jump_menu.insertItem(0, "0")
label2 = QtWidgets.QLabel("Block Number")
self.slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self.slider.setTickPosition(self.slider.NoTicks)
# layouts
main_layout = QtWidgets.QVBoxLayout(self)
menu_layout = QtWidgets.QVBoxLayout()
slider_layout = QtWidgets.QHBoxLayout()
menu_layout.addWidget(label1, alignment=QtCore.Qt.AlignCenter)
menu_layout.addWidget(self.jump_menu, alignment=QtCore.Qt.AlignCenter)
slider_layout.addWidget(label2)
slider_layout.addWidget(self.slider)
# add to main layout
main_layout.addLayout(menu_layout)
main_layout.addLayout(slider_layout)
class StandardBox(QtWidgets.QGroupBox):
"""
Box that holds all the standard info widgets
"""
def __init__(self, standard_vars):
"""
Create standard widgets
"""
super().__init__()
# layout
v_layout = QtWidgets.QVBoxLayout(self)
h_layout = QtWidgets.QHBoxLayout()
col1 = QtWidgets.QVBoxLayout()
col2 = QtWidgets.QVBoxLayout()
# widgets
for x in range(len(standard_vars)):
label = QtWidgets.QLabel(str(standard_vars[x]))
line_edit = QtWidgets.QLineEdit()
col1.addWidget(label)
col2.addWidget(line_edit)
# add to layout
h_layout.addLayout(col1)
h_layout.addLayout(col2)
v_layout.addLayout(h_layout)
v_layout.addStretch()
class VerboseBox(QtWidgets.QGroupBox):
"""
Box that holds all the verbose info widgets
"""
def __init__(self, standard_vars, v_vars):
"""
Create verbose widgets
"""
super().__init__()
# layout
v_layout = QtWidgets.QVBoxLayout(self)
h_layout = QtWidgets.QHBoxLayout()
col1 = QtWidgets.QVBoxLayout()
col2 = QtWidgets.QVBoxLayout()
col3 = QtWidgets.QVBoxLayout()
col4 = QtWidgets.QVBoxLayout()
# widgets
for x in range(len(standard_vars)):
label = QtWidgets.QLabel(str(standard_vars[x]))
line_edit = QtWidgets.QLineEdit()
col1.addWidget(label)
col2.addWidget(line_edit)
for x in range(len(v_vars)):
label = QtWidgets.QLabel(str(v_vars[x]))
line_edit = QtWidgets.QLineEdit()
if x == 0:
col1.addWidget(label)
col2.addWidget(line_edit)
else:
col3.addWidget(label)
col4.addWidget(line_edit)
col3.addSpacing(25)
col4.addSpacing(25)
# add to layout
h_layout.addLayout(col1)
h_layout.addLayout(col2)
h_layout.addLayout(col3)
h_layout.addLayout(col4)
v_layout.addLayout(h_layout)
v_layout.addStretch()
class VVBox(QtWidgets.QGroupBox):
"""
Box that holds all the very verbose info widgets
"""
def __init__(self, first_vv_vars, standard_vars, v_vars, vv_vars):
"""
Create very verbose widgets
"""
super().__init__()
# layout
v_layout = QtWidgets.QVBoxLayout(self)
h_layout = QtWidgets.QHBoxLayout()
col1 = QtWidgets.QVBoxLayout()
col2 = QtWidgets.QVBoxLayout()
col3 = QtWidgets.QVBoxLayout()
col4 = QtWidgets.QVBoxLayout()
col5 = QtWidgets.QVBoxLayout()
col6 = QtWidgets.QVBoxLayout()
col7 = QtWidgets.QVBoxLayout()
col8 = QtWidgets.QVBoxLayout()
# widgets
for x in range(len(first_vv_vars)):
label = QtWidgets.QLabel(str(first_vv_vars[x]))
line_edit = QtWidgets.QLineEdit()
col1.addWidget(label)
col2.addWidget(line_edit)
for x in range(len(standard_vars)):
label = QtWidgets.QLabel(str(standard_vars[x]))
line_edit = QtWidgets.QLineEdit()
if x <= 2:
col1.addWidget(label)
col2.addWidget(line_edit)
else:
col3.addWidget(label)
col4.addWidget(line_edit)
for x in range(len(v_vars)):
label = QtWidgets.QLabel(str(v_vars[x]))
line_edit = QtWidgets.QLineEdit()
if x <= 3:
col3.addWidget(label)
col4.addWidget(line_edit)
else:
col5.addWidget(label)
col6.addWidget(line_edit)
for x in range(len(vv_vars)):
label = QtWidgets.QLabel(str(vv_vars[x]))
line_edit = QtWidgets.QLineEdit()
if x <= 3:
col5.addWidget(label)
col6.addWidget(line_edit)
elif x > 3 and x <= 6:
col7.addWidget(label)
col8.addWidget(line_edit)
else:
col7.addWidget(label)
col8.addWidget(line_edit)
# add to layout
h_layout.addLayout(col1)
h_layout.addLayout(col2)
h_layout.addLayout(col3)
h_layout.addLayout(col4)
h_layout.addLayout(col5)
h_layout.addLayout(col6)
h_layout.addLayout(col7)
h_layout.addLayout(col8)
v_layout.addLayout(h_layout)
v_layout.addStretch()
class UniqueBox(QtWidgets.QGroupBox):
"""
Box that holds all the unique info widgets
"""
def __init__(self):
"""
Create unique widgets
"""
super().__init__()
layout = QtWidgets.QVBoxLayout(self)
select_keys_label = QtWidgets.QLabel("Select Keys:")
self.keys_menu = QtWidgets.QComboBox()
self.keys_menu.setEditable(True)
jump_label = QtWidgets.QLabel("Jump To Block #:")
self.unique_jump = QtWidgets.QComboBox()
self.unique_jump.setEditable(True)
self.unique_infobox = QtWidgets.QTextEdit()
layout.addWidget(select_keys_label)
layout.addWidget(self.keys_menu)
layout.addWidget(jump_label)
layout.addWidget(self.unique_jump)
layout.addWidget(self.unique_infobox)
layout.addStretch()
if __name__ == "__main__":
main()