def test_when_update_time(self) -> None:
not_working_activity = Activity('wm_class1',
'window_name1',
datetime(2020, 7, 21, 21, 30, 0, 3),
is_work_time=False).set_end_time(
datetime(2020, 7, 21, 22, 30, 0,
3))
working_activity = Activity('wm_class1',
'window_name1',
datetime(2020, 7, 21, 22, 30, 0, 4),
is_work_time=True).set_end_time(
datetime(2020, 7, 21, 22, 35, 0, 5))
sub_tests_data = {
'Update off time stat when it was empty':
(self.activity, not_working_activity, timedelta(0, 3600, 1),
timedelta(0, 3600)),
'Update work time stat when it was empty':
(not_working_activity, working_activity, timedelta(0, 300, 1),
timedelta(0, 3600)),
'Update work time stat when it was not empty':
(self.activity, working_activity, timedelta(0, 3900,
2), timedelta(0)),
}
for sub_test, (activity, same_activity_with_diff_time, work_time,
off_time) in sub_tests_data.items():
with self.subTest(name=sub_test):
activity_stat = ActivityStat.from_activity(activity)
activity_stat.update(same_activity_with_diff_time)
self.assertEqual(activity_stat.work_time, work_time)
self.assertEqual(activity_stat.off_time, off_time)
def setUpClass(cls):
cls.activities = ActivitiesStorage()
cls.a = Activity('title', datetime.now() - timedelta(hours=1, minutes=15), datetime.now())
cls.a2 = Activity('title2', datetime.now() - timedelta(minutes=4, seconds=23), datetime.now())
cls.activities2 = ActivitiesStorage()
cls.activities2.storage = [
{
'active_tab': 'title3',
'active_sessions': [{'hours': 2, 'minutes': 20, 'seconds': 0}],
'last_active_session': {'hours': 2, 'minutes': 20, 'seconds': 0},
'total_time': timedelta(seconds=8400, microseconds=11)
}
]
cls.a3 = Activity('title3', datetime.now() - timedelta(minutes=12, seconds=45), datetime.now())
def get_activity(self, key):
with dbapi2.connect(self.app.config['dsn']) as connection:
cursor = connection.cursor()
query = "SELECT TITLE, ACTIVITY_TYPE, FOUNDERID, PARTICIPANT_COUNT, TIME, PLACE, ACTIVITY_INFO FROM ACTIVITY WHERE (ID = %s)"
cursor.execute(query, (key,))
title, activity_type, founder, participant_count, time, place, activity_info = cursor.fetchone()
return Activity(title, activity_type, founder, participant_count, time, place, activity_info)
def getActivityInfo():
activity_id = int(request.form.get("activity_id"))
manager = DataManager(DataType.activity)
activity_info = manager.getInfo(activity_id)
if len(activity_info) == 0:
return json.dumps({'status': 'Not Found'})
activity = Activity(at_id=activity_id,
at_name=activity_info[0][1],
at_description=activity_info[0][2],
at_club_id=activity_info[0][3],
at_place=activity_info[0][4],
at_start_time=activity_info[0][5],
at_end_time=activity_info[0][6],
at_lottery_time=activity_info[0][7],
at_lottery_method=activity_info[0][8],
at_max_number=activity_info[0][9],
at_fee=activity_info[0][10],
at_sign_up_ddl=activity_info[0][11],
at_sponsor=activity_info[0][12],
at_undertaker=activity_info[0][13])
res = activity.Jsonfy()
return res
def test_entity_activity_init_params(self):
uuid = "ActivityUUID-321"
start_datetime = datetime.datetime(year=2018,
month=1,
day=2,
hour=1,
minute=0,
second=0)
end_datetime = datetime.datetime(year=2018,
month=1,
day=2,
hour=1,
minute=0,
second=2)
obj = Activity(uuid=uuid,
start_datetime=start_datetime,
end_datetime=end_datetime)
e_flag = False
try:
str_rep = obj.__str__()
self.assertFalse(
obj.in_daytime(),
msg='activity not properly assigned to day or night time')
self.assertEqual(
obj.seconds,
2,
msg='seconds between start and end datetime calculated wrongly'
)
except Exception as e:
print(e)
e_flag = True
self.assertFalse(e_flag, 'exception thrown')
def _add_activity(self, activity_name, time_entry):
"""
Add the activity with its time entry to the activity list.
If activity was already present in the list, only update the duration
and add the time entry. If activity was not present, add it.
Parameters
----------
activity_name: string
The name of the activity to add
time_entry: TimeEntry
The time entry of the activity to add
Returns
-------
bool: True
"""
for activity in self.activities:
if activity_name == activity.name:
activity.duration += time_entry.delta
activity.entries.append(time_entry)
return True
activity = Activity(name=activity_name,
duration=time_entry.delta,
entries=[time_entry])
self.activities.append(activity)
return True
def activity_stream_item(self, activity_type, revision, user_id):
import ckan.model
import ckan.lib.dictization
import ckan.logic
assert activity_type in ("new", "changed"), (str(activity_type))
# Handle 'deleted' objects.
# When the user marks a package as deleted this comes through here as
# a 'changed' package activity. We detect this and change it to a
# 'deleted' activity.
if activity_type == 'changed' and self.state == u'deleted':
if ckan.model.Session.query(ckan.model.Activity).filter_by(
object_id=self.id, activity_type='deleted').all():
# A 'deleted' activity for this object has already been emitted
# FIXME: What if the object was deleted and then activated
# again?
return None
else:
# Emit a 'deleted' activity for this object.
activity_type = 'deleted'
try:
d = {
'package':
ckan.lib.dictization.table_dictize(
self, context={'model': ckan.model})
}
return Activity(user_id, self.id, revision.id,
"%s package" % activity_type, d)
except ckan.logic.NotFound:
# This happens if this package is being purged and therefore has no
# current revision.
# TODO: Purge all related activity stream items when a model object
# is purged.
return None
def updateTimer(self, event):
self.processTimeActive += self.timerDelay / 1000
windowName = win32gui.GetWindowText(win32gui.GetForegroundWindow())
if self.processName == "ERROR-FINDING-PROCESS":
try:
self.pid = win32process.GetWindowThreadProcessId(
win32gui.GetForegroundWindow())[-1]
self.processName = psutil.Process(self.pid).name()
except:
self.processName = "ERROR-FINDING-PROCESS"
if self.lastWindowName != windowName:
#OutputActivity(startTime, time.time(), lastWindowName, processName)
activity = Activity(self.startTime, time.time(),
self.lastWindowName, self.processName,
self.filePath)
activity.SaveToFile()
self.startTime = time.time()
try:
self.pid = win32process.GetWindowThreadProcessId(
win32gui.GetForegroundWindow())[-1]
self.processName = psutil.Process(self.pid).name()
except:
self.processName = "ERROR-FINDING-PROCESS"
self.lastWindowName = windowName
del activity
self.processTimeActive = 0
self.updateGUI()
def set_work_time_state(self, value: bool) -> None:
if value == self.is_work_time:
self.logger.debug(
'Trying to change is_work_time to the same value')
return
self.is_work_time = value
current_activity = Value.get_or_raise(self.current_activity,
'current_activity')
now = datetime.now()
new_activity = Activity(current_activity.wm_class,
current_activity.window_name, now,
self.is_work_time)
self.__on_activity_changed(current_activity, new_activity)
self.is_work_time_update_time = now
self.logger.debug(f'Set Work Time to [{self.is_work_time}]')
icon = self.active_icon if self.is_work_time else self.disabled_icon
self.tray_icon.set_icon_if_exist(icon)
if self.is_work_time:
self.last_lock_screen_time = now
self.last_break_notification = None
self.last_overtime_notification = None
def test_when_tree_day_activity(self, mock_is_dir_res, mock_open_res) -> None:
files_provider = FilesProvider(Path('/root_dir/'))
self.assertEqual(4, mock_is_dir_res.call_count)
writer = ActivityWriter(files_provider)
handle_new_day_event = Mock()
writer.event.on(ActivityWriter.NEW_DAY_EVENT, handle_new_day_event)
three_days_activity = Activity('wm_class2',
'window_name2',
datetime(2020, 7, 31, 12, 5),
is_work_time=True).set_end_time(datetime(2020, 8, 2, 11, 30))
writer.write(three_days_activity)
mock_open_res.assert_has_calls([
call('/root_dir/dest/2020-07-31_speaking_eye_raw_data.tsv', 'a'),
call().write('2020-07-31 12:05:00\t2020-07-31 23:59:59.999999\t'
'11:54:59.999999\twm_class2\twindow_name2\tTrue\n'),
call().flush(),
call().close(),
call('/root_dir/dest/2020-08-01_speaking_eye_raw_data.tsv', 'a'),
call().write('2020-08-01 00:00:00\t2020-08-01 23:59:59.999999\t'
'23:59:59.999999\twm_class2\twindow_name2\tTrue\n'),
call().flush(),
call().close(),
call('/root_dir/dest/2020-08-02_speaking_eye_raw_data.tsv', 'a'),
call().write('2020-08-02 00:00:00\t2020-08-02 11:30:00\t'
'11:30:00\twm_class2\twindow_name2\tTrue\n'),
call().flush()
])
self.assertEqual(2, handle_new_day_event.call_count)
def test_when_activity_has_not_finished(self, mock_is_dir_res, mock_open_res) -> None:
files_provider = FilesProvider(Path('/root_dir/'))
self.assertEqual(4, mock_is_dir_res.call_count)
writer = ActivityWriter(files_provider)
not_finished_activity = Activity('wm_class1',
'window_name1',
datetime(2020, 7, 21, 20, 30, 0),
is_work_time=True)
handle_new_day_event = Mock()
writer.event.on(ActivityWriter.NEW_DAY_EVENT, handle_new_day_event)
with self.assertRaisesRegex(
ValueError,
expected_regex='Activity \\[2020-07-21 20:30:00\tNone\tNone\twm_class1\twindow_name1\tTrue\n\\] '
'should be finished!'):
writer.write(not_finished_activity)
mock_open_res.assert_not_called()
mock_file = mock_open_res.return_value
mock_file.write.assert_not_called()
mock_file.flush.assert_not_called()
mock_file.close.assert_not_called()
handle_new_day_event.assert_not_called()
def add_activity_to_bucketlist():
''' Add activity to named bucketlist '''
user = None
username = session['user']['username']
if username in users.keys():
user = users[username]
current_bucketlist = request.args.get('name')
if request.method == 'POST':
title = request.form['title']
description = request.form['description']
activity = Activity(title, description)
if current_bucketlist in user.bucketlists.keys():
user.bucketlists[current_bucketlist].add_activity(activity)
activities = user.bucketlists[current_bucketlist].activities
return render_template('bucketlist.html',
name=current_bucketlist,
activities=activities)
else:
return render_template(
'bucketlist.html',
name=current_bucketlist,
activities=user.bucketlists[current_bucketlist].activities)
def get_activities(self):
with dbapi2.connect(self.app.config['dsn']) as connection:
cursor = connection.cursor()
query = "SELECT * FROM ACTIVITY ORDER BY ID"
cursor.execute(query)
activities = [(key, Activity(title, activity_type, founder, participant_count, time, place, activity_info))
for key, title, activity_type, founder, participant_count, time, place, activity_info in cursor]
return activities
def test_when_activities_are_equal(self):
wm_class = 'wm_class'
window_name = 'window_name'
start_time = datetime(2020, 7, 12, 20, 30, 0)
is_work_time = True
left = Activity(wm_class, window_name, start_time, is_work_time)
right = Activity(wm_class, window_name, start_time, is_work_time)
self.assertEqual(left, right)
end_time = datetime(2020, 7, 12, 21, 30, 0)
left.set_end_time(end_time)
right.set_end_time(end_time)
self.assertEqual(left, right)
def __init__(self, db, models):
"""
:type db: flask_sqlalchemy.SQLAlchemy
:type models: models
"""
self.db = db
self.models = models
self.activity = Activity(db=db, models=models, logger=logging)
def search_activity(self, key):
with dbapi2.connect(self.app.config['dsn']) as connection:
cursor = connection.cursor()
query = "SELECT * FROM ACTIVITY WHERE (TITLE ILIKE %s OR ACTIVITY_TYPE ILIKE %s OR PLACE ILIKE %s OR ACTIVITY_INFO ILIKE %s)"
key = '%'+key+'%'
cursor.execute(query, (key, key, key, key))
activities = [(key, Activity( title, activity_type, founder, participant_count, time, place, activity_info))
for key, title, activity_type, founder, participant_count, time, place, activity_info in cursor]
return activities
def test_activity(self):
date = datetime.datetime(2019, 12, 10, 12, 10)
activity = Activity('1', ['1234', '5678'], date.date(), date.time(),
'test')
self.assertEqual(activity.uid, '1')
self.assertEqual(activity.persons_uids, ['1234', '5678'])
self.assertEqual(activity.date, date.date())
self.assertEqual(activity.time, date.time())
self.assertEqual(activity.description, 'test')
def test_add_activity_successfully_to_bucketlist(self):
bucketlist = BucketList('Travels', 'Tour Africa')
activity = Activity('Egypt', 'Visit the Pyramids')
initial_no_of_activities = len(bucketlist.activities)
bucketlist.add_activity(activity)
self.assertEqual(
len(bucketlist.activities) - initial_no_of_activities, 1)
def on_name_changed(self, window: Wnck.Window) -> None:
now = datetime.now()
current_activity = Value.get_or_raise(self.current_activity,
'current_activity')
window_name = get_window_name(window)
new_activity = Activity(current_activity.wm_class, window_name, now,
current_activity.is_work_time)
self.__on_activity_changed(current_activity, new_activity)
def get_all_activities(self):
with dbapi2.connect(app.config['dsn']) as connection:
cursor = connection.cursor()
query = """SELECT ID, ACTIVATOR, STATUS, DATE FROM ACTIVITIES
ORDER BY ID DESC"""
cursor.execute(query)
table = [(id, Activity(activator, status, date))
for id, activator, status, date in cursor]
connection.commit()
cursor.close()
return table
def test_convert_from_string_when_correct_activity_line(self):
sub_tests_data = [(
'2020-07-18 20:00:00.000001\t2020-07-18 20:30:00.000001\t0:30:00.000000\twm_class1\twindow_name1\tFalse\n',
Activity('wm_class1',
'window_name1',
datetime(2020, 7, 18, 20, 0, 0, 1),
is_work_time=False).set_end_time(
datetime(2020, 7, 18, 20, 30, 0, 1)))]
for i, (line, expected) in enumerate(sub_tests_data, 1):
with self.subTest(name=f'Subtest №{i}'):
self.assertEqual(expected, ActivityConverter.from_string(line))
def test_when_activities_are_not_equal(self):
wm_class = 'wm_class'
window_name = 'window_name'
start_time = datetime(2020, 7, 12, 20, 30, 0)
end_time = datetime(2020, 7, 12, 21, 30, 0)
is_work_time = True
activity = Activity(wm_class, window_name, start_time, is_work_time).set_end_time(end_time)
another_wm_class = 'another_wm_class'
another_window_name = 'another_window_name'
another_start_time = datetime(2020, 7, 12, 20, 50, 0)
another_end_time = datetime(2020, 7, 12, 23, 30, 0)
another_is_work_time = False
sub_tests_data = {
'Different wm classes':
Activity(another_wm_class, window_name, start_time, is_work_time).set_end_time(end_time),
'Different window names':
Activity(wm_class, another_window_name, start_time, is_work_time).set_end_time(end_time),
'Different start times':
Activity(wm_class, window_name, another_start_time, is_work_time).set_end_time(end_time),
'Different end times':
Activity(wm_class, window_name, start_time, is_work_time).set_end_time(another_end_time),
'Different "is_work_time" status':
Activity(wm_class, window_name, start_time, another_is_work_time).set_end_time(end_time),
'Different types':
'I am not an Activity',
}
for sub_test, another_activity in sub_tests_data.items():
with self.subTest(name=sub_test):
self.assertNotEqual(activity, another_activity)
def _parse_activity(self, activity_child: ElementTree) -> Activity:
activity_fields = self._parse_activity_fields(activity_child)
return Activity(id=activity_fields.get('id'),
name=activity_fields.get('name'),
distribution=activity_fields.get('distribution', 0),
data_input=activity_fields.get('data_input'),
data_output=activity_fields.get('data_output'),
resources=activity_fields.get('resources'),
failure_rate=activity_fields.get('failure_rate', 0),
retries=activity_fields.get('retries', 0),
timeout=activity_fields.get('timeout'),
priority=activity_fields.get('priority', 'normal'))
def __init__(self, community):
self.schedules = [[], [], [], [], []]
self.community = community
# Class in discovery hall, 1:15 - 3:15pm (start walking at 12:40)
class1 = Activity(start_time=13 * 60 - 20,
end_time=15.25 * 60,
dest_institution_int=1)
# Class in uwbb, 3:30 - 5:30 (start walking at 3:15)
class2 = Activity(start_time=15.25 * 60,
end_time=17.5 * 60,
dest_institution_int=6)
# Go to the parking area 1. (from 5:30pm to 11:59pm)
going_home = Activity(start_time=17.5 * 60,
end_time=23 * 60 + 59,
dest_institution_int=11)
self.schedules[0].append(class1)
self.schedules[0].append(class2)
self.schedules[0].append(going_home)
def build(self) -> Activity:
if self.start_time is None:
raise RuntimeError('start_time should be set!')
if self.end_time is None:
raise RuntimeError('end_time should be set!')
activity = Activity(self.origin_activity.wm_class,
self.origin_activity.window_name, self.start_time,
self.origin_activity.is_work_time)
activity.set_end_time(self.end_time)
return activity
def test_when_end_time_is_greater_than_start_time(self):
start_time = datetime(2020, 7, 12, 20, 30, 0)
end_time = datetime(2020, 7, 12, 21, 30, 0)
expected_activity_time = timedelta(hours=1)
self.assertGreater(end_time, start_time)
activity = Activity('wm_class', 'window_name', start_time, is_work_time=True)
activity.set_end_time(end_time)
self.assertTrue(activity.has_finished())
self.assertEqual(end_time, activity.end_time)
self.assertEqual(expected_activity_time, activity.activity_time)
def test_split_by_day(self) -> None:
one_day_activity = Activity('wm_class1',
'window_name1',
datetime(2020, 7, 21, 12, 5),
is_work_time=True).set_end_time(
datetime(2020, 7, 21, 21, 30))
three_days_activity = Activity('wm_class2',
'window_name2',
datetime(2020, 7, 31, 12, 5),
is_work_time=True).set_end_time(
datetime(2020, 8, 2, 11, 30))
expected_for_three_days_activity = [
(date(2020, 7, 31),
Activity('wm_class2',
'window_name2',
datetime(2020, 7, 31, 12, 5),
is_work_time=True).set_end_time(
datetime(2020, 7, 31, 23, 59, 59, 999_999))),
(date(2020, 8, 1),
Activity('wm_class2',
'window_name2',
datetime(2020, 8, 1),
is_work_time=True).set_end_time(
datetime(2020, 8, 1, 23, 59, 59, 999_999))),
(date(2020, 8, 2),
Activity('wm_class2',
'window_name2',
datetime(2020, 8, 2),
is_work_time=True).set_end_time(
datetime(2020, 8, 2, 11, 30))),
]
for (activity, expected) in [
(one_day_activity, [(date(2020, 7, 21), one_day_activity)]),
(three_days_activity, expected_for_three_days_activity),
]:
self.assertEqual(expected, ActivitySplitter.split_by_day(activity))
def activities_page():
if request.method == 'GET':
activities = app.store.get_activities()
now = datetime.datetime.now()
return render_template('activities.html',
activities=activities,
current_time=now.ctime())
elif 'activities_to_delete' in request.form or 'search' in request.form:
if request.form['submit'] == 'Delete':
keys = request.form.getlist('activities_to_delete')
for key in keys:
app.store.delete_activity(int(key))
return redirect(url_for('activities_page'))
elif request.form['submit'] == 'Search':
keyword = request.form['search']
activities = app.store.search_activity(keyword)
now = datetime.datetime.now()
return render_template('activities.html',
activities=activities,
current_time=now.ctime())
else:
title = request.form['title']
activity_type = request.form.get('activity_type')
time = request.form['time']
place = request.form['place']
activity_info = request.form['activity_info']
if 'username' in session:
name = session['username']
with dbapi2.connect(app.config['dsn']) as connection:
cursor = connection.cursor()
cursor.execute(
"SELECT memberid FROM MEMBERS WHERE username='******';" % name)
founder = cursor.fetchone()[0]
connection.commit()
participant_count = 1
activity = Activity(title, activity_type, founder,
participant_count, time, place, activity_info)
app.store.add_activity(activity)
with dbapi2.connect(app.config['dsn']) as connection:
cursor = connection.cursor()
query = (
"INSERT INTO ACTIVITY_MEMBERS (MEMBERID, ACTIVITYID ) VALUES (%s, %s)"
)
cursor.execute(query, (founder, app.store.activity_last_key))
connection.commit()
return redirect(
url_for('activity_page', key=app.store.activity_last_key))
else:
return render_template('guest.html')
def load_model():
args = get_args()
file_params = get_file_params()
kwargs = {}
if args.folder != None:
assert os.path.exists(args.folder)
prev, directory = make_subfolder(args.folder, args.comments)
with open(os.path.join(prev, 'data.pkl'), 'rb') as f:
network, _, data_rng = cPickle.load(f)
kwargs['seed_or_rng'] = data_rng
network.to_gpu()
network.current_trial = 0
parameters = final_parameters(file_params,
cmd_line_args=args,
network_params=network.parameters)
for attr in [
'dW_rule', 'function', 'time_data', 'norm_infer', 'OC1', 'OC2',
'N', 'p', 'n_layers'
]:
if getattr(network.parameters, attr) != getattr(parameters, attr):
raise ValueError('Value of ' + attr + ' has changed.')
network.parameters = parameters
else:
parameters = final_parameters(file_params, cmd_line_args=args)
network = Network(parameters)
directory = make_folder(parameters)
prev, directory = make_subfolder(directory, args.comments)
dump_parameters(directory, parameters)
learn = Learning_Rule(network)
monitor = Monitor(network)
activity = Activity(network)
if parameters.time_data and not (parameters.static_data_control):
data = Time_Data(
os.path.join(os.environ['DATA_PATH'],
'vanhateren/whitened_images.h5'),
parameters.num_images, parameters.batch_size, parameters.N,
parameters.num_frames, **kwargs)
else:
data = Static_Data(
os.path.join(os.environ['DATA_PATH'],
'vanhateren/whitened_images.h5'),
parameters.num_images, parameters.batch_size, parameters.N,
**kwargs)
plotter = Plot(directory)
return activity, data, directory, learn, monitor, network, parameters, plotter
def test_convert_to_string(self):
sub_tests_data = {
'When is_work_time is [True]':
(Activity('wm_class1',
'window_name1',
datetime(2020, 7, 12, 20, 30, 0, 1),
is_work_time=True).set_end_time(
datetime(2020, 7, 12, 21, 30, 0, 2)),
'2020-07-12 20:30:00.000001\t2020-07-12 21:30:00.000002\t'
'1:00:00.000001\twm_class1\twindow_name1\tTrue\n'),
'When is_work_time is [False]':
(Activity('wm_class2',
'window_name2',
datetime(2020, 7, 13, 20, 30, 0),
is_work_time=False).set_end_time(
datetime(2020, 7, 13, 21, 35, 0)),
'2020-07-13 20:30:00\t2020-07-13 21:35:00\t1:05:00\twm_class2\twindow_name2\tFalse\n'
)
}
for sub_test, (activity, expected) in sub_tests_data.items():
with self.subTest(name=sub_test):
self.assertEqual(expected,
ActivityConverter.to_string(activity))
