def parseFilesAndSave(self, path):
files = [
f for f in listdir(path)
if isfile(join(path, f)) and f.endswith('csv')
]
files.sort()
fundDict = {}
lastDayInfosOfCurrentMonth = {}
lastDayInfosOfLastMonth = {}
db = Database()
db.recreateDatabase()
for file in files:
try:
fundDict, lastDayInfosOfCurrentMonth = self.parseFile(
path, file)
self.calculateReturns(fundDict, lastDayInfosOfLastMonth,
lastDayInfosOfCurrentMonth)
db.insertData(fundDict)
except (Exception):
print('Error reading file:' + path + file)
traceback.print_exc()
raise
def test_save_msg(msg='hahah', tag='test tag', talker='admin',
expiry=None, time=None, force_create=True):
"""test save a message"""
interface = DataTransfer(Database(PATH))
msg = MsgWithTag(msg, tag, talker, expiry, time)
interface.save_msg(msg, force_create=force_create)
assert interface.get_msg_by_id(1) is not None
def test_del_by_time():
"""test delete by time stamp"""
interface = DataTransfer(Database(PATH))
data_num = len(interface.get_all_msgs())
test_save_msg(time=datetime.now() - timedelta(days=3))
interface.del_msg_by_timedelta(timedelta(days=3))
assert len(interface.get_all_msgs()) == data_num
def test_get_all_id_and_tags():
"""test get all id and tags"""
interface = DataTransfer(Database(PATH))
all_data = interface.get_all_id_and_tags()
assert len(all_data) == 2
assert all_data[0][1] == 'test 2'
assert all_data[1][1] == 'test 3'
def test_not_reply():
"""not saying to the bot"""
controller = TagController(DataTransfer(Database(PATH, CONFIG)))
reply = controller.handle_msg(quoted='null',
msg='null',
talker='me',
to_bot=False)
assert not reply
def test_get_msgs_by_time_range():
"""test get msgs by time range"""
interface = DataTransfer(Database(PATH))
start = datetime.now() + timedelta(days=10)
end = start + timedelta(days=20)
for i in range(10):
test_save_msg(time=start + timedelta(days=i))
assert len(interface.get_msgs_by_time_range(start, end)) == 10
def test_create():
"""create table"""
for path in [PATH, 'database_config.pkl']:
try:
os.remove(path)
except FileNotFoundError:
pass
interface = DataTransfer(Database(PATH))
def test_create():
"""create tag_controller"""
for path in [PATH, CONFIG]:
try:
os.remove(path)
except FileNotFoundError:
pass
controller = TagController(DataTransfer(Database(PATH, CONFIG)))
def test_wrong_cron_format():
"""test timed delete with wrong format"""
controller = TagController(DataTransfer(Database(PATH)))
ifreply = controller.handle_msg(quoted=None,
msg=f'{KEY_DELETE} {KEY_SPLIT}*-*-0-0-0-1',
talker='me',
to_bot=True)
assert ifreply
assert controller.reply == reply.parse_datetime_error()
def test_get_all_msgs():
"""test get all messages"""
test_save_msg('second', 'test 2', 'admin2', datetime(2020, 3, 26))
test_save_msg('third', 'test 3')
interface = DataTransfer(Database(PATH))
all_msg = interface.get_all_msgs()
_, msg = all_msg[0]
assert len(all_msg) == 2
assert msg.expiry == datetime(2020, 3, 26)
def total_water(db_file, table):
database = Database(db_file)
if not database.table_exists(table):
database.close()
return None
query_response = database.query("SELECT total FROM " + table +
" ORDER BY total DESC;")
database.close()
return query_response[0][0]
def test_update():
"""test insert duplicated message with different tag"""
interface = DataTransfer(Database(PATH))
test_save_msg(msg='update message', tag='test update')
data_num = len(interface.get_all_msgs())
test_save_msg(msg='update message', tag='test update 2', force_create=False)
all_msg = interface.get_all_msgs()
assert len(all_msg) == data_num
assert all_msg[-1][1].msg == 'update message'
assert all_msg[-1][1].tags == 'test update 2'
def test_insert():
"""insert data"""
database = Database(PATH)
database.insert(TABLE, ["msg", "tags"], ["hehe", "no use"])
database.insert(TABLE, ["msg", "tags"],
["meeting at 9:00", "meeting time"])
database.insert(TABLE, ["msg", "tags"], ["what?", "meeting time"])
assert database.search(TABLE, 'id', 2) is not None
assert len(database.search(TABLE, 'tags', 'meeting time')) == 2
database.close()
def test_expiry():
"""test expiry of messages"""
interface = DataTransfer(Database(PATH))
controller = TagController(interface)
data_num = len(interface.get_all_msgs())
expiry = datetime.now() + timedelta(seconds=1)
msg = f'test expiry, {KEY_EXPIRY}{KEY_SPLIT}{str(expiry)}'
controller.handle_msg(quoted='second', msg=msg, talker='me', to_bot=True)
sleep(1)
assert data_num == len(interface.get_all_msgs())
def __init__(self, data_path='database.db', config_path='config.pkl'):
"""params:
data_path: path of database file,
config_path: path of database config file, which
contains auto-created information"""
self.data_path = data_path
self.config_path = config_path
self.interface = DataTransfer(Database(data_path, config_path))
self.question_answering = QuestionAnswering(self.interface)
self.tag_controller = TagController(self.interface)
self.display = Display(self.interface)
def test_save_msg():
"""test save messaga"""
interface = DataTransfer(Database(PATH))
controller = TagController(interface)
ifreply = controller.handle_msg(quoted='first',
msg='test save msg',
talker='me',
to_bot=True)
assert ifreply
assert controller.reply == reply.save_msg_success()
assert len(interface.get_all_msgs()) == 1
def test_delete_by_time():
"""test delete by time range"""
database = Database(PATH)
data_num = len(database.select(TABLE))
start = datetime.now()
database.insert(
TABLE, ["msg", "tags", 'time'],
["delete by time", "create time", f'{str(datetime.now())}'])
end = datetime.now()
database.delete_by_time(TABLE, 'time', start, end)
assert len(database.select(TABLE)) == data_num
def init_data():
"""create tag_controller"""
for path in [PATH, CONFIG]:
try:
os.remove(path)
except FileNotFoundError:
pass
interface = DataTransfer(Database(PATH, CONFIG))
for quoted, tag, in MSG_CONTENTS:
msg = MsgWithTag(quoted, tag, 'me') # talker is not important here
interface.save_msg(msg)
return interface
def test_delete():
"""test delete message"""
interface = DataTransfer(Database(PATH))
controller = TagController(interface)
data_num = len(interface.get_all_msgs())
ifreply = controller.handle_msg(quoted=None,
msg=f'{KEY_DELETE} {KEY_SPLIT}1',
talker='me',
to_bot=True)
assert ifreply
assert controller.reply == reply.del_msg_success(1)
assert len(interface.get_all_msgs()) == data_num - 1
def _mw_update(self, db, query, vals, etha=1e-4):
# directed query value
y = query.value(db)
r = (vals < y) * y + (vals >= y) * (1 - y)
# next Database
new_xp = np.multiply(np.exp(-etha * r), db.data)
new_x = normalize(new_xp, ord=1)
new_db = Database(new_x, 'probability', db.uni)
new_db._norm = db.norm
return new_db
def action(name):
"""
determines whether to use password or facial
recognition for authenticating, or unlock via Bluetooth and make repairs
"""
if name == 'UserPass':
print("\nAuthenticating {}\n".format(name))
username = Screen().input('Enter in Username: '******'Enter in Password: '******'FaceRecog':
print("\nAuthenticating with Face Recognition")
username = Screen().input('Enter in Username: '******'The car has been unlocked, ' +
'press [enter] to continue.')
elif name == 'EngineerBT':
#publish request to MP, requesting for engineers' Bluetooth MAC addr
pub = Publisher()
pub.publish("Requesting engineers' Bluetooth MAC addresses", 'MAC')
if BluetoothUnlocker().search_and_unlock():
Screen().input('The car has been unlocked, ' +
'press [enter] to scan QR code.')
auth = Authenticator()
if auth.id_engineer():
Screen().input(
'Engineer profile verified!\n' +
'Issue will be marked as fixed if verified. ' +
'Please visit carshare.com\nPress [enter] to continue.')
else:
Screen().input('Engineer profile verification failed, ' +
'press [enter] to continue.')
else:
Screen().input('The car failed to unlock, ' +
'press [enter] to continue.')
elif name == 'Return':
print("\nReturning the car")
username = Screen().input('Enter in Username: '******'username': username,
'timestamp': now_time,
'location': Geolocation().run(),
'agentid': agent_id
}
pub = Publisher()
pub.publish(payload, 'RETURN')
def test_timed_delete():
"""test timed delete"""
controller = TagController(DataTransfer(Database(PATH)))
ifreply = controller.handle_msg(quoted=None,
msg=f'{KEY_DELETE} {KEY_SPLIT}*-*-2-0-0-1',
talker='me',
to_bot=True)
assert ifreply
# substitute former plan
ifreply = controller.handle_msg(quoted=None,
msg=f'{KEY_DELETE} {KEY_SPLIT}*-*-*-*-*-1',
talker='me',
to_bot=True)
assert ifreply
def total_week_water(db_file, table, timestamp):
database = Database(db_file)
if not database.table_exists(table):
database.close()
return None
query_response = database.query("SELECT timestamp, total FROM " + table +
" ORDER BY timestamp ASC;")
database.close()
for i in range(len(query_response)):
if is_same_week(query_response[i][0], timestamp):
if i == 0:
return query_response[-1][1]
return query_response[-1][1] - query_response[i][1]
return 0
def setup_database():
# intialize empty database
db = Database()
# create 'Team' table
db.create_team_table()
# create 'Player' table
# db.create_player_table()
# create 'GameStats' table
# db.create_gamestats_table()
return db
def test_display_msg():
"""test display message function"""
start = datetime.now()
init_data()
end = datetime.now()
interface = DataTransfer(Database(PATH, CONFIG))
display = Display(interface)
assert display.handle_msg(KEY_DISPLAY, True)
assert len(display.reply.split('\n')) == len(MSG_CONTENTS)
assert display.handle_msg(
f'{KEY_DISPLAY}{KEY_SPLIT}'
f'{start.year}.{start.month}.{start.day}'
f'-{end.year}.{end.month}.{end.day}', True)
assert len(display.reply.split('\n')) == len(MSG_CONTENTS)
assert display.handle_msg(f'{KEY_DISPLAY}{KEY_SPLIT}aaaa-aaaaa', True)
assert display.reply == reply.parse_datetime_error()
def __init__(self):
# datapath = str(os.path.dirname(__file__))
# path = datapath + "/data/hilde_data.json"
# if not os.path.isfile(path):
# path = str(os.getcwd() + "/data/hilde_data.json")
# with open(path, 'r') as file:
# self.data = json.load(file)
# if "tfidf" not in data:
# print("[tfidfbot] tfidf not found in data...")
# self.corrected = { "test test": "Test?" }
# else:
# self.corrected = self.data["tfidf"]
self.db = Database()
self.tokenize_cache = {}
def load(cls, folder: str) -> Competition:
"""Laden der Veranstaltung
Args:
folder (str): Ordner der Veranstaltung
Returns:
Competition: Veranstaltung
"""
errors = ErrorCollector()
# Ordner überprüfen
if not os.path.isdir(folder):
logging.error("Angegebner Ordner %s existiert nicht.", folder)
return None
# Einstellungen lesen
settings = SettingsTable(folder)
settings.open()
if errors.has_error():
errors.remove()
return None
# Datenbank erstellen, Gruppen und Stationen auslesen
database = Database(settings)
settings.read_groups(database)
settings.read_stations(database)
settings.read_sclasses(database)
if errors.has_error():
errors.remove()
return None
# Meldung auslesen
attendees_table = AttendeesTable(folder, settings, database)
attendees_table.open()
if errors.has_error():
errors.remove()
return None
database.do_grouping()
if errors.has_error():
errors.remove()
return None
return Competition(folder, settings, database)
def test_create():
"""create table"""
try:
os.remove(PATH)
except FileNotFoundError:
pass
database = Database(PATH)
primary_key = PrimaryKey.id_as_primary()
fields = [
Field("msg", "TEXT"),
Field("tags", "CHAR(50)"),
Field('time',
'CHAR(30)',
others=[f'DEFAULT (\'{str(datetime.now())}\')'])
]
database.create_table(TABLE, primary_key, fields)
assert TABLE in database.tables.keys()
database.close()
def highest_source(db_file, table):
database = Database(db_file)
if not database.table_exists(table):
database.close()
return None
sources = [
x[0]
for x in database.query("SELECT DISTINCT source FROM " + table + ";")
]
highest = 0
highest_source = sources[0]
for source in sources:
source_total = database.query("SELECT total FROM " + table +
" WHERE source='" + source +
"' ORDER BY timestamp ASC;")[-1][0]
if source_total > highest:
highest_source = source
highest = source_total
return highest_source
def test_stop_timed_delete():
"""test stop timed delete task"""
controller = TagController(DataTransfer(Database(PATH)))
controller.handle_msg(quoted=None,
msg=f'{KEY_DELETE} {KEY_SPLIT}*-*-2-0-0-1',
talker='me',
to_bot=True)
ifreply = controller.handle_msg(quoted=None,
msg=f'{KEY_DELETE}{KEY_SPLIT}{KEY_STOP}',
talker='me',
to_bot=True)
assert ifreply
assert controller.reply == reply.stop_timed_delete(True)
ifreply = controller.handle_msg(quoted=None,
msg=f'{KEY_DELETE}{KEY_SPLIT}{KEY_STOP}',
talker='me',
to_bot=True)
assert ifreply
assert controller.reply == reply.stop_timed_delete(False)
