def encrypt(data: dict, pin: int) -> str:
string_data = jdump(data)
encoded = b64encode(string_data)
keycode_generator = (i for i in encoded)
encrypted = "=>".join(
sorted((str((i + v) * pin) + f"x{i}"
for i, v in enumerate(keycode_generator)),
reverse=len(data) % 2 == 0))
return f"{sha256(string_data).hexdigest()}+{encrypted}"
def auto_save(option: bool, location: str, memory: list, events: dict,
encrypted: bool, pin: int):
if option:
events["before_save"]()
with open(location, "w+", encoding="utf-8") as f:
written_data = jdump({
"database": memory
}).decode() if not encrypted else encryption.encrypt(
{"database": memory}, pin)
f.write(written_data)
events["after_save"]()
gccollect()
def save(self) -> bool:
"""Saves database to JSON file."""
self.__events["before_save"]()
with open(self.__location, "w+", encoding="utf-8") as f:
written_data = jdump({"database": self.__memory}).decode(
) if not self.__encrypted else encryption.encrypt({"database": self.__memory}, self.__pin)
f.write(written_data)
self.__events["after_save"]()
gccollect()
return True
def dump(self, location: str, encoding: str = "utf-8") -> bool:
"""Dumps all the data to a file."""
functions.raise_error(location, "location", str)
functions.raise_error(encoding, "encoding", str)
self.__events["before_export"]()
with open(location, "w+", encoding=encoding) as f:
f.write(jdump({"database": self.__memory}).decode())
self.__events["after_export"]()
gccollect()
return True
def __wrapper():
while self.__backup:
last_path = "./"
for path in self.__backup_path.split("/"):
if not opath.exists(f"{last_path}{path}"):
mkdir(f"{last_path}{path}")
last_path += f"{path}/"
will_encrypt = self.__encrypted and should_encrypt
with open(
f"./{self.__backup_path}/backup_{datetime.now().strftime('%d-%m-%Y_%H-%M-%S')}.{'json' if not will_encrypt else 'datagoose'}",
"w+",
encoding="utf-8") as f:
written_data = jdump({"database": self.__memory}).decode(
) if not will_encrypt else encryption.encrypt({"database": self.__memory}, self.__pin)
f.write(written_data)
gccollect()
self.__events["backup"]()
sleep(self.__backup_time)
def __init__(self, name: str, options=None) -> None:
if options is None:
options = {}
functions.raise_error(name, "name", str)
functions.raise_error(options, "options", dict)
self.__path = options['PATH'] if 'PATH' in options and isinstance(
options['PATH'], str) else "datagoose_files"
self.__autosave = options['AUTO_SAVE'] if 'AUTO_SAVE' in options and isinstance(
options['AUTO_SAVE'], bool) else False
self.__hashing = [
i for i in options['HASHING'] if isinstance(
i, str)] if 'HASHING' in options and isinstance(
options['HASHING'], list) else []
self.__safemode = options['SAFE_MODE'] if 'SAFE_MODE' in options and isinstance(
options['SAFE_MODE'], bool) else True
self.__useregex = options['USE_REGEX'] if 'USE_REGEX' in options and isinstance(
options['USE_REGEX'], bool) else False
self.__encrypted = options['ENCRYPTED'] if 'ENCRYPTED' in options and isinstance(
options['ENCRYPTED'], bool) else False
self.__name = name
self.__location = f"./{self.__path}/{self.__name}.{'json' if not self.__encrypted else 'datagoose'}"
self.__pin = options['PIN'] if 'PIN' in options and isinstance(
options['PIN'], int) else 2
self.__backup = False
self.__backup_time = 60
self.__backup_path = "datagoose_backups"
self.__events = {
"before_insert": lambda value: None,
"should_insert": lambda value: True,
"after_insert": lambda value: None,
"before_update": lambda now, changes: None,
"should_update": lambda now, changes: True,
"after_update": lambda now, old: None,
"before_replace": lambda now, new: None,
"should_replace": lambda now, new: True,
"after_replace": lambda now, old: None,
"before_delete": lambda value: None,
"should_delete": lambda value: True,
"after_delete": lambda value: None,
"before_copy": lambda value: None,
"should_copy": lambda value: True,
"after_copy": lambda value: None,
"before_save": lambda: None,
"after_save": lambda: None,
"before_export": lambda: None,
"after_export": lambda: None,
"before_import": lambda: None,
"after_import": lambda: None,
"backup_start": lambda: None,
"backup": lambda: None,
"backup_finish": lambda: None,
"before_garbage_clear": lambda: None,
"after_garbage_clear": lambda: None
}
path_prefix = "./"
for path in self.__path.split("/"):
if not opath.exists(f"{path_prefix}{path}"):
mkdir(f"{path_prefix}{path}")
path_prefix += f"{path}/"
del path_prefix
if not opath.isfile(self.__location):
with open(self.__location, "w+", encoding="utf-8") as f:
written_data = jdump({"database": []}).decode(
) if not self.__encrypted else encryption.encrypt({"database": []}, self.__pin)
f.write(written_data)
with open(self.__location, "r", encoding="utf-8") as f:
self.__memory = jload(
f.read())["database"] if not self.__encrypted else encryption.decrypt(
self.__pin, f.read())["database"]
self.__time_start = datetime.now()