def __init__(self, path, database_backend="leveldb"):
if not (os.path.exists(path) or os.path.isdir(path)):
err_msg = ('"{}" is not a valid directory').format(path)
raise IOError(err_msg)
if database_backend == "unqlite":
assert UNQLITE_AVAILABLE, (
"You selected unqlite as database backend, but it is not "
"installed. Please install it via `pip install unqlite`")
self.cui_db = unqlite.UnQLite(os.path.join(path, "cui.unqlite"))
self.cui_db_put = self.cui_db.store
self.cui_db_get = self.cui_db.fetch
self.semtypes_db = unqlite.UnQLite(
os.path.join(path, "semtypes.unqlite"))
self.semtypes_db_put = self.semtypes_db.store
self.semtypes_db_get = self.semtypes_db.fetch
elif database_backend == "leveldb":
self.cui_db = leveldb.LevelDB(os.path.join(path, "cui.leveldb"))
self.cui_db_put = self.cui_db.Put
self.cui_db_get = self.cui_db.Get
self.semtypes_db = leveldb.LevelDB(
os.path.join(path, "semtypes.leveldb"))
self.semtypes_db_put = self.semtypes_db.Put
self.semtypes_db_get = self.semtypes_db.Get
else:
raise ValueError(
f"database_backend {database_backend} not recognized")
def test(self):
db = unqlite.UnQLite(DBname)
cl = db.collection(COLLECTIONname)
# doc = cl.fetch(0)
# pprint(doc)
cf = cl.filter(lambda x: x["word"].endswith("a"))
pprint(cf)
def toDB(self, dbname, collectionname):
# ～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
#
# ～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
db = unqlite.UnQLite(dbname)
cl = db.collection(collectionname)
if not cl.exists():
cl.create()
else:
cl.drop()
cl.create()
# ～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
#
# ～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～～
pickles = self._getPickles()
for pk in pickles:
print("processing------", pk)
with open(pk, "rb") as target:
tmp = pickle.load(target)
# tmpdict = dict()
# for k, v in tmp.items():
# tmpdict['word'] = k
# for kk, vv in v.items():
# tmpdict[kk] = vv
# cl.store(tmpdict)
# cl.store(tmp)
# pprint(tmp)
for k, v in tmp.items():
cl.store(v)
print("done")
def __init__(self, path):
self.database = unqlite.UnQLite(path)
self.repositories = dict()
for asset_module in ASSET_MODULES:
identifier = asset_module.REPOSITORY
repository = self.database.collection(identifier)
repository.create()
self.repositories[identifier] = repository
def __init__(self, name):
self.db = unqlite.UnQLite(name)
self.bins = self.db.collection('bins')
if not self.bins.exists():
self.bins.create()
self.shoes = self.db.collection('shoes')
if not self.shoes.exists():
self.shoes.create()
def get_db(db_path: str = None, mem_db=False) -> unqlite.UnQLite:
global db
if db == None:
db = unqlite.UnQLite(db_path if not mem_db else ':mem:')
create_collection_if_not_exist('jobs')
create_collection_if_not_exist('task_history')
return db
def __init__(self, subpath):
"""
"""
if op.isfile(subpath):
self.subpath = subpath
self.dbsubs = unqlite.UnQLite("subs.db")
self.dbword = unqlite.UnQLite("word.db")
subtitles = self.dbsubs.collection("subtitles")
if subtitles.exists():
pass
else:
subtitles.create()
words = self.dbword.collection("words")
if words.exists():
pass
else:
words.create()
def setup(self):
self.unq_db = unqlite.UnQLite(
os.path.join(self.db_dir, "blind_settings.db"))
# check_same_thread=False is solely to quiet a spurious error that appears to be due
# to a bug in twisted, where the connection is closed by a different thread than the
# one that opened it. The individual connections in the pool are not used in multiple
# threads.
self.sql_db = adbapi.ConnectionPool('sqlite3',
os.path.join(
self.db_dir, "blind_peers.db"),
check_same_thread=False)
return self.sql_db.runQuery(
"create table if not exists approved_peers (" +
" ip_address text, " + " port integer" + ")")
def wrapper(*args, **kwargs):
# Connect to the database
db = unqlite.UnQLite(filename, flags, open_database)
# Add the connection handle as a keyword argument.
kwargs[keyword] = db
try:
rv = callback(*args, **kwargs)
except unqlite.UnQLiteError as e:
db.rollback()
raise bottle.HTTPError(500, "Database Error", e)
except bottle.HTTPError:
db.rollback()
raise
finally:
db.close()
return rv
def __init__(self, filename):
"""
Initialize the database and flask app
"""
log.info('')
self._single_thread_required = False
# Initialize the input parameters
self._filename = filename
self._db = unqlite.UnQLite(self._filename)
log.debug('Opened unqlite database file {} {}'.format(
self._filename, self._db))
# Setup the unqlite database collections
log.debug('Setting up data collection')
self._data = self._db.collection('data')
if not self._data.exists():
log.debug(' ... doesn' 't exist so creating.')
self._data.create()
self._cutout = self._db.collection('cutout')
log.debug('Setting up cutout collection')
if not self._cutout.exists():
log.debug(' ... doesn' 't exist so creating.')
self._cutout.create()
self._fingerprint = self._db.collection('fingerprint')
log.debug('Setting up fingerprint collection')
if not self._fingerprint.exists():
log.debug(' ... doesn' 't exist so creating.')
self._fingerprint.create()
self._similarity = self._db.collection('similarity')
log.debug('Setting up similarity collection')
if not self._similarity.exists():
log.debug(' ... doesn' 't exist so creating.')
self._similarity.create()
def run(self):
self.fetch() # stores in data
db = unqlite.UnQLite(self.output().path)
etf = db.collection('etf')
etf.create()
etf.store(self.data)
import click
import unqlite
from . import config
database = unqlite.UnQLite(filename=config.dbLocation)
from . import authenticate
@click.group()
def cli():
pass
cli.add_command(authenticate.auth)
if __name__ == "__main__":
cli()
def _open_db(self):
filename = os.path.join(self.db_dir, self.NAME)
log.debug("Opening %s as the settings database", filename)
self.db = unqlite.UnQLite(filename)
return defer.succeed(True)
def connect(cls, uri):
return unqlite.UnQLite(uri)
def open_db():
self.db = unqlite.UnQLite(os.path.join(self.db_dir,
"ptcwallet.db"))
def filter(self):
etf_db = unqlite.UnQLite(self.input().path)
etf_list = etf_db.collection('etf')
filter_lambda = eval(META['ETF_DB']['FILTER_LAMBDA'].format(
**META['ETF_DB']['FILTERS']))
self.data = etf_list.filter(filter_lambda)
def __init__(self, filepath):
self.db = unqlite.UnQLite(str(filepath))