def save_individuals_table_handler(request, project_guid, upload_file_id):
"""Handler for 'save' requests to apply Individual tables previously uploaded through receive_individuals_table(..)
Args:
request (object): Django request object
project_guid (string): project GUID
uploadedFileId (string): a token sent to the client by receive_individuals_table(..)
"""
project = get_project_and_check_permissions(project_guid, request.user)
json_records = load_uploaded_file(upload_file_id)
updated_families, updated_individuals = add_or_update_individuals_and_families(
project, individual_records=json_records, user=request.user
)
# edit individuals
individuals = _get_json_for_individuals(updated_individuals, request.user, add_sample_guids_field=True)
individuals_by_guid = {individual['individualGuid']: individual for individual in individuals}
families = _get_json_for_families(updated_families, request.user, add_individual_guids_field=True)
families_by_guid = {family['familyGuid']: family for family in families}
updated_families_and_individuals_by_guid = {
'individualsByGuid': individuals_by_guid,
'familiesByGuid': families_by_guid,
}
return create_json_response(updated_families_and_individuals_by_guid)
def saved_variants(request, tag):
tag_type = VariantTagType.objects.get(name=tag, project__isnull=True)
saved_variant_models = SavedVariant.objects.filter(varianttag__variant_tag_type=tag_type, family__isnull=False)
saved_variants = get_json_for_saved_variants(saved_variant_models, add_tags=True, add_details=True, user=request.user)
project_models_by_guid = {variant.project.guid: variant.project for variant in saved_variant_models}
families = {variant.family for variant in saved_variant_models}
individuals = Individual.objects.filter(family__in=families)
genes = _saved_variant_genes(saved_variants)
locus_list_guids = _add_locus_lists(project_models_by_guid.values(), saved_variants, genes)
projects_json = get_json_for_projects(project_models_by_guid.values(), user=request.user, add_project_category_guids_field=False)
functional_tag_types = get_json_for_variant_functional_data_tag_types()
for project_json in projects_json:
project_json.update({
'locusListGuids': locus_list_guids,
'variantTagTypes': get_project_variant_tag_types(project_models_by_guid[project_json['projectGuid']]),
'variantFunctionalTagTypes': functional_tag_types,
})
families_json = _get_json_for_families(list(families), user=request.user, add_individual_guids_field=True)
individuals_json = _get_json_for_individuals(individuals, user=request.user)
locus_lists_by_guid = {locus_list['locusListGuid']: locus_list for locus_list in
get_json_for_locus_lists(LocusList.objects.filter(guid__in=locus_list_guids), request.user)}
return create_json_response({
'savedVariantsByGuid': {variant['variantGuid']: variant for variant in saved_variants},
'genesById': genes,
'projectsByGuid': {project['projectGuid']: project for project in projects_json},
'familiesByGuid': {family['familyGuid']: family for family in families_json},
'individualsByGuid': {indiv['individualGuid']: indiv for indiv in individuals_json},
'locusListsByGuid': locus_lists_by_guid,
})
def _retrieve_families(cursor, project_guid, user):
"""Retrieves family-level metadata for the given project.
Args:
cursor: connected database cursor that can be used to execute SQL queries.
project_guid (string): project_guid
user (Model): for checking permissions to view certain fields
Returns:
dictionary: families_by_guid
"""
fields = Family._meta.json_fields + Family._meta.internal_json_fields
family_models = Family.objects.filter(project__guid=project_guid).only(
*fields)
families = _get_json_for_families(family_models,
user,
project_guid=project_guid)
families_by_guid = {}
for family in families:
family_guid = family['familyGuid']
family['individualGuids'] = set()
families_by_guid[family_guid] = family
return families_by_guid
def saved_variants_page(request, tag):
gene = request.GET.get('gene')
if tag == 'ALL':
saved_variant_models = SavedVariant.objects.exclude(varianttag=None)
else:
tag_type = VariantTagType.objects.get(name=tag, project__isnull=True)
saved_variant_models = SavedVariant.objects.filter(varianttag__variant_tag_type=tag_type)
saved_variant_models = saved_variant_models.filter(family__project__in=get_projects_user_can_view(request.user))
if gene:
saved_variant_models = saved_variant_models.filter(saved_variant_json__transcripts__has_key=gene)
elif saved_variant_models.count() > MAX_SAVED_VARIANTS:
return create_json_response({'error': 'Select a gene to filter variants'}, status=400)
prefetch_related_objects(saved_variant_models, 'family__project')
response_json = get_json_for_saved_variants_with_tags(saved_variant_models, add_details=True, include_missing_variants=True)
project_models_by_guid = {variant.family.project.guid: variant.family.project for variant in saved_variant_models}
families = {variant.family for variant in saved_variant_models}
individuals = Individual.objects.filter(family__in=families)
saved_variants = list(response_json['savedVariantsByGuid'].values())
genes = saved_variant_genes(saved_variants)
locus_lists_by_guid = _add_locus_lists(list(project_models_by_guid.values()), genes, include_all_lists=True)
projects_json = get_json_for_projects(list(project_models_by_guid.values()), user=request.user, add_project_category_guids_field=False)
functional_tag_types = get_json_for_variant_functional_data_tag_types()
variant_tag_types = VariantTagType.objects.filter(Q(project__in=project_models_by_guid.values()) | Q(project__isnull=True))
prefetch_related_objects(variant_tag_types, 'project')
variant_tags_json = _get_json_for_models(variant_tag_types)
tag_projects = {vt.guid: vt.project.guid for vt in variant_tag_types if vt.project}
for project_json in projects_json:
project_guid = project_json['projectGuid']
project_variant_tags = [
vt for vt in variant_tags_json if tag_projects.get(vt['variantTagTypeGuid'], project_guid) == project_guid]
project_json.update({
'locusListGuids': list(locus_lists_by_guid.keys()),
'variantTagTypes': sorted(project_variant_tags, key=lambda variant_tag_type: variant_tag_type['order'] or 0),
'variantFunctionalTagTypes': functional_tag_types,
})
families_json = _get_json_for_families(list(families), user=request.user, add_individual_guids_field=True)
individuals_json = _get_json_for_individuals(individuals, add_hpo_details=True, user=request.user)
for locus_list in get_json_for_locus_lists(LocusList.objects.filter(guid__in=locus_lists_by_guid.keys()), request.user):
locus_lists_by_guid[locus_list['locusListGuid']].update(locus_list)
response_json.update({
'genesById': genes,
'projectsByGuid': {project['projectGuid']: project for project in projects_json},
'familiesByGuid': {family['familyGuid']: family for family in families_json},
'individualsByGuid': {indiv['individualGuid']: indiv for indiv in individuals_json},
'locusListsByGuid': locus_lists_by_guid,
})
return create_json_response(response_json)
def _retrieve_families(cursor, project_guid, user):
"""Retrieves family-level metadata for the given project.
Args:
cursor: connected database cursor that can be used to execute SQL queries.
project_guid (string): project_guid
user (Model): for checking permissions to view certain fields
Returns:
dictionary: families_by_guid
"""
families_query = """
SELECT DISTINCT
p.guid AS project_guid,
f.id AS family_id,
f.guid AS family_guid,
f.family_id AS family_family_id,
f.created_date AS family_created_date,
f.display_name AS family_display_name,
f.description AS family_description,
f.analysis_notes AS family_analysis_notes,
f.analysis_summary AS family_analysis_summary,
f.pedigree_image AS family_pedigree_image,
f.analysis_status AS family_analysis_status,
f.causal_inheritance_mode AS family_causal_inheritance_mode,
f.internal_analysis_status AS family_internal_analysis_status,
f.internal_case_review_notes AS family_internal_case_review_notes,
f.internal_case_review_summary AS family_internal_case_review_summary
FROM seqr_project AS p
JOIN seqr_family AS f ON f.project_id=p.id
WHERE p.guid=%s
""".strip()
cursor.execute(families_query, [project_guid])
columns = [col[0] for col in cursor.description]
family_rows = [dict(zip(columns, row)) for row in cursor.fetchall()]
families = _get_json_for_families(family_rows,
user,
add_analysed_by_field=False)
analysed_by = retrieve_multi_family_analysed_by(families)
families_by_guid = {}
for family in families:
family_guid = family['familyGuid']
family['individualGuids'] = set()
family['analysedBy'] = analysed_by[family_guid]
families_by_guid[family_guid] = family
return families_by_guid
def _retrieve_families(project_guid, is_analyst, has_case_review_perm):
"""Retrieves family-level metadata for the given project.
Args:
project_guid (string): project_guid
user (Model): for checking permissions to view certain fields
Returns:
dictionary: families_by_guid
"""
family_models = Family.objects.filter(project__guid=project_guid)
families = _get_json_for_families(
family_models, project_guid=project_guid, is_analyst=is_analyst, has_case_review_perm=has_case_review_perm)
families_by_guid = {}
for family in families:
family_guid = family['familyGuid']
family['individualGuids'] = set()
families_by_guid[family_guid] = family
return families_by_guid
def _get_projects_details(projects, user, project_category_guid=None):
for project in projects:
check_permissions(project, user)
prefetch_related_objects(projects, 'can_view_group')
project_models_by_guid = {project.guid: project for project in projects}
projects_json = get_json_for_projects(projects, user)
locus_lists = set()
functional_data_tag_types = get_json_for_variant_functional_data_tag_types(
)
variant_tag_types_by_guid = {
vtt.guid: vtt
for vtt in VariantTagType.objects.filter(
Q(project__in=projects)
| Q(project__isnull=True)).prefetch_related('project')
}
variant_tag_types = _get_json_for_models(
variant_tag_types_by_guid.values())
for project_json in projects_json:
project = project_models_by_guid[project_json['projectGuid']]
project_locus_lists = get_project_locus_list_models(project)
locus_lists.update(project_locus_lists)
project_json.update({
'locusListGuids':
[locus_list.guid for locus_list in project_locus_lists],
'variantTagTypes': [
vtt for vtt in variant_tag_types
if variant_tag_types_by_guid[vtt['variantTagTypeGuid']].project
is None or variant_tag_types_by_guid[vtt['variantTagTypeGuid']]
.project.guid == project_json['projectGuid']
],
'variantFunctionalTagTypes':
functional_data_tag_types,
})
families = _get_json_for_families(
Family.objects.filter(project__in=projects), user)
individuals = _get_json_for_individuals(
Individual.objects.filter(family__project__in=projects), user=user)
samples = get_json_for_samples(
Sample.objects.filter(individual__family__project__in=projects))
analysis_groups = get_json_for_analysis_groups(
AnalysisGroup.objects.filter(project__in=projects))
individual_guids_by_family = defaultdict(list)
for individual in individuals:
individual_guids_by_family[individual['familyGuid']].append(
individual['individualGuid'])
for family in families:
family['individualGuids'] = individual_guids_by_family[
family['familyGuid']]
sample_guids_by_individual = defaultdict(list)
for sample in samples:
sample_guids_by_individual[sample['individualGuid']].append(
sample['sampleGuid'])
for individual in individuals:
individual['sampleGuids'] = sample_guids_by_individual[
individual['individualGuid']]
response = {
'projectsByGuid': {p['projectGuid']: p
for p in projects_json},
'familiesByGuid': {f['familyGuid']: f
for f in families},
'individualsByGuid': {i['individualGuid']: i
for i in individuals},
'samplesByGuid': {s['sampleGuid']: s
for s in samples},
'locusListsByGuid': {
ll['locusListGuid']: ll
for ll in get_json_for_locus_lists(list(locus_lists), user)
},
'analysisGroupsByGuid':
{ag['analysisGroupGuid']: ag
for ag in analysis_groups},
}
if project_category_guid:
response['projectCategoriesByGuid'] = {
project_category_guid:
ProjectCategory.objects.get(guid=project_category_guid).json()
}
return response
def saved_variants_page(request, tag):
gene = request.GET.get('gene')
tag_type = VariantTagType.objects.get(name=tag, project__isnull=True)
saved_variant_models = SavedVariant.objects.filter(
varianttag__variant_tag_type=tag_type)
if gene:
saved_variant_models = saved_variant_models.filter(
saved_variant_json__transcripts__has_key=gene)
if saved_variant_models.count() > 10000 and not gene:
return create_json_response(
{'message': 'Select a gene to filter variants'}, status=400)
prefetch_related_objects(saved_variant_models, 'family__project')
saved_variants = get_json_for_saved_variants(saved_variant_models,
add_tags=True,
add_details=True)
project_models_by_guid = {
variant.family.project.guid: variant.family.project
for variant in saved_variant_models
}
families = {variant.family for variant in saved_variant_models}
individuals = Individual.objects.filter(family__in=families)
genes = _saved_variant_genes(saved_variants)
locus_list_guids = _add_locus_lists(project_models_by_guid.values(),
saved_variants, genes)
projects_json = get_json_for_projects(
project_models_by_guid.values(),
user=request.user,
add_project_category_guids_field=False)
functional_tag_types = get_json_for_variant_functional_data_tag_types()
variant_tag_types = VariantTagType.objects.filter(
Q(project__in=project_models_by_guid.values())
| Q(project__isnull=True))
prefetch_related_objects(variant_tag_types, 'project')
variant_tags_json = _get_json_for_models(variant_tag_types)
tag_projects = {
vt.guid: vt.project.guid
for vt in variant_tag_types if vt.project
}
for project_json in projects_json:
project_guid = project_json['projectGuid']
project_variant_tags = [
vt for vt in variant_tags_json if tag_projects.get(
vt['variantTagTypeGuid'], project_guid) == project_guid
]
project_json.update({
'locusListGuids':
locus_list_guids,
'variantTagTypes':
sorted(project_variant_tags,
key=lambda variant_tag_type: variant_tag_type['order']),
'variantFunctionalTagTypes':
functional_tag_types,
})
families_json = _get_json_for_families(list(families),
user=request.user,
add_individual_guids_field=True)
individuals_json = _get_json_for_individuals(individuals,
user=request.user)
locus_lists_by_guid = {
locus_list['locusListGuid']: locus_list
for locus_list in get_json_for_locus_lists(
LocusList.objects.filter(guid__in=locus_list_guids), request.user)
}
return create_json_response({
'savedVariantsByGuid':
{variant['variantGuid']: variant
for variant in saved_variants},
'genesById': genes,
'projectsByGuid':
{project['projectGuid']: project
for project in projects_json},
'familiesByGuid':
{family['familyGuid']: family
for family in families_json},
'individualsByGuid':
{indiv['individualGuid']: indiv
for indiv in individuals_json},
'locusListsByGuid': locus_lists_by_guid,
})
def _get_projects_details(projects, user, project_category_guid=None):
for project in projects:
check_project_permissions(project, user)
prefetch_related_objects(projects, 'can_view_group')
project_models_by_guid = {project.guid: project for project in projects}
projects_json = get_json_for_projects(projects, user)
locus_lists = LocusList.objects.filter(
projects__in=projects).prefetch_related('projects')
project_guid = projects[0].guid if len(projects) == 1 else None
functional_data_tag_types = get_json_for_variant_functional_data_tag_types(
)
variant_tag_types_by_guid = {
vtt.guid: vtt
for vtt in VariantTagType.objects.filter(
Q(project__in=projects)
| Q(project__isnull=True)).prefetch_related('project')
}
variant_tag_types = _get_json_for_models(
list(variant_tag_types_by_guid.values()))
for project_json in projects_json:
project = project_models_by_guid[project_json['projectGuid']]
project_json.update({
'locusListGuids': [
locus_list.guid for locus_list in locus_lists
if project in locus_list.projects.all()
],
'variantTagTypes': [
vtt for vtt in variant_tag_types
if variant_tag_types_by_guid[vtt['variantTagTypeGuid']].project
is None or variant_tag_types_by_guid[vtt['variantTagTypeGuid']]
.project.guid == project_json['projectGuid']
],
'variantFunctionalTagTypes':
functional_data_tag_types,
})
family_models = Family.objects.filter(project__in=projects)
families = _get_json_for_families(family_models,
user,
project_guid=project_guid,
skip_nested=True)
individual_models = Individual.objects.filter(family__in=family_models)
individuals = _get_json_for_individuals(individual_models,
user=user,
project_guid=project_guid,
add_hpo_details=True,
skip_nested=True)
sample_models = Sample.objects.filter(individual__in=individual_models)
samples = get_json_for_samples(sample_models,
project_guid=project_guid,
skip_nested=True)
igv_sample_models = IgvSample.objects.filter(
individual__in=individual_models)
igv_samples = get_json_for_samples(igv_sample_models,
project_guid=project_guid,
skip_nested=True)
analysis_group_models = AnalysisGroup.objects.filter(project__in=projects)
analysis_groups = get_json_for_analysis_groups(analysis_group_models,
project_guid=project_guid,
skip_nested=True)
if not project_guid:
project_id_to_guid = {project.id: project.guid for project in projects}
family_id_to_guid = {
family.id: family.guid
for family in family_models
}
individual_id_to_guid = {
individual.id: individual.guid
for individual in individual_models
}
family_guid_to_project_guid = {}
individual_guid_to_project_guid = {}
for family in families:
project_guid = project_id_to_guid[family.pop('projectId')]
family['projectGuid'] = project_guid
family_guid_to_project_guid[family['familyGuid']] = project_guid
for individual in individuals:
family_guid = family_id_to_guid[individual.pop('familyId')]
project_guid = family_guid_to_project_guid[family_guid]
individual['familyGuid'] = family_guid
individual['projectGuid'] = project_guid
individual_guid_to_project_guid[
individual['individualGuid']] = project_guid
for sample in samples:
individual_guid = individual_id_to_guid[sample.pop('individualId')]
sample['individualGuid'] = individual_guid
sample['projectGuid'] = individual_guid_to_project_guid[
individual_guid]
for sample in igv_samples:
individual_guid = individual_id_to_guid[sample.pop('individualId')]
sample['individualGuid'] = individual_guid
sample['projectGuid'] = individual_guid_to_project_guid[
individual_guid]
for group in analysis_groups:
group['projectGuid'] = project_id_to_guid[group.pop('projectId')]
individual_guids_by_family = defaultdict(list)
for individual in individuals:
individual_guids_by_family[individual['familyGuid']].append(
individual['individualGuid'])
for family in families:
family['individualGuids'] = individual_guids_by_family[
family['familyGuid']]
sample_guids_by_individual = defaultdict(list)
for sample in samples:
sample_guids_by_individual[sample['individualGuid']].append(
sample['sampleGuid'])
igv_sample_guids_by_individual = defaultdict(list)
for sample in igv_samples:
igv_sample_guids_by_individual[sample['individualGuid']].append(
sample['sampleGuid'])
for individual in individuals:
individual['sampleGuids'] = sample_guids_by_individual[
individual['individualGuid']]
individual['igvSampleGuids'] = igv_sample_guids_by_individual[
individual['individualGuid']]
response = {
'projectsByGuid': {p['projectGuid']: p
for p in projects_json},
'familiesByGuid': {f['familyGuid']: f
for f in families},
'individualsByGuid': {i['individualGuid']: i
for i in individuals},
'samplesByGuid': {s['sampleGuid']: s
for s in samples},
'igvSamplesByGuid': {s['sampleGuid']: s
for s in igv_samples},
'locusListsByGuid': {
ll['locusListGuid']: ll
for ll in get_json_for_locus_lists(locus_lists, user)
},
'analysisGroupsByGuid':
{ag['analysisGroupGuid']: ag
for ag in analysis_groups},
}
if project_category_guid:
response['projectCategoriesByGuid'] = {
project_category_guid:
ProjectCategory.objects.get(guid=project_category_guid).json()
}
return response
def _get_projects_details(projects, user, project_category_guid=None):
for project in projects:
check_permissions(project, user)
prefetch_related_objects(projects, 'can_view_group')
project_models_by_guid = {project.guid: project for project in projects}
projects_json = get_json_for_projects(projects, user)
locus_lists = set()
functional_data_tag_types = get_json_for_variant_functional_data_tag_types(
)
for project_json in projects_json:
project = project_models_by_guid[project_json['projectGuid']]
project_locus_lists = get_project_locus_list_models(project)
locus_lists.update(project_locus_lists)
project_json.update({
'locusListGuids':
[locus_list.guid for locus_list in project_locus_lists],
'variantTagTypes':
get_project_variant_tag_types(project),
'variantFunctionalTagTypes':
functional_data_tag_types,
})
families = _get_json_for_families(
Family.objects.filter(project__in=projects),
user,
add_individual_guids_field=True)
individuals = _get_json_for_individuals(
Individual.objects.filter(family__project__in=projects),
user=user,
add_sample_guids_field=True)
samples = get_json_for_samples(
Sample.objects.filter(individual__family__project__in=projects))
analysis_groups = get_json_for_analysis_groups(
AnalysisGroup.objects.filter(project__in=projects))
response = {
'projectsByGuid': {p['projectGuid']: p
for p in projects_json},
'familiesByGuid': {f['familyGuid']: f
for f in families},
'individualsByGuid': {i['individualGuid']: i
for i in individuals},
'samplesByGuid': {s['sampleGuid']: s
for s in samples},
'locusListsByGuid': {
ll['locusListGuid']: ll
for ll in get_json_for_locus_lists(list(locus_lists), user)
},
'analysisGroupsByGuid':
{ag['analysisGroupGuid']: ag
for ag in analysis_groups},
}
if project_category_guid:
response['projectCategoriesByGuid'] = {
project_category_guid:
ProjectCategory.objects.get(guid=project_category_guid).json()
}
return response
def _get_saved_variants(variants, families, include_discovery_tags=False):
if not variants:
return {}, {}
variants = _flatten_variants(variants)
prefetch_related_objects(families, 'project')
hg37_family_guids = {
family.guid
for family in families
if family.project.genome_version == GENOME_VERSION_GRCh37
}
variant_q = Q()
discovery_variant_q = Q()
variants_by_id = {}
for variant in variants:
variants_by_id[_get_variant_key(**variant)] = variant
variant_q |= Q(xpos_start=variant['xpos'],
ref=variant['ref'],
alt=variant['alt'],
family__guid__in=variant['familyGuids'])
discovery_variant_q |= Q(
Q(xpos_start=variant['xpos'],
ref=variant['ref'],
alt=variant['alt'])
& ~Q(family__guid__in=variant['familyGuids']))
if variant[
'liftedOverGenomeVersion'] == GENOME_VERSION_GRCh37 and hg37_family_guids:
variant_hg37_families = [
family_guid for family_guid in variant['familyGuids']
if family_guid in hg37_family_guids
]
if variant_hg37_families:
lifted_xpos = get_xpos(variant['liftedOverChrom'],
variant['liftedOverPos'])
variant_q |= Q(xpos_start=lifted_xpos,
ref=variant['ref'],
alt=variant['alt'],
family__guid__in=variant_hg37_families)
variants_by_id[_get_variant_key(
xpos=lifted_xpos,
ref=variant['ref'],
alt=variant['alt'],
genomeVersion=variant['liftedOverGenomeVersion']
)] = variant
saved_variants = SavedVariant.objects.filter(variant_q)
json = get_json_for_saved_variants_with_tags(saved_variants,
add_details=True)
variants_to_saved_variants = {}
for saved_variant in json['savedVariantsByGuid'].values():
family_guids = saved_variant['familyGuids']
searched_variant = variants_by_id.get(
_get_variant_key(**saved_variant))
if not searched_variant:
# This can occur when an hg38 family has a saved variant that did not successfully lift from hg37
continue
saved_variant.update(searched_variant)
# For saved variants only use family it was saved for, not all families in search
saved_variant['familyGuids'] = family_guids
json['savedVariantsByGuid'][
saved_variant['variantGuid']] = saved_variant
if searched_variant['variantId'] not in variants_to_saved_variants:
variants_to_saved_variants[searched_variant['variantId']] = {}
for family_guid in family_guids:
variants_to_saved_variants[searched_variant['variantId']][
family_guid] = saved_variant['variantGuid']
if include_discovery_tags:
discovery_tags = get_json_for_variant_tags(
VariantTag.objects.filter(
variant_tag_type__category='CMG Discovery Tags',
saved_variants__in=SavedVariant.objects.filter(
discovery_variant_q)),
include_variant_details=True)
if discovery_tags:
family_guids = set()
for tag in discovery_tags:
for variant in tag['variants']:
family_guids.update(variant['familyGuids'])
families_by_guid = {
f.guid: f
for f in Family.objects.filter(
guid__in=family_guids).prefetch_related('project')
}
for tag in discovery_tags:
for variant in tag.pop('variants'):
variant_family = families_by_guid[variant['familyGuids']
[0]]
searched_variant = variants_by_id.get(
_get_variant_key(genomeVersion=variant_family.project.
genome_version,
**variant))
if searched_variant:
if not searched_variant.get('discoveryTags'):
searched_variant['discoveryTags'] = []
tag_json = {
'savedVariant': {
'variantGuid': variant['variantGuid'],
'familyGuid': variant_family.guid,
'projectGuid': variant_family.project.guid,
}
}
tag_json.update(tag)
searched_variant['discoveryTags'].append(tag_json)
json['familiesByGuid'] = {
f['familyGuid']: f
for f in _get_json_for_families(families_by_guid.values())
}
return json, variants_to_saved_variants
