def get_editing_dataset(self, request): # Generate a pseudo-return when editing or creating a dataset. # Do not include the settings field; this will be set from the # input-form. Should approximately mirror the Visual API from rest-framework. dose_units = None try: dose_units = int(request.POST.get("dose_units")) except (TypeError, ValueError) as e: # TypeError if dose_units is None; ValueError if dose_units is "" pass data = { "title": request.POST.get("title"), "slug": request.POST.get("slug"), "caption": request.POST.get("caption"), "dose_units": dose_units, "created": datetime.now().isoformat(), "last_updated": datetime.now().isoformat() } data["endpoints"] = [ SerializerHelper.get_serialized(e, json=False) for e in self.get_endpoints(request) ] data["studies"] = [ SerializerHelper.get_serialized(s, json=False) for s in self.get_studies(request) ] return json.dumps(data)
def get_docx_template_context(assessment, queryset): """ Given a queryset of endpoints, invert the cached results to build a top-down data hierarchy from study to endpoint. We use this approach since our endpoints are cached, so while it may require more computation, its close to free on database access. """ endpoints = [ SerializerHelper.get_serialized(obj, json=False) for obj in queryset ] studies = {} # flip dictionary nesting for thisEp in endpoints: thisAG = thisEp["animal_group"] thisExp = thisEp["animal_group"]["experiment"] thisStudy = thisEp["animal_group"]["experiment"]["study"] study = studies.get(thisStudy["id"]) if study is None: study = thisStudy study["exps"] = {} studies[study["id"]] = study exp = study["exps"].get(thisExp["id"]) if exp is None: exp = thisExp exp["ags"] = {} study["exps"][exp["id"]] = exp ag = exp["ags"].get(thisAG["id"]) if ag is None: ag = thisAG ag["eps"] = {} exp["ags"][ag["id"]] = ag ep = ag["eps"].get(thisEp["id"]) if ep is None: ep = thisEp ag["eps"][ep["id"]] = ep # convert value dictionaries to lists studies = sorted(list(studies.values()), key=lambda obj: (obj["short_citation"].lower())) for study in studies: study["exps"] = sorted(list(study["exps"].values()), key=lambda obj: (obj["name"].lower())) for exp in study["exps"]: exp["ags"] = sorted(list(exp["ags"].values()), key=lambda obj: (obj["name"].lower())) for ag in exp["ags"]: ag["eps"] = sorted(list(ag["eps"].values()), key=lambda obj: (obj["name"].lower())) return { "assessment": AssessmentSerializer().to_representation(assessment), "studies": studies }
def to_representation(self, instance): ret = super().to_representation(instance) ret['url_update'] = instance.get_update_url() ret['url_delete'] = instance.get_delete_url() ret["endpoints"] = [ SerializerHelper.get_serialized(d, json=False) for d in instance.get_endpoints() ] ret["studies"] = [ SerializerHelper.get_serialized(d, json=False) for d in instance.get_studies() ] return ret
def invalidate_caches_study(sender, instance, **kwargs): Model = None filters = {} if instance.study_type == 0: Model = get_model('animal', 'Endpoint') filters["animal_group__experiment__study"] = instance.id elif instance.study_type == 1: Model = get_model('epi', 'AssessedOutcome') filters["exposure__study_population__study"] = instance.id elif instance.study_type == 4: Model = get_model('epi', 'MetaResult') filters["protocol__study"] = instance.id Study.delete_caches([instance.id]) if Model: ids = Model.objects.filter(**filters).values_list('id', flat=True) SerializerHelper.delete_caches(Model, ids)
def invalidate_caches_study(sender, instance, **kwargs): Model = None filters = {} if instance.study_type == 0: Model = get_model("animal", "Endpoint") filters["animal_group__experiment__study"] = instance.id elif instance.study_type == 1: Model = get_model("epi", "AssessedOutcome") filters["exposure__study_population__study"] = instance.id elif instance.study_type == 4: Model = get_model("epi", "MetaResult") filters["protocol__study"] = instance.id Study.delete_caches([instance.id]) if Model: ids = Model.objects.filter(**filters).values_list("id", flat=True) SerializerHelper.delete_caches(Model, ids)
def get_docx_template_context(cls, assessment, queryset): studies = [ SerializerHelper.get_serialized(study, json=False) for study in queryset ] return { "assessment": AssessmentSerializer().to_representation(assessment), "studies": studies }
def invalidate_caches_study(sender, instance, **kwargs): Model = None filters = {} if instance.study_type == 0: Model = apps.get_model('animal', 'Endpoint') filters["animal_group__experiment__study"] = instance.id elif instance.study_type == 1: Model = apps.get_model('epi', 'Outcome') filters["study_population__study"] = instance.id elif instance.study_type == 2: Model = apps.get_model('invitro', 'ivendpoint') filters["experiment__study_id"] = instance.id elif instance.study_type == 4: Model = apps.get_model('epimeta', 'MetaResult') filters["protocol__study"] = instance.id models.Study.delete_caches([instance.id]) if Model: ids = Model.objects\ .filter(**filters)\ .values_list('id', flat=True) SerializerHelper.delete_caches(Model, ids)
url = serializers.CharField(source='get_absolute_url', read_only=True) results = ResultSerializer(many=True) comparison_sets = ComparisonSetLinkSerializer(many=True) class Meta: model = models.Outcome fields = '__all__' class ComparisonSetSerializer(serializers.ModelSerializer): url = serializers.CharField(source='get_absolute_url', read_only=True) exposure = ExposureSerializer() outcome = OutcomeSerializer() study_population = StudyPopulationSerializer() groups = GroupSerializer(many=True) class Meta: model = models.ComparisonSet fields = '__all__' class OutcomeCleanupFieldsSerializer(DynamicFieldsMixin, serializers.ModelSerializer): class Meta: model = models.Outcome cleanup_fields = model.TEXT_CLEANUP_FIELDS fields = cleanup_fields + ('id', ) SerializerHelper.add_serializer(models.Outcome, OutcomeSerializer)
def clear_cache(Model, filters): ids = Model.objects\ .filter(**filters)\ .values_list('id', flat=True) SerializerHelper.delete_caches(Model, ids)
can_create_sets = serializers.BooleanField(read_only=True) effects = EffectTagsSerializer() diagnostic = serializers.CharField(source='get_diagnostic_display', read_only=True) url = serializers.CharField(source='get_absolute_url', read_only=True) results = ResultSerializer(many=True) comparison_sets = ComparisonSetLinkSerializer(many=True) class Meta: model = models.Outcome class ComparisonSetSerializer(serializers.ModelSerializer): url = serializers.CharField(source='get_absolute_url', read_only=True) exposure = ExposureSerializer() outcome = OutcomeSerializer() study_population = StudyPopulationSerializer() groups = GroupSerializer(many=True) class Meta: model = models.ComparisonSet class OutcomeCleanupFieldsSerializer(DynamicFieldsMixin, serializers.ModelSerializer): class Meta: model = models.Outcome cleanup_fields = model.TEXT_CLEANUP_FIELDS fields = cleanup_fields + ('id', ) SerializerHelper.add_serializer(models.Outcome, OutcomeSerializer)
study = StudySerializer() inclusion_criteria = serializers.StringRelatedField(many=True) exclusion_criteria = serializers.StringRelatedField(many=True) url = serializers.ReadOnlyField(source="get_absolute_url") protocol_type = serializers.ReadOnlyField(source="get_protocol_type_display") lit_search_strategy = serializers.ReadOnlyField(source="get_lit_search_strategy_display") results = MetaResultLinkSerializer(many=True) class Meta: model = models.MetaProtocol class MetaResultSerializer(serializers.ModelSerializer): protocol = MetaProtocolSerializer() url = serializers.ReadOnlyField(source="get_absolute_url") metric = ResultMetricSerializer() adjustment_factors = serializers.StringRelatedField(many=True) single_results = SingleResultSerializer(many=True) def to_representation(self, instance): ret = super(MetaResultSerializer, self).to_representation(instance) ret['estimateFormatted'] = instance.estimate_formatted return ret class Meta: model = models.MetaResult SerializerHelper.add_serializer(models.MetaProtocol, MetaProtocolSerializer) SerializerHelper.add_serializer(models.MetaResult, MetaResultSerializer)
class FinalRobStudySerializer(StudySerializer): assessment = serializers.PrimaryKeyRelatedField(read_only=True) riskofbiases = RiskOfBiasSerializer(many=True, read_only=True) class Meta: model = models.Study exclude = ( 'searches', 'identifiers', ) def to_representation(self, instance): instance.riskofbiases = instance.riskofbiases.filter(final=True) ret = super().to_representation(instance) return ret class StudyCleanupFieldsSerializer(DynamicFieldsMixin, serializers.ModelSerializer): class Meta: model = models.Study cleanup_fields = model.TEXT_CLEANUP_FIELDS fields = ( 'id', 'short_citation', ) + cleanup_fields SerializerHelper.add_serializer(models.Study, VerboseStudySerializer)
def get_json(self, json_encode=True): return SerializerHelper.get_serialized(self, json=json_encode, from_cache=False)
def get_docx_template_context(assessment, queryset): """ Given a queryset of meta-results, invert the cached results to build a top-down data hierarchy from study to meta-result. We use this approach since our meta-results are cached, so while it may require more computation, its close to free on database access. """ def getStatMethods(mr): key = "{}|{}".format( mr["adjustments_list"], mr["statistical_notes"] ) return key, mr results = [ SerializerHelper.get_serialized(obj, json=False) for obj in queryset ] studies = {} # flip dictionary nesting for thisMr in results: thisPro = thisMr["protocol"] thisStudy = thisMr["protocol"]["study"] study = studies.get(thisStudy["id"]) if study is None: study = thisStudy study["protocols"] = {} studies[study["id"]] = study pro = study["protocols"].get(thisPro["id"]) if pro is None: pro = thisPro pro["inclusion_list"] = ', '.join(pro["inclusion_criteria"]) pro["exclusion_list"] = ', '.join(pro["exclusion_criteria"]) pro["results"] = {} pro["statistical_methods"] = {} study["protocols"][pro["id"]] = pro mr = pro["results"].get(thisMr["id"]) if mr is None: mr = thisMr mr["ci_percent"] = int(mr["ci_units"] * 100.) mr["adjustments_list"] = ', '.join( sorted(mr["adjustment_factors"])) pro["results"][mr["id"]] = mr statKey, statVal = getStatMethods(thisMr) stats = pro["statistical_methods"].get(statKey) if stats is None: stats = statVal pro["statistical_methods"][statKey] = statVal stats["sm_endpoints"] = [] stats["sm_endpoints"].append(thisMr) # convert value dictionaries to lists studies = sorted( list(studies.values()), key=lambda obj: (obj["short_citation"].lower())) for study in studies: study["protocols"] = sorted( list(study["protocols"].values()), key=lambda obj: (obj["name"].lower())) for pro in study["protocols"]: pro["results"] = sorted( list(pro["results"].values()), key=lambda obj: (obj["label"].lower())) pro["statistical_methods"] = list(pro["statistical_methods"].values()) for obj in pro["statistical_methods"]: obj["sm_endpoints"] = "; ".join([ d["label"] for d in obj["sm_endpoints"] ]) return { "assessment": AssessmentSerializer().to_representation(assessment), "studies": studies }
def d_response(self, json_encode=True): return SerializerHelper.get_serialized(self, json=json_encode)
models.EndpointGroup.percentControl(ret['data_type'], ret['endpoint_group']) # get individual animal data if instance.individual_animal_data: models.EndpointGroup.getIndividuals(instance, ret['endpoint_group']) # get BMD ret['BMD'] = None try: model = instance.BMD_session.latest().selected_model if model is not None: ret['BMD'] = BMDModelRunSerializer().to_representation(model) except instance.BMD_session.model.DoesNotExist: pass return ret class Meta: model = models.Endpoint class AggregationSerializer(serializers.ModelSerializer): endpoints = EndpointSerializer(many=True) class Meta: model = models.Aggregation SerializerHelper.add_serializer(models.Endpoint, EndpointSerializer) SerializerHelper.add_serializer(models.Aggregation, AggregationSerializer)
from rest_framework import serializers from utils.helper import SerializerHelper from . import models class HAWCUserSerializer(serializers.ModelSerializer): full_name = serializers.CharField(source='get_full_name') class Meta: model = models.HAWCUser fields = ( 'id', 'full_name', ) SerializerHelper.add_serializer(models.HAWCUser, HAWCUserSerializer)
class Meta: model = models.RiskOfBiasScore fields = ('id', 'score', 'notes', 'metric') class RiskOfBiasSerializer(serializers.ModelSerializer): scores = RiskOfBiasScoreSerializer(read_only=False, many=True, partial=True) author = HAWCUserSerializer(read_only=True) class Meta: model = models.RiskOfBias fields = ('id', 'author', 'active', 'final', 'study', 'created', 'last_updated', 'scores') def update(self, instance, validated_data): """ Updates the nested RiskOfBiasScores with submitted data before updating the RiskOfBias instance. """ score_data = validated_data.pop('scores') for score, form_data in zip(instance.scores.all(), score_data): for field, value in form_data.items(): setattr(score, field, value) score.save() return super(RiskOfBiasSerializer, self).update(instance, validated_data) SerializerHelper.add_serializer(models.RiskOfBias, RiskOfBiasSerializer)
class Meta: model = models.StudyQuality exclude = ('object_id', 'content_type') class StudySerializer(serializers.ModelSerializer): def to_representation(self, instance): ret = super(StudySerializer, self).to_representation(instance) ret['study_type'] = instance.get_study_type_display() ret['coi_reported'] = instance.get_coi_reported_display() ret['url'] = instance.get_absolute_url() return ret class Meta: model = models.Study class VerboseStudySerializer(StudySerializer): assessment = serializers.PrimaryKeyRelatedField(read_only=True) searches = serializers.PrimaryKeyRelatedField(many=True, read_only=True) qualities = StudyQualitySerializer(many=True, read_only=True) identifiers = IdentifiersSerializer(many=True) tags = ReferenceTagsSerializer() class Meta: model = models.Study SerializerHelper.add_serializer(models.Study, VerboseStudySerializer)
ret = super(MetaProtocolSerializer, self).to_representation(instance) ret['url'] = instance.get_absolute_url() ret['protocol_type'] = instance.get_protocol_type_display() ret['lit_search_strategy'] = instance.get_lit_search_strategy_display() return ret class Meta: model = models.MetaProtocol class MetaResultSerializer(serializers.ModelSerializer): protocol = MetaProtocolSerializer() statistical_metric = StatisticalMetricSerializer() single_results = SingleResultSerializer(many=True) adjustment_factors = serializers.StringRelatedField(many=True) def to_representation(self, instance): ret = super(MetaResultSerializer, self).to_representation(instance) ret['url'] = instance.get_absolute_url() ret['estimateFormatted'] = instance.estimate_formatted return ret class Meta: model = models.MetaResult SerializerHelper.add_serializer(models.StudyPopulation, StudyPopulationSerializer) SerializerHelper.add_serializer(models.AssessedOutcome, AssessedOutcomeSerializer) SerializerHelper.add_serializer(models.MetaProtocol, MetaProtocolSerializer) SerializerHelper.add_serializer(models.MetaResult, MetaResultSerializer)
protocol_type = serializers.ReadOnlyField( source="get_protocol_type_display") lit_search_strategy = serializers.ReadOnlyField( source="get_lit_search_strategy_display") results = MetaResultLinkSerializer(many=True) class Meta: model = models.MetaProtocol fields = '__all__' class MetaResultSerializer(serializers.ModelSerializer): protocol = MetaProtocolSerializer() url = serializers.ReadOnlyField(source="get_absolute_url") metric = ResultMetricSerializer() adjustment_factors = serializers.StringRelatedField(many=True) single_results = SingleResultSerializer(many=True) def to_representation(self, instance): ret = super().to_representation(instance) ret['estimateFormatted'] = instance.estimate_formatted return ret class Meta: model = models.MetaResult fields = '__all__' SerializerHelper.add_serializer(models.MetaProtocol, MetaProtocolSerializer) SerializerHelper.add_serializer(models.MetaResult, MetaResultSerializer)
study = StudyAssessmentSerializer(read_only=True) type_display = serializers.CharField(source='get_type_display') status_display = serializers.CharField(source='get_status_display') class Meta: model = models.Task fields = '__all__' read_only_fields = ( 'id', 'study', 'open', 'started', 'completed', ) def update(self, instance, validated_data): if self.initial_data['owner']: owner_id = self.initial_data['owner']['id'] instance.owner = HAWCUser.objects.get(pk=owner_id) instance.save() return super().update(instance, validated_data) class TaskByAssessmentSerializer(TaskSerializer): study = StudyAssessmentSerializer(read_only=True) class Meta(TaskSerializer.Meta): depth = 2 SerializerHelper.add_serializer(models.Task, TaskSerializer)
def get_docx_template_context(assessment, queryset): studies = [SerializerHelper.get_serialized(study, json=False) for study in queryset] return { "assessment": AssessmentSerializer().to_representation(assessment), "studies": studies }
ret["settings"] = settings return ret class Meta: model = models.Visual exclude = ('endpoints', ) class VisualSerializer(CollectionVisualSerializer): def to_representation(self, instance): ret = super().to_representation(instance) ret['url_update'] = instance.get_update_url() ret['url_delete'] = instance.get_delete_url() ret["endpoints"] = [ SerializerHelper.get_serialized(d, json=False) for d in instance.get_endpoints() ] ret["studies"] = [ SerializerHelper.get_serialized(d, json=False) for d in instance.get_studies() ] return ret SerializerHelper.add_serializer(models.Visual, VisualSerializer)
def get_docx_template_context(cls, assessment, queryset): """ Given a queryset of endpoints, invert the cached results to build a top-down data hierarchy from study to endpoint. We use this approach since our endpoints are cached, so while it may require more computation, its close to free on database access. """ endpoints = [ SerializerHelper.get_serialized(obj, json=False) for obj in queryset ] studies = {} # flip dictionary nesting for thisEp in endpoints: thisAG = thisEp["animal_group"] thisExp = thisEp["animal_group"]["experiment"] thisStudy = thisEp["animal_group"]["experiment"]["study"] study = studies.get(thisStudy["id"]) if study is None: study = thisStudy study["exps"] = {} studies[study["id"]] = study exp = study["exps"].get(thisExp["id"]) if exp is None: exp = thisExp exp["ags"] = {} study["exps"][exp["id"]] = exp ag = exp["ags"].get(thisAG["id"]) if ag is None: ag = thisAG ag["eps"] = {} exp["ags"][ag["id"]] = ag ep = ag["eps"].get(thisEp["id"]) if ep is None: ep = thisEp ag["eps"][ep["id"]] = ep # convert value dictionaries to lists studies = sorted( studies.values(), key=lambda obj: (obj["short_citation"].lower())) for study in studies: study["exps"] = sorted( study["exps"].values(), key=lambda obj: (obj["name"].lower())) for exp in study["exps"]: exp["ags"] = sorted( exp["ags"].values(), key=lambda obj: (obj["name"].lower())) for ag in exp["ags"]: ag["eps"] = sorted( ag["eps"].values(), key=lambda obj: (obj["name"].lower())) return { "assessment": AssessmentSerializer().to_representation(assessment), "studies": studies }
endpoints = MiniIVEndpointSerializer(many=True) class IVEndpointCleanupFieldsSerializer(DynamicFieldsMixin, serializers.ModelSerializer): study_short_citation = serializers.SerializerMethodField() class Meta: model = models.IVEndpoint cleanup_fields = ('study_short_citation', ) + model.TEXT_CLEANUP_FIELDS fields = cleanup_fields + ('id', ) def get_study_short_citation(self, obj): return obj.experiment.study.short_citation class IVChemicalCleanupFieldsSerializer(DynamicFieldsMixin, serializers.ModelSerializer): study_short_citation = serializers.SerializerMethodField() class Meta: model = models.IVChemical cleanup_fields = ('study_short_citation', ) + model.TEXT_CLEANUP_FIELDS fields = cleanup_fields + ('id', ) def get_study_short_citation(self, obj): return obj.study.short_citation SerializerHelper.add_serializer(models.IVEndpoint, IVEndpointSerializer)
def get_json(self, json_encode=True): return SerializerHelper.get_serialized(self, json=json_encode)
def delete_caches(cls, ids): SerializerHelper.delete_caches(cls, ids)
settings = {} ret["settings"] = settings return ret class Meta: model = models.Visual exclude = ('endpoints', ) class VisualSerializer(CollectionVisualSerializer): def to_representation(self, instance): ret = super().to_representation(instance) ret['url_update'] = instance.get_update_url() ret['url_delete'] = instance.get_delete_url() ret["endpoints"] = [ SerializerHelper.get_serialized(d, json=False) for d in instance.get_endpoints() ] ret["studies"] = [ SerializerHelper.get_serialized(d, json=False) for d in instance.get_studies() ] return ret SerializerHelper.add_serializer(models.Visual, VisualSerializer)
from rest_framework import serializers from utils.helper import SerializerHelper from . import models class HAWCUserSerializer(serializers.ModelSerializer): full_name = serializers.CharField(source='get_full_name') class Meta: model = models.HAWCUser fields = ('id', 'full_name', ) SerializerHelper.add_serializer(models.HAWCUser, HAWCUserSerializer)
experiment = serializers.PrimaryKeyRelatedField(read_only=True) chemical = _IVChemicalSerializer() groups = serializers.PrimaryKeyRelatedField(read_only=True, many=True) benchmarks = serializers.PrimaryKeyRelatedField(read_only=True, many=True) category = serializers.PrimaryKeyRelatedField(read_only=True) def to_representation(self, instance): ret = super(MiniIVEndpointSerializer, self).to_representation(instance) ret['url'] = instance.get_absolute_url() return ret class Meta: model = models.IVEndpoint class IVExperimentSerializerFull(IVExperimentSerializer): url_update = serializers.CharField(source='get_update_url', read_only=True) url_delete = serializers.CharField(source='get_delete_url', read_only=True) url_create_endpoint = serializers.CharField(source='get_endpoint_create_url', read_only=True) endpoints = MiniIVEndpointSerializer(many=True) class CleanupFieldsSerializer(DynamicFieldsMixin, serializers.ModelSerializer): class Meta: model = models.IVEndpoint cleanup_fields = model.text_cleanup_fields() fields = cleanup_fields + ('id', 'name') SerializerHelper.add_serializer(models.IVEndpoint, IVEndpointSerializer)
""" score_data = validated_data.pop('scores') for score, form_data in zip(instance.scores.all(), score_data): for field, value in list(form_data.items()): setattr(score, field, value) score.save() return super().update(instance, validated_data) class AssessmentMetricScoreSerializer(serializers.ModelSerializer): scores = serializers.SerializerMethodField('get_final_score') class Meta: model = models.RiskOfBiasMetric fields = ('id', 'name', 'description', 'scores') def get_final_score(self, instance): scores = instance.scores.filter(riskofbias__final=True, riskofbias__active=True) serializer = RiskOfBiasScoreSerializer(scores, many=True) return serializer.data class AssessmentRiskOfBiasScoreSerializer(serializers.ModelSerializer): class Meta: model = models.RiskOfBiasScore fields = ('id', 'notes', 'score') SerializerHelper.add_serializer(models.RiskOfBias, RiskOfBiasSerializer)