def record_charging(self, vin, charging_status, charge_date, level,
latitude, longitude):
conn = get_db()
if charging_status == "InProgress":
try:
in_progress = conn.execute(
"SELECT stop_at FROM battery WHERE VIN=? ORDER BY start_at DESC limit 1",
(vin, )).fetchone()[0] is None
except TypeError:
in_progress = False
if not in_progress:
conn.execute(
"INSERT INTO battery(start_at,start_level,VIN) VALUES(?,?,?)",
(charge_date, level, vin))
conn.commit()
else:
try:
start_at, stop_at, start_level = conn.execute(
"SELECT start_at, stop_at, start_level from battery WHERE VIN=? ORDER BY start_at "
"DESC limit 1", (vin, )).fetchone()
in_progress = stop_at is None
if in_progress:
co2_per_kw = Ecomix.get_co2_per_kw(start_at, charge_date,
latitude, longitude)
kw = (level - start_level
) / 100 * self.vehicles_list.get_car_by_vin(
vin).battery_power
conn.execute(
"UPDATE battery set stop_at=?, end_level=?, co2=?, kw=? WHERE start_at=? and VIN=?",
(charge_date, level, co2_per_kw, kw, start_at, vin))
conn.commit()
except TypeError:
logger.debug("battery table is empty")
conn.close()
def load_otp():
try:
with open("otp.bin", 'rb') as input:
return pickle.load(input)
except:
logger.debug(traceback.format_exc())
return None
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 refresh_remote_token(self, force=False):
if not force and self.remote_token_last_update is not None:
last_update: datetime = self.remote_token_last_update
if (datetime.now() - last_update).total_seconds() < MQTT_TOKEN_TTL:
return
self.manager._refresh_token()
res = self.manager.post(remote_url + self.client_id,
json={
"grant_type": "refresh_token",
"refresh_token": self.remote_refresh_token
},
headers=self.headers)
data = res.json()
logger.debug(f"refresh_remote_token: {data}")
if "access_token" in data:
self.remote_access_token = data["access_token"]
self.remote_refresh_token = data["refresh_token"]
self.remote_token_last_update = datetime.now()
else:
logger.error(
f"can't refresh_remote_token: {data}\n Create a new one")
self.remote_token_last_update = datetime.now()
otp_code = self.getOtpCode()
res = self.get_remote_access_token(otp_code)
self.mqtt_client.username_pw_set("IMA_OAUTH_ACCESS_TOKEN",
self.remote_access_token)
return res
def record_position(self, vin, mileage, latitude, longitude, date, level,
level_fuel, moving):
conn = get_db()
if mileage == 0: # fix a bug of the api
logger.error("The api return a wrong mileage for %s : %f", vin,
mileage)
else:
if conn.execute("SELECT Timestamp from position where Timestamp=?",
(date, )).fetchone() is None:
temp = get_temp(latitude, longitude, self.weather_api)
if level_fuel == 0: # fix fuel level not provided when car is off
try:
level_fuel = conn.execute(
"SELECT level_fuel FROM position WHERE level_fuel>0 AND VIN=? ORDER BY Timestamp DESC "
"LIMIT 1", (vin, )).fetchone()[0]
logger.info(
"level_fuel fixed with last real value %f for %s",
level_fuel, vin)
except TypeError:
level_fuel = None
logger.info("level_fuel unfixed for %s", vin)
conn.execute(
"INSERT INTO position(Timestamp,VIN,longitude,latitude,mileage,level,level_fuel,moving,"
"temperature) VALUES(?,?,?,?,?,?,?,?,?)",
(date, vin, longitude, latitude, mileage, level,
level_fuel, moving, temp))
conn.commit()
logger.info("new position recorded for %s", vin)
clean_position(conn)
else:
logger.debug("position already saved")
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("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 load_otp(filename="otp.bin"):
try:
with open(filename, 'rb') as input_file:
return pickle.load(input_file)
except FileNotFoundError:
logger.debug(traceback.format_exc())
return None
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 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 load_cars(name=CARS_FILE):
try:
with open(name, "r") as f:
json_str = f.read()
return Cars.from_json(json.loads(json_str))
except (FileNotFoundError, TypeError) as e:
logger.debug(e)
return Cars()
def __init__(self, hidden_size):
logger.debug('Instance {} created'.format(__class__.__name__))
super(AttentionLayer, self).__init__()
self.hidden_size = hidden_size
#self.match = nn.Linear(2 * hidden_size, hidden_size)
self.match1 = nn.Linear(2 * hidden_size, hidden_size)
self.match2 = nn.Linear(hidden_size, hidden_size)
self.match3 = nn.Linear(hidden_size, hidden_size)
self.to_weight = nn.Linear(hidden_size, 1, bias=False)
def getOtpCode(self):
self.mode = Otp.OTP_MODE
self.activation_start()
res = self.activation_finalyze()
if res == Otp.OTP_TWICE:
self.mode = Otp.OTP_MODE
self.activation_start()
self.activation_finalyze()
otp_code = self._getOtpCode()
logger.debug(f"otp code: {otp_code}")
return otp_code
def clean_position(conn):
res = conn.execute(
"SELECT Timestamp,mileage,level from position ORDER BY Timestamp DESC LIMIT 3;"
).fetchall()
# Clean DB
if len(res) == 3 and res[0]["mileage"] == res[1]["mileage"] == res[2]["mileage"] and \
res[0]["level"] == res[1]["level"] == res[2]["level"]:
logger.debug("Delete duplicate line")
conn.execute("DELETE FROM position where Timestamp=?;",
(res[1]["Timestamp"], ))
conn.commit()
def __init__(self, depth=5):
logger.debug("Creating {} instance".format(__class__.__name__))
super(CifarCNN, self).__init__()
self.depth = depth
self.conv1 = nn.Conv2d(in_channels=3, out_channels=depth, kernel_size=3, stride=2, padding=1)
self.conv2 = nn.Conv2d(in_channels=depth, out_channels=depth//2, kernel_size=3, stride=2, padding=1)
self.conv3 = nn.Conv2d(in_channels=depth//2, out_channels=depth//4, kernel_size=3, stride=2, padding=1)
self.conv3_drop = nn.Dropout2d()
self.fc1 = nn.Linear(depth*4, depth)
self.fc2 = nn.Linear(depth, 10)
def refresh_remote_token(self):
res = self.manager.post(remote_url + self.client_id,
json={
"grant_type": "refresh_token",
"refresh_token": self.remote_refresh_token
},
headers=self.headers)
data = res.json()
logger.debug(f"refresh_remote_token: {data}")
self.remote_access_token = data["access_token"]
self.remote_refresh_token = data["refresh_token"]
return data["access_token"], data["refresh_token"]
def __init__(self, i_dim=784, o_dim=10, depth=0, width=16):
# object initialization
logger.debug("Creating {} instance".format(__class__.__name__))
super(MnistDNN, self).__init__()
# layer architecture (input_dim, output_dim)
# [input_layer, hidden_layers, output_layers]
#IO = [(i_dim, 64), (64, 16), (16, o_dim)]
# start layer definition
self.input = nn.Linear(i_dim, width)
self.layers = nn.ModuleList([nn.Linear(width, width) for i in range(depth)])
self.output = nn.Linear(width, o_dim)
self.depth = depth
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")
def get_otp_code(self):
self.mode = Otp.OTP_MODE
otp_code = None
if self.activation_start():
res = self.activation_finalyze()
if res != Otp.NOK:
if res == Otp.OTP_TWICE:
self.mode = Otp.OTP_MODE
self.activation_start()
self.activation_finalyze()
otp_code = self._get_otp_code()
logger.debug("otp code: %s", otp_code)
if otp_code is None:
raise ConfigException("Can't get otp code")
return otp_code
def sendShort2Long(self,hostname, index_url, short_id):
try:
logger.debug('Sending sync get to {} with {} {}'.format(hostname, index_url, short_id))
request = '{}{}{}'.format(hostname, index_url, short_id)
response = requests.get(request)
if response.status_code >= 400:
succ = False
else:
succ = True
self.result = {
'succ': succ,
}
except Exception as e:
self.result = {
'succ': False
}
def get_temp(latitude: str, longitude: str, api_key: str) -> float:
try:
if not (latitude is None or longitude is None or api_key is None):
weather_rep = requests.get("https://api.openweathermap.org/data/2.5/onecall",
params={"lat": latitude, "lon": longitude,
"exclude": "minutely,hourly,daily,alerts",
"appid": api_key,
"units": "metric"})
temp = weather_rep.json()["current"]["temp"]
logger.debug("Temperature :%fc", temp)
return temp
except ConnectionError:
logger.error("Can't connect to openweathermap :%s", traceback.format_exc())
except KeyError:
logger.error("Unable to get temperature from openweathermap :%s", traceback.format_exc())
return None
class ShallowNet(nn.Module):
logger.debug("Creating {} instance".format(__name__))
def __init__(self, width=100, input_dim=1, output_dim=1):
super(ShallowNet, self).__init__()
self.width = width
self.input = nn.Linear(input_dim, width)
self.output = nn.Linear(width, output_dim)
#@log_method(logger)
def forward(self, x):
x = F.relu(self.input(x))
x = self.output(x)
return x
# get unique string repr for each different net
def get_name(self):
net_name = self.__class__.__name__
return "{}_w{}".format(net_name, self.width)
def summary(self):
model_parameters = filter(lambda p: p.requires_grad, self.parameters())
params = sum([np.prod(p.size()) for p in model_parameters])
print("Model Parameters")
print(self.parameters)
print("Trainable parameters: {}".format(params))
def parms_n(self):
model_parameters = filter(lambda p: p.requires_grad, self.parameters())
params = sum([np.prod(p.size()) for p in model_parameters])
return params
def get_r(self):
if self.action == "upgrade":
iw = self.data.iwK1
# not correctly implemented
else:
iw = self.data.iwK0
if self.action == "synchro":
R2 = self.challenge + ";" + iw + ";" + self.codepin
else:
R2 = self.challenge + ";" + iw + ";"
R0 = self.challenge + ";" + iw + ";" + self.get_serial()
R1 = self.challenge + ";" + iw + ";" + self.data.iwK1
logger.debug("%s\n%s\n%s", R0, R1, R2)
return {"R0": hashlib.sha256(R0.encode("utf-8")).hexdigest(),
"R1": hashlib.sha256(R1.encode("utf-8")).hexdigest(),
"R2": hashlib.sha256(R2.encode("utf-8")).hexdigest()}
def decode_oaep(enc, key):
modulus = int(key, 16)
key = RSA.construct((modulus, Otp.exponent))
cipher = oaep.new(key, hash_algo=Hash.SHA256)
block_size = 128
dec_string = ""
enc_b = bytes.fromhex(enc)
nb_block = ceil(len(enc_b) / block_size)
for x in range(0, nb_block):
if x == nb_block - 1:
maxi = len(enc_b)
else:
maxi = (1 + x) * 128
mini = x * 128
ciphertext = cipher.decrypt(enc_b[mini:maxi])
dec_string += ciphertext.hex()
logger.debug(dec_string)
return dec_string
def record_position(self, vin, res: psac.models.status.Status):
import sqlite3
conn = sqlite3.connect('info.db')
conn.execute(
"CREATE TABLE IF NOT EXISTS position (Timestamp DATETIME PRIMARY KEY, VIN TEXT, longitude REAL, latitude REAL, mileage REAL, level INTEGER);"
)
longitude = res.last_position.geometry.coordinates[0]
latitude = res.last_position.geometry.coordinates[1]
date = res.last_position.properties.updated_at
mileage = res.timed_odometer.mileage
level = res.energy[0]["level"]
try:
conn.execute(
"INSERT INTO position(Timestamp,VIN,longitude,latitude,mileage,level) VALUES(?,?,?,?,?,?)",
(date, vin, longitude, latitude, mileage, level))
conn.commit()
except sqlite3.IntegrityError:
logger.debug("position already saved")
finally:
conn.close()
def sendLong2Short(self, hostname, index_url, convert_url, long_url):
try:
logger.debug('Sending sync post to {} with {}'.format(hostname, long_url))
session = requests.Session()
r = session.get('{}{}'.format(hostname, index_url))
csrftoken = r.cookies[HttpConn.TOKENKEY]
response = session.post('{}{}'.format(hostname, convert_url),
{"url":long_url},
headers={HttpConn.CSRFTOKENKEY: csrftoken})
if response.status_code >= 400:
succ = False
else:
succ = True
self.result = {
'succ': succ,
}
except Exception as e:
self.result = {
'succ': False
}
def refresh_remote_token(self, force=False):
if not force and self.remote_token_last_update is not None:
last_update: datetime = self.remote_token_last_update
if (datetime.now() - last_update).total_seconds() < MQTT_TOKEN_TTL:
return
self.manager._refresh_token()
res = self.manager.post(remote_url + self.client_id,
json={
"grant_type": "refresh_token",
"refresh_token": self.remote_refresh_token
},
headers=self.headers)
data = res.json()
logger.debug(f"refresh_remote_token: {data}")
if "access_token" in data:
self.remote_access_token = data["access_token"]
self.remote_refresh_token = data["refresh_token"]
self.remote_token_last_update = datetime.now()
return data["access_token"], data["refresh_token"]
else:
logger.error(f"can't refresh_remote_token: {data}")
def request(self, param, setup=False):
raw_xml = requests.get(
f"{self.iw_host}/iwws/MAC",
headers={
"Connection": "Keep-Alive",
"Host": "otp.mpsa.com",
"User-Agent": "Dalvik/2.1.0 (Linux; U; Android 8.0.0; Android SDK built for x86_64 "
"Build/OSR1.180418.004) "
},
params=param,
proxies=self.proxies,
verify=self.proxies is None
).text
try:
raw_xml = raw_xml[raw_xml.index("?>") + 2:]
if setup:
return etree_to_dict(ElT.XML(raw_xml))["ActionSetup"]
return etree_to_dict(ElT.XML(raw_xml))["ActionFinalize"]
except KeyError:
logger.debug(raw_xml)
raise ValueError("Bad response from server")
def serve_layout():
global cached_layout
if cached_layout is None:
logger.debug("Create new layout")
try:
figures.get_figures(trips, chargings)
data_div = html.Div([dcc.RangeSlider(
id='date-slider',
min=min_millis,
max=max_millis,
step=step,
marks=marks,
value=[min_millis, max_millis],
),
html.Div([
dbc.Tabs([
dbc.Tab(label="Summary", tab_id="summary", children=[
html.H2(id="consumption",
children=figures.info),
dcc.Graph(figure=figures.consumption_fig, id="consumption_fig"),
dcc.Graph(figure=figures.consumption_fig_by_speed, id="consumption_fig_by_speed"),
figures.consumption_graph_by_temp
]),
dbc.Tab(label="Trips", tab_id="trips", id="tab_trips", children=[figures.table_fig]),
dbc.Tab(label="Battery", tab_id="battery", id="tab_battery", children=[figures.battery_info]),
dbc.Tab(label="Charge", tab_id="charge", id="tab_charge", children=[figures.battery_table]),
dbc.Tab(label="Map", tab_id="map", children=[
dcc.Graph(figure=figures.trips_map, id="trips_map", style={"height": '90vh'})]),
],
id="tabs",
active_tab="summary",
),
html.Div(id="tab-content", className="p-4"),
])])
except (IndexError, TypeError):
logger.debug("Failed to generate figure, there is probably not enough data yet %s", traceback.format_exc())
data_div = ERROR_DIV
cached_layout = dbc.Container(fluid=True, children=[html.H1('My car info'), data_div])
return cached_layout
def record_info(self, vin, status: psac.models.status.Status):
mileage = status.timed_odometer.mileage
level = status.get_energy('Electric').level
level_fuel = status.get_energy('Fuel').level
charge_date = status.get_energy('Electric').updated_at
try:
moving = status.kinetic.moving
logger.debug("")
except AttributeError:
logger.error("kinetic not available from api")
moving = None
try:
longitude = status.last_position.geometry.coordinates[0]
latitude = status.last_position.geometry.coordinates[1]
date = status.last_position.properties.updated_at
except AttributeError:
logger.error("last_position not available from api")
longitude = latitude = None
date = charge_date
logger.debug(
"vin:%s longitude:%s latitude:%s date:%s mileage:%s level:%s charge_date:%s level_fuel:"
"%s moving:%s", vin, longitude, latitude, date, mileage, level,
charge_date, level_fuel, moving)
self.record_position(vin, mileage, latitude, longitude, date, level,
level_fuel, moving)
try:
charging_status = status.get_energy('Electric').charging.status
self.record_charging(vin, charging_status, charge_date, level,
latitude, longitude)
logger.debug("charging_status:%s ", charging_status)
except AttributeError:
logger.error("charging status not available from api")
