def remd(dbcontent, name_, table, id_): if id_ and (not (str(type(id_)) in [ "<class 'str'>", "<class 'int'>", "<class 'float'>" ])): event_log( "Error! Expecting id_ to be of type string or int or float in function drop", name_) return [], "Expecting id_ to be of type string or int or float in function drop" if not (str(type(table)) in ["<class 'str'>", "<class 'list'>"]): event_log( "Error! Expecting table to be of type string or list in function drop", name_) return [], "Expecting table to be of type string or list in function drop" try: if str(type(table)) == "<class 'str'>": if id_: del dbcontent[table][id_] event_log( "Successfully dropped id_ {} in table {} in DB {}".format( id_, table, name_), name_) else: del dbcontent[table] event_log( "Successfully dropped table {} in DB {}".format( table, name_), name_) else: for i in table: del dbcontent[i] return dbcontent, None except Exception as e: event_log( "There was an error droping table {} in DB {} - {}".format( table, name_, str(e)), name_) return {}, str(e)
def exists(self, table=None, id_=None): res, error = exist(self.__name, self.__data, table, id_) if error: event_log("An Error occured when checking if data exists in DB {}".format(self.__name), self.__name) raise Exception(error) event_log("Successfully checked if data exists in DB {}".format(self.__name), self.__name) return res
def dump(source, destination): #Ensure the destination is a string or int or float if not str(type(destination)) in [ "<class 'str'>", "<class 'float'>", "<class 'int'>" ]: event_log( "Error! Expecting destination to be of type string or int or float in function clone", source) return {}, "Error! Expecting destination to be of type string or int or float" #Converts to a string incase it is a float or int destination = str(destination) if len(destination) == 0: event_log("Error! Destination cannot be empty in function clone", source) return "Destination cannot be empty in function clone" if source == destination: e = "Error! destination cant be the same as source in function clone!" event_log(e, source) return e try: #Basically read and write the database stored on the disk with open(source + ".hashdb", "r") as db0: content = db0.read() with open(destination + ".hashdb", "w") as db1: db1.write(dumps(content)) event_log( "Successfully cloned DB {} to {}".format(source, destination), source) return None except Exception as e: event_log( "There was an error cloning DB {} to {} - {}".format( source, destination, str(e)), source) return str(e)
def create(dbname, data={}, password=None): if password: with open(dbname + ".hashdb", "w") as db: db.write(encryptdb(str(data), str(password), dbname)) else: with open(dbname + ".hashdb", "w") as db: db.write(dumps(data, indent=4)) event_log("Successfully created new DB {}".format(dbname), dbname)
def close(dbname): try: event_log("Successfully disconnected from DB {}".format(dbname), dbname) return None except Exception as e: event_log( "There was an error disconnecting from DB {}, Possibly due to Database Corruption - {}" .format(dbname, str(e)), dbname) return str(e)
def drop(self, table=None, id=None): _data = dumps(self.__data) if (not table) and (not id_): event_log("Successfully dropped DB {}".format(self.__name), self.__name) data_ = {} else: data_, error = remd(self.__data, self.__name, table, id) if error: raise Exception(error) self.__dataCP = _data self.__data = data_
def __init__(self, dbname, password=None): _data, self.state, error = load(dbname, password) if str(type(_data)) != "<class 'dict'>": error = "A password is required to connect to DB {}".format(dbname) event_log(error) if error: raise Exception(error) self.__data = _data del _data self.__name = str(dbname) self.__dataCP = dumps(self.__data)
def encpass(password, dbname): password = str(password) password = sha512((password + password + (password[0] * len(password))).encode()).hexdigest() try: tot = 0 for p in range(len(password)): tot += ord(password[p]) * p tot += ord(password[0]) + ord(password[-1]) return (tot % 512) except Exception as e: event_log("There was an error parsing given password for DB {} - {}".format(dbname, str(e)), dbname) return str(e)
def count(self, table=None, id=None): if (not table) and (not id): event_log("Successfully retrieved count of DB {}".format(self.__name), self.__name) return len(self.__data.keys()) elif (not table) and id: error = "Error! Can't get count of table_id without specifying table in function count" event_log(error, self.__name) raise Exception(error) value, error = coun(self.__name, self.__data, table, id) if error: raise Exception(error) return value
def remf(dbname): try: try: remove(dbname + ".hashdb") except Exception as e: event_log( "There was an error destroying DB {} - {}".format( dbname, str(e)), dbname) return (str(e)) except Exception as e: event_log( "There was an error destroying DB {} - {}".format( dbname, str(e)), dbname) return (str(e)) event_log("Successfully deleted DB {}".format(dbname), dbname) return None except Exception as e: event_log( "There was an error destroying DB {} - {}".format(dbname, str(e)), dbname) return str(e)
def insA(data_, dbname): try: if not data_: event_log("Successfully overwritten data in DB {}".format(dbname), dbname) return {}, None if str(type(data_)) == "<class 'dict'>" or str( type(data_)) == "<class 'str'>": if str(type(data_)) == "<class 'str'>": data_ = {"data": data_} event_log("Successfully overwritten data in DB {}".format(dbname), dbname) return data_, None else: event_log( "Expecting data_ to be of type dict or str in function overwrite", dbname) return {}, "Error! Expecting data_ to be of type dict or str" except Exception as e: event_log( "There was an error overwriting data in DB {} - {}".format( dbname, str(e)), dbname) return {}, str(e)
def tab(data_, table_, name_): try: if str(type(table_)) != "<class 'str'>": event_log("Expecting table to be of type str in function table", dbname) return {}, "Error! Expecting table to be of type str" data_[table_] = {} event_log( "Successfully created table {} in DB {}".format(table_, name_), name_) return data_, None except Exception as e: event_log( "There was an error creating table {} in DB {} - {}".format( table_, name_, str(e)), name_) return {}, str(e)
def write(dbname, dbcontent, password=None, prettify=True): try: with open(dbname + ".hashdb", "w") as db: if password: db.write(encryptdb(str(dbcontent), str(password), dbname)) event_log("Successfully saved DB {}".format(dbname), dbname) else: if prettify: db.write(dumps(dbcontent, indent=4)) else: db.write(dumps(dbcontent)) event_log("Successfully saved DB {}".format(dbname), dbname) return None except Exception as e: event_log( "There was an error editing DB {} - {}".format(dbname, str(e)), dbname) return str(e)
def remdd(name_, dbcontent, table, query_): if (str(type(table)) != "<class 'str'>" and str(type(table)) != "<class 'list'>") and table: event_log( "Error! Expecting table to be of type str or list in function delete", name_) return [], "Expecting table to be of type str or list in function delete" if str(type(table)) == "<class 'str'>": table = [table] if str(type(query_)) != "<class 'dict'>" and query_: event_log( "Error! Expecting query_ to be of type dict in function find", name_) return [], "Expecting query_ to be of type dict in function find" if (not query_) and (not table): del dbcontent return {}, None elif not query_: del dbcontent[table] return dbcontent, None try: if table: places_to_search = table else: places_to_search = list(dbcontent.keys()) selected = [] for places in places_to_search: for key in dbcontent[places]: present = False for query in query_: try: if "or" == query.lower() and (not present): for keyy in query_[query]: if dbcontent[places][key][keyy] == query_[ query][keyy]: present = True except: pass try: if "or>" == query.lower() and (not present): for keyy in query_[query]: if dbcontent[places][key][keyy] > query_[ query][keyy]: present = True except: pass try: if "or<" == query.lower() and (not present): for keyy in query_[query]: if dbcontent[places][key][keyy] < query_[ query][keyy]: present = True except: pass if present: selected.append([places, key]) continue valid = True for query in query_: try: if "and" == query.lower(): for keyy in query_[query]: if dbcontent[places][key][keyy] != query_[ query][keyy]: valid = False elif "not" == query.lower(): try: for keyy in query_[query]: if dbcontent[places][key][keyy] == query_[ query][keyy]: valid = False except: pass elif "like" == query.lower(): for keyy in query_[query]: if not (str(query_[query][keyy]).lower( ) in str(dbcontent[places][key][keyy]).lower() and str( type(dbcontent[places][key][keyy])) == "<class 'str'>"): valid = False elif ">" == query: for keyy in query_[query]: if str(type(query_[query][keyy])) in [ "<class 'float'>", "<class 'int'>" ]: if float(dbcontent[places][key][keyy] ) < float(query_[query][keyy]): valid = False elif "<" == query: for keyy in query_[query]: if str(type(query_[query][keyy])) in [ "<class 'float'>", "<class 'int'>" ]: if float(dbcontent[places][key][keyy] ) > float(query_[query][keyy]): valid = False else: if not query.lower() in "or or> or<".split(" "): event_log("Error! Invalid Delete Format", name_) return [], "Invalid Delete Format" elif query.lower() in "or or> or<".split(" "): pass else: valid = False except: valid = False pass if valid: selected.append([places, key]) for i in selected: try: del dbcontent[i[0]][i[1]] except: pass event_log("Successfully Deleted data from DB {}".format(name_), name_) return dbcontent, None except Exception as e: return {}, str(e)
def load(dbname, password=None): if not str(type(dbname)) in [ "<class 'str'>", "<class 'float'>", "<class 'int'>" ]: event_log( "Error! Expecting dbname to be of type string or int or float in function connect", 0) return {}, 0, "Error! Expecting dbname to be of type string or int or float" dbname = str(dbname) try: res = 0 if not path.exists(dbname + ".hashdb"): with open(dbname + ".hashdb", "w") as db: db.write("{}") res = 1 if password: with open(dbname + ".hashdb", "r") as db: try: dbcontent = decryptdb(db.read(), str(password), dbname) dbcontent = literal_eval( dbcontent.replace(": true,", ": True,").replace( ": false,", ": False,")) event_log("Successfully connected to DB {}".format(dbname), dbname) except Exception as e: event_log( "An incorrect password was used in connecting to DB {} or the DB is corrupted" .format(dbname), dbname) return {}, 0, "An incorrect password was used in connecting to DB {} or the DB is corrupted".format( dbname) else: with open(dbname + ".hashdb") as db: try: dbcontent = ll(db) except Exception as e: event_log( "A password is required to connect to DB {} - {}". format(dbname, str(e)), dbname) return {}, 0, "A password is required to connect to DB {}".format( dbname) db.close() event_log("Successfully connected to DB {}".format(dbname), dbname) return dbcontent, res, None except Exception as e: event_log( "There was an error connecting to DB {} - {}".format( dbname, str(e)), dbname) return {}, 0, str(e)
def undo(self): self.__data = literal_eval(self.__dataCP.replace(": true,", ": True,").replace(": false,", ": False,")) event_log("Successfully Reversed Database Action", self.__name)
def ins(data, data_, table, dbname, id_): try: if str(type(data_)) != "<class 'dict'>": event_log("Expecting data_ to be of type dict in function insert", dbname) return {}, "Error! Expecting data_ to be of type dict" if str(type(table)) != "<class 'str'>": event_log("Expecting table to be of type str in function insert", dbname) return {}, "Error! Expecting table to be of type str" if str(type(id_)) != "<class 'str'>" and id_: event_log("Expecting id_ to be of type str in function insert", dbname) return {}, "Error! Expecting id_ to be of type str" if not id_: id_ = "id_{}".format(len(data[table])) try: data[table] except: event_log("table {} does not exist in DB {}".format(table, dbname), dbname) return {}, "table {} does not exist in DB {}".format(table, dbname) data[table][str(id_)] = data_ event_log( "Successfully inserted data into DB {} in table {}".format( dbname, table), dbname) return data, None except Exception as e: event_log( "There was an error inserting data into DB {} in table {} - {} does not exist" .format(dbname, table, str(e)), dbname) return {}, str(e) + "does not exist"
def get(self, table=None, id=None, sort=0): if table: error = None if str(type(table)) != "<class 'str'>": event_log("Expecting table to be of type str in function get", dbname) error = "Expecting table to be of type str in function get" if error: raise (error) try: if id: try: d = self.__data[table][id] event_log("Successfully retrieved table_id {} in table {} in DB {} contents".format(id, table, self.__name), self.__name) except: event_log("The table_id {} does not exist in table {} in DB {}".format(id, table, self.__name), self.__name) raise Exception("The table_id {} does not exist in table {} in DB {}".format(id, table, self.__name)) else: d = self.__data[table] event_log("Successfully retrieved table {} in DB {} contents".format(table, self.__name), self.__name) data = d del d except: event_log("The Table {} does not exist! in DB {}".format(table, self.__name), self.__name) raise Exception("The Table {} does not exist! in DB {}".format(table, self.__name)) else: event_log("Successfully retrieved DB {} contents".format(self.__name), self.__name) data = self.__data if int(sort) != 0: data2 = {} if int(sort) > 0: for i in sorted(data): data2[i] = data[i] elif int(sort) < 0: for i in sorted(data)[::-1]: data2[i] = data[i] data = data2 del data2 return data
def upd(data, data_, table, dbname, id_): try: if str(type(data_)) != "<class 'dict'>": event_log("Expecting data_ to be of type dict in function update", dbname) return {}, "Error! Expecting data_ to be of type dict" if str(type(table)) != "<class 'str'>": event_log("Expecting table to be of type str in function update", dbname) return {}, "Error! Expecting table to be of type str" if not str(type(id_)) in ["<class 'str'>", "<class 'int'>"]: event_log( "Expecting id_ to be of type str or int in function update", dbname) return {}, "Error! Expecting id_ to be of type str or int" if not data_: data_ = {} try: if str(type(id_)) == "<class 'int'>": bin_ = data[table][list(data[table].keys())[id_]] del bin_ data[table][list(data[table].keys())[id_]] = data_ else: bin_ = data[table][str(id_)] del bin_ data[table][str(id_)] = data_ except: event_log( "There is no table_id with {} in table {} in DB {}".format( id_, table, dbname), dbname) return {}, "table_id {} does not exist in table {}".format( id_, table) event_log( "Successfully updated data into DB {} in table {} with id {}". format(dbname, table, id_), dbname) return data, None except Exception as e: event_log( "There was an error updating data in DB {} in table {} with id_ {} - {}" .format(dbname, table, id_, str(e)), dbname) return {}, str(e)
def tables(self): event_log("Successfully retrieved DB {} Tables".format(self.__name), self.__name) return list(self.__data.keys())