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