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")