def remove_premiumize_transfer(transfer_id):
try:
tools.premiumizeDB_lock.acquire()
cursor = _get_connection_cursor(tools.premiumizeDB)
cursor.execute("DELETE FROM transfers WHERE transfer_id=?", (transfer_id,))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.premiumizeDB_lock)
def remove_package_providers(package_name):
try:
tools.providersDB_lock.acquire()
cursor = _get_connection_cursor(tools.providersDB)
cursor.execute("DELETE FROM providers WHERE package=?", (package_name,))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.providersDB_lock)
def cache_clear():
try:
tools.cacheFile_lock.acquire()
cursor = _get_connection_cursor(tools.cacheFile)
for t in [cache_table, 'rel_list', 'rel_lib']:
try:
cursor.execute("DROP TABLE IF EXISTS %s" % t)
cursor.execute("VACUUM")
cursor.connection.commit()
except:
pass
tools.showDialog.notification('{}: {}'.format(tools.addonName, tools.lang(40306)), tools.lang(32078), time=5000)
except:
pass
finally:
tools.try_release_lock(tools.cacheFile_lock)
def add_premiumize_transfer(transfer_id):
try:
tools.premiumizeDB_lock.acquire()
cursor = _get_connection_cursor(tools.premiumizeDB)
cursor.execute("CREATE TABLE IF NOT EXISTS transfers (transfer_id TEXT)")
cursor.execute("CREATE UNIQUE INDEX IF NOT EXISTS ix_transfers ON transfers (transfer_id)")
cursor.execute("REPLACE INTO transfers (transfer_id) VALUES (?)", transfer_id)
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.premiumizeDB_lock)
def get_assist_torrents():
try:
tools.activeTorrentsDBFile_lock.acquire()
cursor = _get_connection_cursor(tools.activeTorrentsDBFile)
cursor.execute("SELECT * FROM torrents")
results = cursor.fetchall()
cursor.close()
return results
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.activeTorrentsDBFile_lock)
def get_providers():
try:
tools.providersDB_lock.acquire()
cursor = _get_connection_cursor(tools.providersDB)
_try_create_provider_table(cursor)
cursor.execute("SELECT * FROM providers")
sources = cursor.fetchall()
cursor.close()
return sources
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.providersDB_lock)
def remove_individual_provider(provider_name, package_name):
try:
tools.providersDB_lock.acquire()
hash = _hash_function('%s%s' % (provider_name, package_name))
cursor = _get_connection_cursor(tools.providersDB)
_try_create_provider_table(cursor)
cursor.execute("DELETE FROM providers WHERE hash=?", (hash,))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.providersDB_lock)
def getTorrents(item_meta):
if tools.getSetting('general.torrentCache') == 'false':
return []
tools.torrentScrapeCacheFile_lock.acquire()
try:
cursor = _get_connection_cursor(tools.torrentScrapeCacheFile)
_try_create_torrent_cache(cursor)
if 'showInfo' in item_meta:
season = item_meta['info']['season']
episode = item_meta['info']['episode']
trakt_id = item_meta['showInfo']['ids']['trakt']
cursor.execute("SELECT * FROM %s WHERE trakt_id=? AND package=?" % cache_table, (trakt_id, 'show'))
torrent_list = cursor.fetchall()
cursor.execute("SELECT * FROM %s WHERE trakt_id=? AND package=? AND season=?" % cache_table,
(trakt_id, 'season', season))
torrent_list += cursor.fetchall()
cursor.execute("SELECT * FROM %s WHERE trakt_id=? AND package=? AND season=? AND episode=?" % cache_table,
(trakt_id, 'single', season, episode))
torrent_list += cursor.fetchall()
else:
trakt_id = item_meta['ids']['trakt']
cursor.execute("SELECT * FROM %s WHERE trakt_id=?" % cache_table, (trakt_id,))
torrent_list = cursor.fetchall()
cursor.close()
torrent_list = [ast.literal_eval(torrent['meta']) for torrent in torrent_list]
return torrent_list
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
return []
finally:
tools.try_release_lock(tools.torrentScrapeCacheFile_lock)
def get_single_provider(provider_name, package, country):
try:
tools.providersDB_lock.acquire()
cursor = _get_connection_cursor(tools.providersDB)
_try_create_provider_table(cursor)
cursor.execute("SELECT * FROM providers WHERE provider_name=? AND package=? AND country=?",
(provider_name, package, country))
sources = cursor.fetchone()
cursor.close()
return sources
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.providersDB_lock)
def add_assist_torrent(debrid_id, provider, status, release_title, progress):
try:
tools.activeTorrentsDBFile_lock.acquire()
cursor = _get_connection_cursor(tools.activeTorrentsDBFile)
_try_create_torrent_table(cursor)
cursor.execute("REPLACE INTO torrents (debrid_id, provider, status, release_title, progress) "
"VALUES (?, ?, ?, ?, ?)",
(debrid_id, provider, status, release_title, progress))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.activeTorrentsDBFile_lock)
def get_provider_packages():
try:
tools.log('Getting provider packages')
tools.providersDB_lock.acquire()
cursor = _get_connection_cursor(tools.providersDB)
_try_create_package_table(cursor)
cursor.execute("SELECT * FROM packages")
packages = cursor.fetchall()
cursor.close()
return packages
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
return None
finally:
tools.try_release_lock(tools.providersDB_lock)
def get_premiumize_transfers():
try:
tools.premiumizeDB_lock.acquire()
cursor = _get_connection_cursor(tools.premiumizeDB)
cursor.execute(
"CREATE TABLE IF NOT EXISTS transfers (transfer_id TEXT)"
)
cursor.execute("SELECT * FROM transfers")
transfers = cursor.fetchall()
cursor.close()
return transfers
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.premiumizeDB_lock)
def adjust_provider_status(provider_name, package_name, state):
try:
tools.providersDB_lock.acquire()
cursor = _get_connection_cursor(tools.providersDB)
_try_create_provider_table(cursor)
cursor.execute(
"UPDATE providers SET status=? WHERE provider_name=? AND package=?",
(state, provider_name, package_name)
)
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.providersDB_lock)
def clear_non_active_assist():
try:
tools.activeTorrentsDBFile_lock.acquire()
cursor = _get_connection_cursor(tools.activeTorrentsDBFile)
cursor.execute(
"DELETE FROM torrents WHERE status = 'failed'"
)
cursor.execute(
"DELETE FROM torrents WHERE status = 'finished'"
)
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.activeTorrentsDBFile_lock)
def add_provider_package(pack_name, author, remote_meta, version):
try:
tools.providersDB_lock.acquire()
hash = _hash_function('%s%s' % (pack_name, author))
cursor = _get_connection_cursor(tools.providersDB)
_try_create_package_table(cursor)
cursor.execute("REPLACE INTO packages (hash, pack_name, author, remote_meta, version) "
"VALUES (?, ?, ?, ?, ?)",
(hash, pack_name, author, remote_meta, version))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.providersDB_lock)
def add_provider(provider_name, package, status, language, provider_type):
try:
tools.providersDB_lock.acquire()
hash = _hash_function('%s%s' % (provider_name, package))
cursor = _get_connection_cursor(tools.providersDB)
_try_create_provider_table(cursor)
cursor.execute("REPLACE INTO providers (hash, provider_name, status, package, country, provider_type) "
"VALUES (?, ?, ?, ?, ?, ?)",
(hash, provider_name, status, package, language, provider_type))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.providersDB_lock)
def cache_insert(key, value):
tools.cacheFile_lock.acquire()
try:
cursor = _get_connection_cursor(tools.cacheFile)
now = int(time.time())
cursor.execute(
"CREATE TABLE IF NOT EXISTS %s (key TEXT, value TEXT, date INTEGER, UNIQUE(key))"
% cache_table
)
cursor.execute("CREATE UNIQUE INDEX IF NOT EXISTS ix_%s ON %s (key)" % (cache_table, cache_table))
cursor.execute("REPLACE INTO %s (key, value, date) VALUES (?, ?, ?)" % cache_table, (key, value, now))
cursor.connection.commit()
cursor.close()
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
pass
finally:
tools.try_release_lock(tools.cacheFile_lock)
def clear_assist_torrents():
try:
tools.activeTorrentsDBFile_lock.acquire()
cursor = _get_connection_cursor(tools.activeTorrentsDBFile)
for t in [cache_table, 'rel_list', 'rel_lib']:
try:
cursor.execute("DROP TABLE IF EXISTS torrents")
cursor.execute("VACUUM")
cursor.connection.commit()
cursor.close()
except:
pass
except:
try:
cursor.close()
except:
pass
import traceback
traceback.print_exc()
finally:
tools.try_release_lock(tools.activeTorrentsDBFile_lock)
tools.showDialog.notification('{}: {}'.format(tools.addonName, tools.lang(40306)), tools.lang(32080), time=5000)
