def clear(self, period=0):
"""
Public slot to clear the complete history.
@param period history period in milliseconds to be cleared (integer)
"""
if period == 0:
self.__history = []
self.historyReset.emit()
else:
breakMS = QDateTime.currentMSecsSinceEpoch() - period
while self.__history and \
(QDateTime(self.__history[0].dateTime).toMSecsSinceEpoch() >
breakMS):
itm = self.__history.pop(0)
self.entryRemoved.emit(itm)
self.__lastSavedUrl = ""
self.__saveTimer.changeOccurred()
self.__saveTimer.saveIfNeccessary()
self.historyCleared.emit()
def __init__(self, apiKey, fairUse=True, parent=None):
"""
Constructor
@param apiKey API key to be used
@type str
@param fairUse flag indicating to follow the fair use policy
@type bool
@param parent reference to the parent object
@type QObject
"""
super(SafeBrowsingAPIClient, self).__init__(parent)
self.__apiKey = apiKey
self.__fairUse = fairUse
self.__nextRequestNoSoonerThan = QDateTime()
self.__failCount = 0
self.__lookupApiCache = {}
def refresh(self):
'''
当时间每隔1s，LCD上信息会刷新一下的。
'''
startDate = QDateTime.currentMSecsSinceEpoch()
# 将其转换成当前时间到1970-01-01T00：00：00世界协调时间以来的毫秒数
endDate = QDateTime(QDate(2020, 2, 4), QTime(0, 0, 0)).toMSecsSinceEpoch()
# 返回2020年2月4日0:0:0自1970-01-01T00：00：00.000世界协调时间以来的毫秒数
interval = endDate - startDate
# 距离冬奥会还有多少时间
if interval > 0:
days = interval // (24 * 60 * 60 * 1000)
hour = (interval - days * 24 * 60 * 60 * 1000) // (60 * 60 * 1000)
min = (interval - days * 24 * 60 * 60 * 1000 - hour * 60 * 60 * 1000) // (60 * 1000)
sec = (interval - days * 24 * 60 * 60 * 1000 - hour * 60 * 60 * 1000 - min * 60 * 1000) // 1000
intervals = str(days) + ':' + str(hour) + ':' + str(min) + ':' + str(sec)
self.lcd.display(intervals)
class MainLcd:
QDATETIME_FORMATTER = QDateTime(1, 1, 1, 0, 0)
def __init__(self, main_qlcd: QLCDNumber, registry=None):
self.qlcd = main_qlcd
self.leading: TimerType = TimerType.LEARN if not registry else registry.main_lcd_leading
self.current_time = 0 if not registry else registry.main_lcd_current_time
def show(self, duration, from_timer: TimerType):
self.current_time += duration if from_timer == self.leading else -duration
if self.current_time < 0:
self.leading = from_timer
self.current_time = abs(self.current_time)
current_qdatetime = self.QDATETIME_FORMATTER.addMSecs(
self.current_time)
text = current_qdatetime.toString('hh:mm:ss.zzz')
if (duration % 500) == 0:
text = text[:8] + ' ' + text[9:]
text = self.leading.value + " " + text
self.qlcd.display(text)
def __init__(self, memo_data: StockMemoData, parent: QWidget = None):
self.__memo_data = memo_data
super(StockMemoEditor, self).__init__(parent)
# The filter of left list
# self.__filter_identity: str = ''
# self.__filter_datetime: datetime.datetime = None
# The stock that selected by combobox or outer setting
self.__current_stock = None
# The current index of editing memo
# Not None: Update exists
# None: Create new
self.__current_index = None
# The memo list that displaying in the left list
self.__current_memos: pd.DataFrame = None
self.__observers = []
self.__sas = self.__memo_data.get_sas(
) if self.__memo_data is not None else None
self.__memo_record = self.__memo_data.get_memo_record(
) if self.__memo_data is not None else None
data_utility = self.__sas.get_data_hub_entry().get_data_utility(
) if self.__sas is not None else None
self.__combo_stock = SecuritiesSelector(data_utility)
self.__table_memo_index = EasyQTableWidget()
self.__datetime_time = QDateTimeEdit(QDateTime().currentDateTime())
self.__line_brief = QLineEdit()
self.__text_record = QTextEdit()
self.__button_new = QPushButton('New')
self.__button_apply = QPushButton('Save')
self.__button_delete = QPushButton('Delete')
self.init_ui()
self.config_ui()
def __init__(self, taskID=None, taskName=None, taskMode=None, taskType=None, project=None, organisation=None,
duetime={}, duedate={}, details={}):
super(Task, self).__init__()
self.taskID = taskID
self.taskName = taskName
self.taskMode = taskMode
self.taskType = taskType
self.project = project
self.details = details
self.organisation = organisation
self.duetime = QTime(duetime['hour'], duetime['minute'], duetime['second'])
self.duedate = QDate(duedate['year'], duedate['month'], duedate['day'])
self.endDate = QDateTime(self.duedate, self.duetime)
self.update()
format = self.countter_format()
self.timer.timeout.connect(self.update)
self.timer.start(format)
def __applyRules(self):
"""
Private method to apply the cookie rules.
"""
cookiesList = self.allCookies()
changed = False
for index in range(len(cookiesList) - 1, -1, -1):
cookie = cookiesList[index]
if self.__isOnDomainList(self.__exceptionsBlock, cookie.domain()):
del cookiesList[index]
changed = True
elif self.__isOnDomainList(self.__exceptionsAllowForSession,
cookie.domain()):
cookie.setExpirationDate(QDateTime())
changed = True
if changed:
self.setAllCookies(cookiesList)
self.__saveTimer.changeOccurred()
self.cookiesChanged.emit()
def update_date_time_input(datetime_input: DateTimeInput,
new: DateTimeInput) -> None:
# noinspection PyTypeChecker
widget: QDateTimeEdit = get_dwidgets()[id(datetime_input)]
widget.blockSignals(True)
if datetime_input.read_only != new.read_only:
widget.setReadOnly(new.read_only)
if datetime_input.value != new.value:
widget.setDateTime(
QDateTime(new.value.year, new.value.month, new.value.day,
new.value.hour, new.value.minute, 0, 0))
if datetime_input.on_input != new.on_input:
widget.dateTimeChanged.disconnect()
widget.dateTimeChanged[QDateTime].connect(
make_action_catcher(
lambda qdtm: datetime_input.on_input(qdtm.toPyDateTime())))
widget.blockSignals(False)
def unit_ui(self):
self.setWindowTitle('不同风格的时间格式')
self.setWindowIcon(QIcon(QPixmap('../images/python.png')))
self.resize(800, 500)
layout = QVBoxLayout()
self.setLayout(layout)
date_time1 = QDateTimeEdit(QDateTime.currentDateTime())
# 设置一些属性
date_time1.setMaximumDate(QDate.currentDate().addDays(365))
date_time1.setMinimumDateTime(QDateTime(1998, 7, 19, 12, 45, 36))
date_time2 = QDateTimeEdit(QDateTime.currentDateTime())
# 将日期编辑栏结合日历控制
date_time2.setCalendarPopup(True)
date_time3 = QDateTimeEdit(QDateTime.currentDateTime())
date_time4 = QDateTimeEdit(QDateTime.currentDateTime())
date_time1.setDisplayFormat("yyyy-MM-dd HH:dd:ss")
date_time2.setDisplayFormat("yyyy/MM/dd HH-dd-ss")
date_time3.setDisplayFormat("yyyy.MM.dd")
date_time4.setDisplayFormat("HH:dd:ss")
# 获取时间编辑栏的属性
button = QPushButton('获取第一行时间')
layout.addWidget(button)
button.clicked.connect(lambda: self.get_time(date_time1))
layout.addWidget(date_time1)
layout.addWidget(date_time2)
layout.addWidget(date_time3)
layout.addWidget(date_time4)
# 有关日期的三个事件
date_time1.timeChanged.connect(self.time_change)
date_time1.dateChanged.connect(self.data_change)
date_time1.dateTimeChanged.connect(self.datetime_change)
def __parseUnixTime(self, monthAbbreviation, day, yearOrTime, urlInfo):
"""
Private method to parse a Unix date and time indication modifying
the given URL info object.
Date time strings in Unix-style directory listings typically
have one of these formats:
<ul>
<li>"Nov 23 02:33" (month name, day of month, time)</li>
<li>"May 26 2005" (month name, day of month, year)</li>
</ul>
@param monthAbbreviation abbreviation of the month name (string)
@param day day of the month (string)
@param yearOrTime string giving the year or a time (string)
@param urlInfo reference to the URL info object (E5UrlInfo)
@exception FtpDirLineParserError Raised if the month abbreviation is
not recognized.
"""
try:
month = FtpDirLineParser.MonthnamesNumbers[
monthAbbreviation.lower()]
except KeyError:
raise FtpDirLineParserError(
"illegal month abbreviation '{0}'".format(
monthAbbreviation))
day = int(day)
if ':' in yearOrTime:
year = QDate.currentDate().year()
hour, minute = yearOrTime.split(':')
hour = int(hour)
minute = int(minute)
else:
year = int(yearOrTime)
hour = 0
minute = 0
lastModified = QDateTime(QDate(year, month, day), QTime(hour, minute))
urlInfo.setLastModified(lastModified)
def set_rows(self, rows):
for idx, row in enumerate(rows):
items = []
for column, item in row.items():
standard_item = QStandardItem()
if item is None:
font = QFont()
font.setItalic(True)
font.setBold(True)
standard_item.setData(QVariant("NULL"), Qt.EditRole)
standard_item.setFont(font)
elif isinstance(item, datetime.datetime):
standard_item.setData(QDateTime(item), Qt.EditRole)
elif isinstance(item, datetime.date):
standard_item.setData(QDate(item), Qt.EditRole)
elif isinstance(item, str):
standard_item.setData(QVariant(item), Qt.EditRole)
else:
standard_item.setData(QVariant(item), Qt.EditRole)
items.append(standard_item)
self.model.insertRow(idx, items)
def __parseDate(self, variableName, parent):
"""
Private method to parse a date.
@param variableName name of the variable to be parsed
@type str
@param parent reference to the dictionary to insert the result into
@type dict
"""
msec, = struct.unpack(">d", self.__data.read(8))
# double, big-endian
# DateObject: Milliseconds Count From Dec. 1, 1969
msec -= self.EpochCorrectionMsecs # correct for Unix epoch
minOffset, = struct.unpack(">h", self.__data.read(2))
# short, big-endian
offset = minOffset // 60 # offset in hours
# Timezone: UTC + Offset
value = QDateTime()
value.setMSecsSinceEpoch(msec)
value.setOffsetFromUtc(offset * 3600)
parent[variableName] = ("date",
value.toString("yyyy-MM-dd HH:mm:ss t"))
def testDateTimeTypes(self):
create_sql = f'CREATE TABLE "{self.schemaName}"."date_time_type" ( ' \
'"id" INTEGER NOT NULL PRIMARY KEY,' \
'"date_field" DATE,' \
'"time_field" TIME,' \
'"datetime_field" TIMESTAMP)'
insert_sql = f'INSERT INTO "{self.schemaName}"."date_time_type" ("id", "date_field", "time_field", "datetime_field") ' \
'VALUES (?, ?, ?, ?)'
insert_args = [[1, '2004-03-04', '13:41:52', '2004-03-04 13:41:52']]
self.prepareTestTable('date_time_type', create_sql, insert_sql,
insert_args)
vl = self.createVectorLayer(
f'table="{self.schemaName}"."date_time_type" sql=',
'testdatetimes')
fields = vl.dataProvider().fields()
self.assertEqual(
fields.at(fields.indexFromName('date_field')).type(),
QVariant.Date)
self.assertEqual(
fields.at(fields.indexFromName('time_field')).type(),
QVariant.Time)
self.assertEqual(
fields.at(fields.indexFromName('datetime_field')).type(),
QVariant.DateTime)
f = next(vl.getFeatures(QgsFeatureRequest()))
date_idx = vl.fields().lookupField('date_field')
self.assertIsInstance(f.attributes()[date_idx], QDate)
self.assertEqual(f.attributes()[date_idx], QDate(2004, 3, 4))
time_idx = vl.fields().lookupField('time_field')
self.assertIsInstance(f.attributes()[time_idx], QTime)
self.assertEqual(f.attributes()[time_idx], QTime(13, 41, 52))
datetime_idx = vl.fields().lookupField('datetime_field')
self.assertIsInstance(f.attributes()[datetime_idx], QDateTime)
self.assertEqual(f.attributes()[datetime_idx],
QDateTime(QDate(2004, 3, 4), QTime(13, 41, 52)))
def dataChanged(self, top_left, bottom_right, roles): #pylint: disable=invalid-name
"""Respond to a RaceTableModel data change by updating input widgets with current values."""
del top_left, bottom_right, roles
if self.race_table_model.reference_clock_is_enabled():
self.reference_clock_radiobutton.click()
# If there's a reference datetime set up, populate the controls with it.
if self.race_table_model.reference_clock_has_datetime():
reference_datetime = self.race_table_model.get_reference_clock_datetime()
# Make our own combined string, because I haven't found a QDateTime format that I like.
# Guess I'll keep looking...this looks really hokey.
datetime_string = reference_datetime.toString(defaults.REFERENCE_CLOCK_DATETIME_FORMAT)
self.reference_datetime_label.setText(datetime_string)
else: # Otherwise, just use the race day's date, time zero.
reference_datetime = QDateTime(QDate.currentDate())
self.reference_datetime_label.setText('Reference clock not set up')
self.datetime_datetimeedit.setDateTime(reference_datetime)
def data(self, index: QModelIndex, role: Optional[int] = None) -> Any:
"""Return the data at the row of the given *index* and for the
specified *role*
:param index: Used for specifying the model's row, the column is \
ignored
:param role: Indicates which type of data the view requested
:return: The data the view requested at the specified *row* for the \
given *role*
"""
# ignore out of range data requests
if 0 <= index.row() < len(self._messages):
# pylint: disable=unsubscriptable-object
message = self._messages[index.row()]
# pylint: enable=unsubscriptable-object
if role == ItemRole.TIME:
return QDateTime(message.time)
if role == ItemRole.SENDER:
return message.sender
if role == ItemRole.CONTENTS:
return message.contents
return None
def __parseWindowsTime(self, date, time, urlInfo):
"""
Private method to parse a Windows date and time indication modifying
the given URL info object.
Date time strings in Windows-style directory listings typically
have the format "10-23-12 03:25PM" (month-day_of_month-two_digit_year,
hour:minute, am/pm).
@param date date string (string)
@param time time string (string)
@param urlInfo reference to the URL info object (E5UrlInfo)
@exception FtpDirLineParserError Raised if either of the strings is not
recognized.
"""
try:
month, day, year = [int(part) for part in date.split('-')]
if year >= 70:
year = 1900 + year
else:
year = 2000 + year
except (ValueError, IndexError):
raise FtpDirLineParserError(
"illegal date string '{0}'".format(month))
try:
hour, minute, am_pm = time[0:2], time[3:5], time[5]
hour = int(hour)
minute = int(minute)
except (ValueError, IndexError):
raise FtpDirLineParserError(
"illegal time string '{0}'".format(month))
if hour == 12 and am_pm == 'A':
hour = 0
if hour != 12 and am_pm == 'P':
hour = hour + 12
lastModified = QDateTime(QDate(year, month, day), QTime(hour, minute))
urlInfo.setLastModified(lastModified)
def __init__(self, meeting: Meeting = None):
super(MeetingEditDialog, self).__init__()
uic.loadUi('./layout/meetingEditDialog.ui', self)
self.meeting_id_input: QtWidgets.QLineEdit = self.findChild(
QtWidgets.QLineEdit, 'meetingIdInput')
self.password_input: QtWidgets.QLineEdit = self.findChild(
QtWidgets.QLineEdit, 'passwordInput')
self.name_input: QtWidgets.QLineEdit = self.findChild(
QtWidgets.QLineEdit, 'nameInput')
self.date_time_input: QtWidgets.QDateTimeEdit = self.findChild(
QtWidgets.QDateTimeEdit, 'dateTimeEdit')
if meeting is not None:
self.meeting_id_input.setText(meeting.meeting_id)
self.password_input.setText(meeting.password)
self.name_input.setText(meeting.name)
datetime = QDateTime(meeting.datetime)
else:
datetime = QDateTime.currentDateTime()
self.date_time_input.setDateTime(datetime)
def update_series(self, item: QStandardItem):
if item.column() == 5: # check for checkbox column
item_idx = item.index()
date = self.dish_data_table_model.data(item_idx.siblingAtColumn(1))
dish_name = self.dish_data_table_model.data(
item_idx.siblingAtColumn(2))
dish_price = self.dish_data_table_model.data(
item_idx.siblingAtColumn(3))
sell_num = self.dish_data_table_model.data(
item_idx.siblingAtColumn(4))
set_name = dish_name + "(" + dish_price + ")"
key = str(
QDateTime(QDate.fromString(date,
"yyyy-MM-dd")).toSecsSinceEpoch())
if key not in self.graph_series:
self.graph_series[key] = {}
if int(item.text()) == 0:
if set_name in self.graph_series[key]:
del self.graph_series[key][set_name]
if not self.graph_series[key]:
del self.graph_series[key]
else:
self.graph_series[key][set_name] = int(sell_num)
def data(self, index, role):
source_index = self.mapToSource(index)
source_data = self.sourceModel().data(source_index, role)
expiration_col = self.sourceModel().columns_ids.index('expiration')
expiration_index = self.sourceModel().index(source_index.row(),
expiration_col)
expiration_data = self.sourceModel().data(expiration_index,
Qt.DisplayRole)
current_time = QDateTime().currentDateTime().toMSecsSinceEpoch()
sig_validity = self.community.parameters['sigValidity']
warning_expiration_time = int(sig_validity / 3)
#logging.debug("{0} > {1}".format(current_time, expiration_data))
if expiration_data is not None:
will_expire_soon = (current_time > expiration_data * 1000 -
warning_expiration_time * 1000)
if role == Qt.DisplayRole:
if source_index.column() == self.sourceModel().columns_ids.index('renewed') \
or source_index.column() == self.sourceModel().columns_ids.index('expiration'):
if source_data is not None:
return QLocale.toString(
QLocale(),
QDateTime.fromTime_t(source_data).date(),
QLocale.dateFormat(QLocale(), QLocale.ShortFormat))
else:
return ""
if source_index.column() == self.sourceModel().columns_ids.index(
'pubkey'):
return "pub:{0}".format(source_data[:5])
if role == Qt.ForegroundRole:
if expiration_data:
if will_expire_soon:
return QColor(Qt.red)
else:
return QColor(Qt.blue)
return source_data
def set_settings(self):
if self.traffic_id:
query = """SELECT Position, Data, Table_Data, Note FROM staff_worker_traffic WHERE Id = %s"""
sql_traffic = my_sql.sql_select(query, (self.traffic_id, ))
if "mysql.connector.errors" in str(type(sql_traffic)):
QMessageBox.critical(self, "Ошибка sql получения записей",
sql_traffic.msg, QMessageBox.Ok)
return False
self.le_position.setText(str(sql_traffic[0][0]))
self.dt_date.setDateTime(sql_traffic[0][1])
self.le_note.setText(sql_traffic[0][3])
if sql_traffic[0][2]:
self.dt_tabel_date.setDateTime(sql_traffic[0][2])
else:
min = sql_traffic[0][1].minute
if 0 <= min <= 15:
tab_date = sql_traffic[0][1].replace(minute=0)
elif 16 <= min <= 45:
tab_date = sql_traffic[0][1].replace(minute=30)
else:
tab_date = sql_traffic[0][1].replace(minute=0)
hour_up = sql_traffic[0][1].hour + 1
if hour_up < 24:
tab_date = tab_date.replace(hour=hour_up)
else:
day = sql_traffic[0][1].day
tab_date = tab_date.replace(day=day + 1,
hour=hour_up - 24)
self.dt_tabel_date.setDateTime(tab_date)
else:
date = self.select_date or QDateTime.currentDateTime()
datetime = QDateTime(date, QTime.currentTime())
self.dt_date.setDateTime(datetime)
self.dt_tabel_date.setDateTime(datetime)
def extractProfileCropsterXLS(file):
res = {} # the interpreted data set
book = xlrd.open_workbook(file)
sheet_names = book.sheet_names()
# extract general profile information
general_sh = book.sheet_by_index(0)
if general_sh.nrows >= 1:
general_data = dict(
zip([x.value for x in general_sh.row(0)], general_sh.row(1)))
if 'Id-Tag' in general_data:
try:
id_tag = general_data['Id-Tag'].value
batch_prefix = id_tag.rstrip('0123456789')
batch_number = int(id_tag[len(batch_prefix):])
res["roastbatchprefix"] = batch_prefix
res["roastbatchnr"] = batch_number
except:
pass
for tag, label in zip([
'Profile', 'Lot name', 'Machine', 'Roast technician',
'Sensorial notes', 'Roasting notes'
], [
'title', 'beans', 'roastertype', 'operator', 'cuppingnotes',
'roastingnotes'
]):
if tag in general_data:
try:
value = str(general_data[tag].value)
res[label] = value
except:
pass
if 'Date' in general_data:
try:
raw_date = general_data['Date'].value
date_tuple = xlrd.xldate_as_tuple(raw_date, book.datemode)
date = QDateTime(*date_tuple)
res["roastdate"] = encodeLocal(date.date().toString())
res["roastisodate"] = encodeLocal(date.date().toString(
Qt.ISODate))
res["roasttime"] = encodeLocal(date.time().toString())
res["roastepoch"] = int(date.toTime_t())
res["roasttzoffset"] = libtime.timezone
except:
pass
if 'Ambient temp.' in general_data:
try:
value = general_data['Ambient temp.'].value
res['ambientTemp'] = float(value)
except:
pass
if 'Start weight' in general_data or 'End weight' in general_data:
cropster_weight_units = ["G", "KG", "LBS", "OZ"]
artisan_weight_units = ["g", "Kg", "lb", "oz"]
weight = [0, 0, artisan_weight_units[0]]
try:
value = general_data['End weight unit'].value
idx = cropster_weight_units.index(value)
weight[2] = artisan_weight_units[idx]
except:
pass
try:
value = general_data['Start weight unit'].value
idx = cropster_weight_units.index(value)
weight[2] = artisan_weight_units[idx]
except:
pass
try:
value = general_data['Start weight'].value
weight[0] = value
except:
pass
try:
value = general_data['End weight'].value
weight[1] = value
except:
pass
res["weight"] = weight
# BT:
try:
BT_idx = sheet_names.index("Curve - Bean temp.")
BT_sh = book.sheet_by_index(BT_idx)
if BT_sh.ncols >= 1:
time = BT_sh.col(0)
temp = BT_sh.col(1)
if len(time) > 0 and len(temp) > 0 and len(time) == len(temp):
if "FAHRENHEIT" in str(temp[0].value):
res["mode"] = 'F'
else:
res["mode"] = 'C'
res["timex"] = [t.value for t in time[1:]]
res["temp2"] = [t.value for t in temp[1:]]
res["temp1"] = [-1] * len(res["timex"])
res["timeindex"] = [0, 0, 0, 0, 0, 0, len(res["timex"]) - 1, 0]
except:
pass
# ET
try:
ET_idx = sheet_names.index("Curve - Env. temp.")
ET_sh = book.sheet_by_index(ET_idx)
if ET_sh.ncols >= 1:
time = ET_sh.col(0)
temp = ET_sh.col(1)
if len(time) > 0 and len(temp) > 0 and len(time) == len(temp):
if "FAHRENHEIT" in str(temp[0].value):
res["mode"] = 'F'
else:
res["mode"] = 'C'
res["temp1"] = [t.value for t in temp[1:]]
if len(res["timex"]) != len(res["temp1"]):
res["timex"] = [t.value for t in time[1:]]
if "temp2" not in res or len(res["temp2"]) != len(
res["timex"]):
res["temp2"] = [-1] * len(res["timex"])
res["timeindex"] = [0, 0, 0, 0, 0, 0, len(res["timex"]) - 1, 0]
except:
pass
# extra temperature curves
channel = 1 # toggle between channel 1 and 2 to be filled with extra temperature curve data
for sn in sheet_names:
if sn.startswith(
"Curve"
) and "temp." in sn and sn != "Curve - Bean temp." and sn != "Curve - Env. temp.":
try:
extra_curve_name = sn.split("Curve - ")
if len(extra_curve_name) > 1:
extra_curve_name = extra_curve_name[1].split("temp.")
extra_curve_name = extra_curve_name[0]
else:
extra_curve_name = extra_curve_name[0]
CT_idx = sheet_names.index(sn)
CT_sh = book.sheet_by_index(CT_idx)
if CT_sh.ncols >= 1:
time = CT_sh.col(0)
temp = CT_sh.col(1)
if len(time) > 0 and len(temp) > 0 and len(time) == len(
temp):
if "extradevices" not in res:
res["extradevices"] = []
if "extraname1" not in res:
res["extraname1"] = []
if "extraname2" not in res:
res["extraname2"] = []
if "extratimex" not in res:
res["extratimex"] = []
if "extratemp1" not in res:
res["extratemp1"] = []
if "extratemp2" not in res:
res["extratemp2"] = []
if "extramathexpression1" not in res:
res["extramathexpression1"] = []
if "extramathexpression2" not in res:
res["extramathexpression2"] = []
if channel == 1:
channel = 2
res["extradevices"].append(25)
res["extraname1"].append(extra_curve_name)
res["extratimex"].append(
[t.value for t in time[1:]])
res["extratemp1"].append(
[t.value for t in temp[1:]])
res["extramathexpression1"].append("")
elif (len(time) - 1) == len(
res["extratimex"][-1]
): # only if time lengths is same as of channel 1
channel = 1
res["extraname2"].append(extra_curve_name)
res["extratemp2"].append(
[t.value for t in temp[1:]])
res["extramathexpression2"].append("")
except:
pass
if "extraname1" in res and "extraname2" in res and len(
res["extraname1"]) != len(res["extraname2"]):
# we add an empty second extra channel if needed
res["extraname2"].append("Extra 2")
res["extratemp2"].append([-1] * len(res["extratemp1"][-1]))
res["extramathexpression2"].append("")
# add events
try:
COMMENTS_idx = sheet_names.index("Comments")
COMMENTS_sh = book.sheet_by_index(COMMENTS_idx)
gas_event = False # set to True if a Gas event exists
airflow_event = False # set to True if an Airflow event exists
specialevents = []
specialeventstype = []
specialeventsvalue = []
specialeventsStrings = []
if COMMENTS_sh.ncols >= 4:
takeClosest = lambda num, collection: min(
collection, key=lambda x: abs(x - num))
for r in range(COMMENTS_sh.nrows):
if r > 0:
try:
time = COMMENTS_sh.cell(r, 0).value
comment_type = COMMENTS_sh.cell(r, 2).value
if comment_type not in [
"Turning point"
]: # TP is ignored as it is automatically assigned
comment_value = COMMENTS_sh.cell(r, 3).value
c = takeClosest(time, res["timex"])
timex_idx = res["timex"].index(c)
if comment_type == "Color change":
res["timeindex"][1] = timex_idx
elif comment_type == "First crack":
res["timeindex"][2] = timex_idx
elif comment_type == "Second crack":
res["timeindex"][4] = timex_idx
else:
specialevents.append(timex_idx)
if comment_type == "Airflow":
airflow_event = True
specialeventstype.append(0)
elif comment_type == "Gas":
gas_event = True
specialeventstype.append(3)
else:
specialeventstype.append(4)
try:
v = float(comment_value)
v = v / 10. + 1
specialeventsvalue.append(v)
except:
specialeventsvalue.append(0)
if comment_type not in [
"Airflow", "Gas", "Comment"
]:
specialeventsStrings.append(comment_type)
else:
specialeventsStrings.append(comment_value)
except:
pass
if len(specialevents) > 0:
res["specialevents"] = specialevents
res["specialeventstype"] = specialeventstype
res["specialeventsvalue"] = specialeventsvalue
res["specialeventsStrings"] = specialeventsStrings
if gas_event or airflow_event:
# first set etypes to defaults
res["etypes"] = [
QApplication.translate("ComboBox", "Air", None),
QApplication.translate("ComboBox", "Drum", None),
QApplication.translate("ComboBox", "Damper", None),
QApplication.translate("ComboBox", "Burner", None), "--"
]
# update
if airflow_event:
res["etypes"][0] = "Airflow"
if gas_event:
res["etypes"][3] = "Gas"
except:
pass
return res
def drawChart(self):
conn=sqlite3.connect('emaildb.sqlite')
cur=conn.cursor()
title=self.lineEditProdName.text()
mall_url=self.farm_combo.currentText()
sql=f"select dt, jjim, sold, review from PROD3 where title='{title}'"
cur.execute(sql)
conn.commit()
rows=cur.fetchall()
series=[]
# series = QLineSeries(self)
series.append(QLineSeries(self))
series.append(QLineSeries(self))
series.append(QLineSeries(self))
tod=datetime.today()
nextday=datetime.today()+timedelta(days=1)
d=QDate(2020,1,3)
dt=QDateTime(d)
d2=d.addDays(1)
dt2=dt.addDays(1)
for i,row in enumerate(rows):
for j, serie in enumerate(series):
# serie.append((dt.addDays(i)).toMSecsSinceEpoch(),int(row[j+1]))
serie.append(i,int(row[j+1]))
for serie in series:
serie.setPointsVisible(True)
self.linechart.removeAllSeries()
self.linechart2.removeAllSeries()
self.linechart3.removeAllSeries()
self.linechart.addSeries(series[0])
self.linechart2.addSeries(series[1])
self.linechart3.addSeries(series[2])
dateAxis=QDateTimeAxis()
dateAxis2=QDateTimeAxis()
dateAxis3=QDateTimeAxis()
self.linechart.addAxis(dateAxis, Qt.AlignBottom)
self.linechart2.addAxis(dateAxis2, Qt.AlignBottom)
self.linechart3.addAxis(dateAxis3, Qt.AlignBottom)
self.linechart.createDefaultAxes()
self.linechart2.createDefaultAxes()
self.linechart3.createDefaultAxes()
self.linechart.setAnimationOptions(QChart.SeriesAnimations)
self.linechart.setTitle("찜")
self.linechart.legend().setVisible(True)
self.linechart2.setAnimationOptions(QChart.SeriesAnimations)
self.linechart2.setTitle("구매")
self.linechart2.legend().setVisible(True)
self.linechart3.setAnimationOptions(QChart.SeriesAnimations)
self.linechart3.setTitle("리뷰")
self.linechart3.legend().setVisible(True)
self.chartview.setRenderHint(QPainter.Antialiasing)
self.chartview2.setRenderHint(QPainter.Antialiasing)
self.chartview3.setRenderHint(QPainter.Antialiasing)
cur.close()
conn.close()
def pd2qtime(pdt):
'''Return a QDateTime from a time objet of Timestamp'''
pdt = pd.Timestamp(pdt)
return QDateTime(pdt.year, pdt.month, pdt.day, pdt.hour, pdt.minute,
pdt.second)
def initUI(self):
# Buttons
downloadButton = QPushButton("Download", self)
downloadButton.clicked.connect(self.downloadClick)
downloadButton.setEnabled(False)
closeButton = QPushButton("Close", self)
closeButton.clicked.connect(self.hide)
# Lists
self.egimList = QListWidget(self)
self.egimList.itemClicked.connect(self.loadInstruments)
self.egimList.setMaximumWidth(200)
self.instrumentList = QListWidget(self)
self.instrumentList.itemClicked.connect(self.loadParameters)
self.instrumentList.setMaximumWidth(290)
self.metadataList = QListWidget(self)
self.parameterList = QListWidget(self)
self.parameterList.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.parameterList.itemClicked.connect(
lambda: downloadButton.setEnabled(True))
self.dateList = QListWidget(self)
self.dateList.itemClicked.connect(self.loadTimes)
self.dateList.setMaximumWidth(150)
self.hourMinuteList = QListWidget(self)
self.hourMinuteList.itemClicked.connect(
lambda: downloadButton.setEnabled(True))
self.hourMinuteList.setMaximumWidth(150)
# Labels
egimLabel = QLabel("EGIM", self)
instrumentLabel = QLabel("Instrument", self)
metadataLabel = QLabel("Metadata", self)
parameterLabel = QLabel("Parameter", self)
startDateLabel = QLabel("Start date", self)
endDateLabel = QLabel("End date", self)
limitLabel = QLabel("Get last X values", self)
hourLabel = QLabel("Hour and minute (HHMM)", self)
dateLabel = QLabel("Available dates", self)
# Date edit
self.startDateEdit = QDateEdit(self)
self.startDateEdit.setCalendarPopup(True)
self.startDateEdit.setDateTime(QDateTime(QDate(2017, 1, 27),
QTime(0, 0, 0)))
self.startDateEdit.setMinimumDateTime(QDateTime(QDate(2017, 1, 27),
QTime(0, 0, 0)))
self.endDateEdit = QDateEdit(self)
self.endDateEdit.setCalendarPopup(True)
self.endDateEdit.setDateTime(QDateTime(QDate(2017, 1, 27),
QTime(0, 0, 0)))
self.endDateEdit.setMinimumDateTime(QDateTime(QDate(2017, 1, 27),
QTime(0, 0, 0)))
# Spin box
self.limitSpinBox = QSpinBox(self)
self.limitSpinBox.setMinimum(0)
self.limitSpinBox.setMaximum(9999999999)
self.limitSpinBox.setSingleStep(100)
self.limitSpinBox.valueChanged.connect(self.enableDate)
# Custom Widgets
# Widget for dates of the acoustic data
self.acousticDateWidget = QWidget(self)
# - Layout
vAcousticDate = QVBoxLayout()
vAcousticDate.addWidget(dateLabel)
vAcousticDate.addWidget(self.dateList)
vAcousticDate.addWidget(hourLabel)
vAcousticDate.addWidget(self.hourMinuteList)
self.acousticDateWidget.setLayout(vAcousticDate)
self.acousticDateWidget.setMaximumWidth(175)
self.acousticDateWidget.setEnabled(False)
# Widget for dates of parameters
self.parameterDateWidget = QWidget(self)
# - Layout
vparameterDate = QVBoxLayout()
vparameterDate.addWidget(startDateLabel)
vparameterDate.addWidget(self.startDateEdit)
vparameterDate.addWidget(endDateLabel)
vparameterDate.addWidget(self.endDateEdit)
vparameterDate.addWidget(limitLabel)
vparameterDate.addWidget(self.limitSpinBox)
vparameterDate.addStretch()
self.parameterDateWidget.setLayout(vparameterDate)
self.parameterDateWidget.setEnabled(False)
# Layout
# - Vertical layout for EGIM --
vEgim = QVBoxLayout()
vEgim.addWidget(egimLabel)
vEgim.addWidget(self.egimList)
# -- Vertical layout for instruments -
vInstrument = QVBoxLayout()
vInstrument.addWidget(instrumentLabel)
vInstrument.addWidget(self.instrumentList)
# - Vertical layout for parameters -
vParameter = QVBoxLayout()
vParameter.addWidget(metadataLabel)
vParameter.addWidget(self.metadataList)
vParameter.addWidget(parameterLabel)
vParameter.addWidget(self.parameterList)
# - Vertical layout for dates and buttons
vButton = QVBoxLayout()
vButton.addWidget(downloadButton)
vButton.addWidget(closeButton)
vButton.addStretch()
# - Layout of the frame -
hFrame = QHBoxLayout()
hFrame.addLayout(vEgim)
hFrame.addLayout(vInstrument)
hFrame.addLayout(vParameter)
hFrame.addWidget(self.parameterDateWidget)
hFrame.addWidget(self.acousticDateWidget)
hFrame.addLayout(vButton)
self.setLayout(hFrame)
def __installQtDoc(self, name, version, engine):
"""
Private method to install/update a Qt help document.
@param name name of the Qt help document (string)
@param version Qt version of the help documens (integer)
@param engine reference to the help engine (QHelpEngineCore)
@return flag indicating success (boolean)
"""
versionKey = "qt_version_{0}@@{1}".format(version, name)
info = engine.customValue(versionKey, "")
lst = info.split('|')
dt = QDateTime()
if len(lst) and lst[0]:
dt = QDateTime.fromString(lst[0], Qt.ISODate)
qchFile = ""
if len(lst) == 2:
qchFile = lst[1]
if version == 4:
docsPath = QDir(
QLibraryInfo.location(QLibraryInfo.DocumentationPath) +
QDir.separator() + "qch")
elif version == 5:
docsPath = QLibraryInfo.location(QLibraryInfo.DocumentationPath)
if (not os.path.isdir(docsPath)
or len(QDir(docsPath).entryList(["*.qch"])) == 0):
# Qt installer is a bit buggy; it's missing a symbolic link
docsPathList = QDir.fromNativeSeparators(docsPath).split("/")
docsPath = os.sep.join(
docsPathList[:-3] +
["Docs", "Qt-{0}.{1}".format(*qVersionTuple())])
docsPath = QDir(docsPath)
else:
# unsupported Qt version
return False
files = docsPath.entryList(["*.qch"])
if not files:
engine.setCustomValue(versionKey,
QDateTime().toString(Qt.ISODate) + '|')
return False
for f in files:
if f.startswith(name + "."):
fi = QFileInfo(docsPath.absolutePath() + QDir.separator() + f)
namespace = QHelpEngineCore.namespaceName(
fi.absoluteFilePath())
if not namespace:
continue
if (dt.isValid()
and namespace in engine.registeredDocumentations()
and (fi.lastModified().toString(Qt.ISODate)
== dt.toString(Qt.ISODate))
and qchFile == fi.absoluteFilePath()):
return False
if namespace in engine.registeredDocumentations():
engine.unregisterDocumentation(namespace)
if not engine.registerDocumentation(fi.absoluteFilePath()):
self.errorMessage.emit(
self.tr(
"""<p>The file <b>{0}</b> could not be"""
""" registered. <br/>Reason: {1}</p>""").format(
fi.absoluteFilePath, engine.error()))
return False
engine.setCustomValue(
versionKey,
fi.lastModified().toString(Qt.ISODate) + '|' +
fi.absoluteFilePath())
return True
return False
def date_changed(self, dc):
if dc == 1:
self.dt_end.setMinimumDateTime(QDateTime(self.dt_beg.dateTime()))
else:
self.dt_beg.setMaximumDateTime(QDateTime(self.dt_end.dateTime()))
def setupUi(self, qWidget):
qWidget.resize(600, 300)
self.qHBoxLayout = QtWidgets.QHBoxLayout(qWidget)
self.qGrounpBox1 = QtWidgets.QGroupBox(qWidget)
self.qGrounpBox1.setTitle("日期时间")
self.qGrounpBox2 = QtWidgets.QGroupBox(qWidget)
self.qGrounpBox2.setTitle("日历选择")
self.qGridLayout1 = QtWidgets.QGridLayout(self.qGrounpBox1)
self.qGridLayout2 = QtWidgets.QGridLayout(self.qGrounpBox2)
self.qPushButton1 = QtWidgets.QPushButton(self.qGrounpBox1)
self.qPushButton1.setText("读取当前日期时间")
self.qPushButton2 = QtWidgets.QPushButton(self.qGrounpBox1)
self.qPushButton2.setText("设置时间")
self.qPushButton3 = QtWidgets.QPushButton(self.qGrounpBox1)
self.qPushButton3.setText("设置日期")
self.qPushButton4 = QtWidgets.QPushButton(self.qGrounpBox1)
self.qPushButton4.setText("设置日期时间")
self.qLabel1 = QtWidgets.QLabel(self.qGrounpBox1)
self.qLabel1.setText("字符串显示")
self.qLabel1.setAlignment(Qt.AlignCenter)
self.qLabel2 = QtWidgets.QLabel(self.qGrounpBox1)
self.qLabel2.setText("时 间")
self.qLabel3 = QtWidgets.QLabel(self.qGrounpBox1)
self.qLabel3.setText("日 期")
self.qLabel4 = QtWidgets.QLabel(self.qGrounpBox1)
self.qLabel4.setText("日期时间")
self.qLineEdit1 = QtWidgets.QLineEdit(self.qGrounpBox1)
self.qLineEdit1.setInputMask("99:99:99;_")
self.qLineEdit2 = QtWidgets.QLineEdit(self.qGrounpBox1)
self.qLineEdit2.setInputMask("9999-99-99")
self.qLineEdit2.setMinimumSize(QSize(150, 0))
self.qLineEdit3 = QtWidgets.QLineEdit(self.qGrounpBox1)
self.qLineEdit3.setInputMask("9999-99-99 99:99:99")
self.qTimeEdit = QtWidgets.QTimeEdit(self.qGrounpBox1)
self.qTimeEdit.setDisplayFormat("hh:mm:ss")
self.qDateEdit = QtWidgets.QDateEdit(self.qGrounpBox1)
self.qDateEdit.setDisplayFormat("yyyy年MM月dd日")
self.qDateEdit.setCalendarPopup(True)
self.qDateTimeEdit = QtWidgets.QDateTimeEdit(self.qGrounpBox1)
self.qDateTimeEdit.setMinimumDateTime(QDateTime(1763, 9, 14, 0, 0, 0))
self.qDateTimeEdit.setMaximumDateTime(QDateTime(3000, 12, 31, 23, 59, 59))
self.qDateTimeEdit.setDisplayFormat("yyyy-MM-dd hh:mm:ss")
self.qDateTimeEdit.setCurrentSection(QDateTimeEdit.YearSection)
self.qLabel5 = QtWidgets.QLabel(self.qGrounpBox2)
self.qLabel5.setText("选择的日期：")
self.qLineEdit4 = QtWidgets.QLineEdit(self.qGrounpBox2)
self.qCalendarWidget = QtWidgets.QCalendarWidget(self.qGrounpBox2)
self.qHBoxLayout.addWidget(self.qGrounpBox1)
self.qHBoxLayout.addWidget(self.qGrounpBox2)
self.qGridLayout1.addWidget(self.qPushButton1, 0, 1, 1, 1)
self.qGridLayout1.addWidget(self.qLabel1, 0, 2, 1, 1)
self.qGridLayout1.addWidget(self.qLabel2, 1, 0, 1, 1)
self.qGridLayout1.addWidget(self.qTimeEdit, 1, 1, 1, 1)
self.qGridLayout1.addWidget(self.qLineEdit1, 1, 2, 1, 1)
self.qGridLayout1.addWidget(self.qPushButton2, 2, 2, 1, 1)
self.qGridLayout1.addWidget(self.qLabel3, 3, 0, 1, 1)
self.qGridLayout1.addWidget(self.qDateEdit, 3, 1, 1, 1)
self.qGridLayout1.addWidget(self.qLineEdit2, 3, 2, 1, 1)
self.qGridLayout1.addWidget(self.qPushButton3, 4, 2, 1, 1)
self.qGridLayout1.addWidget(self.qLabel4, 5, 0, 1, 1)
self.qGridLayout1.addWidget(self.qDateTimeEdit, 5, 1, 1, 1)
self.qGridLayout1.addWidget(self.qLineEdit3, 5, 2, 1, 1)
self.qGridLayout1.addWidget(self.qPushButton4, 6, 2, 1, 1)
self.qGridLayout2.addWidget(self.qLabel5, 0, 0, 1, 1)
self.qGridLayout2.addWidget(self.qLineEdit4, 0, 1, 1, 1)
self.qGridLayout2.addWidget(self.qCalendarWidget, 1, 0, 1, 2)
self.qLineEdit1.setObjectName("qLineEdit1")
self.qLineEdit2.setObjectName("qLineEdit2")
self.qLineEdit3.setObjectName("qLineEdit3")
self.qLineEdit4.setObjectName("qLineEdit4")
self.qPushButton1.setObjectName("qPushButton1")
self.qPushButton2.setObjectName("qPushButton2")
self.qPushButton3.setObjectName("qPushButton3")
self.qPushButton4.setObjectName("qPushButton4")
self.qTimeEdit.setObjectName("qTimeEdit")
self.qDateEdit.setObjectName("qDateEdit")
self.qDateTimeEdit.setObjectName("qDateTimeEdit")
self.qCalendarWidget.setObjectName("qCalendarWidget")
QtCore.QMetaObject.connectSlotsByName(qWidget)
############################ Init ##################################
self.qTimeEdit.setTime(QTime(15, 30, 55))
self.qDateEdit.setDate(QDate(2016, 11, 21))
self.qDateTimeEdit.setDateTime(QDateTime(2018, 10, 9, 8, 21, 28))
def __init__(self, url, custom, parent=None, default=False):
"""
Constructor
@param url AdBlock URL for the subscription (QUrl)
@param custom flag indicating a custom subscription (boolean)
@param parent reference to the parent object (QObject)
@param default flag indicating a default subscription (boolean)
"""
super(AdBlockSubscription, self).__init__(parent)
self.__custom = custom
self.__url = url.toEncoded()
self.__enabled = False
self.__downloading = None
self.__defaultSubscription = default
self.__title = ""
self.__location = QByteArray()
self.__lastUpdate = QDateTime()
self.__requiresLocation = ""
self.__requiresTitle = ""
self.__updatePeriod = 0 # update period in hours, 0 = use default
self.__remoteModified = QDateTime()
self.__rules = [] # list containing all AdBlock rules
self.__networkExceptionRules = []
self.__networkBlockRules = []
self.__domainRestrictedCssRules = []
self.__elementHidingRules = ""
self.__documentRules = []
self.__elemhideRules = []
self.__checksumRe = re.compile(
r"""^\s*!\s*checksum[\s\-:]+([\w\+\/=]+).*\n""",
re.IGNORECASE | re.MULTILINE)
self.__expiresRe = re.compile(
r"""(?:expires:|expires after)\s*(\d+)\s*(hour|h)?""",
re.IGNORECASE)
self.__remoteModifiedRe = re.compile(
r"""!\s*(?:Last modified|Updated):\s*(\d{1,2})\s*"""
r"""(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s*"""
r"""(\d{2,4})\s*((\d{1,2}):(\d{2}))?""", re.IGNORECASE)
self.__monthNameToNumber = {
"Jan": 1,
"Feb": 2,
"Mar": 3,
"Apr": 4,
"May": 5,
"Jun": 6,
"Jul": 7,
"Aug": 8,
"Sep": 9,
"Oct": 10,
"Nov": 11,
"Dec": 12
}
self.__parseUrl(url)
def setCurrentDate(self):
self.ui.deDate.setDate(QDate.currentDate())
self.displayedDate = QDateTime(self.ui.deDate.date())
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
