def save_configs(self):
self.statusBar().showMessage("保存配置")
configs = {"selected_signals": []}
# configs = {}
if self.checkbox_1.checkState() == 2:
configs["checkbox_1"] = True
configs["condition_signal"] = self.lineEdit.text()
configs["condition"] = self.condition_combox.currentText()
configs["lower_range"] = self.lower_range.text()
configs["upper_range"] = self.upper_range.text()
if self.checkbox_2.checkState() == 2:
configs["checkbox_2"] = True
configs["condition_signal_2"] = self.lineEdit_2.text()
configs["condition_2"] = self.condition_combox_2.currentText()
configs["lower_range_2"] = self.lower_range_2.text()
configs["upper_range_2"] = self.upper_range_2.text()
for i in range(self.selected_signals.count()):
configs["selected_signals"].append(
self.selected_signals.item(i).text())
filename, okpressed = QtWidgets.QInputDialog.getText(
self, "保存配置", "请输入文件名:", QtWidgets.QLineEdit.Normal, "")
if okpressed and filename.strip():
with open(filename + ".json", "w") as f:
json.dump(configs, f)
self.statusBar().showMessage(get_message())
def main():
days_data = 10 # 10 days of data.
minutes_data = 10 # Generate data every 10 minutes.
db_name = 'test'
try:
db_name = sys.argv[1]
logger.debug('Database name {} provided')
except:
logger.debug('No database name provided. Using "test"')
tags = {'region': 'Ensenada', 'host': 'localhost'}
db = influxdb.InfluxDBClient('localhost', 8086, 'root', 'root')
all_dbs_list = db.get_list_database()
if db_name not in [str(x['name']) for x in all_dbs_list]:
logger.warn('Database does not exist. Creating database {0}'.format(db_name))
db.create_database(db_name)
else:
logger.info('Reusing database {0}'.format(db_name))
db.switch_database(db_name)
print('Generating {} days worth of data. Data is commited every {} minutes.'.format(days_data, minutes_data))
print('Updating database with data. This could take a while. Please wait...')
for fields, t in generate_data(10, 10):
data = [message.get_message(fields, 'weather', t, tags)]
if db.write_points(data):
logger.debug('Writing {}'.format(data))
else:
logger.debug('Operation failed.')
print('Update is done.')
print('Check results in database {} with the following query: '.format(db_name))
print('SELECT * FROM "weather"')
def recv(self):
while self.connected:
message = None
try:
data = self.s.recv(1)
if data:
message = get_message(data)
if not message:
print("Message is of unknown type.")
continue
buf = bytearray()
while len(buf) < message.get_size():
buf += self.s.recv(min(self.BUFFER_SIZE, message.get_size() - len(buf)))
except socket.error as ex:
if socket.error == socket.timeout:
continue
print("Got socket error on recv - {0}".format(ex))
self.reconnect = True
self.disconnect()
break
if message:
message.from_bytes(buf)
if message.typebyte == MessageType.CLICK:
self.on_click_message(message.state)
print("Recv thread exiting")
def exec_(self):
while True:
msg = get_message(QUEUE_ID_GUI)
self.debug('RECV', msg)
msg_type = msg['type']
if msg_type == 'MOUSE_MOVE':
self.on_mouse_move(msg)
elif msg_type == 'MOUSE_PRESS':
self.on_mouse_press(msg)
elif msg_type == 'MOUSE_RELEASE':
self.on_mouse_release(msg)
elif msg_type == 'CREATE_WINDOW':
self.on_create_window(msg['sender'])
elif msg_type == 'GET_SCREEN_INFO':
self.on_get_screen_info(msg['pid'])
elif msg_type == 'PAINTED':
self.on_painted(msg['sender'])
elif msg_type == 'UPDATE':
self.paint_window(msg['sender'])
elif msg_type == 'OPEN_PROC':
self.open_proc(msg['name'])
elif msg_type == 'DESTROY':
self.on_destroy(msg['sender'])
elif msg_type == 'REGISTER_WINDOWS_CHANGE':
self.on_register_windows_change(msg['sender'])
else:
print 'Unknown', msg
async def on_request(channel, body, envelope, properties):
reply_message = message.get_message()
await channel.basic_publish(payload=reply_message.encode(),
exchange_name='',
routing_key=properties.reply_to,
properties={'correlation_id': properties.correlation_id})
await channel.basic_client_ack(delivery_tag=envelope.delivery_tag)
async def on_request(channel, body, envelope, properties):
reply_message = message.get_message()
await channel.basic_publish(payload=reply_message.encode(),
exchange_name='',
routing_key=properties.reply_to,
properties={'correlation_id': properties.correlation_id})
await channel.basic_client_ack(delivery_tag=envelope.delivery_tag)
def _recvthread(self):
last_signal = time.time()
self.ms = MorseStream()
while self.open:
try:
data = self.conn.recv(1)
if data:
message = get_message(data)
buf = bytearray()
while len(buf) < message.get_size():
buf += self.conn.recv(min(self.BUFFER_SIZE, message.get_size() - len(buf)))
message.from_bytes(buf)
self.message_callback(self, message)
except socket.error:
# better error handling here plox
print("Socket encountered error")
self.open = False
break
self.ms.add_pulse(not d[0], time.time() - last_signal)
last_signal = time.time()
self.close()
def insult(message, group_data, insult_type=''):
# logging.warning("message: "+ message['text']+", "+
# str(group_data['message_num']+1)+" / "+str(group_data['message_limit'])+
# "message_full: " +str(json.dumps(message))+", Chat: "+group_data['bot_id'])
ready = True
reset_message_data(group_data['index'])
msg, msg_type = m.get_message(message['name'], insult_type)
return ready, msg, msg_type
async def subscribe_handler(msg):
subject = msg.subject
reply = msg.reply
data = msg.data.decode()
# print("Received a message on '{subject} {reply}': {data}".format(
# subject=subject, reply=reply, data=data))
reply_message = message.get_message()
await nc.publish(reply, reply_message.encode())
async def subscribe_handler(msg):
subject = msg.subject
reply = msg.reply
data = msg.data.decode()
# print("Received a message on '{subject} {reply}': {data}".format(
# subject=subject, reply=reply, data=data))
reply_message = message.get_message()
await nc.publish(reply, reply_message.encode())
def get(self, _id):
'''
get special news
'''
# logger.info(self.request)
record = message.get_message(_id)
self.render('newsdetail.html', message=record)
def get(self, _id):
'''
get special news
'''
# logger.info(self.request)
record = message.get_message(_id)
self.render('newsdetail.html', message=record)
def render_msg(self, page):
_id = self.get_argument('id')
_message = message.get_message(_id)
news = message.get_messages(NIOT, 0, 0, 3, '', 0, 5)
if message:
self.render('newsdetail.html', _message=_message, news=news)
else:
self.render('news.html', news=news)
def render_msg(self, page):
_id = self.get_argument('id')
_message = message.get_message(_id)
news = message.get_messages(NIOT, 2, 0, 3, '', 0, 5)
if message:
self.render('newsdetail.html', _message=_message, news=news)
else:
self.render('news.html', news=news)
def openfiles(self):
self.statusBar().showMessage('打开多个文件')
self.all_signals.clear()
files, filetype = QtWidgets.QFileDialog.getOpenFileNames(
self, "选取文件", ".",
"MDF Files (*.dat *.mdf *.DAT *.MDF);;All Files (*)")
if not files:
self.statusBar().showMessage(get_message())
return
for filename in files:
if filename[-3:] in ["dat", "mdf", "DAT", "MDF"]:
self.filenames.append(filename)
# 把第一个文件里面的信号名加入到左下角的导出信号框中
filename = self.filenames[0]
self.mdf_file = MDF(filename, memory="minimum") #
signalnames = list(self.mdf_file.channels_db.keys())
signalnames.sort()
self.all_signals.addItems(signalnames)
self.statusBar().showMessage(get_message())
def main(video_mem, qt_callback):
put_message(QUEUE_ID_GUI, {
'type': 'GET_SCREEN_INFO',
'pid': Desktop.__name__
})
msg = get_message(Desktop.__name__)
width = msg['width']
height = msg['height']
wnd = Desktop(width, height)
wnd.exec_()
def reader(IPC_FIFO_NAME, start_time):
fifo = os.open(IPC_FIFO_NAME, os.O_RDONLY | os.O_NONBLOCK)
while True and (start_time + 3 > time.time()):
try:
msg = get_message(fifo)
return msg
except Exception as e:
if e != "unpack requires a buffer of 4 bytes":
assert True, "Error in reading message"
return None
def test_message():
msg = message.ClickMessage()
msg.state = True
msg.time = 1337.0
msg_bytes = msg.to_bytes()
assert len(msg_bytes) == msg.get_size() + 1
msg2 = message.get_message(msg_bytes[0])
msg2.from_bytes(msg_bytes[1:])
assert msg2.state == msg.state
assert msg2.time == msg.time
async def reader_for_async(process, IPC_FIFO_NAME):
fifo = os.open(IPC_FIFO_NAME, os.O_RDONLY | os.O_NONBLOCK)
run_flag = True
while True and run_flag:
try:
msg = get_message(fifo)
return msg
except Exception as e:
if e != "unpack requires a buffer of 4 bytes":
assert True, "Error in reading message"
run_flag = await async_is_processrunning(process)
return None
def morning():
user_id = config.USERID
try:
if request.method == 'POST':
data = request.data.decode('utf-8')
data = json.loads(data)
message = get_message(data)
line_bot_api.push_message(user_id, TextSendMessage(text=message))
return "OK"
except Exception as e:
print(e)
return str(e)
def test_get_message_not_exist(self):
"""Test message function get_message without existed hash message"""
query_string = {
"hash": "9520437ce8902eb379a7d8aaa98fc4c94eeb07b6684854868fa6f72bf34b0fd3"
}
try:
key = message.get_message(query_string["hash"])
# self.assertEqual(key[0]['err_msg'], 'Hash Message not found')
# self.assertEqual(key[1], 404)
print("\ntest_get_message_not_exist Done")
except:
print("Abort Exception")
pass
def __init__(self):
# 初始化
super(Window_test, self).__init__()
uic.loadUi("version_3_3_ui.ui", self)
self.condition_combox.addItems(["step", "range", ">", "<"])
self.condition_combox.setItemText(0, "step")
self.condition_combox_2.addItems(["step", "range", ">", "<"])
self.condition_combox_2.setItemText(0, "step")
self.condition_combox.activated[str].connect(self.condition_select)
self.condition_combox_2.activated[str].connect(self.condition_select)
self.file_open_button.clicked.connect(self.openfiles)
self.lower_range.setText("0")
self.upper_range.setText("0")
self.lower_range_2.setText("0")
self.upper_range_2.setText("0")
self.export_csv_button.clicked.connect(self.to_csv)
self.all_signals.itemDoubleClicked[QtWidgets.QListWidgetItem].connect(
self.select_signal)
self.selected_sig = set() # 选中的信号，不可重复选
self.selected_signals.itemDoubleClicked.connect(self.deselect_signal)
self.all_signals.addItem("hello")
self.lineEdit.setText("信号")
self.lineEdit_2.setText("信号")
# self.add_condition_combox_2.addItem("")
# self.add_condition_combox_2.setItemText(0, "信号")
# 等价于 self.add_condition_combox.addItem("信号")
# self.add_condition_combox.setMaxVisibleItems(20)
# self.add_condition_combox_2.setMaxVisibleItems(20)
self.checkbox_1.stateChanged.connect(self.check)
self.checkbox_2.stateChanged.connect(self.check)
self.check_flag_1 = 0
self.check_flag_2 = 0
self.statusBar().showMessage(get_message())
self.save_config.clicked.connect(self.save_configs)
self.load_config.clicked.connect(self.load_configs)
self.filenames = []
# self.add_condition_combox.setCompleter(self.completer)
# self.add_condition_combox_2.setCompleter(self.completer)
# QCompleter::UnfilteredPopupCompletion 1
# All possible completions are displayed in a popup window with the most likely suggestion indicated as current.
# 设置窗口图标
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap("000.ico"), QtGui.QIcon.Normal,
QtGui.QIcon.Off)
self.setWindowIcon(icon)
self.show()
def test_get_message(self):
"""Test message function get_message with existed hash message"""
query_string = {
"message": "FOO"
}
message.create_hash_sha256(query_string)
query_string = {
"hash": "9520437ce8902eb379a7d8aaa98fc4c94eeb07b6684854868fa6f72bf34b0fd3"
}
key = message.get_message(query_string["hash"])
self.assertEqual(key[0]["message"], 'FOO')
self.assertEqual(key[1], 200)
print("\ntest_get_message Done")
def write_csv(self, data_dict):
self.statusBar().showMessage("数据写入中...")
# for key in data_dict.keys():
# print(key, len(data_dict[key]))
try:
df = pd.DataFrame(data=data_dict)
except ValueError:
QtWidgets.QMessageBox.about(self, "Message", "某些信号采样值缺失")
self.statusBar().showMessage(get_message())
return
# 重新排序列，把timestamps排在第一列
timestamps = df['timestamps']
df.drop(labels=['timestamps'], axis=1, inplace=True)
df.insert(0, 'timestamps', timestamps)
# 保存的文件名
f_name = str(datetime.now()).split(".")[0].replace(":", "_",
2) + ".csv"
f = open(f_name, "w")
f.close()
df.to_csv(f_name, index=False, encoding="gb2312")
self.statusBar().showMessage("finished")
def load_configs(self):
self.statusBar().showMessage("导入筛选条件")
filename, filetype = QtWidgets.QFileDialog().getOpenFileName(
self, "选取文件", ".", "Json Files (*.json);;All Files (*)")
if filename:
with open(filename, "r") as f:
configs = json.load(f)
if "checkbox_1" in configs.keys():
self.checkbox_1.setCheckState(2)
self.lineEdit.setText(configs["condition_signal"])
self.condition_combox.setCurrentText(configs["condition"])
self.lower_range.setText(configs["lower_range"])
self.upper_range.setText(configs["upper_range"])
if "checkbox_2" in configs.keys():
self.checkbox_2.setCheckState(2)
self.lineEdit_2.setText(configs["condition_signal_2"])
self.condition_combox_2.setCurrentText(configs["condition_2"])
self.lower_range_2.setText(configs["lower_range_2"])
self.upper_range_2.setText(configs["upper_range_2"])
self.selected_sig = set(configs["selected_signals"])
self.selected_signals.addItems(list(self.selected_sig))
self.statusBar().showMessage(get_message())
def logOut(self, msg, mod=()):
try:
syslog.openlog(self.name, syslog.LOG_PID, syslog.LOG_LOCAL2)
"""
method designed for logging errors and events
INPUT:
- msg - structure consisting of loh message and its code
- mod - structure contains information additional to error message
OUTPUT: -
"""
sys_msg = get_message(msg)
if sys_msg:
msg = msg[0] % mod
exit_code = msg[1]
res = ""
if not exit_code:
log_arg = syslog.LOG_INFO
res = "success"
self.noerrs = True
else:
if exit_code == 1:
log_arg = syslog.LOG_ERR
elif exit_code == 2:
log_arg = syslog.LOG_WARNING
elif exit_code == 3:
log_arg = LOG_CRIT
res = "failed"
self.noerrs = False
print(sys_msg)
syslog.syslog(log_arg, "sype={} name={} message={} res={}".format(
self.sype_name, self.name, sys_msg, res))
syslog.closelog()
else:
pass
except KeyError:
log(syslog.LOG_CRIT, "Key ERROR IN SYSLOG")
except IndexError:
log(syslog.LOG_CRIT, "Index ERROR IN SYSLOG")
def decode(self, stream: MemoryStream):
self.length = stream.read_ubyte()
self.source_player = stream.read_ubyte()
self.type = stream.read_ubyte()
payload = self.length - self.header
if payload > 0:
self.data = stream.read(payload)
assert self.data and len(self.data) == payload
__share_stream__.position = 0
if self.data:
__share_stream__.write(self.data)
__share_stream__.position = 0
self.message = message.get_message(self.type)
self.message.decode(__share_stream__)
self.print(self.type, message.MessageType(self.type))
if self.id != 0:
print('[Action] {id=%d,size=%d} %s' %
(self.id, self.length, self.message))
else:
print(' [Action] uin:%d %s' % (self.source_player, self.message))
def test_message():
warning = "Message should be 'Hello World'"
assert "Hello" in message.get_message(), warning
async def handle(request):
reply_message = message.get_message()
response = {'message': reply_message}
return web.json_response(response)
def test_message():
warning = "Message should be 'Hello World'"
assert message.get_message() == 'Hello World', warning
async def handle_http(request):
reply_message = message.get_message()
response = {'message': reply_message}
return web.json_response(response)
def hello():
return message.get_message()
