def mark_ended_scene(history_db, scene): """marks a scene as ended in the history db""" from src.praxxis.sqlite import connection from src.praxxis.util import error import itertools conn = connection.create_connection(history_db) cur = conn.cursor() try: check_ended(history_db, scene, conn, cur) except error.SceneNotFoundError as e: raise e except error.EndEndedSceneError as e: raise e active_scenes = get_active_scenes(history_db) if len(active_scenes) <= 1 and scene in list( itertools.chain(*active_scenes)): raise error.LastActiveSceneError(scene) else: end_scene = 'UPDATE "SceneHistory" SET Ended = 1 WHERE Scene = ?' cur.execute(end_scene, (scene, )) conn.commit() conn.close() return 0
def init_user_info(telemetry_db, send_telemetry=1): """From name of database file, creates and initializes user info""" import uuid import getpass from src.praxxis.sqlite import connection conn = connection.create_connection(telemetry_db) cur = conn.cursor() create_userinfo_table = 'CREATE TABLE "UserInfo" (Key TEXT PRIMARY KEY, Value TEXT)' create_user_id = 'INSERT INTO "UserInfo" (Key, Value) VALUES ("ID",?)' create_telem_permissions = 'INSERT INTO "UserInfo" (Key, Value) VALUES ("TELEMETRY", ?)' create_host = 'INSERT INTO "UserInfo" (Key) VALUES ("Host")' create_url = 'INSERT INTO "UserInfo" (Key, Value) VALUES ("URL", ?)' create_user = '******' create_pswd = 'INSERT INTO "UserInfo" (Key) VALUES ("Password")' create_custom_editor = 'INSERT INTO "UserInfo" (Key, Value) VALUES ("custom_editor", ?)' create_telemetry_table = 'CREATE TABLE "TelemBacklog" (LocalCopy TEXT PRIMARY KEY, SceneID TEXT, Error TEXT, ' \ 'Operation INTEGER) ' id_val = str(uuid.uuid4()) cur.execute(create_userinfo_table) cur.execute(create_user_id, (id_val, )) cur.execute(create_telem_permissions, (send_telemetry, )) url = "https://{0}:30443/gateway/default/webhdfs/v1/praxxis" default_editor = "vim" cur.execute(create_host) cur.execute(create_url, (url, )) cur.execute(create_user) cur.execute(create_pswd) cur.execute(create_custom_editor, (default_editor, )) cur.execute(create_telemetry_table) conn.commit() conn.close()
def delete_scene(history_db, scene): """deletes the specified scene""" import itertools from src.praxxis.sqlite import connection from src.praxxis.util import error conn = connection.create_connection(history_db) cur = conn.cursor() try: check_ended(history_db, scene, conn, cur) except error.SceneNotFoundError as e: raise e except error.EndEndedSceneError: pass active_scenes = get_active_scenes(history_db) if len(active_scenes) <= 1 and scene in list( itertools.chain(*active_scenes)): raise error.LastActiveSceneError(scene) else: delete_scene = 'DELETE FROM "SceneHistory" WHERE Scene = ?' cur.execute(delete_scene, (scene, )) conn.commit() conn.close() return 0
def set_notebook_parameters(library_db, notebook_name, parameter_name, parameter_value, library): """set or update an parameter variable""" from src.praxxis.sqlite import connection conn = connection.create_connection(library_db) cur = conn.cursor() set_notebook_param = 'INSERT OR IGNORE INTO "NotebookDefaultParam" (Parameter, Value, Notebook, Library) VALUES(' \ '?, ?, ?, ?) ' update_notebook_param = 'UPDATE "NotebookDefaultParam" SET Value = ? WHERE Parameter = ? AND Notebook = ? AND ' \ 'Library = ? ' cur.execute(set_notebook_param, ( parameter_name, parameter_value, notebook_name, library, )) cur.execute(update_notebook_param, ( parameter_value, parameter_name, notebook_name, library, )) conn.commit() conn.close()
def test_init_history_db(setup, history_db): """ tests the initializing of the history db for columns and tables """ from src.praxxis.sqlite import connection conn = connection.create_connection(history_db) cur = conn.cursor() check_scene_history_table = "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='SceneHistory';" check_scene_list_table = "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='SceneList';" cur.execute(check_scene_history_table) history = bool(cur.fetchone()[0]) cur.execute(check_scene_list_table) scene_list = bool(cur.fetchone()[0]) assert history assert scene_list check_scene_history_columns = "SELECT * FROM 'SceneHistory';" check_scene_list_columns = "SELECT * FROM 'SceneList';" cur.execute(check_scene_history_columns) library_metadata_columns = [description[0] for description in cur.description] cur.execute(check_scene_list_columns) scene_list_columns = [description[0] for description in cur.description] conn.close() assert set(library_metadata_columns) == set(['ID', 'Scene', 'Ended']) assert set(scene_list_columns) == set(['ID', 'Scene'])
def test_init_library_db(setup, library_db): """ tests the initializing of the library db for columns and tables """ from src.praxxis.sqlite import connection conn = connection.create_connection(library_db) cur = conn.cursor() check_library_metadata_table = "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='LibraryMetadata';" check_notebooks_table = "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='Notebooks';" check_parameter_table = "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='Parameters';" check_notebook_parameter_table = "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='NotebookDefaultParam';" cur.execute(check_library_metadata_table) library_metadata = bool(cur.fetchone()[0]) cur.execute(check_notebooks_table) notebooks = bool(cur.fetchone()[0]) cur.execute(check_parameter_table) parameter = bool(cur.fetchone()[0]) cur.execute(check_notebook_parameter_table) notebook_parameter = bool(cur.fetchone()[0]) assert library_metadata assert notebooks assert parameter assert notebook_parameter check_library_metadata_columns = "SELECT * FROM'LibraryMetadata';" check_notebooks_columns = "SELECT * FROM 'Notebooks';" check_parameter_columns = "SELECT * FROM 'Parameters';" check_notebook_parameter_columns = "SELECT * FROM 'NotebookDefaultParam'" cur.execute(check_library_metadata_columns) library_metadata_columns = [ description[0] for description in cur.description ] cur.execute(check_notebooks_columns) notebook_columns = [description[0] for description in cur.description] cur.execute(check_parameter_columns) parameter_columns = [description[0] for description in cur.description] cur.execute(check_notebook_parameter_columns) notebook_parameter_columns = [ description[0] for description in cur.description ] assert library_metadata_columns == ['Path', 'Readme', 'Library', 'Remote'] assert notebook_columns == ['Path', 'Notebook', 'Library', 'RawUrl'] assert parameter_columns == ['Parameter', 'Value'] assert notebook_parameter_columns == [ 'Parameter', 'Value', 'Notebook', 'Library' ] conn.close()
def list_notebook_param(library_db, notebook, library): from src.praxxis.sqlite import connection conn = connection.create_connection(library_db) cur = conn.cursor() param = 'SELECT Parameter, Value from "NotebookDefaultParam" WHERE Notebook = ? AND Library = ?' cur.execute(param, (notebook, library)) rows = cur.fetchall() conn.close() return rows
def set_many_params(current_scene_db, parameter_list): from src.praxxis.sqlite import connection conn = connection.create_connection(current_scene_db) cur = conn.cursor() set_many_params = 'INSERT OR IGNORE INTO "Parameters"(Parameter, Value) VALUES(?,?)' cur.executemany(set_many_params, parameter_list) conn.commit() conn.close()
def remove_ruleset(rulesengine_db, name): """removes a ruleset from the list of rulesets""" from src.praxxis.sqlite import connection conn = connection.create_connection(rulesengine_db) cur = conn.cursor() remove_ruleset = 'DELETE FROM "RulesEngine" WHERE Name = ?' cur.execute(remove_ruleset, (name, )) conn.commit() conn.close()
def clear_ruleset_list(rulesengine_db): """removes all rulesets from list, for testing""" from src.praxxis.sqlite import connection conn = connection.create_connection(rulesengine_db) cur = conn.cursor() cleanup = 'DELETE FROM "RulesEngine"' cur.execute(cleanup) conn.commit() conn.close()
def clear_history(current_scene_db): """empties the history table""" from src.praxxis.sqlite import connection conn = connection.create_connection(current_scene_db) cur = conn.cursor() clear_history = 'DELETE FROM "History"' cur.execute(clear_history) conn.commit() conn.close()
def resume_scene(scene_db, scene): """resumes a scene""" from src.praxxis.sqlite import connection conn = connection.create_connection(scene_db) cur = conn.cursor() end_scene = 'UPDATE "SceneMetadata" SET Ended = 0 WHERE Scene = ?' cur.execute(end_scene, (scene, )) conn.commit() conn.close()
def end_scene(current_scene_db, scene): """marks the specified scene as ended""" from src.praxxis.sqlite import connection conn = connection.create_connection(current_scene_db) cur = conn.cursor() end_scene = 'UPDATE "SceneMetadata" SET Ended = 1 WHERE Scene = ?' cur.execute(end_scene, (scene, )) conn.commit() conn.close()
def write_scene_list(history_db, scene_list): """writes to scene list table""" from src.praxxis.sqlite import connection conn = connection.create_connection(history_db) cur = conn.cursor() insert_line = 'INSERT INTO "SceneList" (Scene) VALUES (?)' cur.executemany(insert_line, scene_list) conn.commit() conn.close()
def clear_notebook_parameters(library_db): """empties the notebook parameter table""" from src.praxxis.sqlite import connection conn = connection.create_connection(library_db) cur = conn.cursor() clear_parameter = 'DELETE FROM "NotebookDefaultParam"' cur.execute(clear_parameter) conn.commit() conn.close()
def update_current_scene(history_db, scene): """updates the current scene in the history db""" from src.praxxis.sqlite import connection conn = connection.create_connection(history_db) cur = conn.cursor() add_current_scene = 'INSERT INTO "SceneHistory"(Scene, Ended) VALUES(?, 0)' cur.execute(add_current_scene, (scene, )) conn.commit() conn.close()
def delete_from_backlog(user_info_db, local_copy): """deletes sent telemetry from backlog, if in backlog""" from src.praxxis.sqlite import connection conn = connection.create_connection(user_info_db) cur = conn.cursor() cleanup = 'DELETE FROM "TelemBacklog" WHERE LocalCopy = ?' cur.execute(cleanup, (local_copy, )) conn.commit() conn.close()
def clear_backlog(user_info_db): """clears backlog completely (for testing purposes)""" from src.praxxis.sqlite import connection conn = connection.create_connection(user_info_db) cur = conn.cursor() cleanup = 'DELETE FROM "TelemBacklog"' cur.execute(cleanup) conn.commit() conn.close()
def load_notebook(library_db, path, notebook, library, raw_url=None): """load a notebook into the library db""" from src.praxxis.sqlite import connection conn = connection.create_connection(library_db) cur = conn.cursor() load_library = 'INSERT OR IGNORE INTO "Notebooks"(Path, Notebook, Library, RawUrl) VALUES(?, ?, ?, ?)' cur.execute(load_library, (path, notebook, library, raw_url)) conn.commit() conn.close()
def mark_resumed_scene(history_db, scene): """mark a scene as resumed in the history db""" from src.praxxis.sqlite import connection conn = connection.create_connection(history_db) cur = conn.cursor() end_scene = 'UPDATE "SceneHistory" SET Ended = 0 WHERE Scene = ?' cur.execute(end_scene, (scene, )) conn.commit() conn.close()
def clear_loaded_libararies(library_db): from src.praxxis.sqlite import connection conn = connection.create_connection(library_db) cur = conn.cursor() clear_metadata = 'DELETE FROM "LibraryMetadata"' clear_notebooks = 'DELETE FROM "Notebooks"' cur.execute(clear_metadata) cur.execute(clear_notebooks) conn.commit() conn.close()
def add_to_backlog(user_info_db, local_copy, scene_id, error, operation=0): """adds this file to the telemetry backlog""" from src.praxxis.sqlite import connection conn = connection.create_connection(user_info_db) cur = conn.cursor() add = 'INSERT OR REPLACE INTO "TelemBacklog" (LocalCopy, SceneID, Error, Operation) VALUES (?,?,?,?)' cur.execute(add, (local_copy, scene_id, error, operation)) conn.commit() conn.close() return
def write_setting(user_info_db, setting, value): """changes the value of setting""" from src.praxxis.sqlite import connection conn = connection.create_connection(user_info_db) cur = conn.cursor() update = 'UPDATE "UserInfo" SET Value = ? WHERE Key = ?' cur.execute(update, (value, setting)) conn.commit() conn.close() return
def get_scene_id(current_scene_db): """gets the scene ID from the scene db""" from src.praxxis.sqlite import connection conn = connection.create_connection(current_scene_db) cur = conn.cursor() get_scene_id = 'SELECT ID FROM "SceneMetadata"' cur.execute(get_scene_id) id = str(cur.fetchone()[0]) conn.close() return id
def telem_on(user_info_db): """returns boolean of whether telemetry is enabled""" from src.praxxis.sqlite import connection conn = connection.create_connection(user_info_db) cur = conn.cursor() query = 'SELECT Value FROM "UserInfo" WHERE Key = "TELEMETRY"' cur.execute(query) conn.commit() response = cur.fetchone()[0] return str(response) == str(1) # True if telemetry is on
def list_notebooks(library_db, query_start, query_end): """lists all loaded notebooks""" from src.praxxis.sqlite import connection conn = connection.create_connection(library_db) cur = conn.cursor() list_libraries = 'SELECT Notebook, Path, Library, RawUrl FROM "Notebooks" LIMIT ?, ?' cur.execute(list_libraries, (query_start, query_end)) rows = cur.fetchall() conn.close() return rows
def remove_notebook(library_db, notebook, library): from src.praxxis.sqlite import connection conn = connection.create_connection(library_db) cur = conn.cursor() clear_parameter = 'DELETE FROM NotebookDefaultParam Where Notebook = ? AND Library = ?' clear_notebook = 'DELETE FROM Notebooks WHERE Notebook = ? AND Library = ?' cur.execute(clear_parameter, (notebook, library)) cur.execute(clear_notebook, (notebook, library)) conn.commit() conn.close()
def get_current_scene(history_db): """gets the current scene from the history db""" from src.praxxis.sqlite import connection conn = connection.create_connection(history_db) cur = conn.cursor() get_current_scene = 'SELECT Scene FROM "SceneHistory" WHERE Ended != 1 ORDER BY ID DESC LIMIT 0, 1' cur.execute(get_current_scene) rows = cur.fetchall() conn.close() return rows[0][0]
def init_rulesengine_db(rulesengine_db): """initializes the base rules engine database""" from src.praxxis.sqlite import connection conn = connection.create_connection(rulesengine_db) cur = conn.cursor() create_rules_table = 'CREATE TABLE "RulesEngine" (ID INTEGER PRIMARY KEY AUTOINCREMENT, Name TEXT, Path TEXT, ' \ 'Active INTEGER) ' cur.execute(create_rules_table) conn.commit() conn.close()
def init_model_db(model_db): """initializes the base model database""" from src.praxxis.sqlite import connection conn = connection.create_connection(model_db) cur = conn.cursor() create_models_table = 'CREATE TABLE "Models" (Name TEXT PRIMARY KEY, Info TEXT, Date TEXT, Path TEXT, ' \ 'ConverterPath TEXT) ' cur.execute(create_models_table) conn.commit() conn.close()