def run_validation(self, data=empty): try: self.validate_data(data['data']) except self.Meta.ValidationError as error: raise ValidationError(format_error_message(error)) except MultiValueDictKeyError as error: if 'data' in str(error): msg = format_error_message('Data key not present') raise ValidationError(msg) raise ValidationError(format_error_message(error)) # only validate data updatint, not creating if (self.context['request'].method != 'POST'): try: try: fields_to_validate = self.Meta.metadata_validation_fields except AttributeError: fields_to_validate = None if fields_to_validate: validate_metadata_data( data['metadata'], fields_to_validate=fields_to_validate) except MetadataValidationError as error: raise ValidationError(format_error_message(error)) return data
def serialize_observation_images_from_request(request, tmp_extract_dir): conf = None if 'multipart/form-data' in request.content_type: create_observation_units = request.data.get(CREATE_OBSERVATION_UNITS, None) zip_file = request.FILES['file'].file logger.debug(type(request.FILES['file'])) logger.debug(request.FILES['file'].name) logger.debug(dir(request.FILES['file'])) logger.debug(type(zip_file)) logger.debug(dir(zip_file)) try: data = list( extract_files_from_zip(zip_file, extract_dir=tmp_extract_dir, make_group_writable=True)) except ValueError as error: raise ValidationError(format_error_message(error)) conf = { CREATE_OBSERVATION_UNITS: create_observation_units, 'extraction_dir': tmp_extract_dir } else: msg = 'Request must be a multipart/form-data request with at least a zip file' raise ValidationError(format_error_message(msg)) return data, conf
def bulk(self, request): action = request.method # prev_time = time() data = request.data if 'multipart/form-data' in request.content_type: try: fhand = request.FILES['file'].file except KeyError: msg = 'could not found the file' raise ValidationError(format_error_message(msg)) try: data = serialize_entity_from_excel(fhand, self.Struct) except ValueError as error: msg = 'Could not read file: {}'.format(error) raise ValidationError(format_error_message(msg)) else: data = request.data if action == 'POST': serializer = self.get_serializer(data=data, many=True) serializer.is_valid(raise_exception=True) self.perform_create(serializer) return Response({'task_id': serializer.instance.id}, status=status.HTTP_200_OK, headers={})
def update_study_in_db(validated_data, instance, user): study_struct = StudyStruct(api_data=validated_data) if (study_struct.name != instance.name): msg = 'Can not change id in an update operation' raise ValidationError(format_error_message(msg)) group_belong_to_user = bool(user.groups.filter(name=study_struct.metadata.group).count()) if not group_belong_to_user and not is_user_admin(user): msg = 'Can not change ownership if group does not belong to you : {}' msg = msg.format(study_struct.metadata.group) raise ValidationError(format_error_message(msg)) try: group = Group.objects.get(name=study_struct.metadata.group) except Group.DoesNotExist: msg = 'Provided group does not exist in db: {}' msg = msg.format(study_struct.metadata.group) raise ValidationError(format_error_message(msg)) instance.description = study_struct.description instance.is_active = study_struct.is_active instance.group = group instance.is_public = study_struct.metadata.is_public instance.data = study_struct.data instance.start_date = study_struct.start_date instance.end_date = study_struct.end_date instance.save() return instance
def update_accessionset_in_db(payload, instance, user): struct = AccessionSetStruct(payload) allowed_changes = set(['is_public', 'group']) changes_in_payload = set() if instance.institute.code != struct.institute_code: changes_in_payload.add('institute') if instance.accessionset_number != struct.accessionset_number: changes_in_payload.add('accessionset_number') db_accessions = set([(accession.institute.code, accession.germplasm_number) for accession in instance.accessions.all()]) payload_accessions = set([(accession[INSTITUTE_CODE], accession[GERMPLASM_NUMBER]) for accession in struct.accessions]) are_payload_accessions_diff = bool( db_accessions.difference(payload_accessions)) if are_payload_accessions_diff: changes_in_payload.add('accessions') if instance.is_public != struct.metadata.is_public: changes_in_payload.add('is_public') if instance.group != struct.metadata.group: changes_in_payload.add('group') not_allowed_changes = changes_in_payload.difference(allowed_changes) if not_allowed_changes: msg = "you are not allowed to change accessionsets's: {}" msg = msg.format(','.join(not_allowed_changes)) raise ValidationError(format_error_message(msg)) group_belong_to_user = bool( user.groups.filter(name=struct.metadata.group).count()) if not group_belong_to_user and not is_user_admin(user): msg = 'Can not change ownership if group does not belong to you : {}' msg = msg.format(struct.metadata.group) raise ValidationError(format_error_message(msg)) try: group = Group.objects.get(name=struct.metadata.group) except Group.DoesNotExist: msg = 'Provided group does not exist in db: {}' msg = msg.format(struct.metadata.group) raise ValidationError(format_error_message(msg)) instance.is_public = struct.metadata.is_public instance.owner = group instance.save() return instance
def retrieve(self, request, task_id): try: task_id = self.filter_by_permission([task_id], user=request.user)[0] except IndexError: return Response(format_error_message('Task does not exists'), status=status.HTTP_404_NOT_FOUND) try: task = TaskResultGetter(task_id) except TaskDoesNotExistError: return Response(format_error_message('Task does not exists'), status=status.HTTP_404_NOT_FOUND) return Response(task.data, status=status.HTTP_200_OK)
def _check_observation_variable_in_filter(self): if 'observation_variable' not in self.data.keys(): msg = 'Can not use value_range filter if not filtered by observation variable' raise ValidationError(format_error_message(msg)) try: observation_variable = ObservationVariable.objects.get( name=self.data['observation_variable']) except ObservationVariable.DoesNotExist: msg = 'Used observation_variable to filter does not exist' raise ValidationError(format_error_message(msg)) if observation_variable.scale.data_type.name not in ('Numerical', ): msg = "Used observation_variable's data type is not numeric" raise ValidationError(format_error_message(msg))
def _populate_with_instance(self, instance, fields): self.metadata.group = instance.group.name self.metadata.is_public = instance.is_public accepted_fields = STUDY_ALLOWED_FIELDS if (fields is not None and len(set(fields).intersection(accepted_fields)) == 0): msg = format_error_message('Passed fields are not allowed') raise ValidationError(msg) if fields is None or STUDY_NAME in fields: self.name = instance.name if fields is None or STUDY_DESCRIPTION in fields: self.description = instance.description if instance.is_active is not None and fields is not None and STUDY_ACTIVE in fields: self.is_active = instance.is_active if fields is None or START_DATE in fields: if instance.start_date is not None: self.start_date = instance.start_date.strftime('%Y/%m/%d') else: self.start_date = None if fields is None or END_DATE in fields: if instance.end_date is not None: self.end_date = instance.end_date.strftime('%Y/%m/%d') else: self.end_date = None if fields is None or LOCATION in fields: self.location = instance.data.get(LOCATION, None) if fields is None or CONTACT in fields: self.contact = instance.data.get(CONTACT, None) if fields is None or PROJECT_NAME in fields: self.project_name = instance.data.get(PROJECT_NAME, None) if fields is None or SEASON in fields: self.season = instance.data.get(SEASON, None) if fields is None or INSTITUTION in fields: self.institution = instance.data.get(INSTITUTION, None)
def bulk(self, request): action = request.method # prev_time = time() data = request.data if 'multipart/form-data' in request.content_type: try: fhand = request.FILES['file'].file data_source_code = request.data['data_source_code'] data_source_kind = request.data['data_source_kind'] except KeyError: msg = 'Could not found excel file or data_store info' raise ValidationError(msg) try: data = serialize_accessions_from_excel(fhand, data_source_code, data_source_kind) except AccessionValidationError as error: raise ValidationError(format_error_message(error)) else: data = request.data # prev_time = calc_duration('csv to json', prev_time) if action == 'POST': serializer = self.get_serializer(data=data, many=True) # prev_time = calc_duration('get_serializer', prev_time) try: serializer.is_valid(raise_exception=True) except BaseException as errors: errors = [error for error in errors.detail if error] raise ValidationError(errors) self.perform_create(serializer) # prev_time = calc_duration('perform_create', prev_time) return Response({'task_id': serializer.instance.id}, status=status.HTTP_200_OK, headers={})
def update(self, instance, validated_data): user = None request = self.context.get("request") if request and hasattr(request, "user"): user = request.user if user is None: error = 'User must be logged' raise ValidationError(format_error_message(error)) if not user.groups.exists(): error = 'User must belong to a group' raise ValidationError(format_error_message(error)) try: return update_institute_in_db(validated_data, instance) except ValueError as error: raise ValidationError(format_error_message(error))
def toggle_public(self, request): try: is_public = request.data['public'] search_params = request.data['search_params'] except KeyError: msg = 'public and search_params keys are mandatory to toogle publc state' raise ValidationError(format_error_message(msg)) queryset = self.filter_queryset(self.get_queryset()) filterset = self.filter_class(search_params, queryset) filterset.qs.update(is_public=is_public) msg = "{} {} made {}".format(filterset.qs.count(), self.serializer_class.data_type, 'public' if is_public else 'private') return Response(format_error_message(msg), status=status.HTTP_200_OK)
def _populate_with_instance(self, instance, fields): accepted_fields = OBSERVATION_ALLOWED_FIELDS if (fields is not None and not set(fields).intersection(accepted_fields)): msg = format_error_message('Passed fields are not allowed') raise ValidationError(msg) if ((fields is None or OBSERVATION_ID in fields) and instance.observation_id is not None): self.observation_id = instance.observation_id if ((fields is None or OBSERVATION_VARIABLE in fields) and instance.observation_unit is not None): self.observation_variable = instance.observation_variable.name if ((fields is None or OBSERVATION_UNIT in fields) and instance.observation_unit is not None): self.observation_unit = instance.observation_unit.name if (fields is None or VALUE in fields) and instance.value is not None: self.value = instance.value if (fields is None or OBSERVER in fields) and instance.observer is not None: self.observer = instance.observer if ((fields is None or OBSERVATION_CREATION_TIME in fields) and instance.creation_time is not None): self.creation_time = instance.creation_time.strftime(DATETIME_FORMAT) if ((fields is None or OBSERVATION_STUDY in fields) and instance.observation_unit is not None and instance.observation_unit.study is not None): self.study = instance.observation_unit.study.name if ((fields is None or ACCESSION in fields) and instance.observation_unit is not None and instance.observation_unit.accession is not None): self.accession = {INSTITUTE_CODE: instance.observation_unit.accession.institute.code, GERMPLASM_NUMBER: instance.observation_unit.accession.germplasm_number} if instance.beauty_value and fields and VALUE_BEAUTY in fields: self.beauty_value = instance.beauty_value
def check_before_remove(self, instance): if Observation.objects.filter( observation_unit__accession=instance).count(): msg = 'Can not delete this accession because there are observations' msg += ' associated to it' return Response(format_error_message(msg), status=status.HTTP_400_BAD_REQUEST)
def create(self, validated_data): user = None request = self.context.get("request") if request and hasattr(request, "user"): user = request.user if user is None: error = 'User must be logged' raise ValidationError(format_error_message(error)) if not user.groups.exists(): error = 'User must belong to a group' raise ValidationError(format_error_message(error)) async_result = create_institutes_task.delay(validated_data) # async_result = wait_func.delay(5) add_task_to_user(user, async_result) return async_result
def bulk(self, request): action = request.method # prev_time = time() with tempfile.TemporaryDirectory(dir=TMP_DIR) as tmp_dir: extract_dir = tmp_dir if 'multipart/form-data' in request.content_type: create_observation_units = request.data.get( CREATE_OBSERVATION_UNITS, None) fhand = request.FILES['file'] logger.debug('1') with tempfile.NamedTemporaryFile(mode='wb', suffix='.zip', dir=TMP_DIR) as destination: for chunk in fhand.chunks(): destination.write(chunk) destination.flush() subprocess.run(['chmod', '777', destination.name]) task = extract_files_from_zip.apply_async( args=[destination.name, extract_dir]) try: data = task.wait() add_task_to_user(self.request.user, task) except ValueError as error: raise ValidationError(format_error_message(str(error))) else: msg = 'Request must be a multipart/form-data request ' msg += 'with at least a zip file' raise ValidationError(format_error_message(msg)) self.conf = { CREATE_OBSERVATION_UNITS: create_observation_units, 'extraction_dir': extract_dir } if action == 'POST': serializer = self.get_serializer(data=data, many=True) serializer.is_valid(raise_exception=True) self.perform_create(serializer) return Response({'task_id': serializer.instance.id}, status=status.HTTP_200_OK, headers={})
def delete(self, request, task_id): try: task_id = self.filter_by_permission([task_id], user=request.user)[0] except IndexError: return Response(format_error_message('You dont have permissions'), status=status.HTTP_403_FORBIDDEN) task = TaskResultGetter(task_id) task.delete() return Response({}, status=status.HTTP_204_NO_CONTENT)
def update_observation_unit_in_db(validated_data, instance, user): struct = ObservationUnitStruct(api_data=validated_data) if struct.name != instance.name: msg = 'Can not change id in an update operation' raise ValidationError(format_error_message(msg)) try: study = Study.objects.get(name=struct.study) except Study.DoesNotExist: msg = 'The study has not been added yet to the database: ' + struct.study raise ValueError(msg) institute_code = struct.accession[INSTITUTE_CODE] germplasm_number = struct.accession[GERMPLASM_NUMBER] try: accession = Accession.objects.get(institute__code=institute_code, germplasm_number=germplasm_number) except Accession.DoesNotExist: msg = 'The given accessoin is not in db: {} {}'.format(institute_code, germplasm_number) raise ValueError(msg) study_belongs_to_user = bool(user.groups.filter(name=study.group.name).count()) if not study_belongs_to_user and not is_user_admin(user): msg = 'Can not change ownership if study does not belong to you : {}' msg = msg.format(study.group.name) raise ValidationError(format_error_message(msg)) instance.accession = accession instance.level = struct.level instance.replicate = struct.replicate instance.study = study instance.save() plants = [] if struct.plants is None else struct.plants instance.plant_set.clear() _add_plants_to_observation_unit(plants, user, instance) return instance
def update_scale_in_db(api_data, instance, _): try: struct = ScaleStruct(api_data) except ScaleValidationError as error: print(error) raise try: data_type = ScaleDataType.objects.get(name=struct.data_type) except ScaleDataType.DoesNotExist: raise ValidationError( format_error_message('data type not valid: ' + struct.data_type)) if instance.description != struct.description: instance.description = struct.description if instance.data_type != data_type: instance.data_type = data_type if instance.max != struct.max: instance.max = struct.max if instance.min != struct.min: instance.min = struct.min if instance.decimal_places != struct.decimal_places: instance.decimal_places = struct.decimal_places instance.save() if struct.data_type in ('Cardinal', 'Ordinal', 'Nominal'): ScaleCategory.objects.filter(scale=instance).delete() for index, category in enumerate(struct.valid_values): value = category['value'] description = category['description'] try: ScaleCategory.objects.create(scale=instance, value=value, description=description, rank=index) except IntegrityError: msg = 'Can not repeate value or description in the same scale' raise ValidationError(format_error_message(msg)) return instance
def list(self, request, *args, **kwargs): queryset = self.filter_queryset(self.get_queryset()) page = self.paginate_queryset(queryset) if page is not None: serializer = self.get_serializer(page, many=True) try: data = list(serializer.data) except ValidationError as error: errors = [e for e in error.detail['detail']] return Response(format_error_message(errors), status=status.HTTP_400_BAD_REQUEST) return self.get_paginated_response(data) serializer = self.get_serializer(queryset, many=True) try: data = list(serializer.data) except ValidationError as error: errors = [e for e in error.detail['detail']] return Response(format_error_message(errors), status=status.HTTP_400_BAD_REQUEST) return Response(serializer.data)
def year_filter(self, queryset, _, value): try: if len(value) != 4: raise ValueError('Year must be a string of 4 digits') year = int(value) except ValueError as error: raise ValidationError(format_error_message(error)) year_start = date(year=year, month=1, day=1) year_end = date(year=year, month=12, day=31) return queryset.filter( Q(start_date__gte=year_start, start_date__lte=year_end) | Q(end_date__gte=year_start, end_date__lte=year_end) | Q(start_date__lte=year_start, end_date__gte=year_end))
def create_scale_in_db(api_data, user): try: struct = ScaleStruct(api_data) except ScaleValidationError as error: print(error) raise try: data_type = ScaleDataType.objects.get(name=struct.data_type) except ScaleDataType.DoesNotExist: raise ValidationError('data type not valid: ' + struct.data_type) group = user.groups.first() with transaction.atomic(): try: scale = Scale.objects.create(name=struct.name, description=struct.description, data_type=data_type, decimal_places=struct.decimal_places, min=struct.min, max=struct.max, group=group) except IntegrityError: msg = 'This scale already exists in db: {}'.format(struct.name) raise ValueError(format_error_message(msg)) if struct.data_type in (ORDINAL, NOMINAL): for index, category in enumerate(struct.valid_values): value = category['value'] description = category['description'] try: ScaleCategory.objects.create(scale=scale, value=value, description=description, rank=index) except IntegrityError: msg = 'Can not repeate value or description in the same scale' raise ValidationError(format_error_message(msg)) return scale
def _populate_with_instance(self, instance, fields): self.metadata.group = instance.group.name self.metadata.is_public = instance.is_public accepted_fields = [INSTITUTE_CODE, GERMPLASM_NUMBER, IS_AVAILABLE, CONSTATUS, PASSPORTS, 'genera', 'countries', 'longitude', 'latitude', 'species', IN_NUCLEAR_COLLECTION] if fields is not None and not set(fields).issubset(accepted_fields): msg = format_error_message('Passed fields are not allowed') raise ValidationError(msg) if fields is None or INSTITUTE_CODE in fields: self.institute_code = instance.institute.code if fields is None or GERMPLASM_NUMBER in fields: self.germplasm_number = instance.germplasm_number if (instance.is_available is not None and (fields is None or IS_AVAILABLE in fields)): self.is_available = instance.is_available if (instance.conservation_status is not None and (fields is None or CONSTATUS in fields)): self.conservation_status = instance.conservation_status if (instance.in_nuclear_collection is not None and (fields is None or IN_NUCLEAR_COLLECTION in fields)): self.in_nuclear_collection = instance.in_nuclear_collection if instance.genera and fields and 'genera' in fields: self.genera = instance.genera if instance.species and fields and 'species' in fields: self.species = instance.species if instance.countries and fields and 'countries' in fields: self.countries = instance.countries if fields is None or (PASSPORTS in fields or 'latitude' in fields or 'longitude' in fields): passports = [] passport_fields = [] if fields and 'latitude' in fields: passport_fields.append('latitude') if fields and 'longitude' in fields: passport_fields.append('longitude') if not passport_fields: passport_fields = None for passport_instance in instance.passports.all(): passport_struct = PassportStruct(instance=passport_instance, fields=passport_fields) passports.append(passport_struct) self.passports = passports
def update_observation_variable_in_db(validated_data, instance, user): struct = ObservationVariableStruct(api_data=validated_data) if struct.name != instance.name: msg = 'Can not change id in an update operation' raise ValidationError(format_error_message(msg)) group_belong_to_user = bool(user.groups.filter(name=struct.metadata.group).count()) if not group_belong_to_user and not is_user_admin(user): msg = 'Can not change ownership if group does not belong to you : {}' msg = msg.format(struct.metadata.group) raise ValidationError(format_error_message(msg)) try: group = Group.objects.get(name=struct.metadata.group) except Group.DoesNotExist: msg = 'Provided group does not exist in db: {}' msg = msg.format(struct.metadata.group) raise ValidationError(format_error_message(msg)) try: scale = Scale.objects.get(name=struct.scale) except Scale.DoesNotExist: raise ValidationError('Scale not valid: ' + struct.scale) try: trait = Trait.objects.get(name=struct.trait) except Trait.DoesNotExist: raise ValidationError('Trait not valid: ' + struct.scale) instance.description = struct.description instance.trait = trait instance.group = group instance.method = struct.method instance.scale = scale instance.save() return instance
def _populate_with_instance(self, instance, fields): accepted_fields = TRAIT_ALLOWED_FIELDS if (fields is not None and len(set(fields).intersection(accepted_fields)) == 0): msg = format_error_message('Passed fields are not allowed') raise ValidationError(msg) if fields is None or TRAIT_NAME in fields: self.name = instance.name if fields is None or TRAIT_DESCRIPTION in fields: self.description = instance.description if fields is None or ONTOLOGY_NAME in fields: self.ontology = instance.ontology if fields is None or ONTOLOGY_ID in fields: self.ontology_id = instance.ontology_id
def update_accession_in_db(validated_data, instance, user): accession_struct = AccessionStruct(api_data=validated_data) if (accession_struct.institute_code != instance.institute.code or accession_struct.germplasm_number != instance.germplasm_number): msg = 'Can not change id in an update operation' raise ValidationError(format_error_message(msg)) group_belong_to_user = bool(user.groups.filter(name=accession_struct.metadata.group).count()) if not group_belong_to_user and not is_user_admin(user): msg = 'Can not change ownership if group does not belong to you : {}' msg = msg.format(accession_struct.metadata.group) raise ValidationError(format_error_message(msg)) if not is_user_admin(user) and instance.is_public != accession_struct.metadata.is_public: msg = 'User can not make accession public or private' raise ValidationError(format_error_message(msg)) try: group = Group.objects.get(name=accession_struct.metadata.group) except Group.DoesNotExist: msg = 'Provided group does not exist in db: {}' msg = msg.format(accession_struct.metadata.group) raise ValidationError(format_error_message(msg)) with transaction.atomic(): instance.is_available = accession_struct.is_available instance.conservation_status = accession_struct.conservation_status instance.in_nuclear_collection = accession_struct.in_nuclear_collection instance.group = group instance.is_public = accession_struct.metadata.is_public instance.passports.all().delete() for passport_struct in accession_struct.passports: _create_passport_in_db(passport_struct, instance) instance.save() return instance
def update(self, instance, validated_data): instances = [] errors = [] with transaction.atomic(): for instance, payload in zip(instance, validated_data): try: instances.append(update_institute_in_db(payload, instance)) except ValueError as error: errors.append(error) except IntegrityError as error: errors.append(error) if errors: raise ValidationError(format_error_message(errors)) else: return instances
def bulk(self, request): action = request.method # prev_time = time() try: data, conf = serialize_observations_from_request(request) except ValueError as error: msg = 'Could not read file: {}'.format(error) raise ValidationError(format_error_message(msg)) self.conf = conf if action == 'POST': serializer = self.get_serializer(data=data, many=True) serializer.is_valid(raise_exception=True) self.perform_create(serializer) return Response({'task_id': serializer.instance.id}, status=status.HTTP_200_OK, headers={})
def create_by_obo(self, request): try: fhand = TextIOWrapper(request.FILES['obo'].file, encoding='utf-8') except KeyError: msg = 'could not found obo file' raise ValidationError(format_error_message(msg)) ontology = parse_obo(fhand) data = transform_to_trait_entity_format(ontology) serializer = self.get_serializer(data=data, many=True) serializer.is_valid(raise_exception=True) self.perform_create(serializer) return Response({'task_id': serializer.instance.id}, status=status.HTTP_200_OK, headers={})
def _populate_with_instance(self, instance, fields): accepted_fields = SEED_REQUEST_ALLOWED_FIELDS if (fields is not None and len(set(fields).intersection(accepted_fields)) == 0): msg = format_error_message('Passed fields are not allowed') raise ValidationError(msg) if fields is None or REQUEST_UID in fields: self.request_uid = instance.request_uid if fields is None or REQUESTER_NAME in fields: self.requester_name = instance.requester_name if fields is None or REQUESTER_TYPE in fields: self.requester_type = instance.requester_type if fields is None or REQUESTER_INSTITUTION in fields: self.requester_institution = instance.requester_institution if fields is None or REQUESTER_ADDRESS in fields: self.requester_address = instance.requester_address if fields is None or REQUESTER_CITY in fields: self.requester_city = instance.requester_city if fields is None or REQUESTER_POSTAL_CODE in fields: self.requester_postal_code = instance.requester_postal_code if fields is None or REQUESTER_REGION in fields: self.requester_region = instance.requester_region if fields is None or REQUESTER_COUNTRY in fields: self.requester_country = instance.requester_country.code if fields is None or REQUESTER_EMAIL in fields: self.requester_email = instance.requester_email if fields is None or REQUEST_DATE in fields: self.request_date = instance.request_date.strftime('%Y/%m/%d') if fields is None or REQUEST_AIM in fields: self.request_aim = instance.request_aim if fields is None or REQUEST_COMMENTS in fields: self.request_comments = instance.request_comments if fields is None or REQUESTED_ACCESSIONS in fields: accessions = [] for accession_instance in instance.requested_accessions.all(): accessions.append({ INSTITUTE_CODE: accession_instance.institute.code, GERMPLASM_NUMBER: accession_instance.germplasm_number }) self.requested_accessions = accessions
def __init__(self, *args, **kwargs): # Don't pass the 'fields' arg up to the superclass fields = kwargs.pop('fields', None) # Instantiate the superclass normally super(serializers.ModelSerializer, self).__init__(*args, **kwargs) if fields is not None: # Drop any fields that are not specified in the `fields` argument. if not set(fields).issubset(self.fields): raise ValidationError( format_error_message('Passed fields are not allowed')) allowed = set(fields) existing = set(self.fields) for field_name in existing - allowed: self.fields.pop(field_name) else: self.fields.pop('stats_by_institute') self.fields.pop('stats_by_taxa')