def update_trips():
global trips, chargings, cached_layout
logger.info("update_data")
try:
trips_by_vin = Trips.get_trips(myp.vehicles_list)
trips = next(iter(trips_by_vin.values())) # todo handle multiple car
chargings = MyPSACC.get_chargings()
except StopIteration:
logger.debug("No trips yet")
return
except AssertionError:
logger.error("update_trips: %s", traceback.format_exc())
# update for slider
global min_date, max_date, min_millis, max_millis, step, marks
try:
min_date = trips[0].start_at
max_date = trips[-1].start_at
min_millis = figures.unix_time_millis(min_date)
max_millis = figures.unix_time_millis(max_date)
step = (max_millis - min_millis) / 100
marks = figures.get_marks_from_start_end(min_date, max_date)
cached_layout = None # force regenerate layout
except (ValueError, IndexError):
logger.error("update_trips (slider): %s", traceback.format_exc())
return
def wakeup(self, vin):
logger.info("ask wakeup to " + vin)
msg = self.mqtt_request(vin, {"action": "state"})
logger.info(msg)
self.mqtt_client.publish(
MQTT_REQ_TOPIC + self.customer_id + "/VehCharge/state", msg)
return True
def wakeup(self, vin):
msg = self.mqtt_request(vin, {"action": "state"})
logger.info(msg)
self.mqtt_client.publish(
"psa/RemoteServices/from/cid/" + self.customer_id +
"/VehCharge/state", msg)
return True
def get_state(self, vin):
logger.info("ask state to " + vin)
msg = self.mqtt_request(vin, {"action": "state"})
logger.info(msg)
self.mqtt_client.publish(
MQTT_REQ_TOPIC + self.customer_id + "/VehicleState", msg)
return True
def __init__(self, workerNum):
self.worker_num = workerNum
logger.info('Creating {} workers'.format(self.worker_num))
self.workers = []
for i in range(self.worker_num):
worker = Worker(i)
self.workers.append(worker)
def generate_player_position(generated_map):
"""
Generates random position for player
:param list generated_map: list with generated empty cells, traps and treasures
:return: generated map with placed player
:rtype: list
"""
logger.debug('Entered generate_player_position(generated_map) function')
generated_map_with_player = generated_map
player_position = 0
logger.info('Generating player position')
while True:
player_position = randrange(len(generated_map_with_player))
if generated_map_with_player[player_position] == EMPTY_CELL:
generated_map_with_player[player_position] = PLAYER
break
logger.debug('Returning generated_map_with_player')
return generated_map_with_player
def eval(self, check_result=False):
# set model to evaluation(testing) mode
self.model.eval()
test_predictions, test_truth = None, None
for batch_idx, batch in enumerate(self.test_loader):
# prepare data
avi_feats, ground_truths, lengths = batch
if self.__CUDA__:
avi_feats, ground_truths = avi_feats.cuda(), ground_truths.cuda()
avi_feats, ground_truths = Variable(avi_feats), Variable(ground_truths)
# start inferencing process
seq_logProb, seq_predictions = self.model(avi_feats, mode='inference')
ground_truths = ground_truths[:, 1:]
test_predictions = seq_predictions[:3]
test_truth = ground_truths[:3]
break
# TODO: testing only pls remove after testing
if check_result:
result = [' '.join(self.helper.index2sentence(s)) for s in test_predictions]
logger.info('Testing Result: \n{} \n{}\n{}\n'.format(result[0], result[1], result[2]))
truth = [' '.join(self.helper.index2sentence(s)) for s in test_truth]
logger.info('Ground Truth: \n{} \n{}\n{}\n'.format(truth[0], truth[1], truth[2]))
def on_mqtt_message(self, client, userdata, msg):
try:
logger.info("mqtt msg %s %s", msg.topic, msg.payload)
data = json.loads(msg.payload)
charge_info = None
if msg.topic.startswith(MQTT_RESP_TOPIC):
if "return_code" not in data:
logger.debug("mqtt msg hasn't return code")
elif data["return_code"] == "400":
self.refresh_remote_token(force=True)
logger.error("retry last request, token was expired")
elif data["return_code"] == "300":
logger.error('%d', data["return_code"])
elif data["return_code"] != "0":
logger.error('%s : %s', data["return_code"],
data["reason"])
if msg.topic.endswith("/VehicleState"):
charge_info = data["resp_data"]["charging_state"]
self.precond_programs[data["vin"]] = data["resp_data"][
"precond_state"]["programs"]
elif msg.topic.startswith(MQTT_EVENT_TOPIC):
charge_info = data["charging_state"]
if charge_info is not None and charge_info[
'remaining_time'] != 0 and charge_info['rate'] == 0:
# fix a psa server bug where charge beginning without status api being properly updated
logger.warning("charge begin but API isn't updated")
sleep(60)
self.wakeup(data["vin"])
except KeyError:
logger.error(traceback.format_exc())
def on_mqtt_message(self, client, userdata, msg):
charge_not_detected = False
try:
logger.info(f"mqtt msg {msg.topic} {str(msg.payload)}")
data = json.loads(msg.payload)
if msg.topic.startswith(MQTT_RESP_TOPIC):
if "return_code" in data:
if data["return_code"] == "0":
pass
elif data["return_code"] == "400":
self.refresh_remote_token(force=True)
logger.error("retry last request, token was expired")
else:
logger.error(
f'{data["return_code"]} : {data["reason"]}')
else:
logger.debug("mqtt msg hasn't return code")
if msg.topic.startswith(MQTT_EVENT_TOPIC):
if data["charging_state"]['remaining_time'] != 0 and data[
"charging_state"]['rate'] == 0:
charge_not_detected = True
elif msg.topic.endswith("/VehicleState"):
if data["resp_data"]["charging_state"]['remaining_time'] != 0 \
and data["resp_data"]["charging_state"]['rate'] == 0:
charge_not_detected = True
if charge_not_detected:
# fix a psa server bug where charge beginning without status api being properly updated
logger.info("charge begin")
sleep(60)
self.wakeup(data["vin"])
except:
logger.error(traceback.format_exc())
def on_mqtt_message(self, client, userdata, msg):
try:
logger.info(f"mqtt msg {msg.topic} {str(msg.payload)}")
data = json.loads(msg.payload)
if msg.topic.startswith(MQTT_RESP_TOPIC):
if "return_code" in data:
if data["return_code"] == "0":
return
elif data["return_code"] == "400":
self.refresh_remote_token(force=True)
logger.error("retry last request, token was expired")
else:
logger.error(
f'{data["return_code"]} : {data["reason"]}')
else:
logger.debug("mqtt msg hasn't return code")
elif msg.topic.startswith(MQTT_EVENT_TOPIC):
# fix charge beginning without status api being updated
if data["charging_state"]['remaining_time'] != 0 and data[
"charging_state"]['rate'] == 0:
logger.info("charge begin")
sleep(60)
self.wakeup(data["vin"])
except:
logger.error(traceback.format_exc())
def lights(self, vin, duration: int):
msg = self.mqtt_request(vin, {
"action": "activate",
"duration": duration
})
logger.info(msg)
self.mqtt_client.publish(MQTT_REQ_TOPIC + self.customer_id + "/Lights",
msg)
def lights(self, vin, duration: int):
msg = self.mqtt_request(vin, {
"action": "activate",
"duration": duration
})
logger.info(msg)
self.mqtt_client.publish(
"psa/RemoteServices/from/cid/" + self.customer_id + "/Lights", msg)
def update_trips():
global trips, chargings
logger.info("update_data")
try:
trips = MyPSACC.get_trips()
chargings = MyPSACC.get_chargings()
except:
logger.error("update_trips: " + traceback.format_exc())
def on_mqtt_connect(self, client, userdata, rc, a):
logger.info("Connected with result code %s", rc)
topics = [MQTT_RESP_TOPIC + self.customer_id + "/#"]
for car in self.vehicles_list:
topics.append(MQTT_EVENT_TOPIC + car.vin)
for topic in topics:
client.subscribe(topic)
logger.info("subscribe to %s", topic)
def refresh_vehicle_info(self):
if self.info_refresh_rate is not None:
while True:
sleep(self.info_refresh_rate)
logger.info("refresh_vehicle_info")
for car in self.vehicles_list:
self.get_vehicle_info(car.vin)
for callback in self.info_callback:
callback()
def _is_token_expired(response: Response) -> bool:
if response.status_code == HTTPStatus.UNAUTHORIZED.value:
logger.info("token expired, renew")
try:
json_data = response.json()
return json_data.get('moreInformation') == 'Token is invalid'
except ValueError:
return False
else:
return False
def start(self):
periodicity = ChargeControl.periodicity
now = datetime.now()
try:
if self._next_stop_hour is not None and self._next_stop_hour < now:
stop_charge = True
self._next_stop_hour += timedelta(days=1)
logger.info("it's time to stop the charge")
else:
stop_charge = False
if self.percentage_threshold != 100 or stop_charge:
res = None
try:
res = self.psacc.get_vehicle_info(self.vin)
except ApiException:
logger.error(traceback.format_exc())
if res is not None:
status = res.energy[0]['charging']['status']
level = res.energy[0]["level"]
logger.info(
f"charging status of {self.vin} is {status}, battery level: {level}"
)
if status == "InProgress":
# force update if the car doesn't send info during 10 minutes
last_update = datetime.strptime(
res.energy[0]['updatedAt'], "%Y-%m-%dT%H:%M:%SZ")
if (datetime.utcnow() -
last_update).total_seconds() > 60 * 10:
self.psacc.wakeup(self.vin)
if (level >= self.percentage_threshold
and self.retry_count < 2) or stop_charge:
self.psacc.charge_now(self.vin, False)
self.retry_count += 1
sleep(ChargeControl.MQTT_TIMEOUT)
res = self.psacc.get_vehicle_info(self.vin)
status = res.energy[0]['charging']['status']
if status == "InProgress":
logger.warn(
f"retry to stop the charge of {self.vin}")
self.psacc.charge_now(self.vin, False)
self.retry_count += 1
if self._next_stop_hour is not None:
next_in_second = (self._next_stop_hour -
now).total_seconds()
if next_in_second < periodicity:
periodicity = next_in_second
else:
self.retry_count = 0
else:
logger.error(f"error when get vehicle info of {self.vin}")
except:
logger.error(traceback.format_exc())
self.thread = threading.Timer(periodicity, self.start)
self.thread.start()
def lock_door(self, vin, lock: bool):
if lock:
value = "lock"
else:
value = "unlock"
msg = self.mqtt_request(vin, {"action": value})
logger.info(msg)
self.mqtt_client.publish(MQTT_REQ_TOPIC + self.customer_id + "/Doors",
msg)
return True
def save_config(self, name="config.json", force=False):
config_str = json.dumps(self,
cls=MyPeugeotEncoder,
sort_keys=True,
indent=4).encode("utf8")
new_hash = md5(config_str).hexdigest()
if force or self._confighash != new_hash:
with open(name, "wb") as f:
f.write(config_str)
self._confighash = new_hash
logger.info("save config change")
def lock_door(self, vin, lock: bool):
if lock:
value = "lock"
else:
value = "unlock"
msg = self.mqtt_request(vin, {"action": value})
logger.info(msg)
self.mqtt_client.publish(
"psa/RemoteServices/from/cid/" + self.customer_id + "/Doors", msg)
return True
def on_mqtt_connect(self, client, userdata, rc, a):
try:
logger.info("Connected with result code " + str(rc))
topics = [MQTT_RESP_TOPIC + self.customer_id + "/#"]
for vin in self.getVIN():
topics.append(MQTT_EVENT_TOPIC + vin)
for topic in topics:
client.subscribe(topic)
logger.info("subscribe to " + topic)
except:
logger.error(traceback.format_exc())
def charge_control():
logger.info(request)
vin = request.args['vin']
charge_control = chc.get(vin)
if charge_control is None:
return jsonify("error: VIN not in list")
if 'hour' in request.args and 'minute' in request.args:
charge_control.set_stop_hour([int(request.args["hour"]), int(request.args["minute"])])
if 'percentage' in request.args:
charge_control.percentage_threshold = int(request.args['percentage'])
chc.save_config()
return jsonify(charge_control.get_dict())
def on_mqtt_connect(self, client, userdata, rc, a):
try:
logger.info("Connected with result code " + str(rc))
topics = ["psa/RemoteServices/to/cid/" + self.customer_id + "/#"]
for vin in self.getVIN():
topics.append("psa/RemoteServices/events/MPHRTServices/" +
vin + "/#")
for topic in topics:
client.subscribe(topic)
logger.info("subscribe to " + topic)
except:
logger.error(traceback.format_exc())
def run(self):
self.worker_mgr = WorkerManager(self.config.getWorkerNum())
self.worker_mgr.execute()
self.createTasks()
while self.getTotalTask() != Stat.finished_tasks.value:
logger.info(
'Task still running {}/{}. Waiting for another 3 seconds'.
format(Stat.finished_tasks.value, self.getTotalTask()))
time.sleep(3)
logger.info('Now sleep 3 seconds and stop all workers')
time.sleep(3)
StopSignal.stop_workers.get_and_set(1)
def veh_charge_request(self, vin, hour, miinute, charge_type):
# todo consider actual state before change the hour
msg = self.mqtt_request(vin, {
"program": {
"hour": hour,
"minute": miinute
},
"type": charge_type
})
logger.info(msg)
self.mqtt_client.publish(
MQTT_REQ_TOPIC + self.customer_id + "/VehCharge", msg)
def save_config(self, force=False):
chd = {}
charge_control: ChargeControl
for charge_control in self.values():
chd[charge_control.vin] = {"percentage_threshold": charge_control.percentage_threshold,
"stop_hour": charge_control.get_stop_hour()}
config_str = json.dumps(chd, sort_keys=True, indent=4).encode('utf-8')
new_hash = md5(config_str).hexdigest()
if force or self._config_hash != new_hash:
with open(self.file_name, "wb") as f:
f.write(config_str)
self._config_hash = new_hash
logger.info("save config change")
def run(self):
while True:
stop = StopSignal.stop_workers.value
if stop:
break
try:
task = Stat.task_queue.get(block=True, timeout=3)
except queue.Empty:
continue
logger.info('Worker {} is executing task {}'.format(
self.id, task.id))
task.execute()
logger.info("Worker stopped: {}".format(self.id))
def createTasks(self):
choice = self.weight_choice()
task_id = 0
for nth_sec in range(self.config.getRuntime()):
logger.info('Creating tasks at {} sec'.format(nth_sec))
for ith_task in range(self.config.getQPS()):
task_type = random.choice(choice)
task_id = task_id + 1
logger.info('Creating tasks {}:{}'.format(task_id, task_type))
task = self.createTask(task_id, task_type)
Stat.gen_tasks += 1
Stat.task_queue.put(task)
time.sleep(1)
def save_config(self, name="charge_config.json", force=False):
chd = {}
for key, el in self.list.items():
chd[el.vin] = {
"percentage_threshold": el.percentage_threshold,
"stop_hour": el._stop_hour
}
config_str = json.dumps(chd, sort_keys=True, indent=4).encode('utf-8')
new_hash = md5(config_str).hexdigest()
if force or self._confighash != new_hash:
with open(name, "wb") as f:
f.write(config_str)
self._confighash = new_hash
logger.info("save config change")
def on_mqtt_message(self, client, userdata, msg):
logger.info(f"mqtt msg {msg.topic} {str(msg.payload)}")
try:
data = json.loads(msg.payload)
if data["return_code"] == "0":
return
elif data["return_code"] == "400":
self.manager._refresh_token()
self.refresh_remote_token()
logger.info("retry last request")
else:
logger.error(f'{data["return_code"]} : {data["reason"]}')
except:
logger.debug("mqtt msg hasn't return code")
