def main(config):
database_manager = DatabaseManager()
if not isinstance(config.V, list):
config.V = [config.V]
if not isinstance(config.E, list):
config.E = [config.E]
if not isinstance(config.T, list):
config.T = [config.T]
print(f"V: {config.V}, E: {config.E}, T: {config.T}")
for V in config.V:
for E in config.E:
for T in config.T:
generate_data(V, E, T, config.datapath)
# I am executing "make target" here
if config.version == "all":
i = 0
while path.exists(f"v{i}"):
run_version(config, i, database_manager)
i += 1
elif isinstance(config.version, list):
for i in config.version:
run_version(config, i, database_manager)
elif isinstance(config.version, int):
run_version(config, config.version, database_manager)
else:
raise Exception("Invalid config version")
database_manager.close()
return
def display_series(self):
"""Retrieves and displays info for selected series.
This function retrieves the unique rowid for the selected
series and retrieves the series from the database. It then
updates all main window elements which show series info to
show up-to-date properties. Once all series information is
properly displayed, buttons which can change the selected
series's properties are enabled.
"""
data_mgr = DatabaseManager(Config().database_name, None)
if self.list_series.currentItem():
series_rowid = self.list_series.currentItem().data(Qt.UserRole)
cur = data_mgr.query("SELECT rowid, * FROM Series WHERE rowid = %d"
% series_rowid)
series = entry_to_series(cur.fetchone())
if series:
self.list_series.currentItem().setText(series.compact_string())
self.table_setup(series)
self.edit_series_button.setEnabled(True)
self.remove_series_button.setEnabled(True)
self.add_next_volume_button.setEnabled(True)
self.mark_as_completed_button.setEnabled(True)
def get_list_items(self):
"""Retrieves all series from database and populates list in main window.
Populates the list in the main window with the compact_string()
representations of all the series in the database, sorting by the
given property (default "name") and placing any series with an
unknown value for that property at the end of the list
"""
order = self.get_list_order()
data_mgr = DatabaseManager(Config().database_name, None)
cur = data_mgr.query("SELECT rowid, * FROM Series ORDER BY %s "
"COLLATE NOCASE ASC, name ASC;" % order)
entries = cur.fetchall()
unknown_entries = []
selected_series = None
selected_series_found = False
if self.list_series.currentItem():
selected_series = self.list_series.currentItem().data(Qt.UserRole)
if hasattr(self, "add_window") and self.add_window.added > -1:
selected_series = self.add_window.added
self.add_window.added = -1
self.list_series.clear()
for entry in entries:
if entry[SI[order.upper()]] in ["Unknown", ""]:
unknown_entries.append(entry)
continue
series = entry_to_series(entry)
# Check if any filters are selected.
if not self.check_filters(series):
continue
series_item = QListWidgetItem(series.compact_string())
series_item.setData(Qt.UserRole, series.rowid)
self.list_series.addItem(series_item)
if selected_series and selected_series == series.rowid:
self.list_series.setCurrentItem(series_item)
selected_series_found = True
for entry in unknown_entries:
series = entry_to_series(entry)
series_item = QListWidgetItem(series.compact_string())
series_item.setData(Qt.UserRole, series.rowid)
self.list_series.addItem(series_item)
if selected_series and selected_series == series.rowid:
self.list_series.setCurrentItem(series_item)
selected_series_found = True
# If previous series item no longer exists, select first entry in list
if selected_series and not selected_series_found:
self.list_series.setCurrentRow(0)
if not self.list_series.currentItem():
self.clear_table()
self.filter_series_list()
def toggle_is_completed(self):
"""Toggles completion status of selected series."""
data_mgr = DatabaseManager(Config().database_name, None)
if self.list_series.currentItem():
series_rowid = self.list_series.currentItem().data(Qt.UserRole)
cur = data_mgr.query("SELECT rowid, * FROM Series WHERE rowid = %d"
% series_rowid)
series = entry_to_series(cur.fetchone())
series.is_completed ^= 1
series.update_database_entry(data_mgr)
self.get_list_items()
def api_add_restaurant_menu(restaurantname, menuname):
with app.app_context():
cache.clear()
id = DatabaseManager.addRestaurantMenu(app.logger, restaurantname,
menuname)
result = 'Restaurant does not exist!'
restaurant_map = DatabaseManager.getRestaurants(app.logger)
if restaurantname in restaurant_map.values():
result = 'Menu added. URL ' + url_for(
'api_restaurant_menus',
restaurantname=restaurantname) + '/' + menuname
return result
def add_next_volume(self):
"""Adds next volume to selected series."""
data_mgr = DatabaseManager(Config().database_name, None)
if self.list_series.currentItem():
series_rowid = self.list_series.currentItem().data(Qt.UserRole)
cur = data_mgr.query("SELECT rowid, * FROM Series WHERE rowid = %d"
% series_rowid)
series = entry_to_series(cur.fetchone())
if not series.is_completed:
series.add_volumes(str(series.next_volume))
series.update_database_entry(data_mgr)
self.get_list_items()
def get_setting(key):
database_manager = DatabaseManager()
value = database_manager.get_setting(key)
if value is None:
print(TAG + "setting("+key+") not found")
return False
else:
print(TAG + "Retrieved setting[" + key + "]: " + str(value))
return value
def api_del_restaurant_menu(restaurantname, menuname):
with app.app_context():
cache.clear()
result = 'Menu not found'
menu_map = DatabaseManager.getRestaurantMenus(app.logger, restaurantname)
if menuname in menu_map.values():
ret = DatabaseManager.delRestaurantMenu(app.logger, restaurantname,
menuname)
result = 'Unable to delete menu named ' + menuname + 'from restaurant named ' + restaurantname
if ret:
result = 'Successfully deleted menu named ' + menuname + ' from restaurant named ' + restaurantname
return result
def api_add_restaurant(restaurantname):
with app.app_context():
cache.clear()
id = DatabaseManager.addRestaurant(app.logger, restaurantname)
result = 'Restaurant added. URL ' + url_for(
'api_restaurants') + '/' + restaurantname
return result
def save_changes(self):
show_empty_series = self.show_empty_series_button_group.checkedId()
self.config.set_property("show_empty_series", show_empty_series)
default_to_gui = self.default_to_gui_button_group.checkedId()
self.config.set_property("default_to_gui", default_to_gui)
name = self.database_name_text.text()
self.results_dialog = QMessageBox()
if name == self.config.database_name:
self.close()
elif is_database(name):
self.config.set_property("database_name", name)
self.results_dialog.setText("Database name has been changed. ")
self.results_dialog.show()
# set up database if table doesn't exist
DatabaseManager(name, init_database, False)
self.close()
else:
self.results_dialog.setText("Database name must match "
"the format *.db and not be "
"a pre-existing file.")
self.results_dialog.show()
def __init__(self, rowid, item=None, parent=None):
"""Initializes edit window
Retrieves series information from database and populates the
table with the results for the user to edit.
"""
super(MangaTrackerEditWindow, self).__init__(parent)
self.setupUi(self)
self.edit_series_save_button.clicked.connect(self.save_edit)
self.edit_series_cancel_button.clicked.connect(self.close)
self.rowid = rowid
data_mgr = DatabaseManager(Config().database_name, None)
cur = data_mgr.query("SELECT rowid, * FROM Series WHERE rowid = %d"
% rowid)
self.series = entry_to_series(cur.fetchone())
self.table_setup(self.series, item)
def api_del_restaurant(restaurantname):
with app.app_context():
cache.clear()
ret = DatabaseManager.delRestaurant(app.logger, restaurantname)
result = 'Unable to delete restaurant named ' + restaurantname
if ret:
result = 'Successfully deleted restaurant named ' + restaurantname
return result
def add_series(self):
data_mgr = DatabaseManager(Config().database_name, None)
series_args = {}
for i in range(self.add_series_table.rowCount()):
try:
if self.add_series_table.item(i, 1).background() == Qt.red:
return
except AttributeError:
pass
curr_heading = self.add_series_table.item(i, 0).text()
try:
curr_text = self.add_series_table.item(i, 1).text()
except AttributeError: # is_completed
curr_text = (self.add_series_table.cellWidget(i, 1)
.currentText())
if curr_heading == "Name":
series_args['name'] = curr_text
if series_args['name'] in ["", "Unknown"]:
self.add_series_table.item(i, 1).setBackground(Qt.red)
return
elif curr_heading == "Alt. Names":
series_args['alt_names'] = curr_text
elif curr_heading == "Author":
series_args['author'] = curr_text
elif curr_heading == "Volumes Owned":
if curr_text in ["None", "0", ""]:
series_args['volumes_owned'] = generate_volumes_owned("")
else:
series_args['volumes_owned'] = generate_volumes_owned(
curr_text)
elif curr_heading == "Publisher":
series_args['publisher'] = curr_text
elif curr_heading == "Completed":
status = curr_text
series_args['is_completed'] = 1 if status == "Yes" else 0
new_series = Series(**series_args)
if new_series.add_series_to_database(data_mgr):
cur = data_mgr.query("SELECT rowid FROM series WHERE name='%s'"
% series_args['name'].replace("'", "''"))
self.added = cur.fetchone()[0]
self.close()
def boot(self):
try:
parsed = BeautifulSoup(self.html_page, 'html.parser')
title = parsed.title.text
image = parsed.find('img', width='110')['src']
datePub = parsed.find(
'div', style='font-size:13px;').find_all("b")[1].text
content = self.content(parsed)
##todo :: See modakira ....
if content:
logthis("Manager. Title : " + title, self.project_name)
dbm = DatabaseManager()
dbm.insertLine(title, image, content, datePub)
logthis("Database. Line inserted", self.project_name)
except Exception as e:
print("Manager. Exception : " + str(e))
logthis("Database. Line not inserted", self.project_name)
logthis("Manager. " + self.url_page + " is ignored ...",
self.project_name)
def api_restaurant_menus(restaurantname):
menu_map = DatabaseManager.getRestaurantMenus(app.logger, restaurantname)
objects_list = []
for j, k in menu_map.iteritems():
d = collections.OrderedDict()
d['id'] = str(j)
d['name'] = str(k)
objects_list.append(d)
js = json.dumps(objects_list)
resp = Response(js, status=200, mimetype='application/json')
return resp
def gui_main():
"""Starts the main window for MangaTracker GUI"""
# initialize config file and database file if needed
config = Config()
DatabaseManager(config.database_name, init_database, False)
app = QApplication(sys.argv)
main_window = MangaTrackerGUI()
main_window.show()
app.exec_()
def validate_cells(self, item):
if item.row() == 0: # Name
name = item.text()
data_mgr = DatabaseManager(Config().database_name, None)
cur = data_mgr.query("SELECT name FROM Series WHERE name = '{0}'"
.format(name.replace("'", "''")))
row = cur.fetchall()
if row or name in ["", "Unknown"]:
item.setBackground(Qt.red)
else:
item.setBackground(Qt.white)
elif item.row() == 3: # Volumes Owned
volumes_owned_raw = item.text()
pattern = r"^\d+(-\d+)?(,\s*\d+(-\d+)?)*\s*$"
if (not regexp(pattern, volumes_owned_raw)
and volumes_owned_raw not in ["None", "0", ""]):
item.setBackground(Qt.red)
else:
item.setBackground(Qt.white)
def coin_db(db_name, coin):
"""Connect to DB, use it and insert prices"""
with DatabaseManager(db_name) as db:
db.use_db()
if db.price_hist_exists(coin):
db.insert_price(coin)
db.commit()
else:
db.write_price_hist(coin)
db.commit()
logger.info('Last price: ' + str(coin.current_price))
def remove_series(self):
"""Remove selected series from database
Removes the currently selected series from the database, after
prompting the user for confirmation.
"""
data_mgr = DatabaseManager(Config().database_name, None)
if self.list_series.currentItem():
series_rowid = self.list_series.currentItem().data(Qt.UserRole)
cur = data_mgr.query("SELECT rowid, * FROM Series WHERE rowid = %d"
% series_rowid)
series = entry_to_series(cur.fetchone())
confirm_dialog = QMessageBox.question(
self, "Remove %s" % series.name,
"Are you sure you want to remove this series?\n"
"This can't be undone.",
QMessageBox.Discard | QMessageBox.Cancel,
QMessageBox.Cancel)
if confirm_dialog == QMessageBox.Discard:
remove_series_from_database(data_mgr, series)
self.list_series.takeItem(self.list_series.currentRow())
self.list_series.setFocus()
def main_db(db_name, tweets, users, start_date):
"""Connect to DB, use it and insert users and tweets"""
with DatabaseManager(db_name) as db:
db.use_db()
new_users, updated_users = db.write_users(users)
new_tweets, updated_tweets = db.write_tweets(tweets)
logger.info(
str(new_users) +
' new users were inserted in the database. For date: ' + start_date)
logger.info(
str(updated_users) + ' users were updated. For date: ' + start_date)
logger.info(
str(new_tweets) +
' new tweets were inserted in the database. For date: ' + start_date)
logger.info(
str(updated_tweets) + ' tweets were updated. For date: ' + start_date)
def options_menu(config):
"""
options_menu()
Change config options for MangaTracker
Options:
1. Change name of database file (default manga.db)
2. Change the maximum number of volumes allowed
per series (default 128)
3. Change number of series displayed per page (default 0)
4. Select either verbose descriptions or
1-line descriptions (default verbose)
5. Show empty series in normal lists (default False)
6. Open GUI or CLI by default (default GUI)
7. Reset all settings to default
8. Clear database
Arguments:
data_mgr - DatabaseManager object connected to current database
config - Config object with current config settings loaded
"""
print("-- OPTIONS --\n"
"1. Change Database Name\n"
"2. Change Volume Limit\n"
"3. Change Series Displayed Per Page\n"
"4. Use Compact Descriptions\n"
"5. Show Empty Series in Lists\n"
"6. Choose whether CLI or GUI opens by default\n"
"7. Reset to Default Settings\n"
"8. Clear Database")
option = input("Enter a number to modify option: ").strip()
try:
option = int(option)
# 1. Change database name
if option == 1:
new_db_name = input("Enter new database name, or leave "
"blank to leave unchanged: ")
if (new_db_name != "" and new_db_name != config.database_name
and is_database(new_db_name)):
config.set_property("database_name", new_db_name)
print("Database changed to %s." % new_db_name)
else:
print("Database name not changed.")
# 2. Change volume limit
elif option == 2:
new_vol_limit = input("Enter new volume limit"
"(Must be multiple of 32): ")
new_vol_limit = int(new_vol_limit)
if new_vol_limit % 32 == 0 and new_vol_limit >= 32:
config.set_property("volume_limit", new_vol_limit)
print("Volume limit changed to %d." % new_vol_limit)
else:
print("Invalid volume limit, not changed.")
# 3. Change series per page ( 0 for no limit)
elif option == 3:
new_series_per_page = input("Enter maximum number of "
"series to display per page, "
"or 0 to not use pages: ").strip()
if new_series_per_page == '0':
config.set_property("series_per_page", 0)
print("Program will not use pages.")
else:
try:
new_series_per_page = int(new_series_per_page)
if new_series_per_page < 1:
print("Series displayed per page must be "
"greater than or equal to 1.")
else:
config.set_property("series_per_page",
new_series_per_page)
print("Series displayed per page "
"set to %d." % new_series_per_page)
except (ValueError, TypeError):
print("Invalid value, series per page not changed.")
# 4. Use compact descriptions when listing series
elif option == 4:
use_compact_list = input(
"Use compact descriptions? (y/N): ").strip()
if use_compact_list in ('y', 'Y'):
config.set_property("compact_list", True)
print("Using compact descriptions.")
else:
config.set_property("compact_list", False)
print("Using full descriptions.")
# 5. Show empty series in normal lists
elif option == 5:
show_empty_series = input("Show series without any "
"volumes in lists? (y/N): ").strip()
if show_empty_series in ('y', 'Y'):
config.set_property("show_empty_series", True)
print("Showing series without any volumes in lists.")
else:
config.set_property("show_empty_series", False)
print("Hiding series without any volumes from lists.")
# 6. Choose whether CLI or GUI opens by default
elif option == 6:
default_to_cli = input(
"Open CLI by default when no "
"command-line options provided? (y/N): ").strip()
if default_to_cli in ('y', 'Y'):
config.set_property("default_to_gui", False)
print("Program will default to CLI "
"when no arguments are provided.")
else:
config.set_property("default_to_gui", True)
print("Program will default to GUI "
"when no arguments are provided.")
# 7. Reset to default
elif option == 7:
default = input("Reset all settings to default? (y/N): ").strip()
if default in ('y', 'Y'):
config.set_default_config("config.ini")
print("Settings reset to default.")
else:
print("Settings not changed.")
# 8. Clear database (Does not prompt user for series)
elif option == 8:
delete_database = input("Remove Database? "
"(will copy to {0}.bak) (y/N): ".format(
config.database_name)).strip()
if delete_database in ('y', 'Y'):
os.rename(config.database_name, config.database_name + ".bak")
print("Database deleted; initializing new database...")
DatabaseManager(False, init_database)
print("Database not changed.")
else:
print("Invalid option, returning to main screen")
# int(option) fails
except ValueError:
print("Invalid option, returning to main screen")
def main():
"""
main()
Main driver function for mangatracker program
"""
config = Config()
data_mgr = DatabaseManager(config.database_name, init_database)
print_all_series(data_mgr)
while True:
try:
user_input = input("[S]earch, [L]ist, [A]dd, [E]dit, "
"[R]emove, [O]ptions, E[x]it: ").strip()
except EOFError:
# No more input, exit program
user_input = 'x'
if user_input in ('x', 'X'):
break
if user_input in ('s', 'S'):
# TODO: color matching text (maybe not?)
entries, search_term = search_for_series(data_mgr)
print()
if not entries:
print("No series found for '{0}'.".format(search_term))
continue
print("Found {0} entries for '{1}':".format(
len(entries), search_term))
print_entries_list(entries)
continue
if user_input in ('l', 'L'):
list_series(data_mgr)
# Add Series
if user_input in ('a', 'A'):
try:
new_series = input_series(data_mgr)
except KeyboardInterrupt:
print("\nAdd series operation cancelled")
new_series = None
if new_series is not None:
new_series.add_series_to_database(data_mgr)
print("----------------------------------------")
print(new_series)
print("----------------------------------------")
continue
# Edit Series
if user_input in ('e', 'E'):
edit_series(data_mgr)
# Remove
if user_input in ('r', 'R'):
remove_series(data_mgr)
# Options
if user_input in ('o', 'O'):
options_menu(config)
# Reset database connection if name changed or database deleted
data_mgr = DatabaseManager(config.database_name, init_database,
False)
def save_edit(self):
"""Saves changes to series object or discards them depending on user choice.
Displays a dialog to the user asking if they want to save. If
'save' is selected, all modified properties of the series are
saved to the database and the edit window closes. If 'discard'
is selected, the window closes without saving any changes. If
'cancel' is selected, the dialog is closed and editing can
continue.
"""
reserved_words = ["unknown"]
confirm_dialog = QMessageBox.question(
self, "Save Changes",
"Are you sure you want to save changes?\nThis cannot be undone.",
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
QMessageBox.Cancel)
if confirm_dialog == QMessageBox.Save:
series_keys = ["name", "alt_names", "author",
"volumes_owned", "next_volume",
"publisher", "is_completed"]
data_mgr = DatabaseManager(Config().database_name, None)
for i in range(len(series_keys)):
try:
new_data = self.edit_series_table.item(i, 1).text()
except AttributeError:
new_data = (self.edit_series_table.cellWidget(i, 1)
.currentText())
if series_keys[i] == "name":
if (new_data
and self.series.name != new_data
and new_data not in reserved_words):
cur = data_mgr.query("SELECT name FROM Series WHERE "
"name = '{0}'"
.format(new_data
.replace("'", "''")))
row = cur.fetchall()
if not row:
self.series.name = new_data
elif series_keys[i] == "volumes_owned":
if new_data in ["None", "0", ""]:
new_data = generate_volumes_owned("")
else:
new_data = generate_volumes_owned(new_data)
self.series.volumes_owned = new_data
self.series.vol_arr = [int(x) for x in
self.series.volumes_owned
.split(',')]
elif series_keys[i] == "next_volume":
self.series.next_volume = (self.series
.calculate_next_volume())
elif series_keys[i] == "is_completed":
if new_data in ["Yes", "yes", "Y", "y", 1]:
self.series.is_completed = 1
elif new_data in ["No", "no", "N", "n", 0]:
self.series.is_completed = 0
else:
self.series.__dict__[series_keys[i]] = new_data
self.series.update_database_entry(data_mgr)
self.close()
elif confirm_dialog == QMessageBox.Discard:
self.close()
def save_setting(key, value):
print(TAG, "saving setting " + key + ", " + value)
database_manager = DatabaseManager()
database_manager.save_setting(key, value)
def api_get_restaurant_menu(restaurantname, menuname):
menu_map = DatabaseManager.getRestaurantMenus(app.logger, restaurantname)
result = 'Unknown menu, name does not exist'
if menuname in menu_map.values():
result = 'Menu name is ' + menuname + ' from restaurant ' + restaurantname + ' and exists in the system'
return result
def api_get_restaurants(restaurantname):
restaurant_map = DatabaseManager.getRestaurants(app.logger)
result = 'Uknown restaurant name does not exist'
if restaurantname in restaurant_map.values():
result = 'Restaurant name is ' + restaurantname + ' and exists in the system'
return result
