def stamp_last_ping_time(self):
'''Stamp last_ping as now.'''
now = datetime.now()
self.last_ping = now
self.save()
def stamp_time(self, now=None):
if now is None:
now = datetime.now()
self.last_activity = now
self.save()
def new_slide_or_widget(cls, name, app_label, htmltemplate, cssfiles, jsfiles):
'''
Create a new slide or widget type with the given name, htmltemplate and
the included cssfiles and jsfiles.
'''
slide_or_widget_type = cls(uid = django.uid(),
htmltemplate = htmltemplate,
name = name,
app_label = app_label,
date_initiated = datetime.now()
)
slide_or_widget_type.save()
if cssfiles:
for filepath in cssfiles:
cssfile = CssFiles.new(filepath=filepath)
slide_or_widget_type.cssfiles.add(cssfile)
if jsfiles:
for filepath in jsfiles:
jsfile = JsFiles.new(filepath=filepath)
slide_or_widget_type.jsfiles.add(jsfile)
return slide_or_widget_type
def initialize(cls):
session_model = cls(uid = django.uid())
session_model.initialized = True
session_model.datetime_initialized = datetime.now()
session_model.save()
return session_model
def stamp_time(self):
'''Stamp last_activity as now. Sync with the experiment session.'''
now = datetime.now()
self.last_activity = now
self.save()
self.experiment_session.stamp_time(now)
def set_completed(self):
"""
Complete the experiment session; complete the playlist session too.
"""
self.status = self.status_completed
self.date_completed = datetime.now()
self.playlist_session.set_completed()
self.save()
def new(cls, class_name):
try:
experiment = cls.objects.get(class_name=class_name)
except ObjectDoesNotExist:
experiment = cls.objects.create(class_name=class_name,
date_created=datetime.now())
return experiment
def new(cls, path_to_git_repository):
name = os.path.basename(path_to_git_repository)
try:
repository = cls.objects.get(name = name,
path = path_to_git_repository)
except ObjectDoesNotExist:
repository = cls.objects.create(name = name,
path = path_to_git_repository,
date_created = datetime.now())
return repository
def new(cls,
subject,
experiment_label):
'''Create a new experiment session.
* experiment_label could be either simply a class_name, e.g. Yarks, or
else a experiment version label, Yarks_210101013_abd3qwa.
'''
try:
experiment_version\
= ExperimentVersion.objects.get(label = experiment_label)
except ObjectDoesNotExist:
experiment = Experiment.objects.get(class_name = experiment_label)
experiment_version = experiment.current_version
playlist_session = experiment_version.playlist.new_session_model()
completions = cls.objects.get_my_completions(experiment, subject)
now = datetime.now()
experiment_session\
= cls(subject=subject,
experiment_version = experiment_version,
attempt=completions,
status = cls.status_initialized,
playlist_session_ct = ContentType.objects.get_for_model(playlist_session),
playlist_session_uid = playlist_session.uid,
uid = django.uid(),
date_started = now,
last_activity = now
)
experiment_session.save()
experiment_session.playlist_session.set_started()
return experiment_session
def new(cls, experiment_session, request=None):
now = datetime.now()
live_experiment_session\
= cls.objects.create(uid=django.uid(),
experiment_session = experiment_session,
alive = True,
date_created = now)
live_experiment_session.experiment_session.make_live(now)
if request:
live_experiment_session.set_user_agent_info(request)
live_experiment_session.set_ip_geoip_info(request)
live_experiment_session.set_server_info()
return live_experiment_session
def hangup(self, status='pause'):
''' Pause or complete the experiment session. If there are no slides
remaining, then hangup with a 'completed' message.
'''
logger.debug('Experiment session hangup. Status=%s.' % status)
self.hangup_nowplaying_safely()
if status == 'pause':
slides_completed, slides_remaining\
= self.slides_completed_slides_remaining
if slides_remaining:
self.status = self.status_paused
else:
self.set_completed()
elif status == 'completed':
self.set_completed()
self.last_activity = datetime.now()
self.save()
def set_completed(self):
self.completed = True
self.datetime_completed = datetime.now()
self.save()
def _set_started_or_completed(self, started_or_completed):
now = datetime.now()
setattr(self, started_or_completed, True)
setattr(self, 'datetime_' + started_or_completed, now)
self.save()
def set_started(self):
self.started = True
self.datetime_started = datetime.now()
self.save()
def release(cls, experiment, new_data_only=True):
try:
exported_data_tmpdir = export_experiment(experiment)
datetime_now = datetime.now()
existing_short_uids\
= [exp_data_export.uid[:settings.UID_SHORT_LENGTH]
for exp_data_export in cls.objects.all()]
while True:
uid = django.uid()
short_uid = uid[:settings.UID_SHORT_LENGTH]
if not (short_uid in existing_short_uids):
break
label = utils.make_release_label(experiment.name,
datetime_now,
uid)
experiment_url = settings.WWWURL + '/' + experiment.name,
readme = utils.make_readme(conf.readme_template,
experiment.name,
experiment_url,
uid,
short_uid,
datetime_now)
license\
= conf.odbl_license_template\
.strip().format(DATA_NAME='data-set', UID=short_uid) + '\n'
boilerplates = [
(conf.readme_txt, readme),
(conf.license_txt, license)
]
tarball_filename, checksums, tarball_filesize\
= utils.make_tarball(exported_data_tmpdir,
boilerplates,
label,
compression_method=conf.tarball_compression_method,
checksum_filename=conf.tarball_checksum)
attachment_filename\
= shorten_uid(uid) + '.tar.' + conf.tarball_compression_method
create_new_data_export_instance\
= lambda: cls.objects.create(uid = uid,
short_uid = shorten_uid(uid),
attachment_filename = attachment_filename,
experiment = experiment,
datetime = datetime_now,
checksums = checksums,
filename = tarball_filename,
filesize = tarball_filesize)
if not new_data_only:
create_new_data_export_instance()
else:
most_recent_data = cls.objects.most_recent_entry(experiment)
if most_recent_data:
if checksums_to_dict(checksums) == checksums_to_dict(most_recent_data.checksums):
msg = 'Not exporting data for %s. New data identical to data previously collected at %s.'
logger.info(msg % (experiment.name,
most_recent_data.datetime.strftime(conf.isoformat))
)
else:
create_new_data_export_instance()
else:
create_new_data_export_instance()
except Exception as e:
exception_msg = 'Could not export data from experiment %s. %s: %s'
logger.warning(exception_msg % (experiment.name,
e.__class__.__name__,
e.message))
