302 lines
7.1 KiB
Python
302 lines
7.1 KiB
Python
import yaml
|
|
import sqlite3
|
|
import os
|
|
import pprint
|
|
import sys
|
|
|
|
DBFILE = 'tmp.db'
|
|
|
|
def main():
|
|
# delete DBfile and run fresh
|
|
os.remove(DBFILE)
|
|
# Load in the yaml data
|
|
with open('basics.yaml') as yl:
|
|
data = yaml.full_load(yl)
|
|
# pprint.pprint(data)
|
|
# Get a DB conn
|
|
conn = get_db_conn()
|
|
# call the functions to input to SQL
|
|
do_abilityscore(data['abilityscore'], conn)
|
|
do_actioncost(data['actioncost'], conn)
|
|
do_alignment(data['alignment'], conn)
|
|
do_frequency(data['frequency'], conn)
|
|
do_langrarity(data['lang_rarity'], conn)
|
|
do_movement(data['movement'], conn)
|
|
do_size(data['size'], conn)
|
|
do_weaponcategory(data['weaponcategory'], conn)
|
|
|
|
# move on to traits
|
|
with open('traits.yaml') as yl:
|
|
data = yaml.full_load(yl)
|
|
# pprint.pprint(data)
|
|
do_traits(data, conn) # does both trait types and traits
|
|
|
|
def do_traits(data, conn):
|
|
# create the two tables
|
|
table = """
|
|
CREATE TABLE traittype (
|
|
traittype_id INTEGER PRIMARY KEY,
|
|
name TEXT NOT NULL
|
|
);
|
|
"""
|
|
table_two = """
|
|
CREATE TABLE trait (
|
|
trait_id INTEGER PRIMARY KEY,
|
|
traittype_id INTEGER,
|
|
short_name TEXT NOT NULL,
|
|
descr TEXT NOT NULL,
|
|
FOREIGN KEY (traittype_id) REFERENCES traittype(traittype_id)
|
|
);
|
|
"""
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
c.execute(table_two)
|
|
# insert data into traittype
|
|
inp_data = []
|
|
for i in data['traittype']:
|
|
inp_data.append((i,)) # trailing comma necessary for one-item tuple
|
|
stmt = "INSERT INTO traittype (name) VALUES (?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
print("Error creating traittype: {}".format(e))
|
|
print(vars(e))
|
|
else:
|
|
conn.commit()
|
|
# insert data into trait
|
|
inp_data = []
|
|
for i in data['trait']:
|
|
inp_data.append((i['descr'], i['name'], i['type'])) # trailing comma necessary for one-item tuple
|
|
stmt = "INSERT INTO trait (descr, short_name, traittype_id) SELECT ?,?, traittype_id FROM traittype WHERE traittype.name=?"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except sqlite3.Error as e:
|
|
print("Error creating trait input: {}".format(e))
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
print("Error creating trait: {}".format(e))
|
|
print(vars(e))
|
|
else:
|
|
conn.commit()
|
|
|
|
def do_size(data, conn):
|
|
table = """
|
|
CREATE TABLE size (
|
|
size_id INTEGER PRIMARY KEY,
|
|
short_name TEXT NOT NULL UNIQUE,
|
|
space_in_ft INTEGER NOT NULL,
|
|
reach_tall_ft INTEGER NOT NULL,
|
|
reach_long_ft INTEGER NOT NULL
|
|
);
|
|
"""
|
|
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
|
|
inp_data = []
|
|
for i in data:
|
|
inp_data.append((i['name'], i['space_in_ft'], i['reach_tall_ft'], i['reach_long_ft']))
|
|
|
|
stmt = "INSERT INTO size (short_name, space_in_ft, reach_tall_ft, reach_long_ft) VALUES (?,?,?,?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
print("Error creating size")
|
|
else:
|
|
conn.commit()
|
|
|
|
def do_weaponcategory(data, conn):
|
|
table = """
|
|
CREATE TABLE weaponcategory (
|
|
weaponcategory_id INTEGER PRIMARY KEY,
|
|
"name" TEXT NOT NULL UNIQUE
|
|
);
|
|
"""
|
|
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
|
|
inp_data = []
|
|
for i in data:
|
|
inp_data.append((i,)) # trailing comma necessary for one-item tuple
|
|
|
|
stmt = "INSERT INTO weaponcategory(name) VALUES (?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
print("Error creating weaponcategory: {}".format(e))
|
|
print(vars(e))
|
|
else:
|
|
conn.commit()
|
|
|
|
def do_movement(data, conn):
|
|
table = """
|
|
CREATE TABLE movement (
|
|
movement_id INTEGER PRIMARY KEY,
|
|
"name" TEXT UNIQUE NOT NULL
|
|
);
|
|
"""
|
|
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
|
|
inp_data = []
|
|
for i in data:
|
|
inp_data.append((i,)) # trailing comma necessary for one-item tuple
|
|
|
|
stmt = "INSERT INTO movement(name) VALUES (?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
print("Error creating movement: {}".format(e))
|
|
print(vars(e))
|
|
else:
|
|
conn.commit()
|
|
|
|
def do_frequency(data, conn):
|
|
table = """
|
|
CREATE TABLE frequency (
|
|
freq_id INTEGER PRIMARY KEY,
|
|
freq_descr TEXT NOT NULL UNIQUE
|
|
);
|
|
"""
|
|
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
|
|
inp_data = []
|
|
for i in data:
|
|
inp_data.append((i,)) # trailing comma necessary for one-item tuple
|
|
|
|
stmt = "INSERT INTO frequency(freq_descr) VALUES (?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
print("Error creating frequency: {}".format(e))
|
|
print(vars(e))
|
|
else:
|
|
conn.commit()
|
|
|
|
def do_alignment(data, conn):
|
|
# print(data)
|
|
table = """
|
|
CREATE TABLE alignment (
|
|
alignment_id INTEGER PRIMARY KEY,
|
|
"name" TEXT UNIQUE NOT NULL, -- 'Lawful Good'
|
|
abbr TEXT UNIQUE NOT NULL -- 'LG'
|
|
);
|
|
"""
|
|
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
|
|
inp_data = []
|
|
for i in data:
|
|
inp_data.append((i['name'], i['abbr']))
|
|
|
|
stmt = "INSERT INTO alignment(name, abbr) VALUES (?,?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
print("Error creating alignment")
|
|
else:
|
|
conn.commit()
|
|
|
|
def do_langrarity(data, conn):
|
|
table = """
|
|
CREATE TABLE langrarity (
|
|
rarity_id INTEGER PRIMARY KEY,
|
|
rarity_name TEXT NOT NULL UNIQUE
|
|
);
|
|
"""
|
|
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
|
|
inp_data = []
|
|
for i in data:
|
|
inp_data.append((i,)) # trailing comma necessary for one-item tuple
|
|
|
|
stmt = "INSERT INTO langrarity(rarity_name) VALUES (?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
e = sys.exc_info()[0]
|
|
print("Error creating langrarity: {}".format(e))
|
|
print(vars(e))
|
|
else:
|
|
conn.commit()
|
|
|
|
def do_actioncost(data, conn):
|
|
table = """
|
|
CREATE TABLE actioncost (
|
|
actioncost_id INTEGER PRIMARY KEY,
|
|
name TEXT NOT NULL UNIQUE,
|
|
abbr TEXT NOT NULL UNIQUE
|
|
);
|
|
"""
|
|
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
|
|
inp_data = []
|
|
for i in data:
|
|
inp_data.append((i['name'], i['abbr']))
|
|
|
|
stmt = "INSERT INTO actioncost(name, abbr) VALUES (?,?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
print("Error creating actioncost")
|
|
else:
|
|
conn.commit()
|
|
|
|
def do_abilityscore(data, conn):
|
|
table = """
|
|
CREATE TABLE abilityscore (
|
|
abilityscore_id INTEGER PRIMARY KEY,
|
|
flag_rep INTEGER NOT NULL,
|
|
short_name TEXT NOT NULL UNIQUE,
|
|
long_name TEXT NOT NULL UNIQUE
|
|
);
|
|
"""
|
|
|
|
c = conn.cursor()
|
|
c.execute(table)
|
|
|
|
inp_data = []
|
|
for i in data:
|
|
inp_data.append((i['flag_rep'], i['short_name'], i['long_name']))
|
|
|
|
stmt = "INSERT INTO abilityscore (flag_rep, short_name, long_name) VALUES (?,?,?)"
|
|
try:
|
|
conn.executemany(stmt,inp_data)
|
|
except:
|
|
print("Error creating abilityscore")
|
|
else:
|
|
conn.commit()
|
|
|
|
def get_db_conn():
|
|
## Get database connection
|
|
conn = sqlite3.connect(DBFILE) # eventually hook this up to be the main db
|
|
## Set pragmas
|
|
pragma1 = "PRAGMA synchronous=OFF;"
|
|
pragma2 = "PRAGMA count_changes=OFF;"
|
|
pragma3 = "PRAGMA journal_mode=MEMORY;"
|
|
pragma4 = "PRAGMA temp_store=MEMORY;"
|
|
pragma5 = "PRAGMA foreign_keys=ON;"
|
|
conn.execute(pragma1)
|
|
conn.execute(pragma2)
|
|
conn.execute(pragma3)
|
|
conn.execute(pragma4)
|
|
conn.execute(pragma5)
|
|
return conn
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|