def test_add_service(self):
test_service = service.Service()
db = database.Database()
db.add_service(test_service)
self.assertEqual(test_service.service_name, db.services[0].service_name)
self.assertEqual(test_service.username, db.services[0].username)
self.assertEqual(test_service.password, db.services[0].password)
def test_update_table(self):
logger = logging.getLogger(__name__)
cfg = utils.load_config(logger, "config/data.json")
db = database.Database(cfg=cfg)
df = pd.DataFrame(columns=["A"])
db._update_table(name="test", data=df)
def login(name: str, password: str) -> database.Database:
if not os.path.isdir(os.getcwd() + "/databases"):
os.mkdir(os.getcwd() + "/databases")
db = database.Database()
storage.read(password, db, "databases/" + name + ".db")
return db
def test_init_invalid_config(self):
logger = logging.getLogger(__name__)
cfg = utils.load_config(logger, "config/data.json")
cfg.pop("resultsTable")
with self.assertRaises(KeyError):
database.Database(cfg=cfg)
def submit_values(self, title, ingredients, instructions, prep_time, cook_time):
'''Docstring'''
if not title.get() or not ingredients.get('1.0', 'end-1c') or not \
instructions.get('1.0', 'end-1c'):
threading.Thread(target=playsound, args=(settings.ALERT,)).start()
messagebox.showerror(title='Input Error', \
message='Required fields: Title, Ingredients, and Instructions')
else:
title = title.get()
ingredients = ingredients.get('1.0', 'end-1c')
instructions = instructions.get('1.0', 'end-1c')
prep_time = prep_time.get()
cook_time = cook_time.get()
q = db.Database().enter_recipe(title, ingredients, instructions, prep_time, cook_time)
threading.Thread(target=playsound, args=(settings.BTN,)).start()
msg = messagebox.askyesno(title='Add Recipe', message='Add another recipe?')
if msg is True:
threading.Thread(target=playsound, args=(settings.WINDOW_OPEN,)).start()
self.top.destroy()
self.my_form()
if msg is False:
threading.Thread(target=playsound, args=(settings.WINDOW_CLOSE,)).start()
self.top.destroy()
first_letter = title[0]
Child3().titlemenu(self.titleframe, self.recipeframe, letter=first_letter)
Child4().recipe(self.recipeframe, recipe_id=q)
def load_signatures(self):
"""
Функция загрузки сигнатур
"""
database = dbase.Database()
self.signatures_database['h'] = database.get_hash_signatures()
self.signatures_database['r'] = database.get_regexp_signatures()
def titlemenu(self, titleframe, recipeframe, letter=db.Database().first_recipe()[0]):
'''title menu'''
###### Query the database for recipe titles from our letter menu defaults to a ######
threading.Thread(target=playsound, args=(settings.BTN,)).start()
data = db.Database().title_query(letter=letter)
###### Create the canvas and scrollbar ######
canvas = tk.Canvas(titleframe, highlightcolor='gray87')
scrollbar = ttk.Scrollbar(titleframe, orient='vertical', command=canvas.yview)
scrollable_frame = ttk.Frame(canvas)
scrollable_frame.bind(
'<Configure>',
lambda e: canvas.configure(scrollregion=canvas.bbox('all'))
)
canvas.create_window((0, 0), window=scrollable_frame, anchor='nw')
canvas.configure(yscrollcommand=scrollbar.set)
###### If there are not any results returned, display message ######
if not data:
threading.Thread(target=playsound, args=(settings.ALERT,)).start()
msg = messagebox.showerror(title='No listing', \
message='Sorry, there have not been any recipes added starting with ' + letter)
if msg == 'ok':
return True
else:
###### Setup our look for the recipe menu ######
style = ttk.Style()
style.map('L.TLabel', \
background=[('pressed', '!disabled', 'gray87'), ('active', '#ffffee')], \
foreground=[('pressed', 'red'), ('active', 'red')])
style.configure('L.TLabel', relief='flat', padding=2, foreground='blue')
###### Loop through and display the return results from the database ######
for recipe_id, title in data:
title = ttk.Button(scrollable_frame, text=title.title(), \
style='L.TLabel', cursor='hand2', \
command=partial(Child4().recipe, recipeframe, recipe_id=recipe_id))
title.grid(column=0, row=recipe_id, sticky='nw')
scrollbar.grid(column=0, row=0, sticky='nsw')
canvas.grid(column=1, row=0, sticky='nsw', padx=8)
def test_read_table_not_found(self):
logger = logging.getLogger(__name__)
cfg = utils.load_config(logger, "config/data.json")
db = database.Database(cfg=cfg)
name = "not_available"
with self.assertRaises(ValueError):
db._read_table(name=name)
def test_get_hash_signatures(self):
"""
Test of reading hash signatures
:return:
"""
db = dbase.Database()
db.get_hash_signatures()
self.assertTrue(True)
def test_update_table_wrong_type(self):
logger = logging.getLogger(__name__)
cfg = utils.load_config(logger, "config/data.json")
db = database.Database(cfg=cfg)
d = 0.5
with self.assertRaises(TypeError):
db._update_table(name="test", data=d)
def write_statistic(cure_result):
"""
Save statistics data
:param cure_result:
:return:
"""
database = dbase.Database()
database.write_statistic(cure_result)
def test_load(self):
db = database.Database()
dic = {
"name": "Hey",
"services": [service.Service()]
}
db.load(dic)
self.assertEqual("Hey", db.name)
self.assertEqual("ServiceName", db.services[0].service_name)
self.assertEqual("Username", db.services[0].username)
self.assertEqual("Password", db.services[0].password)
def export():
"""
Exports signatures
:return:
"""
database = dbase.Database()
raw_signatures = {
'r': database.get_raw_regexp_signatures(),
'h': database.get_hash_signatures()
}
json_data = json.dumps(raw_signatures)
file_system = f_system.FileSystem()
file_system.put_file_content('signatures.json',
bytes(json_data, 'utf-8'))
print('Export complete')
def open_db(db_name: str, db_pass: str) -> (database.Database, str):
db = None
try:
if not db_exists(db_name):
if query_yes_no("Are you willing to create database \"" + db_name +
"\" ?"):
open("databases/" + db_name + ".db", "w+").close()
db = database.Database()
db.name = db_name
db.add_service(create_service())
storage.write(db_pass, db, "databases/" + db.name + ".db")
else:
db = login(db_name, db_pass)
except (pickle.UnpicklingError, EOFError, ValueError):
clear()
return db
def __get_db_content_to_send(self,
db_name: str,
secret: str = None) -> (int, object, object):
if db_exists(db_name):
if secret is None:
with open("databases/" + db_name + ".db", "rb") as infile:
return 200, {
"raw": infile.read().decode("utf-8")
}, self.send
else:
try:
db = database.Database()
storage.read(secret, db, "databases/" + db_name + ".db")
return 200, db.export(), self.send
except (pickle.UnpicklingError, EOFError, ValueError):
return 403, "denied", self.error
else:
return 404, "database not found", self.error
def test_write_signature_statistic(self):
db = dbase.Database()
signatures = db.get_regexp_signatures()
signatures_length = len(signatures)
self.assertTrue(signatures_length > 0)
single_signature = signatures[1]
anamnesis_element = {
'signature_id': single_signature['id'],
'path': '/some/path/script.php',
'size': 1234,
'action': 'cure',
'title': 'KDSH.PHP.Some.Signature',
'type': 'php',
'result': 'cure',
'result_message': '',
'position': '',
'cure': {'start': 1, 'end': 7, 'length': 6, 'sample': ''}
}
print(anamnesis_element)
db.write_statistic(anamnesis_element)
def test_custom_name(self):
db = database.Database()
db.name = "Custom"
self.assertEqual(db.name, "Custom")
def test_init_valid_config(self):
logger = logging.getLogger(__name__)
cfg = utils.load_config(logger, "config/data.json")
database.Database(cfg=cfg)
"""Handler for exit signal."""
print("\nSIGINT signal detected. Exiting")
for module in registered_modules:
module.exit()
if __name__ == "__main__":
signal(SIGINT, _quit_handler)
# TODO: For temporary debug clarity only
if path.isfile(settings.LOG_FILE):
remove(settings.LOG_FILE)
log = logger("Main")
log.info("Starting application")
# Initialize main modules
db = database.Database()
manager = HandlerManager(db)
# Register modules for SIGINT handler
register_modules(db, manager)
if settings.WEB_SERVER:
web = FlaskWebServer(manager, db)
register_modules(web)
# Wait for the manager thread to end
manager.thread.join()
# /usr/bin/env python3.8
###### Do the imports ######
import tkinter as tk
from tkinter import ttk, messagebox
import string
from functools import partial
import webbrowser
from modules import database as db, time_converter as tc, settings
import threading
from playsound import playsound
### Check if Recipe.db exists ###
db.Database().check_for_database()
def opensite():
'''Docstring'''
threading.Thread(target=playsound, args=(settings.LNK,)).start()
webbrowser.open_new('http://recipes.phpshelf.net')
###### Intiate the window ######
class RootWindow:
'''Docstring'''
def __init__(self, master):
self.master = master
self.master.columnconfigure(0, weight=1)
self.master.rowconfigure(0, weight=1)
###### Intiate all of our main containerframes ######
def recipe(self, recipeframe, recipe_id=db.Database().first_recipe()[1]):
'''Docstring'''
threading.Thread(target=playsound, args=(settings.LNK,)).start()
data = db.Database().id_query(recipe_id)
canvas = tk.Canvas(recipeframe, width=600)
canvas.configure(border=5, highlightcolor='gray87')
scrollbar = ttk.Scrollbar(recipeframe, orient='vertical', command=canvas.yview)
scrollable_frame = ttk.Frame(canvas)
scrollable_frame.bind(
'<Configure>',
lambda e: canvas.configure(scrollregion=canvas.bbox('all'))
)
canvas.create_window((0, 0), window=scrollable_frame, anchor='nw')
canvas.configure(yscrollcommand=scrollbar.set)
style = ttk.Style()
### Title
style.configure('Title.TLabel', \
font=('Sans', 12, 'bold', 'underline'), \
foreground='blue4', padding=5, relief='raised')
title = ttk.Label(scrollable_frame, text=f'{data[1].title()}', \
style='Title.TLabel', width=54)
title.grid(columnspan=2, column=0, row=0, sticky='new')
style2 = ttk.Style()
style2.configure('Time.TLabel', \
foreground='blue3', relief='raised', padding=5)
times = ttk.Label(scrollable_frame, \
text=f' Prep Time: {tc.time_converter(data[4])} \
Cook Time: {tc.time_converter(data[5])} \
Total Time: {tc.time_converter((data[4]+data[5]))}', style='Time.TLabel')
times.grid(columnspan=2, column=0, row=1, sticky='new')
### Mini Headers for ingredients and instructions
style3 = ttk.Style()
style3.configure('MiniHeader.TLabel', \
font=('Sans', 10, 'bold', 'underline', \
'italic'), foreground='blue4', relief='raised', padding=5)
mini_header1 = ttk.Label(scrollable_frame, \
text=' Ingredients', style='MiniHeader.TLabel')
mini_header1.grid(column=0, row=2, sticky='new')
mini_header2 = ttk.Label(scrollable_frame, \
text=' Instructions', style='MiniHeader.TLabel')
mini_header2.grid(column=1, row=2, sticky='new')
style4 = ttk.Style()
style4.configure('Recipe.TLabel', \
padding=8, border=8, relief='flat', wraplength=291)
ingredients = ttk.Label(scrollable_frame, \
text=data[2].title(), style='Recipe.TLabel')
ingredients.grid(column=0, row=3, sticky='nw')
instructions = ttk.Label(scrollable_frame, \
text=data[3].title(), style='Recipe.TLabel')
instructions.grid(column=1, row=3, sticky='nw')
scrollbar.grid(column=0, row=0, sticky='nsw')
canvas.grid(column=1, row=0, sticky='nsw')
logger = logging.getLogger('discord')
logger.setLevel(logging.DEBUG)
handler = logging.FileHandler(filename='discord.log', encoding='utf-8', mode='w')
handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s:%(name)s: %(message)s'))
logger.addHandler(handler)
# if configurations.COMMAND_LOG in ["y", "Y", "yes", "Yes", "YES"]:
# if configurations.ERROR_LOG in ["y", "Y", "yes", "Yes", "YES"]:
# -------- Initialize the Bot --------
bot = commands.Bot(configurations.PREFIX)
bot.add_cog(database.Database(bot))
bot.add_cog(help.Help(bot))
bot.add_cog(miscellaneous.Miscellaneous(bot))
bot.add_cog(music.Music(bot))
bot.add_cog(owner_only.Owner_Only(bot))
bot.add_cog(timer.Time(bot))
print("\nPlease wait while the Bot logs in ...")
@bot.event
async def on_ready():
print("\nLogged in as:\n")
print("Username : "******"ID Number: " + bot.user.id)
print('\nType ">>help" in the Discord chat for the list of commands.')
print("=============================================")
def main():
""" execute all the actions """
os.system("cls")
# input("\n\tBienvenu dans l'application Pur Beurre. Cette application a pour fonction"\
# " de vous montrer que parmi des produits du quotidien vous pouvez trouver un "\
# "substitut dont la fabrication est respectueuse de l'environnement.\n")
my_user = us.User("adi", "123", True)
# input(my_user.id)
loop = True
while loop:
os.system("cls")
print("\n", "-" * 30, " PAGE D'ACCUEIL ", "-" * 30, "\n")
if my_user.connected:
print("Vous êtes connecté(e) en tant que : {}.".format(
my_user.pseudo))
answer = input("\nQue voulez-vous faire ?\n"\
" 1 - Me déconnecter\n"\
" 2 - Remplacer un aliment, \n"\
" 3 - Retrouver mes aliments substitués,\n"\
" 4 - Quitter.\n ->")
else:
print("Vous n'êtes pas connecté(e).")
my_user.pseudo = ""
my_user.password = ""
answer = input("\nQue voulez-vous faire ? "\
" (Par exemple : Taper '1' et entrer pour vous connecter) \n"\
" 1 - Me connecter, \n"\
" 2 - Remplacer un aliment, \n"\
" 3 - Retrouver mes aliments substitués,\n"\
" 4 - Quitter.\n ->")
##################################################################################### 1
if answer == "1":
#depend on my_user.connected
if my_user.connected:
my_user.connected = False
my_user.pseudo = ""
my_user.password = ""
else:
my_db = dbu.DbUser()
my_user = my_db.authentication(my_user)
##################################################################################### 2
elif answer == "2":
# if not my_user.connected:
# my_db = dbu.DbUser()
# my_user = my_db.authentication(my_user)
# if not my_user.connected:
# print("Retour au menu principal ! ")
# time.sleep(1)
# continue
loop = True
while loop:
choice = db.Database()
selected_cat = choice.display_choice_cat(my_user)
if selected_cat == "menu":
break
selected_prod = choice.display_choice_prod(
my_user, selected_cat)
if selected_prod == "menu":
break
stop = choice.compare_prod_with_sub(selected_cat,
selected_prod, my_user)
if stop == "menu":
break
after_search = choice.after_search("3")
if after_search == "1":
url = choice.display_more_info_about_product(selected_prod)
webbrowser.open_new(url)
after_web = choice.after_search("2")
if after_web == "2":
break
elif after_search == "2":
pass
elif after_search == "3":
break
else:
break
##################################################################################### 3
elif answer == "3":
my_db = dbu.DbUser()
if not my_user.connected:
my_user = my_db.authentication(my_user)
if not my_user.connected:
print("Retour au menu principal ! ")
time.sleep(1)
continue
#consult_database permit to the user to access the database
os.system("cls")
print("\n", "-" * 30, " BASE DE DONNEES ", "-" * 30, "\n")
chain = my_db.history(my_user)
print(chain)
input("Appuyez sur 'entrer' pour revenir au menu principal.")
##################################################################################### 4
elif answer == "4":
print("A bientôt !")
time.sleep(1)
os.system("cls")
sys.exit(2)
else:
print("Je n'ai pas compris.")
def test_database_creation(self):
self.assertEqual(database.Database().name, "Database")
def main():
# Set maximal threads to eight to avoid computation problems
os.environ['NUMEXPR_MAX_THREADS'] = "8"
# Configure logger
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s - %(name)s - ' +
'%(levelname)s - %(message)s',
filename='applog.log',
filemode='w')
# Get logger with name of module
logger = logging.getLogger(__name__)
logger.info("Starting program.")
# Read config data
cfg = utils.load_config(logger, "config/data.json")
# Set constant paths to where data is stored
# Information is retrieved from config file
logger.info("Reading config file...")
TRAIN_FILE = utils.read_string_from_config(logger=logger,
cfg=cfg,
key="trainFile")
IDEAL_FILE = utils.read_string_from_config(logger=logger,
cfg=cfg,
key="idealFile")
TEST_FILE = utils.read_string_from_config(logger=logger,
cfg=cfg,
key="testFile")
TRAIN_PATH = os.path.join(os.path.dirname(__file__), TRAIN_FILE)
IDEAL_PATH = os.path.join(os.path.dirname(__file__), IDEAL_FILE)
TEST_PATH = os.path.join(os.path.dirname(__file__), TEST_FILE)
logger.info("Reading config file...Done")
# Create database instance
database = db.Database(cfg=cfg)
# Save training data and ideal functions in db
training_data = utils.read_data(logger=logger, path=TRAIN_PATH)
ideal_data = utils.read_data(logger=logger, path=IDEAL_PATH)
database.update_training_table(data=training_data)
database.update_ideal_functions_table(data=ideal_data)
# Initiate training process
trainingData = data.TrainingData(training_data=training_data,
ideal_data=ideal_data)
training_result = trainingData.find_ideal_functions()
# Initiate mapping process
testData = data.TestData(ideal_data=ideal_data,
result_data=training_result,
test_filepath=TEST_PATH)
test_result = testData.map_to_functions()
# Save mapping results in db
database.update_result_table(data=test_result)
# Create plotter instance with results
plotter = plot.Plotter(ideal_data=ideal_data,
training_data=training_data,
training_result=training_result,
deviations=trainingData.deviations(),
test_result=test_result)
# Plot results
plotter.plot_results()
# Show results
plotter.show_results()
logger.info("Program has finished.")
