def get_object(self):
if self.request.method == 'GET':
obj = get_object_with_permissions(self.request, Task,
self.kwargs['pk'],
'tasks.view_task')
else:
obj = get_object_with_permissions(self.request, Task,
self.kwargs['pk'],
'projects.view_project')
return obj
def get_serializer_context(self):
context = super(TaskListAPI, self).get_serializer_context()
project_id = self.request.data.get('project')
if project_id:
context['project'] = get_object_with_permissions(
self.request, Project, project_id,
TaskAPIChangeProjectPermission.perm)
return context
def get_serializer_context(self):
project_id = self.kwargs.get('pk')
if project_id:
project = get_object_with_permissions(self.request, Project,
project_id,
'projects.change_project')
else:
project = None
return {'project': project, 'user': self.request.user}
def post(self, request, *args, **kwargs):
ImportStorageClass = self.serializer_class.Meta.model
storage = get_object_with_permissions(
request, ImportStorageClass, self.kwargs['pk'], StorageAPIBasePermission.perm)
# check connectivity & access, raise an exception if not satisfied
storage.validate_connection()
storage.sync()
storage.refresh_from_db()
return Response(self.serializer_class(storage).data)
def task_page(request, pk):
org_pk = get_organization_from_request(request)
org = get_object_with_permissions(request, Organization, org_pk,
'organizations.view_organization')
project = get_object_with_check_and_log(request, Project, pk=pk)
response = {'project': project, 'version': get_short_version()}
response.update(find_editor_files())
return render(request, 'data_manager/data.html', response)
def create(self, request, *args, **kwargs):
start = time.time()
commit_to_project = bool_from_request(request.query_params,
'commit_to_project', True)
# check project permissions
project = get_object_with_permissions(self.request, Project,
self.kwargs['pk'],
'projects.change_project')
# upload files from request, and parse all tasks
parsed_data, file_upload_ids, could_be_tasks_lists, found_formats, data_columns = load_tasks(
request, project)
if commit_to_project:
# Immediately create project tasks and update project states and counters
tasks, serializer = self._save(parsed_data)
task_count = len(tasks)
annotation_count = len(serializer.db_annotations)
prediction_count = len(serializer.db_predictions)
# Update tasks states if there are related settings in project
# after bulk create we can bulk update tasks stats with
# flag_update_stats=True but they are already updated with signal in same transaction
# so just update tasks_number_changed
project.update_tasks_states(
maximum_annotations_changed=False,
overlap_cohort_percentage_changed=False,
tasks_number_changed=True)
logger.info('Tasks bulk_update finished')
project.summary.update_data_columns(parsed_data)
# TODO: project.summary.update_created_annotations_and_labels
else:
# Do nothing - just output file upload ids for further use
task_count = len(parsed_data)
annotation_count = None
prediction_count = None
duration = time.time() - start
return Response(
{
'task_count': task_count,
'annotation_count': annotation_count,
'prediction_count': prediction_count,
'duration': duration,
'file_upload_ids': file_upload_ids,
'could_be_tasks_list': could_be_tasks_lists,
'found_formats': found_formats,
'data_columns': data_columns
},
status=status.HTTP_201_CREATED)
def get(self, request, *args, **kwargs):
project = get_object_with_permissions(request, Project, kwargs['pk'], 'projects.change_project')
title = request.GET.get('title', '')
title = project.title if not title else title
title = generate_unique_title(request.user, title)
duplicate_tasks = bool_from_request(request.GET, 'duplicate_tasks', default=False)
try:
project = duplicate_project(project, title, duplicate_tasks, request.user)
except Exception as e:
raise ValueError(f"Can't duplicate project: {e}")
return Response({'id': project.pk}, status=status.HTTP_200_OK)
def delete(self, request, *args, **kwargs):
project = get_object_with_permissions(self.request, Project,
self.kwargs['pk'],
'projects.view_project')
ids = self.request.data.get('file_upload_ids')
if ids is None:
deleted, _ = FileUpload.objects.filter(project=project).delete()
elif isinstance(ids, list):
deleted, _ = FileUpload.objects.filter(project=project,
id__in=ids).delete()
else:
raise ValueError(
'"file_upload_ids" parameter must be a list of integers')
return Response({'deleted': deleted}, status=status.HTTP_200_OK)
def get_queryset(self):
project = get_object_with_permissions(self.request, Project,
self.kwargs.get('pk', 0),
'projects.view_project')
if project.is_draft:
# If project is in draft state, we return all uploaded files, ignoring queried ids
logger.debug(
f'Return all uploaded files for draft project {project}')
return FileUpload.objects.filter(project_id=project.id,
user=self.request.user)
# If requested in regular import, only queried IDs are returned to avoid showing previously imported
ids = json.loads(self.request.query_params.get('ids', '[]'))
logger.debug(f'File Upload IDs found: {ids}')
return FileUpload.objects.filter(project_id=project.id,
id__in=ids,
user=self.request.user)
def get(self, request, *args, **kwargs):
project = get_object_with_permissions(request, Project, kwargs['pk'],
ProjectAPIBasePermission.perm)
export_type = request.GET.get('exportType')
is_labeled = not bool_from_request(request.GET, 'download_all_tasks',
False)
logger.debug('Get tasks')
query = Task.objects.filter(project=project, is_labeled=is_labeled)
logger.debug('Serialize tasks for export')
tasks = ExportDataSerializer(query, many=True).data
logger.debug('Prepare export files')
export_stream, content_type, filename = DataExport.generate_export_file(
project, tasks, export_type, request.GET)
response = HttpResponse(File(export_stream), content_type=content_type)
response[
'Content-Disposition'] = 'attachment; filename="%s"' % filename
response['filename'] = filename
return response
def post(self, request, *args, **kwargs):
# get the cancelled task
task = get_object_with_permissions(self.request, Task,
self.kwargs['pk'],
'tasks.change_task')
# validate data from annotation
annotation = AnnotationSerializer(data=request.data)
annotation.is_valid(raise_exception=True)
# set annotator last activity
user = request.user
user.activity_at = timezone.now()
user.save()
# serialize annotation, update task and save
com = annotation.save(completed_by=user, was_cancelled=True, task=task)
task.annotations.add(com)
task.save()
return Response(annotation.data, status=status.HTTP_200_OK)
def create(self, request, *args, **kwargs):
start = time.time()
files_as_tasks_list = bool_from_request(request.data,
'files_as_tasks_list', True)
# check project permissions
project = get_object_with_permissions(self.request, Project,
self.kwargs['pk'],
'projects.change_project')
file_upload_ids = self.request.data.get('file_upload_ids')
tasks, found_formats, data_columns = FileUpload.load_tasks_from_uploaded_files(
project, file_upload_ids, files_as_tasks_list=files_as_tasks_list)
with transaction.atomic():
project.remove_tasks_by_file_uploads(file_upload_ids)
tasks, serializer = self._save(tasks)
duration = time.time() - start
# Update task states if there are related settings in project
# after bulk create we can bulk update task stats with
# flag_update_stats=True but they are already updated with signal in same transaction
# so just update tasks_number_changed
project.update_tasks_states(maximum_annotations_changed=False,
overlap_cohort_percentage_changed=False,
tasks_number_changed=True)
logger.info('Tasks bulk_update finished')
project.summary.update_data_columns(tasks)
# TODO: project.summary.update_created_annotations_and_labels
return Response(
{
'task_count': len(tasks),
'annotation_count': len(serializer.db_annotations),
'prediction_count': len(serializer.db_predictions),
'duration': duration,
'file_upload_ids': file_upload_ids,
'found_formats': found_formats,
'data_columns': data_columns
},
status=status.HTTP_201_CREATED)
def delete(self, request, *args, **kwargs):
project = get_object_with_permissions(self.request, Project,
self.kwargs['pk'],
'projects.change_project')
Task.objects.filter(project=project).delete()
return Response(status=204)
def get_queryset(self):
project = get_object_with_permissions(self.request, Project,
self.kwargs.get('pk', 0),
'projects.view_project')
tasks = Task.objects.filter(project=project)
return paginator(tasks, self.request)
def get(self, request, *args, **kwargs):
project = get_object_with_permissions(request, Project, kwargs['pk'],
ProjectAPIBasePermission.perm)
formats = DataExport.get_export_formats(project)
return Response(formats)
def get_queryset(self):
task = get_object_with_permissions(self.request, Task,
self.kwargs.get('pk', 0),
'tasks.view_task')
return Annotation.objects.filter(
Q(task=task) & Q(was_cancelled=False)).order_by('pk')
def get_object(self):
return get_object_with_permissions(self.request, Annotation,
self.kwargs['pk'],
'annotations.view_annotation')
