def create_short():
''' request.data should contain url and (optional) hash '''
try:
data = json.loads(request.data)
except (TypeError, ValueError):
return jsonify({'error': "Request data must be passed in as a json string"})
url = data.get('url')
if url is None:
return jsonify({'error': "No 'url' parameter present in request data"})
try:
hashed = data['hash']
except KeyError:
hashed = create_hash(url)
try:
if hashed in BANNED_HASHES:
# Cannot create a banned hash
raise DuplicateError
create_redirect(url, hashed)
except DuplicateError:
return jsonify({'error': "hash '{}' already exists".format(hashed)})
return jsonify({'redirect': "/{}".format(hashed)})
def _find_emissions_and_cache(self, detected_plate):
"""Retrieve emissions from database and write to cache for sending.
If license plate is known and found then actual emissions are read,
otherwise average for the vehicle type is used.
Args:
detected_plate (str): License plate text or string identifier for an unknown vehicle
TODO:
Write average vehicle to cache
Returns:
bool: True if emission caching was successful
"""
plate_text = detected_plate["plate_text"]
if plate_text.startswith(UNKNOWN_VEHICLE_PREFIX):
# TODO: retrieve average emissions based on detected_plate["label"]
return True
else:
vehicle = self.DB.get_vehicle(create_hash(plate_text))
if vehicle:
self.DB.write_cache(str(detected_plate["timestamp"]), vehicle)
return True
return False
def reset(self):
if self.pw_entry.get() != self.confpw_entry.get():
tkMessageBox.showwarning("Reset Failed", "The passwords do not match."
" Please re-enter matching passwords.")
else:
hashedpw = hasher.create_hash(self.pw_entry.get())
database.change_password(self.studentID, hashedpw)
self.destroy()
def import_data(self):
"""Import data if DATABASE_IMPORT file exists"""
if not os.path.exists(self.import_file):
logging.error("No import file present: {}".format(self.import_file))
return
logging.info("Deleting existing data")
self.cursor.execute("DELETE FROM emissions;")
logging.info("Importing data")
lastmsg = time.time()
started = time.time()
with open(self.import_file, "rt") as fp:
reader = csv.reader(fp, delimiter=";")
values = []
for i, row in enumerate(reader):
if "-" not in row[0]:
continue
plate = row[0].strip().replace("-", "")
ct = row[1].strip()
gt = row[2].strip()
try:
co2 = int(row[3].strip())
except ValueError:
co2 = None
values.append(
self.cursor.mogrify(
"(%s,%s,%s,%s)", (create_hash(plate), co2, ct, gt)
).decode("utf-8")
)
if i % 50000 == 0:
self.cursor.execute(
"""INSERT INTO emissions(hash, co2, car_type, gas_type)
VALUES """
+ ",".join(values)
+ """ ON CONFLICT DO NOTHING;"""
)
self.connect.commit()
values = []
if time.time() - lastmsg > 10:
logging.info("Imported {} records ...".format(i))
lastmsg = time.time()
if len(values) > 0:
self.cursor.execute(
"""INSERT INTO emissions(hash, co2, car_type, gas_type)
VALUES """
+ ",".join(values)
+ """ ON CONFLICT DO NOTHING;"""
)
values = []
self.cursor.execute("SELECT count(*) FROM emissions;")
if time.time() - lastmsg > 10:
logging.info(
"Imported {} records in {}s".format(i, time.time() - started)
)
self.connect.commit()
return
def _process_files(self, files):
"""Process set of files and remove after them after processing
Args:
files (List): List of frame metadata
"""
if len(files) == 0:
return
self.raw_plate_history = []
logging.info("LAG: {}".format(datetime.datetime.now() -
files[0]["timestamp"]))
for file in files:
# Yolo saw an object here
if len(file["metadata"]["detections"]) > 0:
plate = self._get_plate(file["path"])
try:
for temp in plate["results"]:
logging.info("ALPR like: {}".format(
get_obfuscated_plate(temp["plate"])))
except Exception:
pass
file["plates"] = plate
self.raw_plate_history.append(file)
# Delete files when data has been read
try:
os.remove(file["path"])
except FileNotFoundError:
pass
try:
os.remove(file["path"].replace(".jpg", ".json"))
except FileNotFoundError:
pass
# analyse known plates
roi_plates = self.analyser.analyse_plates(self.raw_plate_history)
for detected_plate in roi_plates:
self._find_emissions_and_cache(detected_plate)
plate_text = detected_plate["plate_text"]
plate_hashed = create_hash(plate_text)
if self.reveal_plate:
logging.info(f"ROI: {self.roi_id}, {plate_text}")
else:
logging.info(f"ROI: {self.roi_id}, {plate_hashed}")
def register(self):
if not self.type_selected:
tkMessageBox.showwarning("Registration Failure", "Must select if creating a " "student or teacher account.")
return
if (self.tpw_entry != None) and (self.tpw_entry.get() != "engineering"):
tkMessageBox.showwarning(
"Registration Failure", "Must enter correct password " "to create teacher account."
)
return
name = self.name_entry.get()
username = self.username_entry.get()
password = self.password_entry.get()
password_conf = self.confpw_entry.get()
for x in [name, username, password, password_conf]:
if x == "":
tkMessageBox.showwarning("Registration Failure", "Please complete all fields.")
return
if password != password_conf:
# Pop up window saying that passwords do not match
tkMessageBox.showwarning(
"Registration Failure",
"The passwords you have entered do not match. "
"Ensure that your passwords are matching and try again.",
)
return
if self.type_selected == "student":
account_type = "student"
else:
account_type = "teacher"
if database.username_exists(username):
tkMessageBox.showwarning(
"Registration Failure",
"The username that you have selected already exists. " "Please choose a different username.",
)
return
else:
database.create_user(name, username, account_type, hasher.create_hash(password))
self.destroy()
login = LoginScreen(master=self.master)
login.pack()
def test_hash_length():
assert len(create_hash("ABC123")) == 24
def test_hash_differs_from_input():
assert create_hash("ABC123") != "ABC123"
