def main():
if len(sys.argv) != 2:
print("Numbers of parameter are wrong")
else:
list_of_prints = scorelib.load(sys.argv[1])
for content in list_of_prints:
content.format()
print()
def database(data, output):
conn = sqlite3.connect(output)
with open('scorelib.sql', 'r') as fd:
script = fd.read()
conn.executescript(script)
conn.commit()
prints = scorelib.load(data)
for p in prints:
process_print(p, conn)
conn.close()
def main():
if len(sys.argv) >= 2:
filename = sys.argv[1]
else:
print('You have to specify a filename as first argument.')
return
prints = load(filename)
for item in prints:
item.format()
print('')
def main(args):
prints = scorelib.load(args[0])
ids = {}
connection = sqlite3.connect(args[1])
connection.cursor().executescript(
open(args[2] if len(args) > 2 else INIT_SCRIPT).read())
storePeople(connection, loadPeople(prints), ids)
storeCompositions(connection, loadCompositions(prints), ids)
storeEditions(connection, loadEditions(prints), ids)
storePrints(connection, prints, ids)
storeEditorLinks(connection, loadEditorLinks(prints), ids)
storeComposerLinks(connection, loadComposerLinks(prints), ids)
connection.commit()
def main():
input_source = argv[1]
output_db_filename = argv[2]
if os.path.isfile(output_db_filename):
os.remove(output_db_filename)
db_conn = sqlite3.connect(output_db_filename)
db_cursor = db_conn.cursor()
sql_source_file = 'scorelib.sql'
create_tables(db_cursor, sql_source_file, output_db_filename)
records = scorelib.load(input_source)
persist_records(db_cursor, records)
db_conn.commit()
def main(argv):
prints = scorelib.load(sys.argv[1])
connection = initialize_database(sys.argv[2])
people = get_people(prints)
insert_people_to_database(people, connection)
compositions = get_compostions(prints)
insert_compositions_to_database(compositions, connection)
editions = get_editions(prints)
insert_editions_to_database(editions, connection)
insert_prints_to_database(prints, connection)
connection.commit()
def main():
if len(sys.argv) != 3:
sys.exit('Wrong program arguments')
_, dataFile, datFile = sys.argv
conn = sqlite3.connect(datFile)
cursor = conn.cursor()
try:
with open('scorelib.sql') as sql_file:
cursor.executescript(sql_file.read())
except sqlite3.OperationalError:
pass
saveData(load(dataFile), cursor)
conn.commit()
conn.close()
def main():
if len(sys.argv) >= 2:
input_filename = sys.argv[1]
else:
print('You have to specify an input filename as a first argument.')
return
if len(sys.argv) >= 3:
output_filename = sys.argv[2]
else:
print('You have to specify an output filename as a second argument.')
return
db_connection = sqlite3.connect(output_filename)
db_cursor = db_connection.cursor()
sql_filename = 'scorelib.sql'
with open(sql_filename, 'r') as sql_schema_file:
sql_script = sql_schema_file.read()
db_cursor.executescript(sql_script)
db_connection.commit()
persisted_people = dict()
persisted_scores = dict()
persisted_editions = dict()
prints = load(input_filename)
for p in prints:
persist_people(db_cursor, persisted_people, p)
persist_score(db_cursor, persisted_people, persisted_scores, p)
persist_edition(db_cursor, persisted_people, persisted_scores,
persisted_editions, p)
persist_print(db_cursor, persisted_editions, p)
db_connection.commit()
db_connection.close()
def main():
if len(sys.argv) < 3:
exit("Too less arguments calling script")
data_file = sys.argv[1]
db_file = sys.argv[2]
create_db_file = "scorelib.sql"
# Delete the old table
if os.path.isfile(db_file):
os.remove(db_file)
# create a database connection
conn = create_connection(db_file)
if conn is not None:
create_db(conn, create_db_file)
else:
print("Error! cannot create the database connection.")
prints = scorelib.load(data_file)
for p in prints:
create_print(conn, p)
conn.commit()
def main():
print()
if len(sys.argv) != 3:
print('Wrong number of arguments')
print('Example: ')
print('./import.py scorelib.txt scorelib.dat')
# Just for comfortable testing
# os.remove(sys.argv[2])
conn = sqlite3.connect(sys.argv[2])
# For debugging SQL queries
# conn.set_trace_callback(print)
cur = conn.cursor()
# with open('scorelib.sql') as fp:
# cur.executescript(fp.read())
init_database(cur)
prints_list = scorelib.load(sys.argv[1])
save_to_database(cur, prints_list)
conn.commit()
def obtain_input_data_as_objects():
return scorelib.load(sys.argv[1])
def main(args):
for i in load(args[0]):
i.format()
from scorelib import load
import sys
data = load(sys.argv[1])
for item in data:
print(item.format())
print("")
def test():
filename = sys.argv[1]
prints = scorelib.load(filename)
for prnt in prints:
prnt.format()
print("")
#!/usr/bin/env python3
import sys
import scorelib
# start
if len(sys.argv) < 2:
print("argv error: not enough program arguments")
print("invocation: ./test.py file")
sys.exit()
for print_instance in scorelib.load(sys.argv[1]):
print_instance.format()
print()
from scorelib import Print
from scorelib import load
import sys
prints = load(sys.argv[1])
for p in prints:
p.format()
print()
def main(argv):
prints = scorelib.load(sys.argv[1])
for item in prints:
item.format()
import sqlite3
import sys
import os
from scorelib import load
input = sys.argv[1]
output = sys.argv[2]
if os.path.isfile(output):
os.remove(output)
con = sqlite3.connect(str(output))
cur = con.cursor()
cur.executescript(open("scorelib.sql").read())
prints = load(input)
for p in prints:
p.save(con)
con.commit()
res = c.fetchone()
if res is None:
c.execute("insert into score_author(score, composer) values (?, ?)", (com_id, author))
def insert_edition_authors(ed_id, ed_author_ids, c):
for author in ed_author_ids:
c.execute("select * from edition_author where edition IS ? and editor IS ?", (ed_id, author))
res = c.fetchone()
if res is None:
c.execute("insert into edition_author(edition, editor) values (?, ?)", (ed_id, author))
def insert_print(p, ed_id, c):
partiture = 'N'
if p.partiture:
partiture = 'Y'
c.execute("select * from print where id IS ? and partiture IS ? and edition IS ?", (p.print_id, partiture, ed_id))
res = c.fetchone()
if res is None:
c.execute("insert into print(id, partiture, edition) values (?, ?, ?)", (p.print_id, partiture, ed_id))
return c.lastrowid
return res[0]
prints = scorelib.load(sys.argv[1])
conn = create_db(sys.argv[2])
insert_to_db(prints, conn)
def processData(sourceFile, cursor, connection):
prints = scorelib.load(sourceFile)
for print in prints:
processPrint(print, cursor)
connection.commit()
if len(sys.argv) != 3:
raise NotImplementedError(
f"Import.py is supposed to be called with two additional parameters, "
f"was called with {len(sys.argv)} instead:\n"
"'./import.py scorelib.txt scorelib.dat'")
filename = sys.argv[1]
database = sys.argv[2]
# Removes the old file.
# if os.path.exists(database):
# os.remove(database)
all_prints = scorelib.load(filename)
try:
with open("scorelib.sql", 'r', encoding='utf-8') as FILE:
sql_script = FILE.read()
# Vytvořit tabulky
db_connection = sqlite3.connect(database) # scorelib.dat
cursor = db_connection.cursor()
cursor.executescript(sql_script)
# Vložit data do tabulek
insert_into_db(all_prints)
db_connection.commit()
db_connection.close()
except FileNotFoundError:
#!/usr/bin/python3
import sys
from scorelib import load
_, textFile = sys.argv
compositions = load(textFile)
for composition in compositions:
format(composition.format())
print()
cur = con.cursor()
cur.executescript(script_file.read())
con.commit()
def persist_objects(database, lst):
"This function persists objects in the given list"
con = sqlite3.connect(database)
con.row_factory = sqlite3.Row
cur = con.cursor()
for obj in lst:
obj.persist(cur)
con.commit()
con.close()
#script body
DB_SCHEMA_SCRIPT = "./scorelib.sql"
#parse arguments
FILENAME, DB = parse_args()
#create db schema
create_db_schema(DB, DB_SCHEMA_SCRIPT)
#load print objects from text file
PRINT_LIST = scorelib.load(FILENAME)
#persist objects
persist_objects(DB, PRINT_LIST)
if tuple not in newVoicesList:
return (False, None)
return (True, foundEdit[0])
def storeAllPrints(cursor, itemPrint):
#store composition, score authors and voices
tupleBooleanAndIdComposition = isCompositionAlreadyInTable(
cursor, itemPrint.composition())
compositionId = tupleBooleanAndIdComposition[1]
if not tupleBooleanAndIdComposition[0]:
compositionId = storeComposition(cursor, itemPrint.composition())
#store edition and edition author
tupleBooleanAndIdEdition = isEditionAlreadyInTable(cursor,
itemPrint.edition)
editionId = tupleBooleanAndIdEdition[1]
if not tupleBooleanAndIdEdition[0]:
editionId = storeEdition(cursor, itemPrint.edition, compositionId)
#store print
storeOnePrint(cursor, itemPrint, editionId)
prints = scorelib.load(input)
for item in prints:
storeAllPrints(cursor, item)
connection.commit()
connection.close()
# -*- coding: utf-8 -*-
import scorelib
import sys
import codecs
if len(sys.argv) < 2:
exit("Too less arguments calling script")
fileName = sys.argv[1]
sys.stdout = codecs.getwriter('utf-8')(sys.stdout.buffer)
prints = scorelib.load(fileName)
for print_obj in prints:
print_obj.format()
print()
def main():
prints = scorelib.load(argv[1])
for record in prints:
record.format()
print('')
import sys
import argparse
from os import path
from scorelib import load
def eprint(*args, **kwargs):
"This function prints message to error output"
print(*args, file=sys.stderr, **kwargs)
def parse_args():
"This function parses command-line arguments and does basic checks"
parser = argparse.ArgumentParser()
parser.add_argument("filename", help="source file")
args = parser.parse_args()
if not path.isfile(args.filename):
eprint("Filename doesn't refer to a valid file")
exit(2)
return args.filename
#script body
filename = parse_args()
print_list = load(filename)
for p in print_list:
p.format()
def main():
if len(sys.argv) != 3:
print("Numbers of parameter are wrong")
else:
to_db(scorelib.load(sys.argv[1]))
