def __load_repo_metadata(self, repo_url):
from dulwich import porcelain
subdir = get_repo_subdir(repo_url)
repo_dir = os.path.join(self.__beq_dir, subdir)
commit_url = get_commit_url(repo_url)
try:
with porcelain.open_repo_closing(repo_dir) as local_repo:
last_commit = local_repo[local_repo.head()]
last_commit_time_utc = last_commit.commit_time
last_commit_qdt = QDateTime()
last_commit_qdt.setTime_t(last_commit_time_utc)
self.lastCommitDate.setDateTime(last_commit_qdt)
from datetime import datetime
import calendar
d = datetime.utcnow()
now_utc = calendar.timegm(d.utctimetuple())
days_since_commit = (now_utc - last_commit_time_utc) / 60 / 60 / 24
warning_msg = ''
if days_since_commit > 7.0:
warning_msg = f" was {round(days_since_commit)} days ago, press the button to update -->"
commit_link = f"{commit_url}/{last_commit.id.decode('utf-8')}"
self.infoLabel.setText(f"<a href=\"{commit_link}\">Last Commit</a>{warning_msg}")
self.infoLabel.setTextFormat(Qt.RichText)
self.infoLabel.setTextInteractionFlags(Qt.TextBrowserInteraction)
self.infoLabel.setOpenExternalLinks(True)
self.lastCommitMessage.setPlainText(
f"Author: {last_commit.author.decode('utf-8')}\n\n{last_commit.message.decode('utf-8')}")
except:
logger.exception(f"Unable to open git repo in {self.__beq_dir}")
self.__beq_dir_not_exists(repo_url)
def on_until_model_changed(self, event):
# When model is updated (e.g. from console)
if not isinstance(event.date, timedelta):
qdatetime = QDateTime()
qdatetime.setSecsSinceEpoch(event.date.timestamp())
self.until_widget.setDateTime(qdatetime)
self.uncheck_radiobuttons
self.model.request_reload()
def setTicksLabels(values):
strings = []
for v in values:
d = QDateTime()
d = d.fromSecsSinceEpoch(v * 30 * 60)
vstr = d.toString('HH:mm dd/MM/yy')
strings.append(vstr)
return strings
def __beq_dir_not_exists(self, repo_url):
target_path = os.path.abspath(os.path.join(self.__beq_dir, get_repo_subdir(repo_url)))
self.infoLabel.setText(
f"BEQ repo not found in {target_path}, press the button to clone the repository -->")
self.lastCommitMessage.clear()
time = QDateTime()
time.setMSecsSinceEpoch(0)
self.lastCommitDate.setDateTime(time)
def __init__(self, *args, catalog, menuBar, zmq_address=None, **kwargs):
super().__init__(*args, **kwargs)
# Define models.
search_state = SearchState(catalog=catalog)
self.search_model = search_state.search_results_model
# Define widgets.
self.search_widget = SearchWidget()
self.summary_widget = SummaryWidget()
left_pane = QSplitter(Qt.Vertical)
left_pane.addWidget(self.search_widget)
left_pane.addWidget(self.summary_widget)
layout = QHBoxLayout()
splitter = QSplitter(Qt.Horizontal)
layout.addWidget(splitter)
splitter.addWidget(left_pane)
self.setLayout(layout)
def show_double_clicked_entry(index):
search_state.search_results_model.emit_open_entries(None, [index])
# Set models, connect signals, and set initial values.
now = time.time()
ONE_WEEK = 60 * 60 * 24 * 7
self.search_widget.search_results_widget.setModel(
search_state.search_results_model)
self.search_widget.search_input_widget.search_bar.textChanged.connect(
search_state.search_results_model.on_search_text_changed)
self.search_widget.catalog_selection_widget.catalog_list.setModel(
search_state.catalog_selection_model)
self.search_widget.search_input_widget.until_widget.dateTimeChanged.connect(
search_state.search_results_model.on_until_time_changed)
self.search_widget.search_input_widget.until_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(now + ONE_WEEK))
self.search_widget.search_input_widget.since_widget.dateTimeChanged.connect(
search_state.search_results_model.on_since_time_changed)
self.search_widget.search_input_widget.since_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(now - ONE_WEEK))
self.search_widget.catalog_selection_widget.catalog_list.currentIndexChanged.connect(
search_state.set_selected_catalog)
self.search_widget.search_results_widget.selectionModel(
).selectionChanged.connect(
search_state.search_results_model.emit_selected_result)
self.search_widget.search_results_widget.doubleClicked.connect(
show_double_clicked_entry)
search_state.search_results_model.selected_result.connect(
self.summary_widget.set_entries)
search_state.search_results_model.valid_custom_query.connect(
self.search_widget.search_input_widget.mark_custom_query)
search_state.sig_update_header.connect(
self.search_widget.search_results_widget.hide_hidden_columns)
search_state.enabled = True
search_state.search()
def on_reload(self, event):
now = time.time()
if isinstance(self.model.since, timedelta):
self.since_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(now +
self.model.since.total_seconds()))
if isinstance(self.model.until, timedelta):
self.until_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(now +
self.model.until.total_seconds()))
def on_since_model_changed(self, event):
# When model is updated (e.g. from console or by clicking a QRadioButton)
now = time.time()
if isinstance(event.date, timedelta):
self.since_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(now + event.date.total_seconds()))
self.until_widget.setDateTime(QDateTime.fromSecsSinceEpoch(now))
if event.date == timedelta(minutes=-60):
self.hour_widget.setChecked(True)
if event.date == timedelta(days=-1):
self.today_widget.setChecked(True)
if event.date == timedelta(days=-7):
self.week_widget.setChecked(True)
if event.date == timedelta(days=-30):
self.month_widget.setChecked(True)
if event.date == timedelta(days=-365):
self.year_widget.setChecked(True)
if event.date == timedelta(seconds=-4861699200):
self.since_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(event.date.total_seconds()))
self.until_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(now))
self.all_widget.setChecked(True)
else:
qdatetime = QDateTime()
qdatetime.setSecsSinceEpoch(event.date.timestamp())
self.since_widget.setDateTime(qdatetime)
self.uncheck_radiobuttons
def set_txt_from_elt(el, param_dict):
"""
get the value of the parameter from the text value of the xml element
Parameters
----------
el: xml element
param_dict: dictionnary from which the parameter will be constructed
"""
val_text = el.text
param_type = el.get('type')
if val_text is not None:
if param_type == 'float':
param_value = float(val_text)
elif param_type == 'int':
param_value = int(float(val_text))
elif param_type == 'slide':
param_value = float(val_text)
elif param_type == 'itemselect':
if val_text == 'None':
param_value = dict(all_items=[], selected=[])
else:
param_value = dict(all_items=eval(el.get(
'all_items', val_text)),
selected=eval(val_text))
elif 'bool' in param_type or 'led' in param_type: # covers 'bool' 'bool_push', 'led' and 'led_push'types
param_value = bool(int(val_text))
elif param_type == 'date_time':
param_value = QDateTime.fromSecsSinceEpoch(int(val_text))
elif param_type == 'date':
param_value = QDateTime.fromSecsSinceEpoch(int(val_text)).date()
elif param_type == 'table':
param_value = eval(val_text)
elif param_type == 'color':
param_value = QtGui.QColor(*eval(val_text))
elif param_type == 'list':
try:
param_value = eval(val_text)
except Exception:
param_value = val_text # for back compatibility
elif param_type == 'table_view':
data_dict = json.loads(val_text)
mod = importlib.import_module(data_dict['module'])
_cls = getattr(mod, data_dict['classname'])
param_value = _cls(data_dict['data'], header=data_dict['header'])
else:
param_value = val_text
param_dict.update(dict(value=param_value))
def __init__(self, parent=None):
super(TSDateWidget, self).__init__(parent=parent)
self.setupUi(self)
self.setWindowTitle("TSAnalyzer - Date Tool")
self.mjd = 51544.5
self.julday = 2451545
self.demical_year = 2000.0
self.doy = "2000-001"
self.date = datetime(2000, 1, 1, 12)
self.dateEdit.setDateTime(QDateTime(2000, 1, 1, 12, 0))
self.conversionButton.clicked.connect(self._click_conversionButton)
self.ydEdit.setInputMask("9999-999")
self.dyEdit.setInputMask("9999.9999")
self.mjdEdit.setValue(51544.5)
self.juldayEdit.setInputMask("9999999")
self.gpsweekEdit.setInputMask("99999")
self.radios = [
self.dateRadio, self.mjdRadio, self.juldayRadio, self.dyRadio,
self.ydRadio, self.gpsweekRadio
]
self.edits = [
self.dateEdit, self.mjdEdit, self.juldayEdit, self.dyEdit,
self.ydEdit, self.gpsweekEdit
]
def createBottomRightGroupBox(self):
self.bottomRightGroupBox = QGroupBox("Group 3")
self.bottomRightGroupBox.setCheckable(True)
self.bottomRightGroupBox.setChecked(True)
lineEdit = QLineEdit('s3cRe7')
lineEdit.setEchoMode(QLineEdit.Password)
spinBox = QSpinBox(self.bottomRightGroupBox)
spinBox.setValue(50)
dateTimeEdit = QDateTimeEdit(self.bottomRightGroupBox)
dateTimeEdit.setDateTime(QDateTime.currentDateTime())
slider = QSlider(Qt.Horizontal, self.bottomRightGroupBox)
slider.setValue(40)
scrollBar = QScrollBar(Qt.Horizontal, self.bottomRightGroupBox)
scrollBar.setValue(60)
dial = QDial(self.bottomRightGroupBox)
dial.setValue(30)
dial.setNotchesVisible(True)
layout = QGridLayout()
layout.addWidget(lineEdit, 0, 0, 1, 2)
layout.addWidget(spinBox, 1, 0, 1, 2)
layout.addWidget(dateTimeEdit, 2, 0, 1, 2)
layout.addWidget(slider, 3, 0)
layout.addWidget(scrollBar, 4, 0)
layout.addWidget(dial, 3, 1, 2, 1)
layout.setRowStretch(5, 1)
self.bottomRightGroupBox.setLayout(layout)
def __init__(self, parent=None):
super(DateDialog, self).__init__(parent=parent)
ui = os.path.join(os.path.dirname(__file__), "../resources/ui/date.ui")
loadUi(ui, self)
self.setWindowTitle("TSAnalyzer - Date Tool")
self.mjd = 51544.5
self.julday = 2451545
self.demical_year = 2000.0
self.doy = "2000-001"
self.date = datetime(2000, 1, 1, 12)
self.dateEdit.setDateTime(QDateTime(2000, 1, 1, 12, 0))
self.conversionButton.clicked.connect(self.conversionButtonClicked)
self.ydEdit.setInputMask("9999-999")
self.dyEdit.setInputMask("9999.9999")
self.mjdEdit.setValue(51544.5)
self.juldayEdit.setInputMask("9999999")
self.gpsweekEdit.setInputMask("99999")
self.radios = [
self.dateRadio, self.mjdRadio, self.juldayRadio, self.dyRadio,
self.ydRadio, self.gpsweekRadio
]
self.edits = [
self.dateEdit, self.mjdEdit, self.juldayEdit, self.dyEdit,
self.ydEdit, self.gpsweekEdit
]
def __init__(self, model, *args, **kwargs):
self.model = model
super().__init__(*args, **kwargs)
# "Since: <datetime picker>"
self.since_widget = QDateTimeEdit()
self.since_widget.setCalendarPopup(True)
self.since_widget.setDisplayFormat("yyyy-MM-dd HH:mm")
since_layout = QHBoxLayout()
since_layout.addWidget(QLabel("Since:"))
since_layout.addWidget(self.since_widget)
since_layout_widget = QWidget()
since_layout_widget.setLayout(since_layout)
# "Until: <datetime picker>"
self.until_widget = QDateTimeEdit()
self.until_widget.setCalendarPopup(True)
self.until_widget.setDisplayFormat("yyyy-MM-dd HH:mm")
until_layout = QHBoxLayout()
until_layout.addWidget(QLabel("Until:"))
until_layout.addWidget(self.until_widget)
until_layout_widget = QWidget()
until_layout_widget.setLayout(until_layout)
self.refresh_button = QPushButton("Refresh")
# Stack them up.
layout = QVBoxLayout()
layout.addWidget(since_layout_widget)
layout.addWidget(until_layout_widget)
layout.addWidget(self.refresh_button)
self.setLayout(layout)
# Initialize values.
qdatetime = QDateTime()
qdatetime.setSecsSinceEpoch(self.model.since)
self.since_widget.setDateTime(qdatetime)
qdatetime = QDateTime()
qdatetime.setSecsSinceEpoch(self.model.until)
self.until_widget.setDateTime(qdatetime)
# Changes to the GUI update the model.
self.since_widget.dateTimeChanged.connect(self.on_since_view_changed)
self.until_widget.dateTimeChanged.connect(self.on_until_view_changed)
self.refresh_button.clicked.connect(self.model.events.reload)
# Changes to the model update the GUI.
self.model.events.since.connect(self.on_since_model_changed)
self.model.events.until.connect(self.on_until_model_changed)
def setEditorData(self, editor, index):
"""
Overriding method setEditorData
Model --> Editor
"""
value = self.get_value(index)
if isinstance(editor, QLineEdit):
if is_binary_string(value):
try:
value = to_text_string(value, 'utf8')
except Exception:
pass
if not is_text_string(value):
value = repr(value)
editor.setText(value)
elif isinstance(editor, QDateEdit):
editor.setDate(value)
elif isinstance(editor, QDateTimeEdit):
editor.setDateTime(QDateTime(value.date(), value.time()))
def convertValue(row, col, columnDtype):
value = None
if columnDtype == object:
value = self._dataFrame.ix[row, col]
elif columnDtype in self._floatDtypes:
value = round(float(self._dataFrame.ix[row, col]),
self._float_precisions[str(columnDtype)])
elif columnDtype in self._intDtypes:
value = int(self._dataFrame.ix[row, col])
elif columnDtype in self._boolDtypes:
# TODO this will most likely always be true
# See: http://stackoverflow.com/a/715455
# well no: I am mistaken here, the data is already in the dataframe
# so its already converted to a bool
value = bool(self._dataFrame.ix[row, col])
elif columnDtype in self._dateDtypes:
#print numpy.datetime64(self._dataFrame.ix[row, col])
value = pd.Timestamp(self._dataFrame.ix[row, col])
value = QDateTime.fromString(str(value), self.timestampFormat)
#print value
# else:
# raise TypeError, "returning unhandled data type"
return value
def __init__(self, parent):
super(TaskOptionsGroupBox, self).__init__(parent)
self.widget_layout = QFormLayout(self)
self.setLayout(self.widget_layout)
self.setTitle("Time")
self.time_label = QLabel(self)
self.time_label.setText("Execute: ")
self.time_now = QRadioButton(self)
self.time_now.setText("Immediately")
self.time_now.setChecked(True)
self.time_schedule = QRadioButton(self)
self.time_schedule.setText("Schedule")
self.schedule_select = QDateTimeEdit(self)
self.schedule_select.setDateTime(QDateTime.currentDateTime())
self.schedule_select.setEnabled(False)
self.user_activity_label = QLabel(self)
self.user_activity_label.setText("User activity")
self.user_activity_combo = QComboBox(self)
self.user_activity_combo.addItems([
"0 - Disabled", "1 - Low", "2 - Normal", "3 - Medium", "4 - High",
"5 - Very high"
])
self.widget_layout.addRow(self.time_label, None)
self.widget_layout.addRow(self.time_now, None)
self.widget_layout.addRow(self.time_schedule, self.schedule_select)
self.widget_layout.addRow(self.user_activity_label,
self.user_activity_combo)
self.time_schedule.toggled.connect(self.on_time_schedule_toggled)
def on_until_model_changed(self, event):
# When model is updated (e.g. from console)
qdatetime = QDateTime()
qdatetime.setSecsSinceEpoch(event.date)
self.until_widget.setDateTime(qdatetime)
def add_text_to_elt(elt, param):
"""Add a text filed in a xml element corresponding to the parameter value
Parameters
----------
elt: XML elt
param: Parameter
See Also
--------
add_text_to_elt, walk_parameters_to_xml, dict_from_param
"""
param_type = str(param.type())
if 'bool' in param_type or 'led' in param_type:
if param.value():
text = '1'
else:
text = '0'
elif param_type == 'itemselect':
if param.value() is not None:
elt.set(
'all_items', str(param.value()['all_items'])
) # use list(eval(val_str[1:-1])) to get back a list of strings
text = str(
param.value()['selected']
) # use list(eval(val_str[1:-1])) to get back a list of strings
else:
text = str(None)
elif param_type == 'color':
text = str([
param.value().red(),
param.value().green(),
param.value().blue(),
param.value().alpha()
])
elif param_type == 'list':
if isinstance(param.value(), str):
text = "str('{}')".format(param.value())
elif isinstance(param.value(), int):
text = 'int({})'.format(param.value())
elif isinstance(param.value(), float):
text = 'float({})'.format(param.value())
else:
str(param.value())
elif param_type == 'int':
if param.value(
) is True: # known bug is True should be clearly specified here
val = 1
else:
val = param.value()
text = str(val)
elif param_type == 'date_time':
text = str(param.value().toSecsSinceEpoch())
elif param_type == 'date':
text = str(QDateTime(param.value()).toSecsSinceEpoch())
elif param_type == 'table_view':
try:
data = dict(classname=param.value().__class__.__name__,
module=param.value().__class__.__module__,
data=param.value().get_data_all(),
header=param.value().header)
text = json.dumps(data)
except Exception:
text = ''
else:
text = str(param.value())
elt.text = text
from qtpy.QtCore import QDate, QDateTime, QTime, Qt
from qtpy.QtWidgets import QApplication, QWidget, QMessageBox, QDesktopWidget, QMainWindow, QAction, qApp, QMenu
from qtpy.QtGui import QIcon
from qtpy import QtGui
import sys
now = QDate.currentDate()
print(now.toString(Qt.ISODate))
print(now.toString(Qt.DefaultLocaleLongDate))
datetime = QDateTime.currentDateTime()
print(datetime.toString())
time = QTime.currentTime()
print(time.toString(Qt.DefaultLocaleLongDate))
# localdatetime
print(datetime.toString(Qt.ISODate))
# Universal datetime
print(datetime.toUTC().toString(Qt.ISODate))
class Example(QMainWindow):
def __init__(self):
super(Example, self).__init__()
self.initUI()
def initUI(self):
exitAct = QAction('&Exit', self)
def transform_data(utc, timezone=None):
utc_fmt = "yyyy-MM-ddTHH:mm:ss.zzzZ"
new_date = QDateTime().fromString(utc, utc_fmt)
if timezone:
new_date.setTimeZone(new_date)
return new_date
def as_datetime(qdatetime):
assert isinstance(qdatetime, QDateTime)
return QDateTime.toPython(qdatetime).replace(tzinfo=LOCAL_TIMEZONE)
def set_time_now(self):
"""Set current date and time to the "dfTo" widget"""
self.dtTo.setDateTime(QDateTime.currentDateTime())
def show(self):
# self.date = datetime.today()
self.dateEdit.setDateTime(QDateTime.currentDateTime())
self.dateRadio.setChecked(True)
self.conversionButtonClicked()
super(DateDialog, self).show()
def __init__(self, *args,
catalog, search_result_row, menuBar,
zmq_address=None, **kwargs):
super().__init__(*args, **kwargs)
# Define models.
search_state = SearchState(
catalog=catalog,
search_result_row=search_result_row)
# Define widgets.
self.search_widget = SearchWidget()
self.summary_widget = SummaryWidget()
left_pane = QVBoxLayout()
left_pane.addWidget(self.search_widget)
left_pane.addWidget(self.summary_widget)
right_pane = QVBoxLayout()
self.viewer = Viewer(menuBar=menuBar)
right_pane.addWidget(self.viewer)
layout = QHBoxLayout()
layout.addLayout(left_pane)
layout.addLayout(right_pane)
self.setLayout(layout)
def show_double_clicked_entry(index):
search_state.search_results_model.emit_open_entries(None, [index])
# Set models, connect signals, and set initial values.
now = time.time()
ONE_WEEK = 60 * 60 * 24 * 7
self.search_widget.search_results_widget.setModel(
search_state.search_results_model)
self.search_widget.search_input_widget.search_bar.textChanged.connect(
search_state.search_results_model.on_search_text_changed)
self.search_widget.catalog_selection_widget.catalog_list.setModel(
search_state.catalog_selection_model)
self.search_widget.search_input_widget.until_widget.dateTimeChanged.connect(
search_state.search_results_model.on_until_time_changed)
self.search_widget.search_input_widget.until_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(now + ONE_WEEK))
self.search_widget.search_input_widget.since_widget.dateTimeChanged.connect(
search_state.search_results_model.on_since_time_changed)
self.search_widget.search_input_widget.since_widget.setDateTime(
QDateTime.fromSecsSinceEpoch(now - ONE_WEEK))
self.search_widget.catalog_selection_widget.catalog_list.currentIndexChanged.connect(
search_state.set_selected_catalog)
self.search_widget.search_results_widget.selectionModel().selectionChanged.connect(
search_state.search_results_model.emit_selected_result)
self.search_widget.search_results_widget.doubleClicked.connect(
show_double_clicked_entry)
search_state.search_results_model.selected_result.connect(
self.summary_widget.set_entries)
search_state.search_results_model.open_entries.connect(
self.viewer.show_entries)
self.summary_widget.open.connect(self.viewer.show_entries)
self.viewer.tab_titles.connect(self.summary_widget.cache_tab_titles)
search_state.search_results_model.valid_custom_query.connect(
self.search_widget.search_input_widget.mark_custom_query)
search_state.enabled = True
search_state.search()
if zmq_address:
self.consumer_thread = ConsumerThread(zmq_address=zmq_address)
self.consumer_thread.documents.connect(self.viewer.consumer)
self.consumer_thread.start()
def on_until_view_changed(self, qdatetime):
# When GUI is updated
self.model.until = QDateTime.toPython(qdatetime)
def as_qdatetime(datetime):
"Create QDateTime set as specified by datetime."
return QDateTime.fromSecsSinceEpoch(
int(secs_since_epoch(datetime) - datetime.utcoffset() / timedelta(seconds=1))
)
def on_since_view_changed(self, qdatetime):
# When GUI is updated
self.model.since = QDateTime.toPython(qdatetime)
def _conversion(self):
for radio, edit in zip(self.radios, self.edits):
if radio.isChecked():
text = edit.text()
if radio == self.dateRadio:
dt = map(int, text.split("-")) + [12]
date = datetime(*dt)
mjd = date2mjd(date)
self.mjdEdit.setValue(date2mjd(date))
self.juldayEdit.setText("%d" % mjd2julday(mjd))
self.dyEdit.setText("%.4f" % mjd2yearfraction(mjd))
yd = date2year_doy(date)
yd_str = '%d-%03d' % (yd[0], yd[1])
self.ydEdit.setText("%s" % yd_str)
self.gpsweekEdit.setText("%d" % date2gpsweek(date))
if radio == self.mjdRadio:
mjd = float(text)
date = mjd2date(mjd)
qdate = QDateTime(date.year, date.month, date.day, 12, 0,
0)
self.dateEdit.setDateTime(qdate)
self.juldayEdit.setText("%d" % mjd2julday(mjd))
self.dyEdit.setText("%.4f" % mjd2yearfraction(mjd))
yd = date2year_doy(date)
yd_str = '%d-%03d' % (yd[0], yd[1])
self.ydEdit.setText("%s" % yd_str)
self.gpsweekEdit.setText("%d" % date2gpsweek(date))
if radio == self.juldayRadio:
jd = int(text)
mjd = julday2mjd(jd) + 0.5
date = mjd2date(mjd)
qdate = QDateTime(date.year, date.month, date.day, 12, 0,
0)
self.dateEdit.setDateTime(qdate)
self.mjdEdit.setValue(date2mjd(date))
self.dyEdit.setText("%.4f" % mjd2yearfraction(mjd))
yd = date2year_doy(date)
yd_str = '%d-%03d' % (yd[0], yd[1])
self.ydEdit.setText("%s" % yd_str)
self.gpsweekEdit.setText("%d" % date2gpsweek(date))
if radio == self.dyRadio:
dy = float(text)
mjd = yearfraction2mjd(dy)
date = mjd2date(mjd)
qdate = QDateTime(date.year, date.month, date.day, 12, 0,
0)
self.dateEdit.setDateTime(qdate)
self.mjdEdit.setValue(date2mjd(date))
self.dyEdit.setText("%.4f" % mjd2yearfraction(mjd))
yd = date2year_doy(date)
yd_str = '%d-%03d' % (yd[0], yd[1])
self.ydEdit.setText("%s" % yd_str)
self.gpsweekEdit.setText("%d" % date2gpsweek(date))
if radio == self.ydRadio:
yd = map(int, str(text).split("-"))
if yd[1] == 0:
edit.setText('%d-00%d' % (yd[0], 1))
yd[1] = 1
# plus 12 hours
date = year_doy2date(*yd) + timedelta(hours=12)
mjd = date2mjd(date)
qdate = QDateTime(date.year, date.month, date.day, 12, 0,
0)
self.dateEdit.setDateTime(qdate)
self.mjdEdit.setValue(date2mjd(date))
self.juldayEdit.setText("%d" % mjd2julday(mjd))
self.dyEdit.setText("%.4f" % mjd2yearfraction(mjd))
self.gpsweekEdit.setText("%d" % date2gpsweek(date))
if radio == self.gpsweekRadio:
date = gpsweek2date(int(self.gpsweekEdit.text()))
mjd = date2mjd(date)
qdate = QDateTime(date.year, date.month, date.day, 12, 0,
0)
self.dateEdit.setDateTime(qdate)
self.mjdEdit.setValue(date2mjd(date))
self.juldayEdit.setText("%d" % mjd2julday(mjd))
self.dyEdit.setText("%.4f" % mjd2yearfraction(mjd))
yd = date2year_doy(date)
yd_str = '%d-%03d' % (yd[0], yd[1])
self.ydEdit.setText("%s" % yd_str)
def __init__(self, model, *args, **kwargs):
self.model = model
super().__init__(*args, **kwargs)
self.setLayout(QFormLayout())
# Radiobuttons to quickly select default time period
self.all_widget = QRadioButton("All")
self.year_widget = QRadioButton("1 Year")
self.month_widget = QRadioButton("30 Days")
self.week_widget = QRadioButton("1 Week")
self.today_widget = QRadioButton("24h")
self.hour_widget = QRadioButton("1 Hour")
self.radio_button_group = QButtonGroup()
self.radio_button_group.addButton(self.all_widget)
self.radio_button_group.addButton(self.year_widget)
self.radio_button_group.addButton(self.month_widget)
self.radio_button_group.addButton(self.week_widget)
self.radio_button_group.addButton(self.today_widget)
self.radio_button_group.addButton(self.hour_widget)
default_period_layout = QGridLayout()
default_period_layout.setHorizontalSpacing(85)
default_period_layout.setVerticalSpacing(10)
default_period_layout.addWidget(self.all_widget, 0, 0, 1, 2)
default_period_layout.addWidget(self.year_widget, 1, 0, 1, 2)
default_period_layout.addWidget(self.month_widget, 2, 0, 1, 2)
default_period_layout.addWidget(self.week_widget, 0, 1, 1, 2)
default_period_layout.addWidget(self.today_widget, 1, 1, 1, 2)
default_period_layout.addWidget(self.hour_widget, 2, 1, 1, 2)
self.layout().addRow("When:", default_period_layout)
# TODO: rethink if restriction to acceptable timedelta values is required
# from ..components.search.search_input import SearchInput
# self.allowed = {timedelta(days=-1), timedelta(days=-30), timedelta(minutes=-60), timedelta(days=-7),
# timedelta(days=-365)}
# def time_validator(since=None, until=None):
# """
# Enforce that since and until are values that a UI can represent.
# This is an example similar to what will be used in the Qt UI.
# """
# now = timedelta()
# if isinstance(since, timedelta):
# if not (until is None or until == now):
# raise ValueError(
# "This UI cannot express since=timedelta(...) unless until "
# "is timedelta() or None."
# )
# for item in allowed:
# if since == item:
# break
# else:
# # No matches
# raise ValueError(
# "This UI can only express since as a timedelta if it is "
# f"one of {allowed}. The value {since} is not allowed"
# )
# s = SearchInput()
# s.time_validator = time_validator
# "Since: <datetime picker>"
self.since_widget = QDateTimeEdit()
self.since_widget.setCalendarPopup(True)
self.since_widget.setDisplayFormat("yyyy-MM-dd HH:mm")
self.layout().addRow("Since:", self.since_widget)
self.since_widget.dateTimeChanged.connect(self.uncheck_radiobuttons)
# "Until: <datetime picker>"
self.until_widget = QDateTimeEdit()
self.until_widget.setCalendarPopup(True)
self.until_widget.setDisplayFormat("yyyy-MM-dd HH:mm")
self.layout().addRow("Until:", self.until_widget)
self.until_widget.dateTimeChanged.connect(self.uncheck_radiobuttons)
# Refresh Button
self.refresh_button = QPushButton("Refresh")
self.layout().addWidget(self.refresh_button)
# Initialize values.
qdatetime = QDateTime()
qdatetime.setSecsSinceEpoch(self.model.since.timestamp())
self.since_widget.setDateTime(qdatetime)
qdatetime = QDateTime()
qdatetime.setSecsSinceEpoch(self.model.until.timestamp())
self.until_widget.setDateTime(qdatetime)
# Changes to the GUI update the model.
self.since_widget.dateTimeChanged.connect(self.on_since_view_changed)
self.until_widget.dateTimeChanged.connect(self.on_until_view_changed)
self.refresh_button.clicked.connect(self.model.request_reload)
self.model.events.reload.connect(self.on_reload)
self.model.events.query.connect(self.on_reload)
# Changes to the model update the GUI.
self.model.events.since.connect(self.on_since_model_changed)
self.model.events.until.connect(self.on_until_model_changed)
# connect QRadioButtons and change date dropdowns (since/until widgets) accordingly
self.hour_widget.clicked.connect(self.on_select_hour)
self.today_widget.clicked.connect(self.on_select_24h)
self.week_widget.clicked.connect(self.on_select_week)
self.month_widget.clicked.connect(self.on_select_month)
self.year_widget.clicked.connect(self.on_select_year)
self.all_widget.clicked.connect(self.on_select_all)
