def __init__(self, screen, items):
Activity.__init__(self, screen)
self.screen = screen
# Position of the categories menu
self.cat_pos = (675, 60)
# Position of the activities menu
self.act_pos = (270, 105)
# items holds the categories
self.menu = Menu(self.cat_pos)
# submenus holds the different activities separated by category
self.submenus = {}
# Wich category is active
self.active = None
if items:
for item in items:
if not self.submenus.has_key(item.category):
submenu = MenuActivity(self.act_pos)
self.submenus[item.category] = submenu
self.submenus[item.category].add(item)
for item in self.submenus.keys():
self.menu.add(ItemCategory(item, self.cat_pos))
introduction = (u"Este contenido educativo",
u"está diseñado con actividades ",
u"lúdicas para la adquisición de ",
u"conceptos y hábitos que contribuyen ",
u"a formar niñas y niños saludables.",
u" ",
u"Esperamos que pases momentos ",
u"agradables y divertidos ",
u"mientras aprendes.")
font_default = pygame.font.SysFont(constants.font_default[0],
constants.font_default[1])
isize = font_default.size(introduction[0])[1]
introduction_pos = (constants.screen_mode[0] / 2.0 + 3, 100)
introduction_ = []
for i in introduction:
line = font_default.render(i, True, (102, 102, 102))
introduction_.append(line)
self.text = ((introduction_, introduction_pos),)
self.finger = Finger()
self.sprites = pygame.sprite.Group()
self.icons = pygame.sprite.Group()
self.icons.add([Icons('stop')])
self.sprites.add((self.finger, self.icons))
self.pos = None
return
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 __init__(self, screen):
Activity.__init__(self, screen)
self.CloseButton = pygame.sprite.RenderUpdates(([Icons('stop')]))
self.finger = Finger()
self.Cursor = pygame.sprite.RenderUpdates((self.finger))
self.pos = None
self.messages_filename = constants.poetry
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 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 __init__(self, screen, pos):
Activity.__init__(self, screen)
self.couple = set()
self.couples = []
self.sprites0 = pygame.sprite.OrderedUpdates()
self.sprites1 = pygame.sprite.OrderedUpdates()
self.pointer_ = pygame.sprite.OrderedUpdates()
self.items = pygame.sprite.Group()
self.icons = pygame.sprite.Group()
self.icons.add([Icons('stop')])
self.sprites0.add(self.icons)
for i in pos.keys():
item = Item(i, pos[i])
self.sprites0.add(item)
self.items.add(item)
self.pointer = Pointer()
self.pointer_.add(self.pointer)
self.arrows = []
self.arrow = None
def add_follower(cls, leader, follower):
# TODO: expand to handle more than 5000 followers, using extra entities
follower_id = follower.key().id() # TickUser.get_by_user_id(follower.user_id(),keys_only=True).id()
leader_id = leader.key().id()
check = cls.all(keys_only=True).ancestor(leader).filter("followers_ids =", follower_id).get()
if not check:
entity = cls.all().ancestor(leader).filter("leader_id =", leader_id).get()
if entity:
entity.follower_ids.append(follower_id)
index = entity.get_follow_index()
index.add_followers(follower.all_user_ids)
index.put()
entity.put()
else:
new_entity = cls(parent=leader, leader_id=leader_id, follower_ids=[follower_id])
new_entity.put()
new_index = FollowIndex(parent=new_entity)
new_index.add_leaders(leader.all_user_ids)
new_index.add_followers(follower.all_user_ids)
new_index.put()
from activity import Activity
Activity.create(
"<actor>|began following|<target>", actor=follower, target=leader, extra_recipients=[leader]
)
return True
else:
return False
def _load_peaks(source: List[int], attributes: Dict[int, str],
activity: Activity):
"""
Load a set of peak data from the nominated source data.
The source data we're given is either the time-series collection of power figures,
or the time-series collection of HR figures.
The attributes we're provided tells us what time periods we need to average that
over. For example: given power data, and an attribute of (5, "peak_5sec_power")
means that we need to take a moving 5 second average of the source data, find the
maximum of those 5 second averages, and store that in the "peak_5sec_power" property
of the Peaks object.
Args:
source: The source data to load from.
attributes: The attributes we load.
activity: The activity object we're populating.
"""
for window, attr_name in attributes.items():
if (moving_average := get_moving_average(source=source,
window=window)):
activity.__dict__[attr_name] = int(max(moving_average))
else:
activity.__dict__[attr_name] = None
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 add_follower(cls, leader, follower):
# TODO: expand to handle more than 5000 followers, using extra entities
follower_id = follower.key().id(
) #TickUser.get_by_user_id(follower.user_id(),keys_only=True).id()
leader_id = leader.key().id()
check = cls.all(keys_only=True).ancestor(leader).filter(
'followers_ids =', follower_id).get()
if not check:
entity = cls.all().ancestor(leader).filter('leader_id =',
leader_id).get()
if entity:
entity.follower_ids.append(follower_id)
index = entity.get_follow_index()
index.add_followers(follower.all_user_ids)
index.put()
entity.put()
else:
new_entity = cls(parent=leader,
leader_id=leader_id,
follower_ids=[follower_id])
new_entity.put()
new_index = FollowIndex(parent=new_entity)
new_index.add_leaders(leader.all_user_ids)
new_index.add_followers(follower.all_user_ids)
new_index.put()
from activity import Activity
Activity.create('<actor>|began following|<target>',
actor=follower,
target=leader,
extra_recipients=[leader])
return True
else:
return False
def validation_data(self, contrast=1., small_batch_size = 1000,large_batch_size = 50000):
parameters = self.network.parameters
parameters.batch_size = small_batch_size
orig_time_data = parameters.time_data
orig_keep_spikes = parameters.keep_spikes
#parameters.time_data = True
#parameters.static_data_control = True
parameters.keep_spikes = True
if orig_keep_spikes == False:
self.network.spike_train = ()
nout = parameters.M
for ii in np.arange(self.network.n_layers):
out_dim = nout[ii]
self.network.spike_train += (nw.make_shared((parameters.batch_size,
out_dim,
parameters.num_iterations)),)
small_bs = self.network.parameters.batch_size
batch_size = large_batch_size
if parameters.time_data and not parameters.static_data_control:
data = Time_Data(os.path.join(os.environ['DATA_PATH'],'vanhateren/whitened_images.h5'),
1000,
parameters.batch_size,
parameters.N,
parameters.num_frames,
start=35)
else:
data = Static_Data(os.path.join(os.environ['DATA_PATH'],'vanhateren/whitened_images.h5'),
1000,
parameters.batch_size,
parameters.N,
start=35)
self.network.to_gpu()
activity = Activity(self.network)
self.big_X = np.zeros((batch_size, parameters.N), dtype='float32')
self.big_Y = ()
for layer in range(self.network.n_layers):
self.big_Y += (np.zeros((batch_size, parameters.M[layer]), dtype='float32'),)
for ii in range(batch_size/small_bs):
data.make_X(self.network)
if contrast != 1.:
self.network.X.set_value(self.network.X.get_value() *
np.array(contrast, dtype='float32'))
activity.get_acts()
self.big_X[ii*small_bs:(ii+1)*small_bs,:] = self.network.X.get_value()
for layer in range(self.network.n_layers):
self.big_Y[layer][ii*small_bs:(ii+1)*small_bs,:] = self.network.Y[layer].get_value()
self.network.to_cpu()
self.network.Y = self.big_Y
self.network.X = self.big_X
self.network.parameters.time_data = orig_time_data
self.network.parameters.keep_spikes = orig_keep_spikes
def choose_item(self):
contents.activityChosen = self.activityList.get(
self.activityList.curselection())
user_interface_handler.load_sections_time(self)
self.activityAnnounce.config(text=contents.activityNom +
contents.activityChosen)
Activity.cancel_edit(self, self.noteTxt)
Activity.update_description(self, self.noteTxt)
def readFile (filename, partition) :
"""
Read files filename and partition and return the correponding work sheet
"""
Activity.readPartition (partition)
w = WorkSheet()
w.read(filename)
return w
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 __init__(self, screen):
Activity.__init__(self, screen)
self.CloseButton = pygame.sprite.RenderUpdates(([Icons('stop')]))
self.finger = Finger()
self.cursor = pygame.sprite.RenderUpdates((self.finger))
self.change = pygame.sprite.Group([Navigation()]) #load next and prev buttons
self.pos = None
self.sprites = pygame.sprite.OrderedUpdates()
self.sprites.add([self.CloseButton, self.change, self.cursor])
self.text()
def set_if_matched(self, activity: Activity) -> None:
"""Set ApplicationInfo to Activity if matched"""
application_info = self.__try_find_app_info_in(
self.distracting_app_infos,
activity) or self.__try_find_app_info_in(self.detailed_app_infos,
activity)
if application_info is None:
return
activity.set_application_info(application_info)
def __init__(self, screen):
Activity.__init__(self, screen)
self.wrong_pos = [
Rect(490, 272, 21, 29),
Rect(439, 315, 47, 21),
Rect(435, 355, 34, 29),
Rect(458, 376, 45, 47),
Rect(517, 372, 63, 36),
Rect(614, 370, 37, 41),
Rect(525, 421, 33, 30),
Rect(567, 454, 25, 20),
Rect(510, 473, 34, 33),
Rect(467, 505, 36, 23),
Rect(541, 516, 33, 28),
Rect(639, 432, 53, 45),
Rect(738, 329, 41, 23),
Rect(722, 206, 29, 21),
Rect(713, 176, 33, 20),
Rect(653, 196, 30, 26),
Rect(519, 271, 61, 52),
Rect(583, 290, 24, 22),
Rect(591, 318, 29, 38),
Rect(401, 536, 105, 61),
Rect(720, 248, 74, 33),
]
self.found = 0
self.screen = screen
path = os.path.join(constants.data_folder, "backgrounds", 'illustration_020_021.png')
self.background, rect = common.load_image(path)
self.title = ("¡Orden en mi habitación!",)
self.instructions = ("Observa estas dos habitaciones. Una está ordenada",
"y la otra desordenada: descubre las 21 diferencias y",
"márcalas con una X en la habitación desordenada")
self.icons = pygame.sprite.Group()
self.icons.add([Icons('stop')])
self.pointer_ = Xs()
self.pointer = sprite.RenderUpdates([self.pointer_, self.icons])
self.xs = sprite.RenderUpdates()
self.xs.draw(self.screen)
self.pointer.draw(self.screen)
self.check = sprite.RenderUpdates()
self.room = Rect(403, 129, 393, 467)
pygame.display.update()
def calculate_transient_values(activity: Activity):
"""
Calculate the transient values for a specific activity.
Lots of this logic comes from https://medium.com/critical-powers/formulas-from-training-and-racing-with-a-power-meter-2a295c661b46.
Args:
activity: The activity to calculate the transient values for.
"""
# Simple stuff
activity.variability_index = round(
((activity.normalised_power - activity.avg_power) /
activity.normalised_power) * 100, 0)
activity.ftp = get_ftp(activity.start_time)
activity.intensity_factor = activity.normalised_power / activity.ftp if activity.ftp else 0
activity.duration_in_seconds = (activity.end_time -
activity.start_time).seconds
activity.tss = int(
(activity.duration_in_seconds * activity.normalised_power *
activity.intensity_factor) /
(activity.ftp * 36)) if activity.ftp else 0
distance_in_meters = activity.distance
speed_in_ms = distance_in_meters / activity.duration_in_seconds
activity.speed_in_kmhr = speed_in_ms * 3600 / 1000
# Now calculate aerobic decoupling
# See https://www.trainingpeaks.com/blog/aerobic-endurance-and-decoupling.
if distance_in_meters >= 10000:
activity.aerobic_decoupling = calculate_aerobic_decoupling(activity)
activity.aerobic_efficiency = activity.normalised_power / activity.avg_hr
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)
class Manager:
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 start(self):
thread = threading.Thread(target=self.run)
thread.start()
def run(self):
print("### run")
try:
self.clear_running()
except Exception as exc:
print("Exception during clear_running():")
print(exc)
while True:
self.loop()
print("run sleep(600)")
sleep(600)
def loop(self):
now = time_in_week(datetime.datetime.now())
tts = self.models.TimeTable.query.filter(
self.models.TimeTable.start <= now,
self.models.TimeTable.end > now,
# self.models.TimeTable.end < self.models.TimeTable.start,
).all()
ids = list(map(lambda tt: tt.account_id, tts))
print("ids: %s" % ids)
for id in ids:
try:
self.activity.start_bot(id)
except Exception as exc:
print("Exception during loop():")
print(exc)
self.db.session.rollback()
print("Session.rollback() Done")
def clear_running(self):
delete = self.db.session.query(self.models.Running).delete(synchronize_session='fetch')
self.db.session.commit()
print("### clear Entries: %r" % str(delete))
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 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 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 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 test_when_end_time_is_not_greater_than_start_time(self):
start_time = datetime(2020, 7, 12, 20, 30, 0)
end_time = datetime(2020, 7, 12, 19, 30, 0)
self.assertLess(end_time, start_time)
activity = Activity('wm_class', 'window_name', start_time, is_work_time=True)
with self.assertRaisesRegex(ValueError,
expected_regex=r'end_time \[2020-07-12 19:30:00\] should be greater '
r'than start_time \[2020-07-12 20:30:00\]!'):
activity.set_end_time(end_time)
self.assertFalse(activity.has_finished())
self.assertIsNone(activity.end_time)
self.assertIsNone(activity.activity_time)
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 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 _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 store(self, *, activity: Activity):
"""
Persist an activity in the SQLite database.
Args:
activity: The activity to persist.
"""
# Setup parameters for insert.
params = {}
for key, value in activity.__dict__.items():
if key in ["raw_power", "raw_hr"]:
params[key] = ",".join(str(x) for x in value)
else:
params[key] = value
# Insert the record.
self.conn.execute(INSERT_SQL, params)
self.conn.commit()
# Fetch the row ID
cursor = self.conn.cursor()
try:
cursor.execute('select last_insert_rowid() as "last_row_id"')
records = cursor.fetchall()
assert len(records) == 1
activity.rowid = int(records[0][0])
finally:
cursor.close()
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 Transform(self, client, activity, callback):
from activity import Activity
from asset_id import AssetIdUniquifier
from device import Device
def _OnUpdate(new_activity):
"""Delete the old activity."""
if Version._mutate_items:
activity.Delete(client, partial(callback, new_activity))
else:
callback(new_activity)
timestamp, device_id, uniquifier = Activity.DeconstructActivityId(
activity.activity_id)
if device_id == Device.SYSTEM:
if activity.activity_id in DisambiguateActivityIds2._unique_activity_ids:
# Already saw this activity id, so append viewpoint id to it.
assert uniquifier.server_id is None, (activity, uniquifier)
new_uniquifier = AssetIdUniquifier(uniquifier.client_id,
activity.viewpoint_id)
new_activity_id = Activity.ConstructActivityId(
timestamp, device_id, new_uniquifier)
new_activity_dict = activity._asdict()
new_activity_dict['activity_id'] = new_activity_id
new_activity = Activity.CreateFromKeywords(**new_activity_dict)
logging.info('%s\n%s (%s/%s/%s) => %s (%s/%s/%s/%s)' %
(activity, activity.activity_id, timestamp,
device_id, uniquifier.client_id, new_activity_id,
timestamp, device_id, new_uniquifier.client_id,
new_uniquifier.server_id))
if Version._mutate_items:
new_activity.Update(client,
partial(_OnUpdate, new_activity))
else:
_OnUpdate(new_activity)
else:
DisambiguateActivityIds2._unique_activity_ids.add(
activity.activity_id)
callback(activity)
else:
assert activity.activity_id not in DisambiguateActivityIds2._unique_activity_ids, activity
callback(activity)
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 parse(path):
with open(os.path.join(os.getcwd(), path), "r") as data:
total_jobs, total_machines, max_operations = re.findall(
'\S+', data.readline())
number_total_jobs, number_total_machines, number_max_operations = int(
total_jobs), int(total_machines), int(float(max_operations))
jobs_list = []
# Current job's id
id_job = 1
for key, line in enumerate(data):
if key >= number_total_jobs:
break
# Split data with multiple spaces as separator
parsed_line = re.findall('\S+', line)
# Current job
job = Job(id_job)
# Current activity's id
id_activity = 1
# Current item of the parsed line
i = 1
while i < len(parsed_line):
# Total number of operations for the activity
number_operations = int(parsed_line[i])
# Current activity
activity = Activity(job, id_activity)
for id_operation in range(1, number_operations + 1):
activity.add_operation(
Operation(id_operation,
int(parsed_line[i + 2 * id_operation - 1]),
int(parsed_line[i + 2 * id_operation])))
job.add_activity(activity)
i += 1 + 2 * number_operations
id_activity += 1
jobs_list.append(job)
id_job += 1
# Machines
machines_list = []
for id_machine in range(1, number_total_machines + 1):
machines_list.append(Machine(id_machine, number_max_operations))
return jobs_list, machines_list, number_max_operations
def test_entity_activity_init_from_sensor_logs(self):
uuid1 = "uuid-01"
node_id1 = 1
event1 = 0
ts1 = datetime.datetime(year=2018,
month=1,
day=2,
hour=1,
minute=0,
second=0)
obj1 = Sensor_Log(uuid=uuid1,
node_id=node_id1,
event=event1,
recieved_timestamp=ts1)
uuid2 = "uuid-02"
node_id2 = 2
event2 = 225
ts2 = datetime.datetime(year=2018,
month=1,
day=2,
hour=1,
minute=0,
second=2)
obj2 = Sensor_Log(uuid=uuid2,
node_id=node_id2,
event=event2,
recieved_timestamp=ts2)
obja = Activity(start_log=obj1, end_log=obj2)
e_flag = False
try:
str_rep = obja.__str__()
self.assertFalse(
obja.in_daytime(),
msg='activity not properly assigned to day or night time')
self.assertEqual(
obja.seconds,
2,
msg='seconds between start and end datetime calculated wrongly'
)
except:
e_flag = True
self.assertFalse(e_flag, 'exception thrown')
def like():
try:
id = flask.request.args['id']
n = flask.request.args['n']
act = Activity.load_from_db(id)
act.like(int(n))
return json.dumps({'status': 'ok'})
except Exception as e:
return json.dumps({'status': 'error', 'message': str(e)})
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 __init__(self, screen):
Activity.__init__(self, screen)
self.close_button = pygame.sprite.RenderUpdates(([Icons('stop')]))
self.finger = Finger()
self.cursor = pygame.sprite.RenderUpdates((self.finger))
self.pos = None
self.line_start = (0, 0)
self.draw_color = (0, 0, 0)
self.line_width = 3
self.line_end = None
self.text()
self.transparent = pygame.Rect(297, 96, 400, 408)
# Color palette
self.palette = {}
self.mk_palette(constants.rgb_colors)
# Thickness
self.thickness = {}
self.mk_thickness()
def __init__(self, window, app, antfile):
Gtk.ListBoxRow.__init__(self)
Activity.__init__(self, app, antfile)
self.window = window
grid = Gtk.Grid(margin=6)
grid.set_column_spacing(10)
self.add(grid)
self.image = Gtk.Image(icon_name='preferences-system-time-symbolic',
icon_size=self.ICON_SIZE)
self.label = Gtk.Label()
self.label.set_ellipsize(Pango.EllipsizeMode.END)
self.label.set_valign(Gtk.Align.CENTER)
self.label.set_halign(Gtk.Align.START)
self.spinner = Gtk.Spinner()
self.spinner.set_valign(Gtk.Align.CENTER)
self.spinner.set_halign(Gtk.Align.END)
self.spinner.set_hexpand(True)
self.spinner.set_no_show_all(True)
self.selector_button = Gtk.CheckButton()
self.selector_button.set_valign(Gtk.Align.CENTER)
self.selector_button.set_halign(Gtk.Align.END)
self.selector_button.set_hexpand(True)
self.selector_button.set_no_show_all(True)
grid.attach(self.image, 0, 0, 1, 1)
grid.attach(self.label, 1, 0, 1, 1)
grid.attach(self.spinner, 2, 0, 1, 1)
# don't show spinner yet
grid.attach(self.selector_button, 3, 0, 1, 1)
# don't show selector button yet
if not self.downloaded:
self.label.set_sensitive(False)
self.image.set_from_icon_name('dialog-question-symbolic',
self.ICON_SIZE)
self.connect('status-changed', self.status_changed_cb)
self.status_changed_cb(self, self.status)
def __init__(self, screen):
Activity.__init__(self, screen)
self.background = common.load_image(constants.illustration_019)[0]
words = {
'saludable': (114, 236),
'risa': (41, 264),
'alimentos': (143, 283),
'agua': (41, 307),
'descanso': (101, 346),
'amor': (89, 375),
'limpieza': (26, 407),
'deporte': (149, 445),
'sol': (59, 463),
'aire': (109, 490),
'aseo': (55, 514),
'banarse': (193, 542),
}
self.title = ("¡Palabras largas, palabras cortas!",)
self.instructions = ("Estas palabras están relacionadas con la salud.",
" ",
"Arrastra hacia la bolsa roja",
"las palabras que tienen",
"menos de 5 letras y hacia la",
"bolsa azul las que tienen",
"más de 5 letras.")
self.informative_text(self.title, self.instructions)
self.hand = Hand()
self.icons = pygame.sprite.Group()
self.icons.add([Icons('stop')])
self.words = pygame.sprite.Group()
self.sprites = pygame.sprite.OrderedUpdates()
for word, pos in words.items():
word_ = Word(word, pos)
self.sprites.add(word_)
self.words.add(word_)
self.sprites.add([self.icons, self.hand])
self.sprites.draw(self.screen)
self.selected = None
self.bags = (Bag('cortas', (430, 150, 170, 150), (475, 175, 100, 120)),
Bag('largas', (430, 375, 170, 160), (480, 395, 105, 130)))
return
def __init__(self, screen):
Activity.__init__(self, screen)
self.count = 0
self.id = ""
# Change the mouse pointer by a hand
self.button_down = 0
self.selection = 0
self.hand = Hand()
self.sprites = pygame.sprite.OrderedUpdates()
self.pictures = pygame.sprite.Group() # Picture that can be move
self.transparent= pygame.sprite.Group() # Picture that cann't be move
self.icons = pygame.sprite.Group()
self.icons.add([Icons('stop')])
self.transparent.add([ \
ImagePuzzle(302, 100, 1, "5"), \
ImagePuzzle(500, 100, 2, "5"), \
ImagePuzzle(302, 250, 3, "5"), \
ImagePuzzle(500, 250, 4, "5")]
)
def __init__(self, window, app, antfile):
Gtk.ListBoxRow.__init__(self)
Activity.__init__(self, app, antfile)
self.window = window
grid = Gtk.Grid(margin=6)
grid.set_column_spacing(10)
self.add(grid)
self.image = Gtk.Image(icon_name='preferences-system-time-symbolic',
icon_size=self.ICON_SIZE)
self.label = Gtk.Label()
self.label.set_ellipsize(Pango.EllipsizeMode.END)
self.label.set_valign(Gtk.Align.CENTER)
self.label.set_halign(Gtk.Align.START)
self.spinner = Gtk.Spinner()
self.spinner.set_valign(Gtk.Align.CENTER)
self.spinner.set_halign(Gtk.Align.END)
self.spinner.set_hexpand(True)
self.spinner.set_no_show_all(True)
self.selector_button = Gtk.CheckButton()
self.selector_button.set_valign(Gtk.Align.CENTER)
self.selector_button.set_halign(Gtk.Align.END)
self.selector_button.set_hexpand(True)
self.selector_button.set_no_show_all(True)
grid.attach(self.image, 0, 0, 1, 1)
grid.attach(self.label, 1, 0, 1, 1)
grid.attach(self.spinner, 2, 0, 1, 1)
# don't show spinner yet
grid.attach(self.selector_button, 3, 0, 1, 1)
# don't show selector button yet
if not self.downloaded:
self.label.set_sensitive(False)
self.image.set_from_icon_name('dialog-question-symbolic', self.ICON_SIZE)
self.connect('status-changed', self.status_changed_cb)
self.status_changed_cb(self, self.status)
def _new_activity(self, activity_id, tp, room):
try:
objid = self._get_next_object_id()
activity = Activity(self._session_bus, objid, self, tp, room,
id=activity_id)
except Exception:
# FIXME: catching bare Exception considered harmful
_logger.debug("Invalid activity:", exc_info=1)
try:
del self._activities_by_handle[tp][room]
except KeyError:
pass
return None
activity.connect("validity-changed",
self._activity_validity_changed_cb)
activity.connect("disappeared", self._activity_disappeared_cb)
self._activities_by_id[activity_id] = activity
self._activities_by_handle[tp][room] = activity
return activity
def append_extra(self, trs):
"""
Append extra tiers in trs: Activity and PhnTokAlign.
"""
tokenalign = trs.Find("TokensAlign")
if tokenalign is None:
self.print_message("No time-aligned tokens found. No extra tier can be generated.", indent=2, status=WARNING_ID)
return trs
# PhnTokAlign tier
if self._options['phntok'] is True:
try:
phonalign = trs.Find("PhonAlign")
tier = self.phntokalign_tier(phonalign,tokenalign)
trs.Append(tier)
trs.GetHierarchy().addLink("TimeAssociation", tokenalign, tier)
except Exception as e:
self.print_message("PhnTokAlign generation: %s"%str(e), indent=2, status=WARNING_ID)
# Activity tier
if self._options['activity'] is True or self._options['activityduration']:
try:
activity = Activity( trs )
tier = activity.get_tier()
if self._options['activity'] is True:
trs.Append(tier)
trs.GetHierarchy().addLink("TimeAlignment", tokenalign, tier)
if self._options['activityduration'] is True:
dtier = tier.Copy()
dtier.SetName( "ActivityDuration" )
trs.Append(dtier)
for a in dtier:
d = a.GetLocation().GetDuration().GetValue()
a.GetLabel().SetValue( '%.3f' % d )
except Exception as e:
self.print_message("Activities generation: %s"%str(e), indent=2, status=WARNING_ID)
return trs
def __init__(self, screen):
Activity.__init__(self, screen)
"""change the mouse pointer by a hand"""
self.button_down = 0
self.rectList = [
pygame.Rect(311, 91, 158, 51),
pygame.Rect(546, 414, 67, 121),
pygame.Rect(157, 358, 72, 109),
]
self.sprites = pygame.sprite.OrderedUpdates()
self.icons = pygame.sprite.Group()
self.icons.add([Icons('stop')])
image_check = image_normal = os.path.join(constants.icons_folder,\
"check.png")
self.checkImage, self.checkRect = common.load_image\
(image_check)
self.hand = Hand()
self.tex_info = {
'title': ["Una boca bien sana", None],
'instructions' : [["Selecciona aquellos objetos", \
"que son necesarios para mantener tu boca sana"], None]
}
def remove_follower(leader, follower):
follower_id = follower.key().id()
existing = (
Follow.all()
.ancestor(leader)
.filter("leader_id =", leader.key().id())
.filter("follower_ids =", follower_id)
.get()
)
if not existing:
return False
existing.follower_ids.remove(follower_id)
existing.put()
# do dependent index
index = existing.get_follow_index()
for user_id in follower.all_user_ids:
index.remove_follower(user_id)
index.put()
from activity import Activity
Activity.create("<actor>|stopped following|<target>", actor=follower, target=leader, extra_recipients=[leader])
return True
def __init__(self, screen):
Activity.__init__(self, screen)
self.correct = set()
self.rectangleListEnter = [
pygame.Rect(345, 90, 10, 15),
pygame.Rect(340, 480, 10, 15),
pygame.Rect(300, 390, 10, 15),
pygame.Rect(493, 325, 10, 15),
pygame.Rect(362, 299, 10, 15)
]
self.pointList = [
(350, 123),
(400, 460),
(277, 279),
(451, 365)
]
self.checkList = [
(390, 80),
(360, 520),
(260, 340),
(494, 358),
(407, 304),
]
self.ball = Ball(self.screen, (200,80))
self.text_info = {
'title': {
'text': u"El laberinto de la salud",
'offset': None
},
'instructions': {
'text': [u" Ayuda a Nina a realizar",
u"las tareas diarias a través",
u"del laberinto. Utiliza las",
u"teclas de desplazamiento."],
'offset': 490
}
}
def read(self, filename) :
"""
Read a work sheet in a file
"""
with open(filename, 'rb') as f :
reader = csv.reader(f, dialect = CsvDialectSemiColon())
ln = 0
for row in reader :
ln += 1
try:
a = Activity.fromList(row)
self.add(a)
except Exception as exc:
raise IOError("error at line %d: %s"%(ln,str(exc)))
def __init__(self, screen):
Activity.__init__(self, screen)
self.background = common.load_image(constants.illustration_024)[0]
self.instruction_text()
def __init__(self):
Activity.__init__(self, None)
def __init__(self, screen):
Activity.__init__(self, screen)
self.informative_text()
def __init__(self, screen):
Activity.__init__(self, screen)
if properties:
raise ValueError('Unsupported properties given: <%s>'
% ', '.join(properties.iterkeys()))
except ValueError, e:
async_err_cb(e)
return
objid = self._get_next_object_id()
# XXX: is the preferred Telepathy plugin always the right way to
# share the activity?
# We set private=True here - when the activity becomes shared
# via join(), we'll set private to the correct value.
activity = Activity(self._session_bus, objid, self,
self._get_preferred_plugin(), 0,
id=actid, type=atype,
name=name, color=self._owner.props.color,
local=True, private=True, tags=tags)
activity.connect("validity-changed",
self._activity_validity_changed_cb)
activity.connect("disappeared", self._activity_disappeared_cb)
self._activities_by_id[actid] = activity
def activity_shared():
tp, room = activity.room_details
self._activities_by_handle[tp][room] = activity
async_cb(activity.object_path())
activity.join(activity_shared, async_err_cb, sharing=True,
private=private, sender=sender)
def __init__(self, icarus):
Activity.__init__(self, icarus)
def __init__(self, fsm, core, mon_data):
Activity.__init__(self)
self.fsm = fsm
self.core = core
self.mon_data = mon_data
self.canceled = False
def do_activity(self, _args):
"""
Interact with exported activities on the device
"""
subconsole = Activity(self.session)
subconsole.cmdloop()
def test_decompose(self):
self.assertRaises(UserWarning, Activity.decompose, [])
self.assertRaises(UserWarning, Activity.decompose, 4.3)
self.assertRaises(UserWarning, Activity.decompose, 'nop')
self.assertRaises(UserWarning, Activity.decompose, sum([x.value for x in Activity.flags()])+1)
def __init__(self, icarus):
Activity.__init__(self, icarus)
self.canceled = False
def __init__(self, screen):
Activity.__init__(self, screen)
self.back1 = common.load_image(constants.illustration_005)[0]
self.back2 = common.load_image(constants.illustration_006)[0]
self.background = self.back1
def __init__(self, screen):
Activity.__init__(self, screen)
self.correct = set()
