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))