def filter_queryset(self, queryset):
project = get_permissible_project(view=self)
auditor.record(event_type=PROJECT_EXPERIMENT_GROUPS_VIEWED,
instance=project,
actor_id=self.request.user.id)
queryset = queryset.filter(project=project)
return super().filter_queryset(queryset=queryset)
def get_object(self):
project = get_permissible_project(view=self)
job = get_object_or_404(Job, project=project, id=self.kwargs['id'])
auditor.record(event_type=JOB_OUTPUTS_DOWNLOADED,
instance=job,
actor_id=self.request.user.id)
return job
def filter_queryset(self, queryset):
independent = to_bool(self.request.query_params.get(
'independent', None),
handle_none=True,
exception=ValidationError)
group_id = self.request.query_params.get('group', None)
if independent and group_id:
raise ValidationError(
'You cannot filter for independent experiments and '
'group experiments at the same time.')
project = get_permissible_project(view=self)
queryset = queryset.filter(project=project)
if independent:
queryset = queryset.filter(experiment_group__isnull=True)
if group_id:
group = self.get_group(project=project, group_id=group_id)
if group.is_study:
queryset = queryset.filter(experiment_group=group)
elif group.is_selection:
queryset = group.selection_experiments.all()
else:
raise ValidationError('Invalid group.')
auditor.record(event_type=PROJECT_EXPERIMENTS_VIEWED,
instance=project,
actor_id=self.request.user.id,
actor_name=self.request.user.username)
return super().filter_queryset(queryset=queryset)
def get_job(self):
# Get project and check access
self.project = get_permissible_project(view=self)
self.job = get_object_or_404(BuildJob,
project=self.project,
id=self.kwargs['job_id'])
return self.job
def get_experiment(self):
# Get project and check access
self.project = get_permissible_project(view=self)
sequence = self.kwargs['experiment_sequence']
self.experiment = get_object_or_404(Experiment,
project=self.project,
sequence=sequence)
return self.experiment
def get_object(self):
project = get_permissible_project(view=self)
repo = get_object_or_404(Repo, project=project)
if not is_internal_user(self.request.user):
auditor.record(event_type=REPO_DOWNLOADED,
instance=repo,
actor_id=self.request.user.id)
return repo
def get_experiment_group(self):
# Get project and check access
self.project = get_permissible_project(view=self)
group_id = self.kwargs['group_id']
self.group = get_object_or_404(ExperimentGroup,
project=self.project,
id=group_id)
return self.group
def filter_queryset(self, queryset):
project = get_permissible_project(view=self)
auditor.record(event_type=PROJECT_TENSORBOARDS_VIEWED,
instance=project,
actor_id=self.request.user.id,
actor_name=self.request.user.username)
queryset = queryset.filter(project=project)
return super().filter_queryset(queryset=queryset)
def get_experiment(self):
# Get project and check access
self.project = get_permissible_project(view=self)
experiment_id = self.kwargs['experiment_id']
self.experiment = get_object_or_404(Experiment,
project=self.project,
id=experiment_id)
return self.experiment
def get_object(self):
project = get_permissible_project(view=self)
experiment = get_object_or_404(Experiment,
project=project,
id=self.kwargs['id'])
auditor.record(event_type=EXPERIMENT_OUTPUTS_DOWNLOADED,
instance=experiment,
actor_id=self.request.user.id)
return experiment
def get_object(self):
project = get_permissible_project(view=self)
try:
repo = Repo.objects.get(project=project)
except Repo.DoesNotExist:
raise Http404('Repo does not exist.')
if not is_internal_user(self.request.user):
auditor.record(event_type=REPO_DOWNLOADED, instance=repo, actor_id=self.request.user.id)
return repo
def filter_queryset(self, queryset):
independent = self.request.query_params.get('independent', None)
filters = {}
if independent is not None and to_bool(independent):
filters['experiment_group__isnull'] = True
project = get_permissible_project(view=self)
auditor.record(event_type=PROJECT_EXPERIMENTS_VIEWED,
instance=project,
actor_id=self.request.user.id)
return queryset.filter(project=project, **filters)
def get_group(self):
sequence = self.kwargs['sequence']
# Get project and check permissions
project = get_permissible_project(view=self)
group = get_object_or_404(ExperimentGroup, project=project, sequence=sequence)
auditor.record(event_type=EXPERIMENT_GROUP_EXPERIMENTS_VIEWED,
instance=group,
actor_id=self.request.user.id)
return group
def filter_queryset(self, queryset):
independent = self.request.query_params.get('independent', None)
filters = {}
if independent is not None and to_bool(independent):
filters['experiment_group__isnull'] = True
project = get_permissible_project(view=self)
auditor.record(event_type=PROJECT_EXPERIMENTS_VIEWED,
instance=project,
actor_id=self.request.user.id)
return queryset.filter(project=project, **filters)
def perform_create(self, serializer):
project = get_permissible_project(view=self)
instance = serializer.save(user=self.request.user, project=project)
experiment_ids = self.request.data.get('experiment_ids')
if instance.is_selection and experiment_ids:
experiment_ids = set(experiment_ids)
if len(experiment_ids) != project.experiments.filter(
id__in=experiment_ids).count():
raise ValidationError('Experiments selection is not valid.')
instance.selection_experiments.set(experiment_ids)
def get_object(self):
project = get_permissible_project(view=self)
experiment_id = self.kwargs.get('experiment_id')
group_id = self.kwargs.get('group_id')
if experiment_id:
return get_object_or_404(Experiment, project=project, id=experiment_id)
elif group_id:
return get_object_or_404(ExperimentGroup, project=project, id=group_id)
return project
def perform_create(self, serializer):
project = get_permissible_project(view=self)
code_reference = get_project_latest_code_reference(project=project)
instance = serializer.save(user=self.request.user,
project=project,
code_reference=code_reference)
auditor.record(event_type=BUILD_JOB_CREATED, instance=instance)
# Trigger build scheduling
celery_app.send_task(SchedulerCeleryTasks.BUILD_JOBS_START,
kwargs={'build_job_id': instance.id},
countdown=1)
def get_object(self):
project = get_permissible_project(view=self)
try:
repo = Repo.objects.get(project=project)
except Repo.DoesNotExist:
raise Http404('Repo does not exist.')
if not is_internal_user(self.request.user):
auditor.record(event_type=REPO_DOWNLOADED,
instance=repo,
actor_id=self.request.user.id)
return repo
def perform_create(self, serializer):
ttl = self.request.data.get(RedisTTL.TTL_KEY)
if ttl:
try:
ttl = RedisTTL.validate_ttl(ttl)
except ValueError:
raise ValidationError('ttl must be an integer.')
instance = serializer.save(user=self.request.user,
project=get_permissible_project(view=self))
auditor.record(event_type=JOB_CREATED, instance=instance)
if ttl:
RedisTTL.set_for_job(job_id=instance.id, value=ttl)
def get_group(self):
sequence = self.kwargs['sequence']
# Get project and check permissions
project = get_permissible_project(view=self)
group = get_object_or_404(ExperimentGroup,
project=project,
sequence=sequence)
auditor.record(event_type=EXPERIMENT_GROUP_EXPERIMENTS_VIEWED,
instance=group,
actor_id=self.request.user.id)
return group
def get_object(self):
project = get_permissible_project(view=self)
if project.has_notebook:
self.permission_denied(
self.request,
'The Project `{}` is currently running a Notebook. '
'You must stop it before uploading a new version of the code.'.format(project.name))
repo, created = Repo.objects.get_or_create(project=project)
if not created and not os.path.isdir(repo.project_path):
set_git_repo(repo)
else:
auditor.record(event_type=REPO_CREATED, instance=repo, actor_id=self.request.user.id)
return repo
def get_object(self):
project = get_permissible_project(view=self)
if project.has_notebook:
self.permission_denied(
self.request,
'The Project `{}` is currently running a Notebook. '
'You must stop it before uploading a new version of the code.'.format(project.name))
repo, created = Repo.objects.get_or_create(project=project)
if not created and not os.path.isdir(repo.user_path):
set_git_repo(repo)
else:
auditor.record(event_type=REPO_CREATED, instance=repo, actor_id=self.request.user.id)
return repo
def perform_create(self, serializer):
ttl = self.request.data.get(RedisTTL.TTL_KEY)
if ttl:
try:
ttl = RedisTTL.validate_ttl(ttl)
except ValueError:
raise ValidationError('ttl must be an integer.')
project = get_permissible_project(view=self)
group = self.request.data.get('experiment_group')
if group and ExperimentGroup.objects.filter(
id=group, project=project).count() == 0:
raise ValidationError('Received an invalid group.')
instance = serializer.save(user=self.request.user, project=project)
auditor.record(event_type=EXPERIMENT_CREATED, instance=instance)
if ttl:
RedisTTL.set_for_experiment(experiment_id=instance.id, value=ttl)
def perform_create(self, serializer):
ttl = self.request.data.get(RedisTTL.TTL_KEY)
if ttl:
try:
ttl = RedisTTL.validate_ttl(ttl)
except ValueError:
raise ValidationError('ttl must be an integer.')
project = get_permissible_project(view=self)
instance = serializer.save(user=self.request.user, project=project)
auditor.record(event_type=BUILD_JOB_CREATED, instance=instance)
if ttl:
RedisTTL.set_for_build(build_id=instance.id, value=ttl)
# Trigger build scheduling
celery_app.send_task(SchedulerCeleryTasks.BUILD_JOBS_START,
kwargs={'build_job_id': instance.id},
countdown=1)
def filter_queryset(self, queryset):
independent = self.request.query_params.get('independent', None)
if independent is not None:
independent = to_bool(independent)
else:
independent = False
group_id = self.request.query_params.get('group', None)
if independent and group_id:
raise ValidationError(
'You cannot filter for independent experiments and '
'group experiments at the same time.')
project = get_permissible_project(view=self)
queryset = queryset.filter(project=project)
if independent is not None and to_bool(independent):
queryset = queryset.filter(experiment_group__isnull=True)
if group_id:
group = self.get_group(project=project, group_id=group_id)
queryset = queryset.filter(experiment_group=group)
auditor.record(event_type=PROJECT_EXPERIMENTS_VIEWED,
instance=project,
actor_id=self.request.user.id)
return super().filter_queryset(queryset=queryset)
def perform_create(self, serializer):
ttl = self.request.data.get(RedisTTL.TTL_KEY)
if ttl:
try:
ttl = RedisTTL.validate_ttl(ttl)
except ValueError:
raise ValidationError('ttl must be an integer.')
project = get_permissible_project(view=self)
group = self.request.data.get('experiment_group')
if group:
try:
group = ExperimentGroup.objects.get(id=group, project=project)
except ExperimentGroup.DoesNotExist:
raise ValidationError('Received an invalid group.')
if group.is_selection:
self.request.data.pop('experiment_group')
instance = serializer.save(user=self.request.user, project=project)
if group and group.is_selection: # Add the experiment to the group selection
group.selection_experiments.add(instance)
auditor.record(event_type=EXPERIMENT_CREATED, instance=instance)
if ttl:
RedisTTL.set_for_experiment(experiment_id=instance.id, value=ttl)
def perform_create(self, serializer):
return serializer.save(user=self.request.user,
project=get_permissible_project(view=self))
def get_object(self):
return get_permissible_project(view=self)
def filter_queryset(self, queryset):
return queryset.filter(project=get_permissible_project(view=self))
def perform_create(self, serializer):
project = get_permissible_project(view=self)
code_reference = get_project_latest_code_reference(project=project)
return serializer.save(user=self.request.user,
project=project,
code_reference=code_reference)
def get_object(self):
return get_object_or_404(Repo, project=get_permissible_project(view=self))
def perform_create(self, serializer):
return serializer.save(user=self.request.user, project=get_permissible_project(view=self))
def filter_queryset(self, queryset):
return queryset.filter(user=self.request.user,
project=get_permissible_project(view=self))
def get_experiment(self):
# Get project and check access
self.project = get_permissible_project(view=self)
sequence = self.kwargs['experiment_sequence']
self.experiment = get_object_or_404(Experiment, project=self.project, sequence=sequence)
return self.experiment
def filter_queryset(self, queryset):
return queryset.filter(project=get_permissible_project(view=self))
def perform_create(self, serializer):
instance = serializer.save(user=self.request.user,
project=get_permissible_project(view=self))
auditor.record(event_type=EXPERIMENT_CREATED, instance=instance)
def get_object(self):
return get_object_or_404(Repo,
project=get_permissible_project(view=self))
def filter_queryset(self, queryset):
project = get_permissible_project(view=self)
auditor.record(event_type=PROJECT_BUILDS_VIEWED,
instance=project,
actor_id=self.request.user.id)
return queryset.filter(project=project)
