def new(cls,
experiment,
ping_uid,
slideview_type,
**slideview_kwargs):
try:
slide_to_be_launched\
= cls.objects.select_related().get(experiment = experiment,
ping_uid = ping_uid,
slideview_type = slideview_type,
slideview_kwargs = slideview_kwargs)
except ObjectDoesNotExist:
slide_to_be_launched\
= cls.objects.create(uid = django.uid(),
experiment = experiment,
ping_uid = ping_uid,
slideview_type = slideview_type,
slideview_kwargs=slideview_kwargs)
return slide_to_be_launched
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 _new(cls, wordlist_stimulus, wordlist):
wordlist_items = []
for i, word in enumerate(wordlist):
lexicon_item, _word_created\
= Lexicon.objects.get_or_create(word = word)
try:
wordlist_item\
= cls.objects.get(wordlist_stimulus = wordlist_stimulus,
lexicon = lexicon_item,
order = i)
except ObjectDoesNotExist:
wordlist_item\
= cls.objects.create(uid = django.uid(),
wordlist_stimulus = wordlist_stimulus,
lexicon = lexicon_item,
order = i)
wordlist_items.append(wordlist_item)
return wordlist_items
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 create_subject(self, user, **kwargs):
user_does_not_exist_err = 'User "%s" does not exist.' % user.username
user_has_subject_err = 'User "%s" already has a subject.' % user.username
assert user_exists(user), user_does_not_exist_err
assert self.user_does_not_have_subject_entry(user), user_has_subject_err
subject_uid = uid()
return Subject.objects.create(uid=subject_uid,
user=user,
**kwargs)
def _new(cls, **kwargs):
slide_type = cls.get_slide_type()
try:
return cls.objects.select_related().get(slide_type = slide_type,
**kwargs)
except ObjectDoesNotExist:
return cls.objects.select_related().create(uid = django.uid(),
slide_type = slide_type,
**kwargs)
def create_temp_subject(self, user):
while True:
subject_uid = uid()
if not self.filter(uid=subject_uid):
break
now = datetime.datetime.today()
subject = self.create(uid=subject_uid,
user=user,
temp_subject=True,
created=now)
return subject
def new(cls, wordlist):
'''
Get or create.
'''
wordlist_stimulus = cls.get_wordlist(wordlist)
if not wordlist_stimulus:
wordlist_stimulus = cls.objects.create(uid = django.uid())
WordlistItems.new(wordlist_stimulus, wordlist)
return wordlist_stimulus
def new(cls, wordlist, expected_responses):
'''
Get or create.
'''
wordlist_stimulus_object = cls.get_wordlist(wordlist, expected_responses)
if not wordlist_stimulus_object:
wordlist_stimulus_object = cls.objects.create(uid = django.uid())
WordlistTestItems.new(wordlist_stimulus_object,
wordlist,
expected_responses)
return wordlist_stimulus_object
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 _new(cls, **kwargs):
'''
Get or create a new instance of this widget class.
'''
widgettype = cls.get_widget_type()
try:
return cls.objects.select_related().get(widgettype = widgettype,
**kwargs)
except ObjectDoesNotExist:
return cls.objects.select_related().create(uid = django.uid(),
widgettype = widgettype,
**kwargs)
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 __init__(self, experiment_name, request=None):
self.experiment_name = experiment_name
self.template_data = {}
self.slideview_kwargs = {}
# TODO. Sept 16, 2014. We need this "skin" configuration information to
# be somewhere else. E.g. in settings.py.
self.cssfiles = ['front/css/main.css', 'bartlett/css/bartlett.css']
self.jsfiles = ['base/widgets/hangup.js']
self.template_data['cssfiles'] = self.cssfiles
self.template_data['jsfiles'] = self.jsfiles
self.template_data['experiment_name'] = experiment_name
self.template_data['experiment_title'] = experiment_name.capitalize()
self.ping_uid = django.uid() # This is the baptism.
self.template_data['short_uid'] = self.ping_uid_short
self.experiment = archives_models.Experiment.objects.get(
class_name = self.experiment_name.capitalize()
)
def test_iterate_playlist_and_hangup(self):
live_session = models.LiveExperimentSession.objects.get(
uid=self.live_session_uid)
self.assertEqual(live_session.nowplaying_ping_uid, None)
self.assertFalse(live_session.is_nowplaying)
ping_uid = django.uid()
session_slide = live_session.iterate_playlist(ping_uid)
self.assertEqual(live_session.nowplaying_ping_uid, ping_uid)
self.assertTrue(live_session.is_nowplaying)
self.assertEqual(session_slide.ping_uid, ping_uid)
live_session.hangup_nowplaying()
self.assertEqual(live_session.nowplaying_ping_uid, None)
self.assertFalse(live_session.is_nowplaying)
def _new(cls, slides):
'''
Make a new Playlist instance given the set of slides instances. This
function will usually be invoked from within a PlaylistFactory in an
experiments.py module in a experiments repository.
It checks if a Playlist instance with this set of slides already
exists. If it does, it returns it. This allows this function to be
repeatedly called without leading to an error. It will create the
Playlist instance if it does not exist, and it will return it if it
already exists.
'''
try:
matching_playlists\
= SlideAndPlaylistJoinModel.get_playlists_with_slides(slides)
if len(matching_playlists) == 0:
raise ObjectDoesNotExist
elif len(matching_playlists) > 1:
raise MultipleObjectsReturned
else:
return matching_playlists.pop()
except ObjectDoesNotExist:
playlist = cls(uid = django.uid())
playlist.save()
for k, slide in enumerate(slides):
SlideAndPlaylistJoinModel.new(container=playlist,
element=slide)
return playlist
def new(cls,
sessionwidget,
stimulus,
order,
stimulus_onset_datetime,
response_datetime):
sessionwidget_ct = ContentType.objects.get_for_model(sessionwidget)
sessionwidget_uid = sessionwidget.uid
stimulus_ct = ContentType.objects.get_for_model(stimulus)
stimulus_uid = stimulus.uid
choice_model = cls.objects.create(
sessionwidget_ct = sessionwidget_ct,
sessionwidget_uid = sessionwidget_uid,
stimulus_ct = stimulus_ct,
stimulus_uid = stimulus_uid,
uid = django.uid(),
order = order,
stimulus_onset_datetime = stimulus_onset_datetime,
response_datetime = response_datetime)
return choice_model
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))
