class TinydbStorage(interface.StorageInterface):
def __init__(self, db_path):
super(TinydbStorage, self).__init__()
self.db = TinyDB(db_path)
def create_table(self, table_name):
self._assert_no_table(table_name)
table = self.db.table(table_name)
table.insert({'table_exists': True})
def get_tables(self):
return self.db.tables()
def get(self, table_name, key):
self._assert_table(table_name)
table = self.db.table(table_name)
element = Query()
result = table.search(element.key == key)
if len(result) == 0:
raise interface.DataException("Key {} not found in table".format(key))
return result[0]['val']
def set(self, table_name, key, val):
self._assert_table(table_name)
table = self.db.table(table_name)
element = Query()
table.remove(element.key == key)
table.insert({'key': key, 'val': val})
def append(self, table_name, list_key, val):
self._assert_table(table_name)
table = self.db.table(table_name)
l = self.get(table_name, list_key)
#TODO: check if l is a list maybe
if val in l:
raise interface.DataException("Value: {0} already exists in list: {1}".format(val, list_key))
l.append(val)
element = Query()
table.update({'val': l}, element.key == list_key)
def remove(self, table_name, list_key, val):
#TODO: do
raise NotImplementedError("Storage module must implement this")
def _assert_no_table(self, table_name):
table = self.db.table(table_name)
if len(table) > 0:
raise interface.DataException("Table already exists: {}".format(table_name))
def _assert_table(self, table_name):
table = self.db.table(table_name)
if len(table) == 0:
raise interface.DataException("Table does not exist: {}".format(table_name))
class Base(object):
def __init__(self, **attributes):
self.__dict__ = attributes
self.db = TinyDB(TINY_DB_PATH)
self.table = self.db.table(self.__class__.__name__)
def all(self):
monitors = []
for elem in self.table.all():
monitors.append(self.__class__(**elem))
return monitors
def load(self, label):
query = Query()
self.__dict__.update(self.table.search(query.label == label)[0])
def save(self):
attributes = self.get_attributes()
if self.__new_record__():
self.table.insert(attributes)
else:
query = Query()
self.table.update(attributes, query.label == self.label)
return True
def destroy(self):
query = Query()
self.table.remove(eids=[self.table.search(query.label == self.label)[0].eid])
def get_attributes(self):
attributes = self.__dict__.copy()
attributes.pop('db')
attributes.pop('table')
return attributes
def __new_record__(self):
query = Query()
return len(self.table.search(query.label == self.label)) == 0
def __init__(self):
self.sentCache = {}
self.checkingThread = threading.Thread(target = self.startThread)
#self.checkingThread.daemon = True
self.keepChecking = True
self.config = Config()
if self.config.winning_streak:
self.winning_streak_messages = self.read_spree_file(self.config.winning_streak_file)
if self.config.losing_streak:
self.losing_streak_messages = self.read_spree_file(self.config.losing_streak_file)
# Debug purposes
self.printOutput = False
# Initializing the API
key = dotamatch.get_key() # Steam Dev Key (~/.steamapi)
try:
self.match_history = MatchHistory(key)
self.match_details = MatchDetails(key)
self.account_details = PlayerSummaries(key)
self.heroes = Heroes(key).heroes()
# ActualDB
db = TinyDB(self.config.db_path)
#db.purge()
#db.purge_tables()
self.matches_table = db.table('matches')
self.matches_info_table = db.table('matches_info')
except dotamatch.api.ApiError:
print u"Erro ao conectar à API."
class EventModel(object):
def __init__(self, uri):
self.uri = uri
self.db = None
self.reload()
def reload(self):
if self.db is not None:
self.db.close()
self.db = TinyDB(self.uri, indent=2)
self.actions = self.db.table('actions')
self.alarms = self.db.table('alarms')
def get_action_by_id(self, action_id):
return self.actions.get(eid=action_id)
def get_alarm_by_id(self, alarm_id):
return self.alarms.get(eid=alarm_id)
def get_actions_by_alarm(self, alarm):
for action_id in alarm.get('actions', []):
action = self.get_action_by_id(action_id)
if action is None: continue
yield action
def get_all_alarms(self):
return self.alarms.all()
def get_all_actions(self):
return self.actions.all()
def get_all_alarms_expanded(self):
for alarm in self.get_all_alarms():
for action in self.get_actions_by_alarm(alarm):
yield alarm, action
def add_event(self, alarm, actions):
action_ids = [self.add_action(a) for a in actions]
alarm['actions'] = action_ids
return self.alarms.insert(alarm)
def add_action(self, action):
return self.actions.insert(action)
def add_alarm(self, alarm):
return self.add_event(alarm, [])
def update_alarm(self, alarmid, new_fields={}):
return self.alarms.update(new_fields, eids=[alarmid])
def update_action(self, actionid, new_fields={}):
return self.actions.update(new_fields, eids=[actionid])
def delete_alarm(self, alarmid):
return self.alarms.remove(eids=[alarmid])
def delete_action(self, actionid):
return self.actions.remove(eids=[actionid])
def load_db(bot, conn):
"""Load in our database and the Headers."""
global CACHE, USERS, LORE, COLLECTIONS, LINKS, DB_Q, HEADERS
CACHE = TinyDB('destiny.json')
USERS = CACHE.table('users')
LORE = CACHE.table('lore')
COLLECTIONS = CACHE.table('collections')
LINKS = CACHE.table('links')
DB_Q = Query() # This is our query object used. Use it in all queries.
HEADERS = {'X-API-Key': bot.config.get('api_keys', {}).get('destiny', None)}
class LocalCollectionStore(object):
def __init__(self):
if TinyDB.DEFAULT_STORAGE == JSONStorage:
self._db = TinyDB(path=self.path)
else:
self._db = TinyDB()
def add(self, piece):
"""
:param Piece piece:
:return:
"""
self._piece_table().insert(piece.to_dict())
def piece_list(self):
"""
:rtype: list(Piece)
"""
return [Piece.from_dict(piece_dict) for piece_dict in self._piece_table().all()]
@contract
def state_list(self):
"""
:rtype: list(WatchState)
"""
state_entry_list = self._state_table().all()
if not state_entry_list:
return []
return jsonpickle.loads(state_entry_list[0]['pickle'])
def set_state_list(self, state_list):
"""
:type state_list: list(WatchState)
"""
state_table = self._state_table()
state_table.purge()
self._state_table().insert({'pickle': jsonpickle.dumps(state_list)})
def _piece_table(self):
return self._db.table("piece")
def _state_table(self):
return self._db.table("state")
def _state_entry(self):
Entry = Query()
entry_search_list = self._state_table().search(Entry.name == "state_list")
if entry_search_list:
return entry_search_list[0]
def __init__(self, path):
root_dir = os.path.abspath(path)
if not os.path.exists(root_dir):
raise IOError('Path does not exist: %s' % path)
fs = HashFS(os.path.join(root_dir, 'hashfs'), depth=3,
width=2, algorithm='md5')
# Setup Serialisation for non list/dict objects
serialization_store = SerializationMiddleware()
serialization_store.register_serializer(DateTimeSerializer(),
'TinyDate')
serialization_store.register_serializer(FileSerializer(fs),
'TinyFile')
if opt.has_numpy:
serialization_store.register_serializer(NdArraySerializer(),
'TinyArray')
if opt.has_pandas:
serialization_store.register_serializer(DataFrameSerializer(),
'TinyDataFrame')
serialization_store.register_serializer(SeriesSerializer(),
'TinySeries')
db = TinyDB(os.path.join(root_dir, 'metadata.json'),
storage=serialization_store)
self.db = db
self.runs = db.table('runs')
self.fs = fs
def prelimsearchURLs():
db = TinyDB('db.json')
prelimtable = db.table('prelimcasedetails')
cases = getAllSearchResults()
prelimtable.purge()
for idx, case in enumerate(cases):
prelimtable.insert({'caseid': case.caseid, 'casename': case.casename, 'prelimvideourl': case.videourl,'detailedVideoURL':'0'})
class ArtemisApplication(Application):
def __init__(self, db_file, *args, **kwargs):
super(ArtemisApplication, self).__init__(*args, **kwargs)
self._db = TinyDB(db_file)
def merge_host(self, host):
specs = filter(lambda (hostrx, _): hostrx.pattern == host, self.handlers)
map(self.handlers.remove, specs)
self.add_handlers(host, reduce(add, [s for _, s in specs]))
def table(self, tname):
return self._db.table(tname)
def model(self, model_name):
def _outer(model_cls):
model_cls.__table__ = self.table(model_name)
self.add_handlers('.*', [
(r'/{}'.format(model_name),
ModelBaseRequest, dict(model=model_cls)),
(r'/{}/query'.format(model_name),
ModelQueryRequest, dict(model=model_cls)),
(r'/{}/([a-zA-Z\-_0-9]+)'.format(model_name),
ModelIDRequest, dict(model=model_cls)),
(r'/{}/([a-zA-Z\-_0-9]+)/([a-zA-Z\-_0-9]+)'.format(model_name),
ModelMethodRequest, dict(model=model_cls))
])
return model_cls
return _outer
def test_purge_table():
db = TinyDB(storage=MemoryStorage)
assert [TinyDB.DEFAULT_TABLE] == list(db.tables())
db.purge_table(TinyDB.DEFAULT_TABLE)
assert [] == list(db.tables())
table_name = 'some-other-table'
db = TinyDB(storage=MemoryStorage)
db.table(table_name)
assert set([TinyDB.DEFAULT_TABLE, table_name]) == db.tables()
db.purge_table(table_name)
assert set([TinyDB.DEFAULT_TABLE]) == db.tables()
db.purge_table('non-existent-table-name')
assert set([TinyDB.DEFAULT_TABLE]) == db.tables()
class Repository(Singleton):
USERS_TABLE = 'users'
USERS_RANK_TABLE = 'users_rank_stat'
""" Repository class """
def __init__(self):
self.database = None
def init_db(self, dbfile):
""" Init repository """
serialization = SerializationMiddleware()
serialization.register_serializer(DateTimeSerializer(), 'TinyDate')
self.database = TinyDB(dbfile, storage=serialization)
def user_exists(self, wg_id):
""" Check users exists """
user = Query()
count = self.database.table(Repository.USERS_TABLE).count(user.wg_id == wg_id)
return count > 0
def save_user(self, user_obj):
""" Update user """
table = self.database.table(Repository.USERS_TABLE)
query = Query()
users = table.search(query.wg_id == user_obj.wg_id)
if len(users) > 0:
existing = DbUser.fromdict(users[0])
existing.last_date = user_obj.last_date
table.update(existing.__dict__, query.wg_id == existing.wg_id)
else:
table.insert(user_obj.__dict__)
def all_users(self):
""" Get all users """
table = self.database.table(Repository.USERS_TABLE)
users_data = table.all()
users = list()
for item in users_data:
users.append(DbUser.fromdict(item))
return users
def rank_history(self, wg_id):
""" Get all rank history records """
table = self.database.table(Repository.USERS_RANK_TABLE)
query = Query()
return table.search(query.wg_id == wg_id)
def db_smartcache():
db_ = TinyDB(storage=MemoryStorage)
db_.purge_tables()
db_.table_class = SmartCacheTable
db_ = db_.table('_default')
db_.insert_multiple({'int': 1, 'char': c} for c in 'abc')
return db_
def getdetailedSearchURL():
db = TinyDB('db.json')
prelimtable = db.table('prelimcasedetails')
query = Query()
elementstoupdate = prelimtable.search(query.detailedVideoURL == '0')
for iter,element in enumerate(elementstoupdate):
prelimURL = element['prelimvideourl']
detailedVideoURL = getvideosourceinfo(prelimURL)
caseid = element['caseid']
prelimtable.update({'detailedVideoURL':detailedVideoURL},Query()['caseid'] == caseid)
def patched_modules():
db = TinyDB(recipyGui.config.get('tinydb'))
modules = db.table('patches').all()
db.close()
form = SearchForm()
return render_template('patched_modules.html', form=form,
active_page='patched_modules', modules=modules,
dbfile=recipyGui.config.get('tinydb'))
def test_gc(tmpdir):
# See https://github.com/msiemens/tinydb/issues/92
path = str(tmpdir.join('db.json'))
db = TinyDB(path)
table = db.table('foo')
table.insert({'something': 'else'})
table.insert({'int': 13})
assert len(table.search(where('int') == 13)) == 1
assert table.all() == [{'something': 'else'}, {'int': 13}]
db.close()
class MainView(Frame):
def __init__(self, parent):
"docstring"
Frame.__init__(self, parent)
self.parent = parent
self.initUI()
def initUI(self):
self.parent.title("Pycollect")
self.pack(fill=BOTH)
menubar = Menu(self.parent)
self.parent.config(menu=menubar)
filemenu = Menu(menubar)
filemenu.add_command(label="Open", command=self.open_database)
filemenu.add_command(label="Exit", command=self.on_exit)
menubar.add_cascade(label="File", menu=filemenu)
frame1 = Frame(self)
frame1.pack(fill=X)
self.game_count = StringVar()
game_count_label = Label(frame1, textvariable=self.game_count).pack()
frame2 = Frame(self)
frame2.pack(fill=X, side=LEFT, expand=True)
self.game_list = Listbox(frame2)
self.game_list.pack(fill=Y, side=LEFT, expand=True)
# Events
self.bind('<<update_game_count>>', self.update_game_count)
self.bind('<<update_game_list>>', self.update_game_list)
def on_exit(self):
self.quit()
def open_database(self):
filename = tkFileDialog.askopenfilename(filetypes=[('Database files', '.db'), ('All files', '.*')])
self.db = TinyDB(filename)
self.games = self.db.table('games')
print len(self.games)
self.event_generate('<<update_game_count>>')
self.event_generate('<<update_game_list>>')
def update_game_count(self, args):
self.game_count.set('Game total: {}'.format(len(self.games)))
def update_game_list(self, args):
self.game_list.delete(0, END)
game_titles = [g['name'] for g in self.games.all()]
for title in game_titles:
self.game_list.insert(END, title)
class Database(object):
def __init__(self, path):
self.db = TinyDB(path)
def get_user_value(self, user, key):
key = '_' + key
table = self.db.table('user_values')
value = table.get(where('id') == user.id)
try:
return value[key]
except KeyError:
return None
def set_user_value(self, user, key, value):
self.insert_else_update_user(user, {key: value})
def insert_else_update_user(self, user, extra_params=None):
table = self.db.table('user_values')
if not table.get(where('id') == user.id):
table.insert({
'id': user.id,
'username': user.username,
'first_name': user.first_name,
'last_name': user.last_name
})
else:
table.update({
'username': user.username,
'first_name': user.first_name,
'last_name': user.last_name,
}, where('id') == user.id)
if extra_params:
for k in extra_params:
new_key = k if k.startswith('_') else '_' + k
extra_params[new_key] = extra_params.pop(k)
table.update(extra_params, where('id') == user.id)
def process_message(self, message):
if message.from_user:
self.insert_else_update_user(message.from_user)
class dal(object):
def __init__(self, data_base_file):
if not os.path.isfile(data_base_file):
open(data_base_file, 'a')
self.db = TinyDB(data_base_file, default_table='contacts')
self.users = self.db.table("users")
self.conversations = self.db.table("conversations")
self.contacts = self.db.table("contacts")
self.instance = True
def add_user(self, element):
self._insert(self.users, element)
def remove_user(self):
pass
def get_users(self):
return self.users.all()
def write_message(self, element):
self._insert(self.conversations, element)
def get_user_messages(self, phone):
conversation = Query()
return self.db.search(conversation.phone == phone)
def get_user_contacts(self, phone):
contact = Query()
a = self.db.search(contact.phone == phone)
return a
def add_contact(self, element):
self._insert(self.contacts, element)
def _insert(self, table, element={}):
try:
table.insert(element)
except Exception as ex:
print(ex)
def add_to_db(self, db, table):
database = TinyDB(str(db))
tbl = database.table(str(table))
id = len(tbl) # The id of the formula, auto incrementing
tbl.insert({
"id": id,
"name": self.name,
"units": self.units,
"formula": self.formula,
"explanation": self.explanation,
"information": {"name_added_by": self.name_added_by, "date": self.date}
})
def _convert_to_sqlitedb(self):
old_db = TinyDB(DATABASE_SETTINGS['database'])
self.mem_db = []
total = 0
for table in old_db.tables():
for item in old_db.table(table).all():
total += 1
print "MIGRATING DATABASE"
print "--OLD DATABASE: " + str(total)
i = 0
for table in old_db.tables():
for item in old_db.table(table).all():
if len(item['accn']) < 15:
if int(item['time']) > self.purge_date:
self.mem_db.append(item)
print " Converted: " + str(i) + " of " + str(total)
i += 1
self.dict_db[str(item['time'])] = item
else:
print "REMOVING OLD THING"
print "DATABASE MIGRATION COMPLETE"
print "COMMITING CHANGES"
self.get_last_filed()
def run_details():
form = SearchForm()
annotateRunForm = AnnotateRunForm()
query = request.args.get('query', '')
run_id = int(request.args.get('id'))
db = TinyDB(recipyGui.config.get('tinydb'))
r = db.get(eid=run_id)
diffs = db.table('filediffs').search(Query().run_id == run_id)
db.close()
return render_template('details.html', query=query, form=form,
annotateRunForm=annotateRunForm, run=r,
dbfile=recipyGui.config.get('tinydb'), diffs=diffs)
def latest_run():
form = SearchForm()
annotateRunForm = AnnotateRunForm()
db = TinyDB(recipyGui.config.get('tinydb'))
runs = db.all()
runs = sorted(runs, key = lambda x: parse(x['date'].replace('{TinyDate}:', '')), reverse=True)
r = db.get(eid=runs[0].eid)
diffs = db.table('filediffs').search(Query().run_id == r.eid)
db.close()
return render_template('details.html', query='', form=form, run=r,
annotateRunForm=annotateRunForm,
dbfile=recipyGui.config.get('tinydb'), diffs=diffs,
active_page='latest_run')
def load():
db = TinyDB('db.json')
player_stats = db.table(name_input)
player.time_advance = (player_stats.get(eid=1))['time_advance']
player.bow_message = (player_stats.get(eid=2))['bow_message']
player.hunt_message = (player_stats.get(eid=3))['hunt_message']
player.can_hunt = (player_stats.get(eid=4))['can_hunt']
player.exploration1_message = (player_stats.get(eid=5))['exploration1_message']
player.sword_message = (player_stats.get(eid=6))['sword_message']
player.can_go_to_town = (player_stats.get(eid=7))['can_go_to_town']
player.health = (player_stats.get(eid=8))['health']
player.weapon = (player_stats.get(eid=9))['weapon']
player.energy = (player_stats.get(eid=10))['energy']
player.exploration_count = (player_stats.get(eid=11))['exploration_count']
player.town_count = (player_stats.get(eid=12))['town_count']
player.money = (player_stats.get(eid=13))['money']
player.inventory = player_stats.get(eid=14)
print "Your inventory has %r" %player.inventory
def main():
db = TinyDB('db.json')
table = db.table('newsbot')
while True:
try:
news = utility.get_news()
except:
news = []
last = utility.last_new(table)
for i, (title, url) in enumerate(news):
if last in url:
del news[i:]
if news:
chat_id = "@mvnews"
table.insert({'url': str(news[0][1])})
for n in news:
text = ('[{}]' + '({})').format(n[0], n[1])
bot.send_message(chat_id, text, parse_mode='Markdown')
time.sleep(10)
def test_custom_table_class():
from tinydb.database import Table
class MyTableClass(Table):
pass
# Table class for single table
db = TinyDB(storage=MemoryStorage)
assert isinstance(TinyDB(storage=MemoryStorage).table(),
Table)
assert isinstance(db.table('my_table', table_class=MyTableClass),
MyTableClass)
# Table class for all tables
TinyDB.table_class = MyTableClass
assert isinstance(TinyDB(storage=MemoryStorage).table(),
MyTableClass)
assert isinstance(TinyDB(storage=MemoryStorage).table('my_table'),
MyTableClass)
# Reset default table class
TinyDB.table_class = Table
def test_string_key2():
from tinydb.database import Table, StorageProxy, Document
from tinydb.storages import MemoryStorage
class StorageProxy2(StorageProxy):
def _new_document(self, key, val):
# Don't convert the key to a number here!
return Document(val, key)
class Table2(Table):
def _init_last_id(self, data):
if data:
self._last_id = len(data)
else:
self._last_id = 0
def _get_next_id(self):
next_id = self._last_id + 1
data = self._read()
while str(next_id) in data:
next_id += 1
self._last_id = next_id
return str(next_id)
def _get_doc_id(self, document):
if not isinstance(document, dict):
raise ValueError('Document is not a dictionary')
return document.get('doc_id') or self._get_next_id()
TinyDB.storage_proxy_class = StorageProxy2
db = TinyDB(storage=MemoryStorage, table_class=Table2)
table = db.table()
table.insert({'doc_id': 'abc'})
assert table.get(doc_id='abc')['doc_id'] == 'abc'
assert table._last_id == 0
table.insert({'abc': 10})
assert table.get(doc_id='1')['abc'] == 10
assert table._last_id == 1
class DBEntity(object):
def __init__(self, db_path):
self._db = TinyDB(db_path)
def table(self, tname):
return self._db.table(tname)
def model(self, model_name):
def _outer(model_cls):
model_cls.__table__ = self.table(model_name)
model_cls.routes = [
(r'/{}'.format(model_name),
ModelBaseRequest, dict(model=model_cls)),
(r'/{}/query'.format(model_name),
ModelQueryRequest, dict(model=model_cls)),
(r'/{}/([a-zA-Z\-_0-9]+)'.format(model_name),
ModelIDRequest, dict(model=model_cls)),
(r'/{}/([a-zA-Z\-_0-9]+)/([a-zA-Z\-_0-9]+)'.format(model_name),
ModelMethodRequest, dict(model=model_cls))
]
return model_cls
return _outer
def save():
db = TinyDB('db.json')
player_stats = db.table(name_input)
if db.get(where('name') == name_input):
player_stats.update({'time_advance' : player.time_advance}, eids=[1])
player_stats.update({'bow_message': player.bow_message}, eids=[2])
player_stats.update({'hunt_message': player.hunt_message}, eids=[3])
player_stats.update({'can_hunt': player.can_hunt}, eids=[4])
player_stats.update({'exploration1_message': player.exploration1_message}, eids=[5])
player_stats.update({'sword_message': player.sword_message}, eids=[6])
player_stats.update({'can_go_to_town': player.can_go_to_town}, eids=[7])
player_stats.update({'health': player.health}, eids=[8])
player_stats.update({'weapon': player.weapon}, eids=[9])
player_stats.update({'energy': player.energy}, eids=[10])
player_stats.update({'exploration_count': player.exploration_count}, eids=[11])
player_stats.update({'town_count': player.town_count}, eids=[12])
player_stats.update({'money': player.money}, eids=[13])
player_stats.update(player.inventory, eids=[14])
print "Saved"
else:
player_stats.insert({'time_advance' : player.time_advance})
player_stats.insert({'bow_message': player.bow_message})
player_stats.insert({'hunt_message': player.hunt_message})
player_stats.insert({'can_hunt': player.can_hunt})
player_stats.insert({'exploration1_message': player.exploration1_message})
player_stats.insert({'sword_message': player.sword_message})
player_stats.insert({'can_go_to_town': player.can_go_to_town})
player_stats.insert({'health': player.health})
player_stats.insert({'weapon': player.weapon})
player_stats.insert({'energy': player.energy})
player_stats.insert({'exploration_count': player.exploration_count})
player_stats.insert({'town_count': player.town_count})
player_stats.insert({'money': player.money})
player_stats.insert(player.inventory)
db.insert({'name' : name_input})
print "First save"
def scale(vnfi_id):
req = request.get_json(force=True)
cur_flv_id = req['cur_flavor_id']
dst_flv_id = req['flavor_id']
vnfi_name = req['vnfi_name']
vnfd_id = req['vnfd_id']
# Get VNFCI settings
db = TinyDB('data/preins.json')
tbl = db.table('settings_vdus_table')
q = Query()
docs = tbl.search(q.vnfi_id == vnfi_id)
if len(docs) <= 0:
return Response('', status=403)
vnfcis = docs[0]['settings']['vnfcs']
# Get VNFD info
uri = '/manager/v2/vnf/packages/' + vnfd_id
status, res_body, msglog = http_send_to_vnfm('GET', uri, '', "vnfm")
if status == 200:
pkginfo = json.loads(res_body)
vnfd_flv = pkginfo['vnfd']['flavors']
for flv in vnfd_flv:
if flv['flavor_id'] == cur_flv_id:
cur_flv_info = flv
elif flv['flavor_id'] == dst_flv_id:
dst_flv_info = flv
scale_body = {
"vnf": {
"ns_instance_id": vnfi_id,
"vnf_descriptor_id": pkginfo['vnfd']['vnfd_id'],
"name": vnfi_name,
"flavor_id": dst_flv_id
}
}
if int(cur_flv_info['grade']) > int(
dst_flv_info['grade']): # case scale-out
vnfcs = []
for c_vdu in cur_flv_info['vdus']:
for d_vdu in dst_flv_info['vdus']:
if c_vdu['vdu_id'] == d_vdu['vdu_id']:
if int(c_vdu['num_instances']) != int(
d_vdu['num_instances']):
vdu_id = c_vdu['vdu_id']
begin = int(c_vdu['num_instances'])
end = int(d_vdu['num_instances'])
for vnfci in vnfcis:
if vnfci['vdu_id'] == vdu_id:
if int(vnfci['sequence']) > begin:
if int(vnfci['sequence']) <= end:
vnfci['sequence'] = str(
int(vnfci['sequence']) - begin)
vnfcs.append(vnfci)
scale_body['vnf']['vnfcs'] = vnfcs
uri = '/v2/vnf/instances/' + vnfi_id + '/scale'
status, res_body, msglog = http_send_to_vnfm('POST', uri,
json.dumps(scale_body),
"nfvo")
job_url = ''
if status == 202:
res_json = json.loads(res_body)
job_url = res_json['job']['id']
return Response(msglog, status=200, headers={'X-Job-ID': job_url})
def __init__(self,
config_path=args.config,
ws_server=args.host,
ws_port=args.port):
# Setting up logging first and foremost
self.log = get_logger("midi_to_obs")
# Internal service variables
self._action_buffer = []
self._action_counter = 2
self._portobjects = []
self._lastTbarMove = time()
self._tbarActive = False
self._tbarDir = 0
# Feedback blocking
self.blockcount = 0
self.block = False
#load tinydb configuration database
self.log.debug("Trying to load config file from %s" % config_path)
tiny_database = TinyDB(config_path, indent=4)
tiny_db = tiny_database.table("keys", cache_size=20)
tiny_devdb = tiny_database.table("devices", cache_size=20)
#get all mappings and devices
self._mappings = tiny_db.all()
self._devices = tiny_devdb.all()
#open dbj datebase for mapping and clear
self.mappingdb = dbj("temp-mappingdb.json")
self.mappingdb.clear()
#convert database to dbj in-memory
for _mapping in self._mappings:
self.mappingdb.insert(_mapping)
self.log.debug("Mapping database: `%s`" % str(self.mappingdb.getall()))
if len(self.mappingdb.getall()) < 1:
self.log.critical("Could not cache device mappings")
# ENOENT (No such file or directory)
exit(2)
self.log.debug("Successfully imported mapping database")
result = tiny_devdb.all()
if not result:
self.log.critical("Config file %s doesn't exist or is damaged" %
config_path)
# ENOENT (No such file or directory)
exit(2)
self.log.info("Successfully parsed config file")
self.log.debug("Retrieved MIDI port name(s) `%s`" % result)
#create new class with handler and open from there, just create new instances
for device in result:
self._portobjects.append(
(DeviceHandler(device, device.doc_id), device.doc_id))
self.log.info("Successfully initialized midi port(s)")
del result
# close tinydb
tiny_database.close()
# setting up a Websocket client
self.log.debug("Attempting to connect to OBS using websocket protocol")
self.obs_socket = WebSocketApp("ws://%s:%d" % (ws_server, ws_port))
self.obs_socket.on_message = lambda ws, message: self.handle_obs_message(
ws, message)
self.obs_socket.on_error = lambda ws, error: self.handle_obs_error(
ws, error)
self.obs_socket.on_close = lambda ws: self.handle_obs_close(ws)
self.obs_socket.on_open = lambda ws: self.handle_obs_open(ws)
def getTable(self):
db = TinyDB(Constants.DATABASE_ROOT_PATH + Constants.UNITED_DATABASE_FILENAME)
return db.table(self.TABLE_NAME)
from flask import Flask, request, send_from_directory
from flask.json import jsonify
from tinydb import TinyDB, Query
import os
from flask_cors import CORS
from Deck import Deck
# Prepare the app and configurations
app = Flask(__name__)
CORS(app)
# Setup the document DB
db = TinyDB('db.json')
deck = db.table('deck')
# Setup the static file directory
static_file_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'./wwwroot')
@app.after_request
def add_header(response):
response.cache_control.max_age = 86400
del response.headers['Server']
return response
@app.route('/', methods=['GET'])
def serve_dir_directory_index():
''' Serves the static index file '''
return send_from_directory(static_file_dir, 'index.html')
#!/usr/bin/env python
from tinydb import TinyDB, Query
from config import SL_HPL2_KEY
import json
import httplib2
http = httplib2.Http()
db = TinyDB('db.json')
sitestable = db.table('sites')
sitestable.purge()
sitesarr = []
url = 'http://api.sl.se/api2/LineData.json?model=site&key=' + SL_HPL2_KEY
resp, content = http.request(url)
sites = json.loads(str(content, 'utf8'))
sites = sites['ResponseData']['Result']
for index, site in enumerate(sites):
sitename = site['SiteName']
siteobj = {'name': sitename, 'id': site['SiteId']}
sitesarr.append(siteobj)
print(index, site)
sitestable.insert_multiple(sitesarr)
print('finished OK!')
exit()
from googleapiclient import discovery
from tinydb import TinyDB
db = TinyDB('entities.json')
group_table = db.table('Instance Groups')
template_table = db.table('Instance Templates')
credentials = GoogleCredentials.get_application_default()
from oauth2client.file import Storage
storage = Storage('creds.data')
service = discovery.build('compute', 'v1', credentials=storage.get())
instanceGroups = service.instances()
instanceTemplates = service.instanceTemplates()
zones = service.zones()
def insert_templates():
projectId = TinyDB('projects.json').table("Project").all()
request = instanceTemplates.list(project=projectId)
try:
while request is not None:
response = request.execute()
for instanceTemplate in response['items']:
template_table.insert(instanceTemplate)
request = instanceTemplates.list_next(previous_request=request, previous_response=response)
except KeyError:
pass
def insert_instance_groups():
projectId = TinyDB('projects.json').table("Project").all()
class TinyDBBinding(object):
def __init__(self, path=None):
self.path = path
self.cacheSize = Configuration.get('db.cacheSize')
Logging.log('Cache Size: %s' % self.cacheSize)
# create transaction locks
self.lockResources = Lock()
self.lockIdentifiers = Lock()
self.lockSubscriptions = Lock()
self.lockStatistics = Lock()
self.lockAppData = Lock()
def openDB(self):
if Configuration.get('db.inMemory'):
Logging.log('DB in memory')
self.dbResources = TinyDB(storage=MemoryStorage)
self.dbIdentifiers = TinyDB(storage=MemoryStorage)
self.dbSubscriptions = TinyDB(storage=MemoryStorage)
self.dbStatistics = TinyDB(storage=MemoryStorage)
self.dbAppData = TinyDB(storage=MemoryStorage)
else:
Logging.log('DB in file system')
self.dbResources = TinyDB(self.path + '/resources.json')
self.dbIdentifiers = TinyDB(self.path + '/identifiers.json')
self.dbSubscriptions = TinyDB(self.path + '/subscriptions.json')
self.dbStatistics = TinyDB(self.path + '/statistics.json')
self.dbAppData = TinyDB(self.path + '/appdata.json')
self.tabResources = self.dbResources.table('resources',
cache_size=self.cacheSize)
self.tabIdentifiers = self.dbIdentifiers.table(
'identifiers', cache_size=self.cacheSize)
self.tabSubscriptions = self.dbSubscriptions.table(
'subsriptions', cache_size=self.cacheSize)
self.tabStatistics = self.dbStatistics.table('statistics',
cache_size=self.cacheSize)
self.tabAppData = self.dbAppData.table('appdata',
cache_size=self.cacheSize)
def closeDB(self):
Logging.log('Closing DBs')
self.dbResources.close()
self.dbIdentifiers.close()
self.dbSubscriptions.close()
self.dbStatistics.close()
self.dbAppData.close()
def purgeDB(self):
Logging.log('Purging DBs')
self.tabResources.purge()
self.tabIdentifiers.purge()
self.tabSubscriptions.purge()
self.tabStatistics.purge()
self.tabAppData.purge()
#
# Resources
#
def insertResource(self, resource):
with self.lockResources:
self.tabResources.insert(resource.json)
def upsertResource(self, resource):
with self.lockResources:
self.tabResources.upsert(
resource.json,
Query().ri ==
resource.ri) # Update existing or insert new when overwriting
def updateResource(self, resource):
ri = resource.ri
with self.lockResources:
self.tabResources.update(resource.json, Query().ri == ri)
# remove nullified fields from db and resource
for k in list(resource.json):
if resource.json[k] is None:
self.tabResources.update(delete(k), Query().ri == ri)
del resource.json[k]
return resource
def deleteResource(self, resource):
with self.lockResources:
self.tabResources.remove(Query().ri == resource.ri)
def searchResources(self, ri=None, csi=None, srn=None, pi=None, ty=None):
# find the ri first and then try again recursively
if srn is not None:
if len((identifiers := self.searchIdentifiers(srn=srn))) == 1:
return self.searchResources(ri=identifiers[0]['ri'])
return []
with self.lockResources:
if ri is not None:
r = self.tabResources.search(Query().ri == ri)
elif csi is not None:
r = self.tabResources.search(Query().csi == csi)
elif pi is not None and ty is not None:
r = self.tabResources.search((Query().pi == pi)
& (Query().ty == ty))
elif pi is not None:
r = self.tabResources.search(Query().pi == pi)
elif ty is not None:
r = self.tabResources.search(Query().ty == ty)
return r
def save_tournament_in_db(self):
db = TinyDB('database.json')
table = db.table('tournaments')
self.tournament.serialize()
table.insert(self.tournament.params)
import simplejson as json
from tinydb import TinyDB, Query, where
db = TinyDB('databases/database.db')
users = db.table('users')
todos = db.table('todos')
Users = Query()
Todos = Query()
# 여러가지 조회방법
# print(users.search(Users.id == 7))
# print(users.search(Users['id'] == 7))
# print(users.search(where('id') == 7))
# print(users.search(Query()['id'] == 7))
# print(users.search(where('address')['zipcode'] == '90566-7771'))
# print(users.search(where('address').zipcode == '90566-7771'))
# 고급 쿼리
# print(users.search(Users.email.exists())) # 특정 키가 있는 row를 다 가져옴
# NOT
# print(users.search(~(Users.username == 'Antonette')))
# OR
# print(users.search( (Users.username == 'Antonette') | (Users.username == 'Kamren') ))
# And
# print(users.search( (Users.username == 'Antonette') & (Users.id == 2) ))
from prompt_toolkit.completion import WordCompleter
from prompt_toolkit.formatted_text import FormattedText
from prompt_toolkit.history import FileHistory
from prompt_toolkit.styles import Style
from tinydb import Query, TinyDB, where
from tinydb.operations import delete
from art import text2art
style = Style.from_dict({'': 'gold'})
prompt_symbol = FormattedText([('gold bold', '<< tasker >> ')])
dirname = os.path.dirname(__file__)
datafile = os.path.join(dirname, 'db.json')
db = TinyDB(datafile)
task_table = db.table('tasks')
project_table = db.table('projects')
name_table = db.table('names')
number_of_concurrent_tasks = 3
max_line_length = 25
project_list = []
format_date_str = "%A, %d %b %Y %I:%M:%S %p"
format_delta_str_hours = "%d days %H:%M:%S"
# format_delta_str_days = "%d days %H:%M:%S"
filename_format = '%Y-%m-%d %I%M-%p'
if (not path.exists(configPath)):
with open(configPath, "w") as config:
blankConfigFile = {
"aws_access_key_id": "",
"aws_secret_access_key": "",
"aws_object_name": "",
"token": "",
"queue_channels": [],
"report_channels": [],
"leaderboard_channel": -1
}
json.dump(blankConfigFile, config)
db = TinyDB(dataPath, indent=2)
currQueue = db.table("queue")
activeMatches = db.table("activeMatches")
leaderboard = db.table("leaderboard")
def getDiscordToken() -> str:
with open(configPath, "r") as config:
token = json.load(config)["token"]
return token
def updateDiscordToken(newToken: str) -> str:
with open(configPath, "r") as configFile:
config = json.load(configFile)
config["token"] = newToken
from asyspider.spider import Spider, Proxy, DBProxy, headers_raw_to_dict
import re
from pyquery import PyQuery as pq
import logging
from tools import log
from pprint import pprint as pp
from pprint import pformat
import argparse
import time
from urllib.parse import urljoin
from tinydb import TinyDB, Query
import os
db = TinyDB(os.path.join(os.path.dirname(__file__), './db.json'))
articles = db.table('articles')
query = Query()
logger = logging.getLogger('demo')
HOST = 'http://www.huntcoco.com/index.php'
class Crawler(Spider):
status_code = (200, 301, 302)
platform = 'desktop'
max_tasks = 15
sleep_time = None
timeout = 30
retries = 10
check_crawled_urls = True
update_cookies = True
from sys import path
TEST_DIR = 'tests/test_db'
test_database = TinyDB(join(TEST_DIR, 'test_database.json'))
with open(join(TEST_DIR, 'data.py'), 'w') as file:
# test_sample_url_can_be_generated
data = {'dept': 'test_dept', 'course': 'test_course'}
file.write(f"test_sample_url_can_be_generated_data = {data}\n")
# test_get_one_dept
data = {'dept': 'CS'}
dept = test_database.table(f"{data['dept']}").all()
file.write(f"test_get_one_dept_data = {dept}\n")
# test_get_one_dept_and_course
data = {'dept': 'CS', 'course': '2A'}
dept = test_database.table(f"{data['dept']}").all()
course = next(
(e[f"{data['course']}"] for e in dept if f"{data['course']}" in e))
file.write(f"test_get_one_dept_and_course_data = {course}\n")
# test_get_two_dept
data = {'courses': [{'dept': 'CS'}, {'dept': 'MATH'}]}
def load_tournament_from_db(self):
db = TinyDB('database.json')
table = db.table('tournaments')
for item in table:
self.create_tournament(item)
def del_vdus_settings_from_vnfr(vnfi_id):
db = TinyDB('data/preins.json')
settbl = db.table('settings_vdus_table')
q = Query()
settbl.remove(q.vnfi_id == vnfi_id)
return
from utils import Conf
from tinydb import TinyDB
from tinydb import where
import argparse
import shutil
import os
# construct the argument parser and parse the arguments
ids = input("Input the id to be deleted")
config_file = "D:/Attendance Management System/config/config.json"
conf = Conf(config_file)
db = TinyDB(conf["db_path"])
studentTable = db.table("student")
student = studentTable.search(where(args["id"]))
student[0][args["id"]][1] = "unenrolled"
studentTable.write_back(student)
# delete the student's data from the dataset
shutil.rmtree(os.path.join(conf["dataset_path"], conf["class"], ids))
print(
"[INFO] Please extract the embeddings and re-train the face recognition model..."
)
db.close()
def delete_vnfcis_settings(vnfi_id):
db = TinyDB('data/preins.json')
tbl = db.table('settings_vdus_table')
q = Query()
tbl.remove(q.vnfi_id == vnfi_id)
import simplejson as json
from tinydb.storages import MemoryStorage
from tinydb import TinyDB, Query, where
db = TinyDB('g:/python/section2/python_practice/files/database.db')
# db = TinyDB(storage = MemoryStorage, default_table ='users')
users = db.table("users")
todos = db.table("todos")
Users = Query()
Todos = Query()
print(users.search(Users.id == 7))
print(users.search(where('address')['zipcode'] == '90566-7771'))
print(users.search(where('address').zipcode == '90566-7771'))
# users.insert({'name' : 'kim', 'email' : '*****@*****.**'})
# todos.insert({'name' : 'homework', 'complete' : False})
# with open('g:/python/section2/python_practice/files/users.json', 'r') as infile:
# r = json.loads(infile.read())
# for u in r:
# users.insert(u)
# users.purge()
# todos.purge()
from tinydb import TinyDB, Query
from config import base
base = base.base()
db_path = base['db_path']
db = TinyDB(db_path)
white_list = db.table('white_list', cache_size=0)
in_white = Query()
def add_to_white(id, amis_peer_id, name):
try:
if (white_list.search(in_white.id == str(id)) != []): # 有在裡面就算了
return True
white_list.insert({
'id': str(id),
'amis_peer_id': str(amis_peer_id),
'name': str(name)
})
return True
except Exception as e:
raise e
def rm_from_white(id):
try:
if (white_list.search(in_white.id == str(id)) == []): # 不在裡面就算了
return True
white_list.remove(in_white.id == str(id))
return True
except Exception as e:
def __init__(self):
db = TinyDB(CODE_DB_FILE)
self.code = db.table('Code')
root = '/home/lml/smart_city/StreetscapeLocation/'
query = osp.join(root, 'query/query_sencex/*.png')
db_path = '/home/lml/smart_city/StreetscapeLocation/datasets_db/datasetx.db'
search_list = []
value_list = []
for n in range(1, 9):
s = list(query)
s[query.rfind("/") - 1] = str(n)
query = ''.join(s)
s = list(db_path)
s[-4] = str(n)
db_path = ''.join(s)
print(db_path)
for img_path in glob.glob(query):
db = TinyDB(db_path)
table = db.table('feature')
cache_features = table.all()[0]
match_result = image_search(img_path)
print(match_result)
query_name = img_path[img_path.rfind("/") + 1:img_path.rfind(".")]
row1 = [
query_name, match_result[0][0], match_result[1][0],
match_result[2][0], match_result[3][0], match_result[4][0],
match_result[5][0]
]
row2 = [
query_name, match_result[0][1], match_result[1][1],
match_result[2][1], match_result[3][1], match_result[4][1],
match_result[5][1]
]
def __init__(self):
db = TinyDB(GS_DB_FILE)
self.gs_config = db.table('GS_Config')
from spideradmin.api_app.scrapyd_utils import get_server_status, cancel_all_spider, check_server
from spideradmin.version import VERSION
from puremysql import PureMysql
from tinydb import TinyDB, Query
sys.path.insert(0, os.getcwd())
try:
import config
except Exception as e:
from spideradmin import default_config as config
api_app = Blueprint(name="api", import_name=__name__)
db = TinyDB("server.db")
user_server_table = db.table("user_servers")
query = Query()
# 初始化配置文件中的服务器插入db.sqlit
def init_servers():
if len(user_server_table.all()) == 0:
# 初始化配置文件中配置的服务器
[
user_server_table.insert({
"server_name": server_name,
"server_host": server_host
}) for server_name, server_host in config.SCRAPYD_SERVERS
if (not all([server_name, server_host])) or (
check_server(server_host) is False)
]
from tinydb import TinyDB, Query, operations, where
db = TinyDB('./data/db.json')
db_tags = db.table('tags')
db_admin_roles = db.table('admin_roles')
db_user_roles = db.table('user_roles')
db_user_data = db.table('user_data')
db_voice_text = db.table('voice_text')
db_role_data = db.table('role_data')
# functions for tag db
def get_tag(name):
Tag = Query()
tags = db_tags.search(Tag.name == name)
if len(tags) > 0:
return tags[0]
else:
return None
def exists_tag(name):
tag = get_tag(name)
return tag is not None
def get_all_tags():
return db_tags.all()
def add_tag(name, response):
import os
import json
import falcon
from tinydb import TinyDB, Query
#変数dbにjsonの場所を指定
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DB_PLACE = os.path.join(BASE_DIR, 'db.json')
db = TinyDB(DB_PLACE)
table = db.table('subway')
Data = Query()
msg = []
items = {}
class Search():
'''パラメータを取得し、その条件を満たしたデータだけを返す'''
def on_get(self, req, resp):
# パラメータを取得
name = req.get_param('name')
types = req.get_param('type')
# nameパラメータに値が入っているのかを確認
if name:
if types:
# name,typeパラメータ共に値が存在するとき
# データをDBから取得
get_data = table.search((Data.name == name)
& (Data.type == types))
def pre_instances():
db = TinyDB('data/preins.json')
nstbl = db.table('ns_table')
nss = nstbl.all()
return render_template('vnf-records.html', site_name=site_name, nss=nss)
import subprocess
import sys
import io
import datetime
# database
from tinydb import TinyDB
top_database = TinyDB('data/live_mapping.json')
database = top_database.table('data')
from kalman_filter.sensor.nonmetric_map import NonMetricMap
nmap = NonMetricMap(top_database)
from kalman_filter.sensor import SensorData
def schema_to_db(time: 'datetime.datetime', data):
return {
'time': {
'year': time.year,
'month': time.month,
'day': time.day,
'hour': time.hour,
'minute': time.minute,
'second': time.second,
'microsecond': time.microsecond
},
'data': data
}
class SchedulerBot(discord.Client):
def __init__(self, discord_token):
super(SchedulerBot, self).__init__()
self.discord_token = discord_token
# Represents very small database inside a json file using TinyDB
self.db = TinyDB("db.json")
# Represents all available commands and how to use them.
# @TODO: Make command classes?!
#!schedule "Hearthstone Tourney 4" 2017-06-07 7:30PM PST "Bring your best decks!"
self.commands = {
"!schedule": {
"examples": [
"!schedule \"Game Night\" 2017-06-01 05:30PM PST \"Bring your own beer.\""
]
},
"!reply": {
"examples": ["!reply \"Game Night\" yes"]
},
"!events": {
"examples": ["!events 2017-06-01"]
},
"!scheduler-bot": {
"examples": ["!scheduler-bot"]
},
"!delete-event": {
"examples": ["!delete-event \"Game Night\""]
},
"!edit-event": {
"examples":
["!edit-event \"Game Night\" date 2017-06-06 time 5:30PM"]
}
#,
#"!remind":{
# "examples": ["!remind \"Game Night\" 30 minutes"]
#}
}
@asyncio.coroutine
def check_for_reminders(self, task_name, seconds_to_sleep=3):
while True:
yield from asyncio.sleep(seconds_to_sleep)
now = datetime.now().strftime("%Y-%m-%d %I:%M:%p")
reminders = self.get_data("Reminder", "reminder_datetime", now)
if len(reminders) > 0:
yield from self.handle_reminders(reminders)
def main(self):
pass
# @TODO: Commenting this out for reminders.
# loop = asyncio.get_event_loop()
# try:
# asyncio.async(self.check_for_reminders('reminder_task',1))
# asyncio.async(self.run())
# loop.run_forever()
# except KeyboardInterrupt:
# pass
# finally:
# print('step: loop.close()')
# loop.close()
def run(self):
print("superclass being called...")
# Calling superclass to do discord.Client's run.
super(SchedulerBot, self).run(self.discord_token)
# Discord client function that is called when the bot has logged into the registered server.
@asyncio.coroutine
def on_ready(self):
print('Logged in as')
print(self.user.name)
print(self.user.id)
print('------')
# Bot function that handles the reminders of a certain time and alerts all attendies.
@asyncio.coroutine
def handle_reminders(self, reminders):
names = [reminder["attendie"] for reminder in reminders]
reminders_by_name = {}
for reminder in reminders:
if reminder["attendie"] not in reminders_by_name:
reminders_by_name[reminder["attendie"]] = []
reminders_by_name[reminder["attendie"]].append(reminder)
print("Handling unique reminders for the following events: {}".format(
set([reminder["event_name"] for reminder in reminders])))
for i in self.get_all_members():
if i.name in names:
user = i
for reminder in reminders_by_name[i.name]:
event_date = self.get_data(
table_name="Event",
field="name",
field_value=reminder["event_name"])[0]["date"]
event_time = self.get_data(
table_name="Event",
field="name",
field_value=reminder["event_name"])[0]["time"]
event_timezone = self.get_data(
table_name="Event",
field="name",
field_value=reminder["event_name"])[0]["timezone"]
yield from self.send_message(
user,
'Reminding you that {} starts at {} {} {}.'.format(
reminder["event_name"], event_date, event_time,
event_timezone))
self.delete_reminder(reminders_by_name[i.name])
break
# Delete reminder from db.
def delete_reminder(self, reminders):
for reminder in reminders:
self.db.table("Reminder").remove(eids=[reminder.eid])
#self.db.table("Reminder").update(delete('eid'), where('eid') == reminder["eid"])
#self.db.update(delete(), User.name == 'John')
# Helper function that handles tokens captured within quotations.
# If there are tokens captured in two quotes, it will treat said tokens as a single token.
def handle_quotations(self, tokens):
new_tokens = []
phrase_found = False
phrase = ""
for token in tokens:
if "\"" in token:
token_ = token.strip("\"")
phrase += (token_ + " ")
if phrase_found or token.count("\"") == 2:
new_tokens.append(phrase.strip())
phrase = " "
phrase_found = False
else:
phrase_found = True
else:
if phrase_found:
phrase += (token + " ")
else:
new_tokens.append(token.strip())
return new_tokens
# Database helper function that strictly pulls events from the database.
# Pulls events based on desired fields.
# @param: field="date", field_value="2017-01-06"
# @TODO: Allow this function to query multiple parameters at once
# @TODO: Allow this function to look at differ
def get_data(self, table_name, field=None, field_value=None):
table = self.db.table(table_name)
if field:
all_results = table.search(Query()[field] == field_value)
else:
all_results = table.all()
return all_results
# Database helper function that gets all the field names from a given table.
def get_field_names(self, table_name):
table = self.db.table(table_name)
all_keys = table.all()[0].keys()
return all_keys
# Bot function that creates an event in the database.
def create_event(self, event_name, event_date, event_time, event_timezone,
event_description, event_author):
table = self.db.table('Event')
# Checks if the event has already been created.
# If it has, don't override the event.
if table.search(Query().name == event_name):
return "Event {} already created. Cannot override this event.".format(
event_name)
# Calculates the date, time, and timezone that the event was created.
# This helps with logging purposes.
now_date = time.strftime("%Y-%m-%d")
now_time = time.strftime("%I:%M%p")
now_tz = time.tzname[0]
now_tz_tokens = now_tz.split(" ")
if len(now_tz_tokens) > 1:
now_tz = "".join([token[0] for token in now_tz_tokens])
# Create the dictionary that represents the record in the event table.
event_record = {
'name': event_name,
'date': event_date,
'time': event_time,
'timezone': event_timezone,
'description': event_description,
'author': event_author,
'created_date': now_date,
'created_time': now_time,
'created_timezone': now_tz
}
# Try to insert the record into the table.
try:
table.insert(event_record)
return "{} event successfully recorded. Others may now reply to this event.".format(
event_name)
except:
return "Cannot insert record into the Event table."
# Bot function that edits an event that has already been created.
# @format field_values: {"name": "event1", "date": 2017-01-01}
def edit_event(self, event_name, reply_author, field_values):
table = self.db.table("Event")
response = ""
if table.search(Query().name == event_name):
if table.search((Query().author == reply_author)
& (Query().name == event_name)):
table.update(field_values, ((Query().author == reply_author) &
(Query().name == event_name)))
# If date, time, or timezone changed in the event, delete the reminder and make a new one with the updated times.
#if set(["date","time","timezone"]).intersection(set(field_values.keys())):
#reminder_data = [(reminder_record['attendie'], reminder_record['time_metric'], reminder_record['diff_value']) for reminder_record in self.get_data('Reminder', 'event_name', event_name)]
# print("Editing event, reminder_data: {}".format(reminder_data))
# self.delete_reminders_by_event_name(event_name, reply_author)
#for reminder in reminder_data:
# self.create_reminder(event_name, reminder[0], reminder[1], reminder[2])
response += "Event table has been edited with new values: {}".format(
field_values)
else:
response += "You do not have permission to edit this event."
else:
response += "Event {} does not exist.".format(event_name)
return response
# Database function that creates a reminder in the database.
def create_reminder(self, event_name, attendie, time_metric, diff_value):
event_data = self.get_data('Event', 'name', event_name)[0]
event_time = event_data['time']
event_date = event_data['date']
reminder_table = self.db.table('Reminder')
reply_data = [
reply_record for reply_record in self.get_data('Reply')
if reply_record['event_name'] == event_name
and reply_record['author'] == attendie
and reply_record['status'] == 'yes'
]
if len(reply_data) <= 0:
return "Attendie did not reply yes to the event."
if time_metric not in ("minutes", "hours", "days"):
return "Invalid time metric."
print("event_date: {}, event_time: {}".format(event_date, event_time))
event_dt = datetime.strptime(" ".join((event_date, event_time)),
'%Y-%m-%d %I:%M%p')
if time_metric == "minutes":
reminder_dt = event_dt - timedelta(minutes=diff_value)
elif time_metric == "hours":
reminder_dt = event_dt - timedelta(hours=diff_value)
elif time_metric == "days":
reminder_dt = event_dt - timedelta(days=diff_value)
reminder_dt = reminder_dt.strftime("%Y-%m-%d %I:%M:%p")
print("reminder_dt: {}".format(reminder_dt))
reply_data = self.get_data('Reply', 'event_name', event_name)
print("attendie: {}".format(attendie))
reminder_record = {
"event_name": event_name,
"attendie": attendie,
"reminder_datetime": reminder_dt,
"time_metric": time_metric,
"diff_value": diff_value,
"is_sent": False
}
try:
reminder_table.insert(reminder_record)
except:
return "Reminder not recorded into db. Check connection."
return "Reminder set. You'll be alerted {} {} before {} begins.".format(
diff_value, time_metric, event_name)
# @TODO finish reminder stuff right here.
# Bot function that creates a reply [to an event] in the database.
def create_reply(self, event_name, reply_status, reply_author):
reply_table = self.db.table('Reply')
# Checks if the event has been created.
# If it hasn't been created, there is no event to reply to.
event_table = self.db.table('Event')
if not event_table.search(Query().name == event_name):
return "This event hasn\'t been scheduled yet."
# Checks if the user has already submitted a reply to this event.
# If they have already replied, the reply is overwritten and the user is notified of it's updated value.
if reply_table.search((Query().author == reply_author)
& (Query().event_name == event_name)):
reply_table.update({'status': reply_status},
((Query().author == reply_author) &
(Query().event_name == event_name)))
#if reply_status == "yes":
# print(self.create_reminder(event_name, reply_author, "hours", 1))
#print(self.create_reminder(event_name, reply_author, "days", 1))
return "Your old reply has been updated to {}.".format(
reply_status)
# Calculates the date, time, and timezone that the event was created.
# This helps with logging purposes.
now_date = time.strftime("%Y-%m-%d")
now_time = time.strftime("%I:%M %p")
now_tz = time.tzname[0]
# Create the dictionary that represents the record in the reply table.
reply_record = {
'event_name': event_name,
'status': reply_status,
'author': reply_author,
'created_date': now_date,
'created_time': now_time,
'created_timezone': now_tz
}
# Try to insert the record into the table.
try:
reply_table.insert(reply_record)
#if reply_status == "yes":
# Create error handling for this. @TODO
# print(self.create_reminder(event_name, reply_author, "hours", 1))
# print(self.create_reminder(event_name, reply_author, "days", 1))
return "Your reply has been successfully recorded."
except:
return "Cannot insert record into the Reply table."
# Helper function that determines whether or not a string is of the correct date format.
# @param: date i.e. "2017-06-01"
def is_date(self, date):
# Try to convert the date into a struct_time. If it works, it's of a correct format.
try:
format_correct = isinstance(time.strptime(date, "%Y-%m-%d"),
time.struct_time)
return format_correct
except:
return False
# Helper function that determines whether or not a string is of the correct time format.
# @param: time_str i.e. "5:30PM"
def is_time(self, time_str):
time_str = time_str.lower()
time_period = time_str.split(":")
time_ = (":".join(time_period[:2]))[:-2]
period = time_str[-2:]
# Try to convert the date into a struct_time. If it works, it's of a correct format.
try:
time_correct = isinstance(time.strptime(time_, '%H:%M'),
time.struct_time)
period_correct = period in ("am", "pm")
return period_correct
except:
return False
# Helper function that determines whether or not a string is a valid time zone abbreviation.
def is_timezone(self, tz_str):
known_timezones = [
"ACDT", "ACST", "ACT", "ACT", "ADT", "AEDT", "AEST", "AFT", "AKDT",
"AKST", "AMST", "AMT", "AMT", "ART", "AST", "AST", "AWST", "AZOST",
"AZOT", "AZT", "BDT", "BIOT", "BIT", "BOT", "BRST", "BRT", "BST",
"BST", "BST", "BTT", "CAT", "CCT", "CDT", "CDT", "CEST", "CET",
"CHADT", "CHAST", "CHOT", "CHOST", "CHST", "CHUT", "CIST", "CIT",
"CKT", "CLST", "CLT", "COST", "COT", "CST", "CST", "ACST", "ACDT",
"CST", "CT", "CVT", "CWST", "CXT", "DAVT", "DDUT", "DFT", "EASST",
"EAST", "EAT", "ECT", "ECT", "EDT", "AEDT", "EEST", "EET", "EGST",
"EGT", "EIT", "EST", "AEST", "FET", "FJT", "FKST", "FKT", "FNT",
"GALT", "GAMT", "GET", "GFT", "GILT", "GIT", "GMT", "GST", "GST",
"GYT", "HADT", "HAEC", "HAST", "HKT", "HMT", "HOVST", "HOVT",
"ICT", "IDT", "IOT", "IRDT", "IRKT", "IRST", "IST", "IST", "IST",
"JST", "KGT", "KOST", "KRAT", "KST", "LHST", "LHST", "LINT",
"MAGT", "MART", "MAWT", "MDT", "MET", "MEST", "MHT", "MIST", "MIT",
"MMT", "MSK", "MST", "MST", "MUT", "MVT", "MYT", "NCT", "NDT",
"NFT", "NPT", "NST", "NT", "NUT", "NZDT", "NZST", "OMST", "ORAT",
"PDT", "PET", "PETT", "PGT", "PHOT", "PHT", "PKT", "PMDT", "PMST",
"PONT", "PST", "PST", "PYST", "PYT", "RET", "ROTT", "SAKT", "SAMT",
"SAST", "SBT", "SCT", "SGT", "SLST", "SRET", "SRT", "SST", "SST",
"SYOT", "TAHT", "THA", "TFT", "TJT", "TKT", "TLT", "TMT", "TRT",
"TOT", "TVT", "ULAST", "ULAT", "USZ1", "UTC", "UYST", "UYT", "UZT",
"VET", "VLAT", "VOLT", "VOST", "VUT", "WAKT", "WAST", "WAT",
"WEST", "WET", "WIT", "WST", "YAKT", "YEKT"
]
return (tz_str in known_timezones)
# Helper function that determines whether or not a string has a digit.
# This is used as quick hack to look for strings that may have dates.
def has_digit(self, input_str):
return any(char.isdigit() for char in input_str)
# Helper function that determines whether or not an event exists.
def event_exists(self, event_name):
table = self.db.table("Event")
return len(table.search(Query().name == event_name)) > 0
# String formatter function that determines how the events are displayed in the Discord client.
def format_events(self, events):
events_str = "**EVENTS**\n"
events_str += "```{:12} {:25} {:10} {:6} {:8}\n".format(
"Host", "Name", "Date", "Time", "Timezone")
# Sort the events by date.
date_string = '2009-11-29 03:17 PM'
events_by_datetime = {
event["name"]:
(datetime.strptime(event["date"] + " " + event["time"],
'%Y-%m-%d %I:%M%p'))
for event in events
}
sorted_events = sorted(events_by_datetime.items(),
key=lambda p: p[1],
reverse=False)
print("events_sorted_by_datetime: {}".format(sorted_events))
for target_event in sorted_events:
for event in events:
if target_event[0] == event["name"]:
author = event["author"]
name = event["name"]
date = event["date"]
time = event["time"]
timezone = event["timezone"]
events_str += "{:12} {:25} {:10} {:6} {:8}\n".format(
author, name if len(name) < 25 else name[:22] + "...",
date, time, timezone)
break
events_str += "```"
# Just for debugging purposes.
print("events_str: {}".format(events_str))
return events_str
# String formatter function that determines how single events are displayed in the Discord client.
def format_single_event(self, event, replies):
event_str = "**{}**".format(event["name"])
event_str += "```{:12} {:15} {:10} {:6} {:8}\n".format(
"Host", "Name", "Date", "Time", "Timezone")
author = event["author"]
name = event["name"]
date = event["date"]
time = event["time"]
timezone = event["timezone"]
desc = event["description"]
event_str += "{:12} {:15} {:10} {:6} {:8}\n\n{}\n\n".format(
author, name[:15], date, time, timezone, desc)
reply_statuses = {"yes": [], "no": [], "maybe": []}
for reply in replies:
user = reply["author"]
status = reply["status"]
reply_statuses[status].append(user)
event_str += "Yes: {}\n".format(", ".join(reply_statuses["yes"]))
event_str += "No: {}\n".format(", ".join(reply_statuses["no"]))
event_str += "Maybe: {}".format(", ".join(reply_statuses["maybe"]))
event_str += "```"
return event_str
# Bot function that deletes certain reminders from the database based on the event name.
def delete_reminders_by_event_name(self, event_name, author):
event_table = self.db.table("Event")
if not event_table.search(Query().name == event_name):
return "Event {} not in the table.".format(event_name)
elif not event_table.search((Query().author == author)
& (Query().name == event_name)):
return "You do not have permission to delete this event."
reminder_table = self.db.table("Reminder")
# Remove all reminders from the reminder table with that event name.
try:
reminder_table.remove(Query().event_name == event_name)
except:
return "Cannot connect to Reminder table."
return "Reminders successfully deleted for event {}.".format(
event_name)
# Bot function that deletes a certain event from the database.
def delete_event(self, event_name, reply_author):
event_table = self.db.table("Event")
reply_table = self.db.table("Reply")
#reminder_table = self.db.table("Reminder")
if not event_table.search(Query().name == event_name):
return "Event {} not in the table.".format(event_name)
elif not event_table.search((Query().author == reply_author)
& (Query().name == event_name)):
return "You do not have permission to delete this event."
# Remove event from event table.
try:
event_table.remove(Query().name == event_name)
except:
return "Cannot connect to the Event table."
# Remove all replies from the reply table with that event name.
try:
reply_table.remove(Query().event_name == event_name)
except:
return "Cannot connect to the Reply table."
# Remove all reminders from the reminder table with that event name.
# try:
# reminder_table.remove(Query().event_name == event_name)
#except:
#return "Cannot connect to Reminder table."
return "Event successfully deleted."
# Discord client function that determines how to handle a new message when it appears on the Discord server.
@asyncio.coroutine
def on_message(self, message):
tokens = message.content.split(' ')
tokens = [str(token) for token in tokens]
bot_command = tokens[0].lower()
# !schedule command.
if bot_command == '!schedule':
tokens = tokens[1:]
if len(tokens):
tokens = self.handle_quotations(tokens)
if len(tokens) > 5:
create_event_response = "Invalid input: too many parameters."
else:
event_name = tokens[0].strip()
event_date = tokens[1]
event_time = tokens[2]
event_timezone = tokens[3]
event_description = tokens[4].strip()
event_author = message.author.name
# Setup input rules to check inputs.
date_rule = InputRule(
self.is_date,
"Invalid date format. Use: YYYY-MM-DD i.e. 2017-01-01")
time_rule = InputRule(
self.is_time,
"Invalid time format. Use: HH:MMPP i.e. 07:58PM")
if date_rule.passes(event_date) is False:
create_event_response = date_rule.fail_msg
elif time_rule.passes(event_time) is False:
create_event_response = time_rule.fail_msg
else:
create_event_response = self.create_event(
event_name, event_date, event_time, event_timezone,
event_description, event_author)
else:
create_event_response = "Invalid input: not enough inputs."
yield from self.send_message(message.channel,
create_event_response)
# !reply command.
elif bot_command == '!reply':
# print("message.author: {}, type(message.author): {}".format(message.author, type(message.author)))
tokens = tokens[1:]
if len(tokens) >= 2:
tokens = self.handle_quotations(tokens)
if len(tokens) == 2:
event_name = tokens[0].strip()
reply_status = tokens[1].strip().lower()
reply_author = message.author.name
event_created_rule = InputRule(
self.event_exists,
"Invalid input. Event not yet created.")
reply_rule = InputRule(
lambda v1: (v1 in ("yes", "no", "maybe")),
"Invalid input. Use: yes, no, or maybe.")
if not event_created_rule.passes(event_name):
create_reply_response = event_created_rule.fail_msg
elif not reply_rule.passes(reply_status):
create_reply_response = reply_rule.fail_msg
else:
create_reply_response = self.create_reply(
event_name, reply_status, reply_author)
else:
create_reply_response = "Invalid input: Too many parameters."
else:
create_reply_response = "Invalid input: Not enough inputs. Provide event name and reply status."
yield from self.send_message(message.channel,
create_reply_response)
# !events command.
elif bot_command == '!events':
tokens = tokens[1:]
if tokens:
if len(tokens) == 1:
date = tokens[0].lower()
# Setup input rules to check inputs.
date_rule = InputRule(
self.is_date,
"Invalid date format. Use: YYYY-MM-DD i.e. 2017-01-01")
today_tomorrow_rule = InputRule(
lambda x: x.lower() in ("today", "tomorrow"),
"Invalid day format. Use: today or tomorrow.")
if self.has_digit(date):
if not date_rule.passes(date):
create_events_response = date_rule.fail_msg
else:
all_events_str = self.format_events(
self.get_data("Event", "date", date))
create_events_response = all_events_str
else:
if not today_tomorrow_rule.passes(date):
create_events_response = today_tomorrow_rule.fail_msg
else:
date_ = datetime.now().strftime(
"%Y-%m-%d") if date == "today" else (
datetime.now() +
timedelta(days=1)).strftime("%Y-%m-%d")
all_events_str = self.format_events(
self.get_data("Event", "date", date_))
create_events_response = all_events_str
else:
create_events_response = "Invalid input: Too many parameters."
else:
create_events_response = self.format_events(
self.get_data("Event"))
yield from self.send_message(message.channel,
create_events_response)
elif bot_command == '!event':
tokens = tokens[1:]
if tokens:
tokens = self.handle_quotations(tokens)
if len(tokens) == 1:
event_name = tokens[0]
all_events = self.get_data("Event", "name", event_name)
all_replies = self.get_data("Reply", "event_name",
event_name)
if len(all_events) > 0:
event_response = self.format_single_event(
all_events[0], all_replies)
else:
event_response = "Invalid input: event not yet created."
else:
event_response = "Invalid input: Too many parameters."
else:
event_response = "Invalid input: no event name."
yield from self.send_message(message.channel, event_response)
# !scheduler-bot command. (list commands)
elif bot_command == '!scheduler-bot' and len(tokens) == 1:
list_commands_response = "**COMMANDS**\n```"
for command in list(self.commands.keys()):
list_commands_response += "{}: \n\t {}\n\n".format(
command, self.commands[command]["examples"][0])
list_commands_response += "```"
yield from self.send_message(message.channel,
list_commands_response)
# !delete-event command.
elif bot_command == '!delete-event':
tokens = tokens[1:]
if tokens:
tokens = self.handle_quotations(tokens)
if len(tokens) == 1:
event_name = tokens[0]
reply_author = message.author.name
all_events = self.get_data("Event", "name", event_name)
if len(all_events) > 0:
delete_event_response = self.delete_event(
event_name, reply_author)
else:
delete_event_response = "Invalid input: event not yet created."
else:
delete_event_response = "Invalid input: Too many parameters."
else:
delete_event_response = "Invalid input: no event name."
yield from self.send_message(message.channel,
delete_event_response)
# !remind command.
# !remind OverwatchNight 2 days
elif bot_command == "!remind":
tokens = tokens[1:]
if tokens:
if len(tokens) < 3:
remind_response = "Invalid input: missing arguments."
else:
tokens = self.handle_quotations(tokens)
event_table = self.db.table('Event')
reply_table = self.db.table('Reply')
if not event_table.search(Query().name == tokens[0]):
remind_response = "Invalid input: This event hasn\'t been scheduled yet."
elif not tokens[1].isdigit():
remind_response = "Invalid input: bad numeric."
elif not tokens[2] in ["minutes", "hours", "days"]:
remind_response = "Invalid input: did not use 'minutes','hours', or 'days'."
elif not reply_table.search(
(Query().author == message.author.name)
& (Query().event_name == tokens[0])):
remind_response = "Invalid input: User has not replied 'yes' to the event."
else:
remind_response = self.create_reminder(
tokens[0], message.author.name, tokens[2],
int(tokens[1]))
else:
remind_response = "Invalid input: no event name."
yield from self.send_message(message.channel, remind_response)
# !edit-event command.
# !edit OverwatchNight date 1/6/17 time 5:30PM
# @TODO: InputRule for time and timezone.
elif bot_command == '!edit-event':
tokens = tokens[1:]
if tokens:
tokens = self.handle_quotations(tokens)
event_name = tokens[0]
event_author = message.author.name
if len(tokens) <= 1:
edit_event_response = "No fields given to edit."
else:
tokens = tokens[1:]
if len(tokens) % 2 == 0:
is_event_field_rule = InputRule(
lambda x: x.lower() in self.get_field_names(
"Event"), "Field does not exist.")
date_rule = InputRule(
self.is_date,
"Invalid date format. Use: YYYY-MM-DD i.e. 2017-01-01"
)
time_rule = InputRule(
self.is_time,
"Invalid time format. Use: HH:MMPP i.e. 07:58PM")
timezone_rule = InputRule(
self.is_timezone, "Invalid timezone abbreviation.")
field_values = {}
rule_fail = False
for p in range(0, len(tokens), 2):
if not is_event_field_rule.passes(tokens[p]):
return is_event_field_rule.fail_msg
else:
# @TODO Rulechecker would fix this awful redundancy.
if tokens[p] == "date":
if not date_rule.passes(tokens[p + 1]):
edit_event_response = date_rule.fail_msg
rule_fail = True
break
elif tokens[p] == "time":
if not time_rule.passes(tokens[p + 1]):
edit_event_response = time_rule.fail_msg
rule_fail = True
break
elif tokens[p] == "timezone":
if not timezone_rule.passes(tokens[p + 1]):
edit_event_response = timezone_rule.fail_msg
rule_fail = True
break
field_values[tokens[p]] = tokens[p + 1]
if not rule_fail:
edit_event_response = self.edit_event(
event_name, event_author, field_values)
else:
edit_event_response = "Invalid input: incorrect number of parameters."
else:
edit_event_response = "Invalid input: no event name."
yield from self.send_message(message.channel, edit_event_response)
def __init__(self):
tiny_db = TinyDB(Config.database_file)
self._task_cache = tiny_db.table('tasks_cache')
self._log = logging.getLogger(self.__class__.__name__)
# TinyDBを使うためライブラリのインポート
from tinydb import TinyDB, Query
# データベースに接続
filepath = 'test-tynydb.json'
db = TinyDB(filepath)
# 既存のデータがあれば破棄
#db.purge_table('fruits')
# テーブルを得る
table = db.table('fruits')
# データをデータベースに挿入
table.insert({'name': 'Banana', 'price': 600})
table.insert({'name': 'Orange', 'price': 1200})
table.insert({'name': 'Mango', 'price': 840})
# 全データを抽出して表示
print(table.all())
# 特定のデータを抽出して表示
# Orangeを検索
Item = Query()
res = table.search(Item.name == 'Orange')
print('Orange is', res[0]['price'])
# 値段が800円以上のものを抽出
print('800円以上のもの：')
res = table.search(Item.price >= 800)
for it in res:
from tinydb import TinyDB, Query
import arrow
reprapDB = TinyDB('reprap.json')
factoids = reprapDB.table('factoids')
#{"id":3027,"item":"vodka","are":0,"value":"what comes out of russia's tap","nick":"eogra7_","dateset":"2014-01-01 02:43:41","locked":null,"lastsync":null}
factoids_history = reprapDB.table('factoids_history')
seen = reprapDB.table('seen')
tell = reprapDB.table('tell')
Nick = Query()
x = None
#{"id":3030,"item":"JATMN","are":0,"value":"JAT.MN","nick":"JATMN","dateset":"2014-01-01 02:46:48","locked":null,"lastsync":null}
count = factoids_history.count(Nick.item == x)
namelist = factoids.search(Nick.nick == x)
# for name in namelist:
# name["dateset"] = arrow.get(name["dateset"]).timestamp
# sorted_facts = sorted(namelist, key=lambda k: k["dateset"], reverse=True)
try:
# print ('count: {}'.format(count))
b = tell.all()
print(len(b))
except:
pass
#print(factoids.get(eid=2674))
def open():
global db, pipes
db = TinyDB(DB)
pipes = db.table('pipes', cache_size=0)
