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()
