class DB:
def __init__(self,db_path):
self.db = TinyDB(db_path)
def add(self, data):
# Only add it if you can't find it
Track = Query()
if not self.db.get(Track.display_id == data['display_id']):
return self.db.insert(data)
def searchById(self, video_id):
Track = Query()
return self.db.get(Track.display_id == video_id)
def search(self, text):
pattern = re.compile(text,re.IGNORECASE)
def test(txt):
return pattern.search(txt)
Track = Query()
q = Track.title.test(test) | Track.description.test(test)
return self.db.search(q)
def all(self):
return self.db.all()
class Test_007_Delete_Not_existing_data_by_valid_query_Function(unittest.TestCase):
def setUp(self):
self.db = TinyDB('db.json')
def tearDown(self):
self.db.purge()
self.db.all()
def test_simple_delete_not_exist(self):
print("case 7 Delete Non-existing data by valid query")
result=self.db.remove(where('Name') == 'Wendy')
self.assertEqual(result,None)
class Test_006_Modify_Not_existing_data_by_valid_query_Function(unittest.TestCase):
def setUp(self):
self.db = TinyDB('db.json')
def tearDown(self):
self.db.purge()
self.db.all()
def test_simple_modify_not_exist(self):
print("case 6 modify Non-existing data by valid query")
result=self.db.update({'int': 10}, where('Name') == 'Wendy')
self.assertEqual(result,None)
class Test_005_Search_Not_existing_data_by_valid_query_Function(unittest.TestCase):
def setUp(self):
self.db = TinyDB('db.json')
def tearDown(self):
self.db.purge()
self.db.all()
def test_simple_search_not_exist(self):
print("case 5 search Non-existing data by valid query")
result=self.db.search(where('Name') == 'Wendy')
self.assertEqual(result,[])
class Test_001_Insert_by_valid_query_Function(unittest.TestCase):
def setUp(self):
self.db = TinyDB('db.json')
def tearDown(self):
self.db.purge()
self.db.all()
def test_simple_insert_valid_exist(self):
print("case 1 insert data by valid query")
self.db.insert({'Name': 'Greg', 'Email': '*****@*****.**', 'int' : 1, 'char':1})
result=self.db.search(where('Name') == 'Greg')
self.assertEqual(result,[{'Name': 'Greg', 'Email': '*****@*****.**', 'int' : 1, 'char':1}])
def index():
form = SearchForm()
query = request.args.get('query', '').strip()
db = TinyDB(recipyGui.config.get('tinydb'))
if not query:
runs = db.all()
else:
# Search run outputs using the query string
runs = db.search(
where('outputs').any(lambda x: listsearch(query, x)) |
where('inputs').any(lambda x: listsearch(query, x)) |
where('script').search(query) |
where('notes').search(query) |
where('unique_id').search(query))
runs = sorted(runs, key = lambda x: parse(x['date'].replace('{TinyDate}:', '')) if x['date'] is not None else x['eid'], reverse=True)
run_ids = []
for run in runs:
if 'notes' in run.keys():
run['notes'] = str(escape(run['notes']))
run_ids.append(run.eid)
db.close()
return render_template('list.html', runs=runs, query=query, form=form,
run_ids=str(run_ids),
dbfile=recipyGui.config.get('tinydb'))
def test_serialisation_of_pandas_dataframe(tmpdir):
from sacred.observers.tinydb_hashfs import (DataFrameSerializer,
SeriesSerializer)
from tinydb_serialization import SerializationMiddleware
import numpy as np
import pandas as pd
# Setup Serialisation object for non list/dict objects
serialization_store = SerializationMiddleware()
serialization_store.register_serializer(DataFrameSerializer(),
'TinyDataFrame')
serialization_store.register_serializer(SeriesSerializer(),
'TinySeries')
db = TinyDB(os.path.join(tmpdir.strpath, 'metadata.json'),
storage=serialization_store)
df = pd.DataFrame(np.eye(3), columns=list('ABC'))
series = pd.Series(np.ones(5))
document = {
'foo': 'bar',
'some_dataframe': df,
'nested': {
'ones': series
}
}
db.insert(document)
returned_doc = db.all()[0]
assert returned_doc['foo'] == 'bar'
assert (returned_doc['some_dataframe'] == df).all().all()
assert (returned_doc['nested']['ones'] == series).all()
def test_serialisation_of_numpy_ndarray(tmpdir):
from sacred.observers.tinydb_hashfs import NdArraySerializer
from tinydb_serialization import SerializationMiddleware
import numpy as np
# Setup Serialisation object for non list/dict objects
serialization_store = SerializationMiddleware()
serialization_store.register_serializer(NdArraySerializer(), 'TinyArray')
db = TinyDB(os.path.join(tmpdir.strpath, 'metadata.json'),
storage=serialization_store)
eye_mat = np.eye(3)
ones_array = np.ones(5)
document = {
'foo': 'bar',
'some_array': eye_mat,
'nested': {
'ones': ones_array
}
}
db.insert(document)
returned_doc = db.all()[0]
assert returned_doc['foo'] == 'bar'
assert (returned_doc['some_array'] == eye_mat).all()
assert (returned_doc['nested']['ones'] == ones_array).all()
class pcDB:
def __init__(self,table="default"):
#'/path/to/db.json'
path=''
self.table=table
self.db = TinyDB(path).table(table)
def insert(self,_dict):
'''
:return:
'''
self.db.insert(_dict)
# db.insert({'int': 1, 'char': 'a'})
# db.insert({'int': 1, 'char': 'b'})
pass
def getAll(self):
'''
not param just get all data
:return:
'''
return self.db.all()
#db.search()
pass
pass
#
# from tinydb.storages import JSONStorage
# from tinydb.middlewares import CachingMiddleware
# db = TinyDB('/path/to/db.json', storage=CachingMiddleware(JSONStorage))
def test_write_first_cache(self):
"""test write behavior on first pass (cache-buster mode)"""
self.test_clear_existing_cache() #blowup existing cache again
dummy_data = forecast_utils.parse_emd_data(DEMO_DATA['result'])
forecast_utils.write_prediction_cache(
self.region_id,
self.type_id,
dummy_data,
cache_path=self.cache_path
)
assert path.isfile(self.cache_filepath)
tdb = TinyDB(self.cache_filepath)
data = tdb.all()[0]
keys_list = [
'cache_date',
'region_id',
'type_id',
'lastWrite',
'prediction'
]
assert set(keys_list) == set(data.keys())
dummy_str_data = dummy_data.to_json(
date_format='iso',
orient='records'
)
cached_data = pd.read_json(data['prediction'])
assert data['prediction'] == dummy_str_data
tdb.close()
def update_statistic():
db = TinyDB("data/db.json")
rows = db.all()
rows.sort(key=lambda x: int(x['rid']), reverse=True)
levels = {1: [], 2: [], 3: []}
for row in rows:
levels[row['level']].append(row)
out = []
header = '|%-35s|%-40s|%-6s|%-10s|%5s|%10s|' % ("round", "problem", "solved", "ave_pts",
"rate", "submission")
for k, v in levels.items():
out.append('# LEVEL %d' % k)
out.append('-' * len(header))
out.append(header)
out.append('-' * len(header))
v.sort(key=lambda x: difficulty(x), reverse=True)
for i in v:
out.append('|%-35s|%-40s|%-6s|%-10.2lf|%-4.3lf|%10s|' % (i['round'], i['name'], i['solved'],
i['average_pts'], i['correct_rate'], i['submissions']))
out.append('*' * len(header))
with open("data/statistic.txt", 'w') as f:
for i in out:
f.write(i + '\n')
print '>>>> data/statistic.txt has been updated.'
def get_coffees(active):
name = ''
name_link = ''
nav_links = []
description = ''
db = TinyDB('db/coffee.json')
coffee = db.all()
count = 0
coffee_id = 0
for i in coffee:
if active == -1 and count == 0:
nav_links.append(("/"+str(i['id']),"active",i['name']))
name = i['name']
description = i['description']
coffee_id = i['id']
name_link = '/'+str(i['id'])
elif active == -1 and count > 0:
nav_links.append(("/"+str(i['id']),"",i['name']))
elif active == i['id']:
nav_links.append(("/"+str(i['id']),"active",i['name']))
name = i['name']
description = i['description']
coffee_id = i['id']
name_link = '/'+str(i['id'])
else:
nav_links.append(("/"+str(i['id']),"",i['name']))
count = count+1
for i in nav_links:
print i
print name
print name_link
return nav_links, name, name_link, description, coffee_id
class NumberStore():
def __init__(self, filename):
self.db = TinyDB(filename)
def initNumber(self, number):
if not self.getNumberDict(number):
self.db.insert({'number': number, 'accesses': [], 'info': '#yolo'})
def touchNumber(self, number):
self.initNumber(number)
#print(self.getNumberDict(number))
#accesses = self.getNumberDict(number)['accesses'].append(datetime.datetime.now())
#self.db.update({'accesses': accesses}, where('number') == number)
def getNumberDict(self, number):
return self.db.get(where('number') == number)
def getNumberList(self):
return (entry['number'] for entry in self.db.all())
def getAccesses(self, number):
# if not number in self.db['numbers']:
# return None
# if not 'info' in self.db['numbers'][number]:
# return None
#
# return self.db['numbers'][number]['info']
return []
def getInfo(self, number):
return self.getNumberDict(number)['info']
def setInfo(self, number, info):
self.initNumber(number)
self.db.update({'info': info}, where('number') == number)
print(self.db.all())
def deleteNumber(self, number):
self.db.remove(where('number') == number)
print(self.db.all())
def close(self):
self.db.close()
def test_gc(tmpdir):
# See https://github.com/msiemens/tinydb/issues/92
path = str(tmpdir.join('db.json'))
table = TinyDB(path).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}]
def get_genres(database_name):
"""Utility method to get all the genres as a set"""
db = TinyDB(os.path.join(os.getcwd(), database_name))
all_genres = { song['genre'] for song in db.all() }
specific_genres = set()
for genre in all_genres:
specific_genres = specific_genres.union(set(genre.strip().split('/')))
db.close()
return _strip_spaces(specific_genres)
class Test_008_Insert_exits_data_Function(unittest.TestCase):
def setUp(self):
self.db = TinyDB('db.json')
def tearDown(self):
self.db.purge()
self.db.all()
def test_simple_insert_by_query(self):
print("case 8 can insert existing data")
self.db.insert({'Name': 'Yingyu Wu', 'Email': '*****@*****.**', 'int' : 1, 'char':1})
self.db.insert({'Name': 'Yingyu Wu', 'Email': '*****@*****.**', 'int' : 1, 'char':1})
result_array = self.db.search(where('Name') == 'Yingyu Wu')
num = len(result_array)
#print (result_array)
#print("search one key,get %d result" %(num))
self.assertEqual(2,num)
class FolderManager:
def __init__(self, path):
self.db_file = os.path.join(path, CONF_DIR, FOLDER_DB_FN)
self._db = TinyDB(self.db_file)
def open_db(self):
self._db = TinyDB(self.db_file)
def close_db(self):
self._db.close()
def add_folder(self, file_name):
if not self.folder_exists(file_name):
entry = {'file_name': file_name}
self._db.insert(entry)
def get_all_entries(self):
return self._db.all()
def folder_exists(self, file_name):
""" checks if a folder has been added """
entries = self._db.search(where('file_name') == file_name)
if entries:
return True
else:
return False
def remove_element(self, file_name):
self._db.remove(where('file_name') == file_name)
def get_file_names(self):
""" returns all the file names of folders that the user has added """
file_names = []
for entry in self._db.all():
file_names.append(entry['file_name'])
return file_names
def get_folder_by_name(self, expected_name):
""" get documents by the specified property """
entry = self._db.get(where('file_name') == expected_name)
return entry
def clear_all(self):
self._db.purge()
def sync_existing(dry_run=True, verbose=True):
"""Manually sync files by comparing modification time with last known.
"""
home = os.path.expanduser('~/')
truncate = len(home)
os.chdir(home)
db = TinyDB('.sdpp-sync.json')
for elem in db.all():
sony, paperpile, modtime = [elem[k]
for k in ['box', 'paperpile', 'modtime']]
modified_action(elem, sony, paperpile, modtime,
dry_run=dry_run, verbose=verbose)
def update_similarity_matrix(newDOI):
if(os.path.isfile(sim_matrix)):
db = TinyDB(db_loc)
paper = Query()
this_paper_dict = db.search(paper.ownDOI == newDOI)[0] #returns entry as dictionary
name = this_paper_dict['filename']
vector_path = vector_dir + name+'.pkl'
vec_file = open(vector_path, 'rb')
newVector = pickle.load(vec_file)
#now load the matrix
mat_file = open(sim_matrix,'rb')
mat_list = pickle.load(mat_file)
index_dict = mat_list[0];
mat = mat_list[1];
if newDOI in index_dict:
return False
num_ent = np.size(mat,axis = 0)
## if sizemat == 1:
## num_ent = 1
## else:
## num_ent = sizemat[0]
index_dict[newDOI] = num_ent
#extend the matrix to appropriate size
mat = np.vstack((mat,np.zeros((1,num_ent))))
mat = np.hstack((mat,np.zeros((num_ent+1,1))))
print mat
#get all the entries of the db
all_DOIs = db.all()
for line in all_DOIs:
print vector_path
name = line['filename']
vector_path = vector_dir+name+'.pkl'
print vector_path
vec_file = open(vector_path,'rb')
vec = pickle.load(vec_file)
closeness = vector_mult_and_add(newVector,vec)
newInd = index_dict[newDOI]
oldInd = index_dict[line['ownDOI']]
mat[newInd][oldInd] = closeness;
mat[oldInd][newInd] = closeness;
output_mat_list = [index_dict,mat]
output = open(sim_matrix,'wb')
pickle.dump(output_mat_list,output)
return None
else:
init_similarity_matrix(newDOI)
return None
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)
db.close()
return render_template('details.html', query='', form=form, run=runs[0],
annotateRunForm=annotateRunForm,
active_page='latest_run')
class ListCache(object):
DB_FILE = 'listing_db.json'
DB_TTL = timedelta(hours=12)
def __init__(self):
self.db = TinyDB(os.path.join(os.path.join(os.getcwd(), os.path.dirname(__file__)), ListCache.DB_FILE))
@property
def db(self):
return self._db
@db.setter
def db(self, db):
self._db = db
def listing_in_cache(self, listing):
lquery = Query()
return self.db.contains(lquery.hsh == listing.hsh)
def retrieve_listing(self, listing):
lquery = Query()
list_dict = self.db.get(lquery.hsh == listing.hsh)
return Listing.from_dict(list_dict)
def insert_listing(self, listing):
if self.listing_in_cache(listing):
self.update_listing(listing)
else:
list_dict = listing.as_dict()
list_dict['last_updated'] = datetime.now().isoformat()
list_dict['hsh'] = listing.hsh
self.db.insert(list_dict)
def remove_listing(self, listing):
lquery = Query()
self.db.remove(lquery.hsh == listing.hsh)
def update_listing(self, listing):
lquery = Query()
if self.listing_in_cache(listing):
self.remove_listing(listing)
self.insert_listing(listing)
def remove_old_listings(self):
list_ar = self.db.all()
for listing in list_ar:
if datetime.strptime(listing['last_updated'], '%Y-%m-%dT%H:%M:%S.%f') < datetime.now() - ListCache.DB_TTL:
self.remove_listing(Listing.from_dict(listing))
class MapController(BaseController):
def __init__(self):
self.addresses = TinyDB(self.databaseDirectory + "/addresses.json")
def get(self):
addresses = self.addresses.all()
markers = []
for address in addresses:
location = address["cords"]
if location[0] and location[1]:
markers.append(address["cords"])
return markers
def test_empty_cache(self):
"""test un-cached behavior"""
data = forecast_utils.check_prediction_cache(
self.region_id,
self.type_id,
cache_path=self.cache_path
)
assert data is None
assert path.isfile(self.cache_filepath)
tdb = TinyDB(self.cache_filepath)
assert tdb.all() == []
tdb.close()
def test_db_purge_when_all_posted(self):
available_files = list()
for index in range(1,101):
image_name = 'image{0}.png'.format(index)
available_files.append(image_name)
db = TinyDB(storage=storages.MemoryStorage)
for id in range(1,106):
image_name = 'image{0}.png'.format(id)
db.insert({'image': image_name})
self.assertEqual(len(db.all()), 105)
unused_files = utils.get_unused_files(db, available_files)
self.assertEqual(len(unused_files), 100)
self.assertEqual(unused_files[0], 'image1.png')
self.assertEqual(unused_files[5], 'image6.png')
self.assertEqual(unused_files[10], 'image11.png')
self.assertEqual(unused_files[33], 'image34.png')
self.assertEqual(unused_files[50], 'image51.png')
def test_tweet_insert_into_db(self):
config_parser = configparser.ConfigParser()
config_parser.optionxform = str
config_parser.read('tests/goldfinchsong.ini')
active_configuration = parse_configuration(config_parser)
credentials = active_configuration['credentials']
text_conversions = active_configuration['text_conversions']
try:
db = TinyDB(active_configuration['db_location'])
manager = Manager(credentials, db, active_configuration['image_directory'], text_conversions)
manager.api = MockManagerAPI()
manager.post_tweet()
tweets = db.all()
self.assertEqual(len(tweets), 1)
finally:
if os.path.isfile(active_configuration['db_location']):
os.remove(active_configuration['db_location'])
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 test_storage_in_db(self):
image_directory = 'tests/images/'
# let's load a list of tweets into the db
db = TinyDB(storage=storages.MemoryStorage)
image_names = [
'goldfinch1.jpg',
'goldfinch2.jpg',
'goldfinch3.jpg',
'goldfinch4.jpg'
]
for image_name in image_names:
delivery_timestamp = datetime.now(tz=timezone.utc).isoformat()
tweet = {'image': image_name, 'delivered_on': delivery_timestamp}
db.insert(tweet)
content = utils.load_content(db, image_directory)
self.assertEqual(content[2], 'goldfinch5.jpg')
tweets = db.all()
self.assertEqual(len(tweets), 4, msg=tweets)
class BotHelper:
def __init__(self, bot):
self.db = TinyDB('db.json')
self.bot = bot
def executeAssignment(self, chat_id, assignment):
if assignment['command'] == 'add':
entries = Query()
if self.db.search(entries.trigger == assignment['trigger']):
self.bot.sendMessage(chat_id=chat_id, text='No duplicates allowed for now')
return False
else:
if assignment['response_type'] == 'image' or assignment['response_type'] == 'gif':
filename = assignment['response'].split('/')[-1]
extention = filename.split('.')[-1]
urllib.request.urlretrieve(assignment['response'], 'media/images/' + assignment['trigger'] + '.' + extention)
assignment['response'] = 'media/images/' + assignment['trigger'] + '.' + extention
self.db.insert({
'trigger': assignment['trigger'],
'response_type':assignment['response_type'],
'response': assignment['response'],
})
if assignment['command'] == 'del':
self.db.remove(where('trigger') == assignment['trigger'])
if assignment['command'] == 'list':
entries = self.db.all()
for entry in entries:
self.bot.sendMessage(chat_id=chat_id, text=entry)
def executeTrigger(self, chat_id, message):
words = message.split(' ')
entries = Query()
for word in words:
entry = self.db.search(entries.trigger == word)
if entry:
if entry[0]['response_type'] == 'text':
self.bot.sendMessage(chat_id=chat_id, text=entry[0]['response'])
if entry[0]['response_type'] == 'image':
img = open(entry[0]['response'], 'rb')
self.bot.sendPhoto(chat_id=chat_id, photo=img)
if entry[0]['response_type'] == 'gif':
img = open(entry[0]['response'], 'rb')
self.bot.sendDocument(chat_id=chat_id, document=img)
class DataStore(object):
def __init__(self, store_path):
self.store_path = os.path.join(store_path,"META")
try:
os.makedirs(self.store_path)
except OSError as exc:
if exc.errno != errno.EEXIST:
raise
self.db = TinyDB(os.path.join(self.store_path,"__meta__.json"))
def add_file(self, file_path):
file_path = self._get_internal_path(file_path)
self._add_to_db(file_path)
def remove_file(self,file_path):
file_path = self._get_internal_path(file_path)
self._remove_from_db(file_path)
def list_all(self):
return self._list_all_db()
def _init_file_list(self):
with open(self.store_path,"r") as f:
for line in tqdm(f):
self.file_list.append(f)
def _init_db(self):
self.db = TinyDB(self.store_path)
def _add_to_db(self,file_path):
if not self.db.contains(where('file_path')== file_path):
self.db.insert({'file_path':file_path})
def _remove_from_db(self,file_path):
self.db.remove(where('file_path') == file_path)
def _list_all_db(self):
return [rec['file_path'] for rec in self.db.all()]
def _get_internal_path(self, path):
return get_internal_path(path)
def get_db_list(self, PATH=None):
'''
:param PATH:
:return:
'''
db = TinyDB(os.environ[config.STORAGE_INDEX_DB])
list = db.all()
results = []
for i in list:
results.append(
{
'name': i['data']['name'],
'map': i['data']['map'],
'selfid': i['id'],
'id': i['data']['id'],
'addresses': i['data']['url'],
'type': 'url',
'data': i['data']['data']
}
)
return results
ap = S[input_var - 1]
print ap["ssid"]
print ap["address"]
print ap["encrypted"]
print ap["channel"]
print "---------------------------------------------"
loop = True
while loop:
try:
input_var = int(
input("1: Store Valid AP \n2: Disregard and Continue\n:"))
if input_var > 0 and input_var <= 2:
loop = False
except ValueError:
pass
if input_var == 1:
if db.search((where('ssid') == ap["ssid"])
& (where('address') == str(ap["address"]))) == []:
db.insert(ap)
else:
print "already Stored in the database"
'''
print all database
'''
print db.all()
scan = scanning("wlan4", db)
scan.scan()
class atxserver2(object):
"""
According to users requirements to select devices
"""
def __init__(self, url):
"""
Construct method
"""
self._db = TinyDB(storage=MemoryStorage)
if url and re.match(r"(http://)?(\d+\.\d+\.\d+\.\d+:\d+)", url):
if '://' not in url:
url = 'http://' + url
else:
url = url
self._url = url
self.load()
else:
logger.error('Atx server addr error')
self.load()
def load(self, **kwargs):
"""
Use the data which got from stf platform to crate query db
:return: the len of records in the db's table
"""
kwargs['headers'] = {"Authorization": "Bearer " + token}
res = requests.get(self._url + '/api/v1/devices', **kwargs).json()
if res is not None:
eids = self._db.insert_multiple(res['devices'])
return len(eids)
else:
return 0
def find(self, cond=None):
"""
According condition to filter devices and return
:param cond: condition to filter devices
:type cond: where
:return: stf_selector object and its db contains devices
"""
if cond is not None:
res = self._db.search(cond)
self.purge()
self._db.insert_multiple(res)
return self
def devices(self):
"""
return all devices that meeting the requirement
:return: list of devices
"""
return self._db.all()
def refresh(self):
"""
reload the devices info from stf
:return: the len of records in the db's table
"""
self.purge()
return self.load()
def count(self):
"""
count the records in the db's table
:return: the len of records in the db's table
"""
return len(self._db.all())
def purge(self):
"""
remove all the data from the db
:return:
"""
self._db.purge()
def online_devices(self):
'''查找online 的设备'''
self.refresh()
devices = self.find(where('present') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def present_ios_devices(self, **kwargs):
kwargs['headers'] = {"Authorization": "Bearer " + token}
self.refresh()
self.find(where('platform') == 'apple').devices()
devices = self.find(where('present') == True).devices()
if len(devices) > 0:
return [
requests.get(
self._url + '/api/v1/user/devices/' + device['udid'],
**kwargs).json()['device'] for device in devices
]
else:
return False
def present_android_devices(self, **kwargs):
kwargs['headers'] = {"Authorization": "Bearer " + token}
self.refresh()
self.find(where('platform') == 'android').devices()
devices = self.find(where('present') == True).devices()
if len(devices) > 0:
return [
requests.get(
self._url + '/api/v1/user/devices/' + device['udid'],
**kwargs).json()['device'] for device in devices
]
else:
return False
def present_udid_devices(self, **kwargs):
kwargs['headers'] = {"Authorization": "Bearer " + token}
present_udid_devices_list = []
for udid in ReadConfig().get_server_udid():
self.refresh()
self.find(where('udid') == udid).devices()
device = self.find(where('present') == True).devices()
if device:
present_udid_devices_list.append(
requests.get(self._url + '/api/v1/user/devices/' + udid,
**kwargs).json()['device'])
else:
pass
if len(present_udid_devices_list) > 0:
return present_udid_devices_list
else:
return False
def using_device(self, udid, **kwargs):
kwargs['headers'] = {"Authorization": "Bearer " + token}
# kwargs['json'] = {"udid": udid}
ret = requests.post(self._url + '/api/v1/user/devices',
json={
"udid": udid,
"idleTimeout": 7200
},
**kwargs)
if ret.status_code == 200:
print(ret.json())
return True
else:
return False
def release_device(self, udid, **kwargs):
kwargs['headers'] = {"Authorization": "Bearer " + token}
ret = requests.delete(self._url + '/api/v1/user/devices/' + udid,
**kwargs)
if ret.status_code == 200:
print(ret.json())
return True
else:
return False
def get_unregistered_tip():
db = TinyDB(config.unregistered_tip_user)
data = db.all()
db.close()
return data
class TinyDBCatalogueProvider(BaseProvider):
"""TinyDB Catalogue Provider"""
def __init__(self, provider_def):
"""
Initialize object
:param provider_def: provider definition
:returns: pygeoapi.provider.tinydb_.TinyDBCatalogueProvider
"""
self.excludes = [
'_metadata-anytext',
]
super().__init__(provider_def)
LOGGER.debug('Connecting to TinyDB db at {}'.format(self.data))
if not os.path.exists(self.data):
msg = 'TinyDB does not exist'
LOGGER.error(msg)
raise ProviderConnectionError(msg)
self.db = TinyDB(self.data)
self.fields = self.get_fields()
def get_fields(self):
"""
Get provider field information (names, types)
:returns: dict of fields
"""
fields = {}
try:
r = self.db.all()[0]
except IndexError as err:
LOGGER.debug(err)
return fields
for p in r['properties'].keys():
if p not in self.excludes + ['extent']:
fields[p] = {'type': 'string'}
fields['q'] = {'type': 'string'}
return fields
def query(self,
offset=0,
limit=10,
resulttype='results',
bbox=[],
datetime_=None,
properties=[],
sortby=[],
select_properties=[],
skip_geometry=False,
q=None,
**kwargs):
"""
query TinyDB document store
:param offset: starting record to return (default 0)
:param limit: number of records to return (default 10)
:param resulttype: return results or hit limit (default results)
:param bbox: bounding box [minx,miny,maxx,maxy]
:param datetime_: temporal (datestamp or extent)
:param properties: list of tuples (name, value)
:param sortby: list of dicts (property, order)
:param select_properties: list of property names
:param skip_geometry: bool of whether to skip geometry (default False)
:param q: full-text search term(s)
:returns: dict of 0..n GeoJSON feature collection
"""
Q = Query()
LOGGER.debug('Query initiated: {}'.format(Q))
QUERY = []
feature_collection = {'type': 'FeatureCollection', 'features': []}
if resulttype == 'hits':
LOGGER.debug('hits only specified')
limit = 0
if bbox:
LOGGER.debug('processing bbox parameter')
bbox_as_string = ','.join(str(s) for s in bbox)
QUERY.append(
"Q.properties.extent.spatial.bbox.test(bbox_intersects, '{}')".
format(bbox_as_string)) # noqa
if datetime_ is not None:
LOGGER.debug('processing datetime parameter')
if self.time_field is None:
LOGGER.error('time_field not enabled for collection')
raise ProviderQueryError()
if '/' in datetime_: # envelope
LOGGER.debug('detected time range')
time_begin, time_end = datetime_.split('/')
if time_begin != '..':
QUERY.append(
"(Q.properties[self.time_field]>='{}')".format(
time_begin)) # noqa
if time_end != '..':
QUERY.append(
"(Q.properties[self.time_field]<='{}')".format(
time_end)) # noqa
else: # time instant
LOGGER.debug('detected time instant')
QUERY.append("(Q.properties[self.time_field]=='{}')".format(
datetime_)) # noqa
if properties:
LOGGER.debug('processing properties')
for prop in properties:
QUERY.append("(Q.properties['{}']=='{}')".format(*prop))
if q is not None:
for t in q.split():
QUERY.append(
"(Q.properties['_metadata-anytext'].search('{}', flags=re.IGNORECASE))"
.format(t)) # noqa
QUERY_STRING = '&'.join(QUERY)
LOGGER.debug('QUERY_STRING: {}'.format(QUERY_STRING))
SEARCH_STRING = 'self.db.search({})'.format(QUERY_STRING)
LOGGER.debug('SEARCH_STRING: {}'.format(SEARCH_STRING))
LOGGER.debug('querying database')
if len(QUERY) > 0:
LOGGER.debug('running eval on {}'.format(SEARCH_STRING))
results = eval(SEARCH_STRING)
else:
results = self.db.all()
feature_collection['numberMatched'] = len(results)
if resulttype == 'hits':
return feature_collection
for r in results:
for e in self.excludes:
del r['properties'][e]
len_results = len(results)
LOGGER.debug('Results found: {}'.format(len_results))
if len_results > limit:
returned = limit
else:
returned = len_results
feature_collection['numberReturned'] = returned
if sortby:
LOGGER.debug('Sorting results')
if sortby[0]['order'] == '-':
sort_reverse = True
else:
sort_reverse = False
results.sort(key=lambda k: k['properties'][sortby[0]['property']],
reverse=sort_reverse)
feature_collection['features'] = results[offset:offset + limit]
return feature_collection
def get(self, identifier, **kwargs):
"""
Get TinyDB document by id
:param identifier: record id
:returns: `dict` of single record
"""
LOGGER.debug('Fetching identifier {}'.format(identifier))
record = self.db.get(Query().id == identifier)
if record is None:
raise ProviderItemNotFoundError('record does not exist')
for e in self.excludes:
del record['properties'][e]
return record
def _bbox(input_bbox, record_bbox):
"""
Test whether one bbox intersects another
:param input_bbox: `list` of minx,miny,maxx,maxy
:param record_bbox: `list` of minx,miny,maxx,maxy
:returns: `bool` of result
"""
return True
def __repr__(self):
return '<TinyDBCatalogueProvider> {}'.format(self.data)
# We use a TinyDB as a database for our games
from tinydb import TinyDB, Query
# We create a flask app
app = flask.Flask(__name__)
# This will prevent errors beacaus of CORS but is probably making this unsecure
CORS(app)
# We use debug mode for now
app.config["DEBUG"] = True
# We open our TinyDB. Note that the file ist not yet in the github repository.
# There is a Jupyter notebook which builds the database.
game_db = TinyDB('spiele_tinydb.json')
# Create some test data for our catalog in the form of a list of dictionaries.
games = game_db.all()[0:4]
# This is just a static response if no existing API is given
@app.route('/', methods=['GET'])
def home():
return '''<h1>My Game DB</h1>
<p>A prototype API for querying my collection of computer games.</p>'''
# We us this for testing for now to get a end to end prototype
@app.route('/api/v1/resources/games/all', methods=['GET'])
def api_all():
return jsonify(games)
def normalize_images(file_index_fn,
table_name="hdf5_proc",
date=None,
sample=None,
energy=None,
average_ff=True,
cores=-2,
query=None,
jj=False,
read_norm_ff=False):
"""Normalize images of one experiment.
If date, sample and/or energy are indicated, only the corresponding
images for the given date, sample and/or energy are normalized.
The normalization of different images will be done in parallel. Each
file, contains a single image to be normalized.
.. todo: This method should be divided in two. One should calculate
the average FF, and the other (normalize_images), should receive
as input argument, the averaged FF image (or the single FF image).
"""
start_time = time.time()
file_index_db = TinyDB(file_index_fn,
storage=CachingMiddleware(JSONStorage))
db = file_index_db
if table_name is not None:
file_index_db = file_index_db.table(table_name)
#print(file_index_db.all())
files_query = Query()
if date or sample or energy:
temp_db = TinyDB(storage=MemoryStorage)
if date:
records = file_index_db.search(files_query.date == date)
temp_db.insert_multiple(records)
if sample:
records = temp_db.search(files_query.sample == sample)
temp_db.purge()
temp_db.insert_multiple(records)
if energy:
records = temp_db.search(files_query.energy == energy)
temp_db.purge()
temp_db.insert_multiple(records)
file_index_db = temp_db
root_path = os.path.dirname(os.path.abspath(file_index_fn))
file_records = file_index_db.all()
#print(file_records)
dates_samples_energies = []
for record in file_records:
data = (record["date"], record["sample"], record["energy"])
if jj is True:
data += (record["jj_u"], record["jj_d"])
dates_samples_energies.append(data)
dates_samples_energies = list(set(dates_samples_energies))
num_files_total = 0
for date_sample_energy in dates_samples_energies:
date = date_sample_energy[0]
sample = date_sample_energy[1]
energy = date_sample_energy[2]
# Raw image records by given date, sample and energy
query_cmd = ((files_query.date == date) &
(files_query.sample == sample) &
(files_query.energy == energy) &
(files_query.FF == False))
if jj is True:
jj_u = date_sample_energy[3]
jj_d = date_sample_energy[4]
query_cmd &= ((files_query.jj_u == jj_u) &
(files_query.jj_d == jj_d))
if query is not None:
query_cmd &= query
h5_records = file_index_db.search(query_cmd)
# FF records by given date, sample and energy
query_cmd_ff = ((files_query.date == date) &
(files_query.sample == sample) &
(files_query.energy == energy) &
(files_query.FF == True))
if jj is True:
jj_u = date_sample_energy[3]
jj_d = date_sample_energy[4]
query_cmd_ff &= ((files_query.jj_u == jj_u) &
(files_query.jj_d == jj_d))
h5_ff_records = file_index_db.search(query_cmd_ff)
files = get_file_paths(h5_records, root_path)
#print(files)
n_files = len(files)
num_files_total += n_files
files_ff = get_file_paths(h5_ff_records, root_path)
if not files_ff:
msg = "FlatFields are not present, images cannot be normalized"
raise Exception(msg)
# print("------------norm")
# import pprint
# prettyprinter = pprint.PrettyPrinter(indent=4)
# prettyprinter.pprint(files)
# prettyprinter.pprint(files_ff)
if average_ff:
# Average the FF files and use always the same average (for a
# same date, sample, energy and jj's)
# Normally the case of magnetism
if read_norm_ff is True:
ff_norm_image = get_normalized_ff(files_ff)
else:
#print("---files ff")
#print(files_ff)
#print("---files")
#print(files)
_, ff_norm_image = normalize_image(files[0],
ff_img_filenames=files_ff)
files.pop(0)
if len(files):
Parallel(n_jobs=cores,
backend="multiprocessing")(delayed(normalize_image)(
h5_file, average_normalized_ff_img=ff_norm_image)
for h5_file in files)
else:
# Same number of FF as sample data files
# Normalize each single sample data image for a single FF image
# Normally the case of spectrocopies
# TODO
pass
print("--- Normalize %d files took %s seconds ---\n" %
(num_files_total, (time.time() - start_time)))
db.close()
def average_ff(file_index_fn,
table_name="hdf5_proc",
date=None,
sample=None,
energy=None,
cores=-2,
query=None,
jj=False):
start_time = time.time()
file_index_db = TinyDB(file_index_fn,
storage=CachingMiddleware(JSONStorage))
db = file_index_db
if table_name is not None:
file_index_db = file_index_db.table(table_name)
files_query = Query()
if date or sample or energy:
temp_db = TinyDB(storage=MemoryStorage)
if date:
records = file_index_db.search(files_query.date == date)
temp_db.insert_multiple(records)
if sample:
records = temp_db.search(files_query.sample == sample)
temp_db.purge()
temp_db.insert_multiple(records)
if energy:
records = temp_db.search(files_query.energy == energy)
temp_db.purge()
temp_db.insert_multiple(records)
file_index_db = temp_db
root_path = os.path.dirname(os.path.abspath(file_index_fn))
file_records = file_index_db.all()
dates_samples_energies = []
for record in file_records:
data = (record["date"], record["sample"], record["energy"])
if jj is True:
data += (record["jj_u"], record["jj_d"])
dates_samples_energies.append(data)
dates_samples_energies = list(set(dates_samples_energies))
num_files_total = 0
for date_sample_energy in dates_samples_energies:
date = date_sample_energy[0]
sample = date_sample_energy[1]
energy = date_sample_energy[2]
# FF records by given date, sample and energy
query_cmd_ff = ((files_query.date == date) &
(files_query.sample == sample) &
(files_query.energy == energy) &
(files_query.FF == True))
if jj is True:
jj_u = date_sample_energy[3]
jj_d = date_sample_energy[4]
query_cmd_ff &= ((files_query.jj_u == jj_u) &
(files_query.jj_d == jj_d))
h5_ff_records = file_index_db.search(query_cmd_ff)
files_ff = get_file_paths(h5_ff_records, root_path)
normalize_ff(files_ff)
print("END OF TOURNAMENT")
tournamentdb.insert(newtournament)
elif len(tournamentdb.search(existingTID.TID == newhand["TID"])) == 1:
handcount = tournamentdb.search(existingTID.TID == newhand["TID"])[0]["handcount"] + 1
if lasthand == True:
print("END OF TOURNAMENT")
tournamentdb.update({"duration": time_difference(newtournament["time"], newhand["time"])}, existingTID.TID == newhand["TID"])
tournamentdb.update({"result": result}, existingTID.TID == newhand["TID"])
tournamentdb.update({"handcount": handcount}, existingTID.TID == newhand["TID"])
# # calculate end time and determine place
# duration = time_difference(newtournament["time"], lasttime)# start time - end time in seconds.
# newtournament["duration"] = duration
# newtournament["handcount"] = handcount + 1
# newtournament["buyin"] = newhand["buyin"]
# newtournament["rake"] = newhand["rake"]
# print(newtournament) # insert tournament into dataset
# # create new tournament
# lastTID = newhand["TID"]
# newtournament = {"ID": lastTID, "time":newhand["time"]}
# lasttime = newhand["time"]
start = time.time()
parse_file("may21-may29.txt")
end = time.time() - start
print("\ntotal seconds: " + str(end))
handdb = TinyDB("handdb.json")
print("time per hand: " + str(end/len(handdb.all())))
import simplejson as json
from tinydb import TinyDB, Query, where
db = TinyDB('C:/python_Webcroling/section5/databases/database1.db')
# db.insert({'name':'kim','email':'*****@*****.**'}) #json(dict) {}
# db.insert_multiple([{'name':'lee','email':'*****@*****.**'},{'name':'park','email':'*****@*****.**'}]) #jsonArray(dict) [{},{},{}]
SQL = Query()
el = db.get(SQL.name == 'kim')
print(el)
print(el.doc_id)
#데이터 수정
db.update({'email': '*****@*****.**'}, doc_ids=[1])
#데이터 수정 및 수정
db.upsert({'email': 'tesdf@naver', 'login': True}, SQL.name == 'park')
#데이터 삭제
# db.remove(doc_ids=[1,3])
# db.remove(SQL.name=='park')
#전체조회
print(db.all())
from tinydb import TinyDB, Query
db = TinyDB('World.json')
print(db.all()[0])
class Blockchain():
def __init__(self):
self.db = TinyDB('blks.json')
self.utxo_pool = Utxos()
self.utxo_pool.update_pool([]) ##############################
self.bits = 0x33222222
try:
with open("miner_key", "r") as f:
self.miner_wif = f.read(51)
with open("miner_address.txt", "r") as f2:
self.address = f2.read(34)
except:
with open("miner_key", "w") as f:
privkey = wallet.gen_privkey()
self.miner_wif = wallet.privkey_to_wif(privkey)
f.write(self.miner_wif + "\n")
with open("miner_address.txt", "w") as f2:
self.address = wallet.gen_address(
wallet.get_pubkey_str(privkey))
f2.write(self.address + "\n")
def mine(self):
if self.height() == 0:
return self.genesis_block()
txs = pending_pool.get_first3()
fee = 0
if len(txs) > 0:
fee = (len(txs)) * tx_fee
print(f'fee = {fee}')
coinbase_tx = form_coinbase(self.address, self.miner_wif,
self.get_current_reward() + fee)
serialized_cb = Serializer().serialize(coinbase_tx)
txs.insert(0, serialized_cb)
b = Block(time.time(), self.prev_hash(), txs, 0, self.bits).mine()
b.height = self.height()
print("Congratulations! Block " + b.toJSON() + " was mined!")
self.db.insert({
'Block Size': 0xffffffff,
'Version': 1,
'Previous Block Hash': b.prev_hash,
'Merkle Root': b.merkle,
'Timestamp': int(b.timestamp),
'Difficulty Target': hex(b.bits),
'Nonce': b.nonce,
'Transaction Counter': len(b.txs),
'Transactions': b.txs
})
if self.height() % 5 == 0:
self.recalculate_bits()
self.utxo_pool.update_pool(txs)
def genesis_block(self):
serialized_cb = Serializer().serialize(
form_coinbase(self.address, self.miner_wif,
self.get_current_reward()))
txs = [serialized_cb]
b = Block(time.time(), first_prev_txid, txs, 0, self.bits).mine()
print("Congratulations! Block " + b.toJSON() + " was mined!")
self.db.insert({
'Block Size': 0xffffffff,
'Version': 1,
'Previous Block Hash': b.prev_hash,
'Merkle Root': b.merkle,
'Timestamp': int(b.timestamp),
'Difficulty Target': hex(b.bits),
'Nonce': b.nonce,
'Transaction Counter': len(b.txs),
'Transactions': b.txs
})
self.utxo_pool.update_pool(txs)
def resolve_conflicts(self):
nodes_list = self.get_nodes_list()
if len(nodes_list) == 0:
print("There are no nodes in the list")
return
longest_chain_url = nodes_list[0]
longest_length = 0
for node in nodes_list:
cur_len = requests.get("http://" + node + "/chain/length")
cur_len = int(cur_len.json())
if longest_length < cur_len:
longest_chain_url = node
longest_length = cur_len
chain = requests.get("http://" + longest_chain_url + "/chain").json()
if self.height() < longest_length: #check
open("blks.json", "w").close()
open("utxo.json", "w").close()
for c in chain:
print("BLOCK----> " + str(c))
self.db.insert(c)
self.utxo_pool.update_pool(c['Transactions'])
def recalculate_bits(self):
print(f'Old bits: {self.bits}')
diff_time = self.db.all()[-1]['Timestamp'] - self.db.all(
)[-5]['Timestamp']
print(f'diff time: {diff_time}')
if diff_time > max_time:
diff_time = max_time
elif diff_time < min_time:
diff_time = min_time
new_target = (diff_time * count_target(self.bits)) // max_time
if new_target > max_target:
new_target = max_target
self.bits = to_bitsn(new_target)
print(f'New bits: {self.bits}')
def is_valid_chain(self):
prev = block_from_JSON(1)
if prev.hash != prev.calculate_hash() \
or prev.merkle != merkle.calculate(prev):
return False
for i in range(2, self.height() + 1):
blk = block_from_JSON(i)
if blk.hash != blk.calculate_hash() \
or blk.merkle != merkle.calculate(blk) \
or blk.prev_hash != prev.hash:
return False
return True
def get_nodes_list(self):
try:
f = open("nodes.txt", "r")
lines = f.readlines()
nodes = []
for l in lines:
nodes.append(l.replace("\n", ""))
f.close()
return nodes
except:
return []
def add_node(self, ip):
if not re.match(r'(\d{1,3}\.){3}\d{1,3}:\d{4}', ip):
print(
"Please, enter node in format: ip:port (ex.: 192.12.0.1:5050)")
return
with open("nodes.txt", "a+") as f:
f.write(ip + "\n")
print(str(ip) + " was added to list of nodes.")
def submit_tx(self, route, tx):
requests.post(route, json=tx)
def prev_hash(self):
prev_block = block_from_JSON(self.height() - 1)
prev_hash = prev_block.calculate_hash()
return prev_hash
def height(self):
height = len(self.db)
return height
def get_difficulty(self):
diff = self.db.all()[self.height()]['difficulty']
return diff
def get_current_reward(self):
denominator = math.pow(2, self.height() // 5)
return int(g_miner_reward / denominator)
def get_block_info(self, data):
if data.isnumeric():
blk = block_from_JSON(int(data))
if blk:
return blk.toJSON()
for i in range(self.height()):
blk = block_from_JSON(i)
if blk and blk.hash == data:
return blk.toJSON()
print(f'Block with hash {data} doesnt exist.')
import signal
import time
import sys
import requests
import uuid
import json
import ast
from pirc522 import RFID
from tinydb import TinyDB, Query
from ast import literal_eval
# https://tinydb.readthedocs.io/en/latest/getting-started.html
# https://pcmweb.nl/artikelen/programmeren/bouw-je-eigen-sommentelefoon-met-een-raspberry-pi/?article-page=1
db = TinyDB('/home/pi/test/db.json')
db.all()
for item in db:
print str((item))
Card = Query()
search = db.search(Card.tag == 70246357)
names = [r['name'] for r in search]
names = ast.literal_eval(json.dumps(names))
#print (names[0])
#names.encode("utf-8")
run = True
rdr = RFID()
util = rdr.util()
def load_cookies() -> Dict[str, Any]:
db = TinyDB(path.join(DATA_DIR, 'cookies.json'))
return db.all()[0] or {}
import rq_dashboard
from worker_functions import start_check
import subprocess
import serial
r = redis.Redis()
q = Queue(connection=r, default_timeout=144000)
app = Flask(__name__)
app.config.from_object(rq_dashboard.default_settings)
app.register_blueprint(rq_dashboard.blueprint, url_prefix="/rq")
db = TinyDB('db.json')
# lock to control access to variable
th = threading.Thread(target=ScoreChecker, args=(db.all()[0]['id'], ))
def start_checking_thread():
th.start()
def stop_checking_thread():
pass
@app.route('/')
def hello_world():
records = db.all()
#checking_score = db.table("game").all()[0]["checking_score"]
class FileHandler():
# Private variables
__machineryFilePath = os.path.abspath("./data/machinery.json")
__adjusterFilePath = os.path.abspath("./data/adjuster.json")
__utilizationFilePath = os.path.abspath("./data/simulationResult.json")
def __init__(self, *args, **kwargs):
self.mcDB = TinyDB(self.__machineryFilePath)
self.adDB = TinyDB(self.__adjusterFilePath)
self.utDB = TinyDB(self.__utilizationFilePath)
def close_db(self):
self.mcDB.close()
self.adDB.close()
self.utDB.close()
# TODO:
def readAll(self):
data = {
"adj": None,
"mch": None,
}
data["adj"] = self.adDB.all()
data["mch"] = self.mcDB.all()
return data # string
def writeToFile(self, name, data):
if name == _ADJ:
success = self.adDB.insert(data)
adjuster = Query()
self.adDB.update({'ident': success}, doc_ids=[success])
elif name == _MCH:
success = self.mcDB.insert(data)
return success #int
def deleteAll(self):
self.adDB.purge_tables()
self.mcDB.purge_tables()
self.utDB.purge_tables()
def deleteRow(self, store, id):
if store == _ADJ:
self.adDB.remove(where('ident') == id)
elif store == _MCH:
self.mcDB.remove(where('name') == id)
def searchAdjuster(self, id):
adjuster = Query()
data = self.adDB.search(adjuster.ident == int(id))
return data #STRING
def searchCategory(self, name):
category = Query()
data = self.mcDB.search(category.name == name)
return data
def updateCategoryFile(self, id, new_name, quantity, MTTF):
category = Query()
sucess = self.mcDB.update(
{
"name": new_name,
"quantity": int(quantity),
"MTTF": float(MTTF)
},
doc_ids=[id])
return sucess #int
# TODO:
def updateAdjusterFile(self, option, name, qunatity, MTTF):
sucess = ""
return sucess #int
# TODO:
def updateUtilization(self, option, list):
success = ""
return success #int
def parse_hands(hands):
handdb = TinyDB("handdb.json") # initialize DB
#handdb.truncate() # clear entire DB
tournamentdb = TinyDB("tournamentdb.json")
#tournamentdb.truncate() # clear entire DB
for hand in hands:
newhand = {}
hand = hand.split("\n")
if hand[1].split()[7:10] != ['(SNG', 'JackPot', 'Tournament']:
print(hand[1].split()[7:10])
print("not spin & go")
print(hand)
continue
newhand["ID"] = hand[0].split()[5]
# check for duplicate hand
if len(handdb.all()) != 0:
existinghand = Query()
if len(handdb.search(existinghand.ID == newhand["ID"])) > 0:
print("duplicate hand... ignoring")
continue
print(newhand["ID"]) # print hand ID for debugging purposes
newhand["TID"] = hand[1].split()[10][1:-1]
newhand["buyin"] = hand[1].split()[12][1:]
newhand["rake"] = hand[1].split()[14][1:-1]
newhand["stakes"] = hand[1].split()[0]
newhand["time"] = hand[1].split()[17:]
newhand["players"] = hand[3].split()[5][0]
if newhand["players"] == "2":
if hand[6].startswith("Hero"):
newhand["position"] = "SB"
elif hand[7].startswith("Hero"):
newhand["position"] = "BB"
try:
lasthand, cards, net, showdown, allin, cev, result = twohanded_action(hand[4:])
except:
print("error parsing hand ID: "+ newhand["ID"] + " ... skipping")
continue
elif newhand["players"] == "3":
if hand[7].startswith("Hero"):
newhand["position"] = "SB"
elif hand[8].startswith("Hero"):
newhand["position"] = "BB"
else:
newhand["position"] = "BU"
try:
lasthand, cards, net, showdown, allin, cev, result = threehanded_action(hand[4:])
except:
print("error parsing hand ID: "+ newhand["ID"] + " ... skipping")
continue
newhand["cards"] = cards
newhand["net"] = net
newhand["showdown"] = showdown
newhand["cev"] = cev
# insert hand into DB
handdb.insert(newhand)
# query existing tournament database and check if tournament already exists
existingTID = Query()
if (tournamentdb.search(existingTID.TID == newhand["TID"])) == []:
newtournament = {}
newtournament["TID"] = newhand["TID"]
newtournament["handcount"] = 1
newtournament["buyin"] = newhand["buyin"]
newtournament["rake"] = newhand["rake"]
newtournament["time"] = newhand["time"]
newtournament["result"] = "unfinished"
newtournament["duration"] = "unfinished"
if lasthand == True:
newtournament["duration"] = "0"
newtournament["result"] = result
print("END OF TOURNAMENT")
tournamentdb.insert(newtournament)
elif len(tournamentdb.search(existingTID.TID == newhand["TID"])) == 1:
handcount = tournamentdb.search(existingTID.TID == newhand["TID"])[0]["handcount"] + 1
if lasthand == True:
print("END OF TOURNAMENT")
tournamentdb.update({"duration": time_difference(newtournament["time"], newhand["time"])}, existingTID.TID == newhand["TID"])
tournamentdb.update({"result": result}, existingTID.TID == newhand["TID"])
tournamentdb.update({"handcount": handcount}, existingTID.TID == newhand["TID"])
class ATX_Server(object):
"""
According to users requirements to select devices
"""
def __init__(self, url):
"""
Construct method
"""
self._db = TinyDB(storage=MemoryStorage)
if url and re.match(r"(http://)?(\d+\.\d+\.\d+\.\d+:\d+)", url):
if '://' not in url:
url = 'http://' + url + '/list'
else:
url = url + '/list'
self._url = url
self.load()
else:
logger.error('Atx server addr error')
self.load()
def load(self):
"""
Use the data which got from stf platform to crate query db
:return: the len of records in the db's table
"""
res = requests.get(self._url).json()
if res is not None:
eids = self._db.insert_multiple(res)
return len(eids)
else:
return 0
def find(self, cond=None):
"""
According condition to filter devices and return
:param cond: condition to filter devices
:type cond: where
:return: stf_selector object and its db contains devices
"""
if cond is not None:
res = self._db.search(cond)
self.purge()
self._db.insert_multiple(res)
return self
def devices(self):
"""
return all devices that meeting the requirement
:return: list of devices
"""
return self._db.all()
def refresh(self):
"""
reload the devices info from stf
:return: the len of records in the db's table
"""
self.purge()
return self.load()
def count(self):
"""
count the records in the db's table
:return: the len of records in the db's table
"""
return len(self._db.all())
def purge(self):
"""
remove all the data from the db
:return:
"""
self._db.purge()
def ready_devices(self):
'''查找标记为ready的设备'''
self.refresh()
devices = self.find(where('ready') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def online_devices(self):
'''查找online 的设备'''
self.refresh()
devices = self.find(where('present') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def model_devices(self, model):
'''查找特定型号的设备'''
self.refresh()
devices = self.find(where('model') == model).devices()
if len(devices) > 0:
return devices
else:
return False
def brand_devices(self, brand):
'''查找特定品牌的设备'''
self.refresh()
devices = self.find(where('brand') == brand).devices()
if len(devices) > 0:
return devices
else:
return False
def sdk_devices(self, sdk):
'''查找特定SDK的设备'''
self.refresh()
devices = self.find(where('sdk') == sdk).devices()
if len(devices) > 0:
return devices
else:
return False
def version_devices(self, version):
'''查找特定SDK的设备'''
self.refresh()
devices = self.find(where('version') == version).devices()
if len(devices) > 0:
return devices
else:
return False
def serial_devices(self, serial):
'''查找特定serial的设备'''
self.refresh()
devices = self.find(where('serial') == serial).devices()
if len(devices) > 0:
return devices
else:
return False
def all_devices(self):
'''返回所有的设备'''
self.refresh()
devices = self.find().devices()
if len(devices) > 0:
return devices
else:
return False
reddit = praw.Reddit(config.bot_config)
print "Current gold credit => " + str(reddit.user.me().gold_creddits)
else:
print "Formater used for analysis is " + args.formater
# check users history, list file in path
history_path = config.history_path
only_files = [f for f in listdir(history_path) if isfile(join(history_path, f))]
for username in only_files:
clean_user = username.replace('.json', '')
u = models.User(clean_user)
db = TinyDB(config.history_path + clean_user + '.json')
data_histo = db.all()
for row in data_histo:
date_check = datetime.datetime.strptime(row['time'], '%Y-%m-%dT%H:%M:%S.%f')
key = date_check.strftime(args.formater)
# Compute registration
if u.is_registered():
if clean_user not in list_of_user['all']:
list_of_user['all'].append(clean_user)
if key not in list_of_user.keys():
list_of_user[key] = []
if clean_user not in list_of_user[key]:
list_of_user[key].append(clean_user)
from tinydb import TinyDB, Query
db = TinyDB("database.json")
q = Query()
db.remove(q.username == "Azim")
data = db.all()
print(data)
ml=StringVar()
url=Entry(window,width=38,textvariable=ur)
url.grid(row=1,column=2,sticky=W,padx=5,pady=5)
token=Entry(window,width=38,textvariable=tk)
token.grid(row=3,column=2,sticky=W,padx=5,pady=5)
mail=Entry(window,width=38,textvariable=ml)
mail.grid(row=4,column=2,sticky=W,padx=5,pady=5)
#button
Button(window,text="Generate xlsx",width=15,command=start).grid(row=6,column=2)
Button(window,text="Reset",width=15,command=end_t).grid(row=6,column=1)
#status
progress=Progressbar (window, orient = HORIZONTAL, length=390, mode = 'determinate')
progress.grid(row=7,column=1,columnspan=2,padx=5,pady=5,sticky=W)
#listbox
logs =Listbox(window,width=65)
logs.grid(row=8,column=1,columnspan=2,padx=2,pady=2,sticky=W)
logs.insert(0,"Waiting to srart")
#auto-put data into textbox
if len(db.all())!=0:
ur.set(db.all()[0]['url'])
tk.set(db.all()[0]['token'])
ml.set(db.all()[0]['mail'])
window.mainloop()
'percentOwnership': 1,
'thresholds': []
})
# insert BCE
db.insert({
'assetID': 'BCE',
'assetType': 'COMMON',
'purchaseDate': '1997-12-12',
'purchasePrice': 2.858,
'volume': 179,
'saleDate': None,
'salePrice': None,
'priceFeedType': 'YAHOO',
'priceFeedRef': 'BCE.TO',
'debtFeedType': None,
'debtFeedRef': None,
'percentOwnership': 1,
'thresholds': []
})
allAssets = db.all()
for ass in allAssets:
print ass
frame = pd.DataFrame(allAssets)
print frame
#%%
import base64
from tinydb import TinyDB, Query
import os
# %%
db = TinyDB(os.path.join('/mnt/c/pcloud_ben/personal_project/quiz', 'question.json'))
#%%
for q in db.all():
q['question_body'] = base64.b64encode(q['question_body'].encode()).decode('utf-8')
for ch in q['choices']:
ch['choice_body'] = base64.b64encode(ch['choice_body'].encode()).decode('utf-8')
Question = Query()
db.remove(Question.id == q["id"])
db.insert(q)
class devices(object):
def __init__(self):
self.olts = TinyDB('olts.json')
self.pon_ports = TinyDB('pon_ports.json')
self.onus = TinyDB('onus.json')
self.uni_ports = TinyDB('uni_ports.json')
def get_mock_data(self):
"""
Get all the mock data,
this method is mostly intended for debugging
:return: a dictionary containing all the mocked data
"""
olts = self.olts.all()
pon_ports = self.pon_ports.all()
onus = self.onus.all()
uni_ports = self.uni_ports.all()
return {
'olts': olts,
'pon_ports': pon_ports,
'onus': onus,
'uni_ports': uni_ports,
}
def clean_storage(self):
self.olts.purge()
self.pon_ports.purge()
self.onus.purge()
self.uni_ports.purge()
###############################################################
# OLT #
###############################################################
def create_mock_olts(self, num_olts, voltservice_id):
"""
:param num_olts: Number of OLTs to be created
:param voltservice_id: ID if the vOLT service
:return:
"""
olts = []
for index in range(1, int(num_olts) + 1):
olt = {
'name': 'Test OLT%s' % index,
'volt_service_id': voltservice_id,
'device_type': 'fake_olt',
'host': '127.0.0.1',
'port': index,
'uplink': '65536',
'switch_datapath_id': 'of:0000000000000001',
'switch_port': str(index),
'of_id': 'of:000000%s' % index,
'dp_id': 'of:000000%s' % index,
}
# logger.info('Created OLT %s' % olt, also_console=True)
olts.append(olt)
self.olts.insert(olt)
return olts
def get_rest_olts(self):
"""
Get all the OLTs that have been created for the test
formatted for the XOS Rest API
:return: a list of OLTs
"""
return self.olts.all()
def update_olt_id(self, olt, id):
"""
Update in the memory storage the XOS ID
of a particular OLT as it's needed to create PON Ports
:param olt: The OLT object to update
:param id: The ID returned from XOS
:return: None
"""
Olt = Query()
self.olts.update({'id': id}, Olt.name == olt['name'])
###############################################################
# PON PORT #
###############################################################
def create_mock_pon_ports(self, num_pon):
ports = []
for olt in self.olts.all():
for index in range(1, int(num_pon) + 1):
port = {
'name': 'Test PonPort %s Olt %s' % (index, olt['id']),
'port_no': index,
'olt_device_id': olt['id']
}
ports.append(port)
self.pon_ports.insert(port)
return ports
def get_rest_pon_ports(self):
"""
Get all the PON Ports that have been created for the test
formatted for the XOS Rest API
:return: a list of PON Ports
"""
return self.pon_ports.all()
def update_pon_port_id(self, pon_port, id):
"""
Update in the memory storage the XOS ID
of a particular PON Port as it's needed to create ONUs
:param pon_port: The PON Port object to update
:param id: The ID returned from XOS
:return: None
"""
PonPort = Query()
self.pon_ports.update({'id': id}, PonPort.name == pon_port['name'])
###############################################################
# ONU #
###############################################################
def create_mock_onus(self, num_onus):
onus = []
j = 0
for port in self.pon_ports.all():
j = j + 1
for index in range(1, int(num_onus) + 1):
onu = {
'serial_number': "ROBOT%s%s" % (j, index),
'vendor': 'Robot',
'pon_port_id': port['id']
}
onus.append(onu)
self.onus.insert(onu)
return onus
def get_rest_onus(self):
return self.onus.all()
def update_onu_id(self, onu, id):
Onu = Query()
self.onus.update({'id': id}, Onu.serial_number == onu['serial_number'])
###############################################################
# UNI #
###############################################################
def create_mock_unis(self):
# NOTE I believe UNI port number must be unique across OLT
unis = []
i = 0
for onu in self.onus.all():
uni = {
'name': 'Test UniPort %s' % i,
'port_no': i,
'onu_device_id': onu['id']
}
unis.append(uni)
self.uni_ports.insert(uni)
i = i + 1
return unis
def get_rest_unis(self):
return self.uni_ports.all()
def update_uni_id(self, uni, id):
UniPort = Query()
self.uni_ports.update({'id': id}, UniPort.name == uni['name'])
###############################################################
# WHITELIST #
###############################################################
def create_mock_whitelist(self, attworkflowservice_id):
entries = []
for onu in self.onus.all():
e = {
'owner_id': attworkflowservice_id,
'serial_number': onu['serial_number'],
'pon_port_id': self._find_pon_port_by_onu(onu)['port_no'],
'device_id': self._find_olt_by_onu(onu)['of_id']
}
entries.append(e)
return entries
###############################################################
# EVENTS #
###############################################################
def generate_onu_events(self):
events = []
for onu in self.onus.all():
ev = {
'status': 'activated',
'serialNumber': onu['serial_number'],
'portNumber': str(self._find_uni_by_onu(onu)['port_no']),
'deviceId': self._find_olt_by_onu(onu)['of_id'],
}
events.append(ev)
return events
def generate_auth_events(self):
events = []
for onu in self.onus.all():
ev = {
'authenticationState': "APPROVED",
'deviceId': self._find_olt_by_onu(onu)['dp_id'],
'portNumber': self._find_uni_by_onu(onu)['port_no'],
}
events.append(ev)
return events
def generate_dhcp_events(self):
events = []
for onu in self.onus.all():
ev = {
'deviceId': self._find_olt_by_onu(onu)['dp_id'],
'portNumber': self._find_uni_by_onu(onu)['port_no'],
"macAddress": "aa:bb:cc:ee:ff",
"ipAddress": "10.10.10.10",
"messageType": "DHCPACK"
}
events.append(ev)
return events
###############################################################
# HELPERS #
###############################################################
def _find_uni_by_onu(self, onu):
Uni = Query()
# NOTE there's an assumption that 1 ONU has 1 UNI Port
return self.uni_ports.search(Uni.onu_device_id == onu['id'])[0]
def _find_pon_port_by_onu(self, onu):
# this does not care about the olt id...
PonPort = Query()
return self.pon_ports.search(PonPort.id == onu['pon_port_id'])[0]
def _find_olt_by_onu(self, onu):
pon_port = self._find_pon_port_by_onu(onu)
Olt = Query()
return self.olts.search(Olt.id == pon_port['olt_device_id'])[0]
class Cart:
def __init__(self, port = 9001):
self.port = port
self.db = TinyDB('db/db.json')
def create_payment(self, item, amount = 1):
payment = paypalrestsdk.Payment({
"intent": "sale",
"payer": {
"payment_method": "paypal"},
"redirect_urls": {
"return_url": "http://localhost:%s/payment/execute" % self.port,
"cancel_url": "http://localhost:3000/"},
"transactions": [{
"item_list": {
"items": [{
"name": item['name'],
"sku": str(uuid.uuid4()),
"price": item['price'],
"currency": "USD",
"quantity": amount}]},
"amount": {
"total": item['price'] * amount,
"currency": "USD"},
"description": "This is the payment transaction description."}]})
if payment.create():
print("Payment created successfully")
else:
print(payment.error)
return payment
def execute_payment(self, payment_id, payer_id='DUFRQ8GWYMJXC'):
# ID of the payment. This ID is provided when creating payment.
payment = Payment.find(payment_id)
# PayerID is required to approve the payment.
if payment.execute({"payer_id": payer_id}): # return True or False
print("Payment[%s] execute successfully" % (payment.id))
else:
print(payment.error)
def get_payments(self, count = 10):
payment_history = Payment.all({"count": count}).payments
return payment_history
def get_data_file(self, filename):
return os.path.join(DATA_DIR, filename)
def record_item(self, item, payment=True):
if 'user' not in item:
item['user'] = fake.name()
if 'converted' not in item:
item['converted'] = random.choice([True, False])
res = False
if payment:
res = self.create_payment(item, 1)
self.db.insert(item)
return res
def get_items(self):
return self.db.all()
class ProgramEngine:
# pylint: disable=exec-used
_instance = None
def __init__(self):
self._program = None
self._log = ""
self._programs = TinyDB("data/programs.json")
query = Query()
for dirname, dirnames, filenames, in os.walk(PROGRAM_PATH):
dirnames
for filename in filenames:
if PROGRAM_PREFIX in filename:
program_name = filename[len(PROGRAM_PREFIX):-len(PROGRAM_SUFFIX)]
if self._programs.search(query.name == program_name) == []:
logging.info("adding program %s in path %s as default %r", program_name, dirname, ("default" in dirname))
self._programs.insert({"name": program_name, "filename": os.path.join(dirname, filename), "default": str("default" in dirname)})
@classmethod
def get_instance(cls):
if not cls._instance:
cls._instance = ProgramEngine()
return cls._instance
def prog_list(self):
return self._programs.all()
def save(self, program):
query = Query()
self._program = program
program_db_entry = program.as_dict()
program_db_entry["filename"] = os.path.join(PROGRAM_PATH, PROGRAM_PREFIX + program.name + PROGRAM_SUFFIX)
if self._programs.search(query.name == program.name) != []:
self._programs.update(program_db_entry, query.name == program.name)
else:
self._programs.insert(program_db_entry)
f = open(program_db_entry["filename"], 'w+')
json.dump(program.as_dict(), f)
f.close()
def load(self, name):
query = Query()
program_db_entries = self._programs.search(query.name == name)
if program_db_entries != []:
logging.info(program_db_entries[0])
f = open(program_db_entries[0]["filename"], 'r')
self._program = Program.from_dict(json.load(f))
return self._program
def delete(self, name):
query = Query()
program_db_entries = self._programs.search(query.name == name)
if program_db_entries != []:
os.remove(program_db_entries[0]["filename"])
self._programs.remove(query.name == name)
def create(self, name, code):
self._program = Program(name, code)
return self._program
def is_running(self, name):
return self._program.is_running() and self._program.name == name
def check_end(self):
return self._program.check_end()
def log(self, text):
self._log += text + "\n"
def get_log(self):
return self._log
class Nekowat(object):
"""Attributes:
_conf_path (str): Path to the configuration file.
_conf (dict): Parsed configuration
token (str): Telegram bot token
owner (int): ID of the bot owner. The owner can do certain special actions
such as adding or removing users from whitelist.
use_whitelist (bool): Flag indicating whether the bot allows commands from
any user (False) or only users defined in the whitelist (True)
whitelist (dict): Users that are allowed to interact with the bot.
It uses the following structure:
{
'user1': 123456789,
'user2': 123456788
}
bot (TeleBot): TeleBot instance.
db (TinyDB): Database instance.
wat (Query): TinyDB query.
"""
def init_bot(self, config_path=None, level='INFO'):
"""Initializer.
Args:
config_path (str): Path to the configuration file. If this is not
provided, the bot expects the path to be available in the
environment variable 'NEKOWAT_CONF'.
level (str): Logging level to use in the internal logger of the bot.
"""
# Parse configuration file
if not config_path:
config_path = os.path.abspath(os.getenv('NEKOWAT_CONF', ''))
if not config_path or not os.path.isfile(config_path):
sys.exit('Could not find configuration file')
self._conf_path = config_path
with open(config_path) as f:
self._conf = json.load(f)
# Bot settings
self.token = self._conf['tg']['token']
self.owner = self._conf['tg']['owner']
self.use_whitelist = self._conf['tg']['use_whitelist']
self.whitelist = self._conf['tg']['whitelist']
# TinyDB
#
# Row structure:
#
# - name (str): Name of the file
# - file_ids (list): List of file IDs ordered by size
# - expressions (list): List of expressions that match the image
self.db = TinyDB(self._conf['db'])
self.db.table_class = SmartCacheTable
self.wat = Query()
# Bot initialization
telebot.logger.setLevel(level)
self.bot = telebot.TeleBot(self.token,
threaded=True,
skip_pending=True)
# Inherit bot methods
self.answer_inline_query = self.bot.answer_inline_query
self.inline_handler = self.bot.inline_handler
self.message_handler = self.bot.message_handler
self.register_next_step_handler = self.bot.register_next_step_handler
self.reply_to = self.bot.reply_to
self.send_message = self.bot.send_message
self.send_photo = self.bot.send_photo
def _save_conf(self):
"""Save configuration to file."""
with open(self._conf_path, 'w') as f:
json.dump(self._conf, f)
def start(self):
"""Bot starter."""
print('Start polling')
self.bot.polling(none_stop=True)
def stop(self):
"""Bot stopper."""
print('Stop polling')
self.bot.stop_polling()
def is_owner(self, user_id):
"""Checks whether a message comes from the owner."""
return user_id == self.owner
def is_allowed(self, user_id):
"""Checks whether a message comes from a whitelisted user.
Note that disabling the whitelist results in every user being able
to communicate with the bot.
"""
if not self.use_whitelist or user_id == self.owner:
return True
return user_id in self.whitelist.values()
def add_whitelist(self, name, user_id):
"""Adds a user to the whitelist.
This updates the configuration file.
Args:
name (str): Name of the user.
user_id (int): User ID.
Returns:
Boolean indicating if the user was added or not.
"""
if name in self.whitelist.keys():
# Already exists
return False
self.whitelist[name] = user_id
self._conf['tg']['whitelist'] = self.whitelist
self._save_conf()
return True
def rm_whitelist(self, name):
"""Removes a user from the whitelist.
This updates the configuration file.
Args:
name (str): Name of the user.
Returns:
Boolean indicating if the user was removed or not.
"""
if name not in self.whitelist.keys():
# Does not exist
return False
del self.whitelist[name]
self._conf['tg']['whitelist'] = self.whitelist
self._save_conf()
return True
def toggle_whitelist(self):
"""Toggle use of whitelist."""
new_status = not self.use_whitelist
self._conf['tg']['use_whitelist'] = new_status
self.use_whitelist = new_status
self._save_conf()
def create_wat(self, name, file_ids):
"""Insert a new wat record in the database.
Args:
name (str): Name of the wat.
file_ids (list[str]): List of file IDs in Telegram (ordered by size)
"""
self.db.insert({'name': name, 'file_ids': file_ids, 'expressions': []})
def get_all_wats(self):
"""Get all wats from the database.
Returns:
List of tuples containing file ID and name
"""
return self.db.all()
def get_wats_by_expression(self, expression):
"""Get all rows that match an expression.
Returns:
List of database rows
"""
return self.db.search(self.wat.expressions.any([expression]))
def wat_exists(self, name):
"""Check whether a wat exists already."""
wat = self.db.get(self.wat.name == name)
if wat:
return True
return False
def get_wat(self, name):
"""Get a WAT by name."""
return self.db.get(self.wat.name == name)
def set_wat_expressions(self, name, expressions):
"""Update a WAT and set the new expressions."""
self.db.update({'expressions': expressions}, self.wat.name == name)
def remove_wat(self, doc_id):
"""Remove a WAT by ID."""
return self.db.remove(doc_ids=[
doc_id,
])
def my_index():
data = TinyDB("data.json")
data = data.table("Zone")
return jsonify({"data": data.all()})
from tinydb import TinyDB
# connect to database
db = TinyDB('sensor_reports.json')
#print first 5
print(db.all()[:5])
def get_drafts():
db = TinyDB(cfg.config['db_name'])
# Record = Query()
records = [x for x in db.all() if x['draft_user'] > 0]
db.close()
return sorted(records, key=itemgetter('pubdate_api'), reverse=True)
def test_caching_read():
db = TinyDB(storage=CachingMiddleware(MemoryStorage))
assert db.all() == []
