Ensembl / ensembl-vep / 765

pending completion

Build # 765

Build Type

api

travis-ci

Committed by

willmclaren

Commit Message

<a href="https://github.com/Ensembl/ensembl-vep/commit/<a class=hub.com/Ensembl/ensembl-vep/commit/1b645a54a5e671cc41b7c56356ac35dad276c6e9">1b645a54a<a href="https://github.com/Ensembl/ensembl-vep/commit/1b645a54a5e671cc41b7c56356ac35dad276c6e9">&quot;&gt;Build triggered by upstream Ensembl/ensembl-variation repo (commit: </a><a class="double-link" href="https://github.com/Ensembl/ensembl-vep/commit/<a class="double-link" href="https://github.com/Ensembl/ensembl-vep/commit/d6c040b479f07633316926838852e1da4a088763">d6c040b47</a>">d6c040b47</a><a href="https://github.com/Ensembl/ensembl-vep/commit/1b645a54a5e671cc41b7c56356ac35dad276c6e9">, branch: master).

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

9813 of 9900 relevant lines covered (99.12%)

23173.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.15

/modules/Bio/EnsEMBL/VEP/OutputFactory/JSON.pm

=head1 LICENSE

Copyright [2016-2017] EMBL-European Bioinformatics Institute

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

=cut


=head1 CONTACT

 Please email comments or questions to the public Ensembl
 developers list at <http://lists.ensembl.org/mailman/listinfo/dev>.

 Questions may also be sent to the Ensembl help desk at
 <http://www.ensembl.org/Help/Contact>.

=cut

# EnsEMBL module for Bio::EnsEMBL::VEP::OutputFactory::JSON
#
#

=head1 NAME

Bio::EnsEMBL::VEP::OutputFactory::JSON - JSON format output factory

=head1 SYNOPSIS

my $of = Bio::EnsEMBL::VEP::OutputFactory::JSON->new({
  config => $config,
});

# print output
print "$_\n" for @{$of->get_all_lines_by_InputBuffer($ib)};

=head1 DESCRIPTION

An OutputFactory class to generate JSON output. This is used
by the REST API to retrieve hashrefs structured ready to be
returned as JSON, but also can be used as an output format by
script users.

It differs significantly in its structure from the other output
formats in that each line or hashref returned contains the data
for *all* allele/feature overlaps for the variant along with any
locus-specific data.

This is somewhat more efficient in that data is not duplicated
between lines or blocks as with the other output formats, but
loses efficiency as each data point has a key that is repeated
for each variant.

It does offer significant advantages in the representation of
more structured data, as the JSON format allows as many layers of
depth as required to represent the data.

This different structure is also apparent in the structure of the
API calls as executed here; the way they are separated in the parent
OutputFactory class largely assists their reimplementation in this
class.

=head1 METHODS

=cut


use strict;
use warnings;

package Bio::EnsEMBL::VEP::OutputFactory::JSON;

use base qw(Bio::EnsEMBL::VEP::OutputFactory);

use Bio::EnsEMBL::Utils::Exception qw(throw warning);
use Bio::EnsEMBL::Variation::Utils::Constants;

use Bio::EnsEMBL::VEP::Utils qw(numberify);

use JSON;
use Scalar::Util qw(looks_like_number);

my %SKIP_KEYS = (
  'Uploaded_variation' => 1,
  'Location' => 1,
);

my %RENAME_KEYS = (
  'consequence' => 'consequence_terms',
  'gene' => 'gene_id',
  'allele' => 'variant_allele',
  'symbol' => 'gene_symbol',
  'symbol_source' => 'gene_symbol_source',
  'overlapbp' => 'bp_overlap',
  'overlappc' => 'percentage_overlap',
  'refseq' => 'refseq_transcript_ids',
  'ensp' => 'protein_id',
  'chr' => 'seq_region_name',
  'variation_name' => 'id',
  'sv' => 'colocated_structural_variants',
);

my %NUMBERIFY_EXEMPT = (
  'seq_region_name' => 1,
  'id' => 1,
  'gene_symbol' => 1,
);

my @LIST_FIELDS = qw(
  clin_sig
  pubmed
);


=head2 new

  Arg 1      : hashref $args
  Example    : $of = Bio::EnsEMBL::VEP::OutputFactory::JSON->new({
                 config => $config,
               });
  Description: Creates a new Bio::EnsEMBL::VEP::OutputFactory::JSON object.
               Has its own constructor to add several params via
               add_shortcuts()
  Returntype : Bio::EnsEMBL::VEP::OutputFactory::JSON
  Exceptions : none
  Caller     : Runner
  Status     : Stable

=cut

sub new {
  my $caller = shift;
  my $class = ref($caller) || $caller;
  
  my $self = $class->SUPER::new(@_);

  # add shortcuts to these params
  $self->add_shortcuts([qw(
    assembly
    cache_assembly
    delimiter
  )]);

  $self->{delimiter} = " " if $self->{delimiter} =~ /\+/;

  return $self;
}


=head2 output_hash_to_line

  Arg 1      : hashref $vf_hash
  Example    : $line = $of->output_hash_to_line($vf_hash);
  Description: Takes a hashref as generated by get_all_output_hashes_by_InputBuffer
               and returns a JSON-encoded string ready for printing.
  Returntype : string
  Exceptions : none
  Caller     : get_all_lines_by_InputBuffer()
  Status     : Stable

=cut

sub output_hash_to_line {
  my $self = shift;
  my $hash = shift;

  $self->{json_obj} ||= JSON->new;
  return $self->{json_obj}->encode($hash);
}


=head2 get_all_output_hashes_by_InputBuffer

  Arg 1      : Bio::EnsEMBL::VEP::InputBuffer $ib
  Example    : $hashes = $of->get_all_output_hashes_by_InputBuffer($ib);
  Description: Gets all hashrefs of data given an annotated input buffer.
               One hashref corresponds to one variant.
  Returntype : arrayref of hashrefs
  Exceptions : none
  Caller     : get_all_lines_by_InputBuffer(), Runner
  Status     : Stable

=cut

sub get_all_output_hashes_by_InputBuffer {
  my $self = shift;
  my $buffer = shift;

  $self->rejoin_variants_in_InputBuffer($buffer) if $buffer->rejoin_required;

  my @return;

  foreach my $vf(@{$buffer->buffer}) {

    my $hash = {
      id              => $vf->{variation_name},
      seq_region_name => $vf->{chr},
      start           => $vf->{start},
      end             => $vf->{end},
      strand          => $vf->{strand},
      allele_string   => $vf->{allele_string} || $vf->{class_SO_term},
      assembly_name   => $self->{assembly} || $self->{cache_assembly},
      # _order        => $vf->{_order},
    };

    # add original input for use by POST endpoints
    $hash->{input} = join($self->{delimiter}, @{$vf->{_line}}) if defined($vf->{_line});

    # add custom annotations here and delete so they don't get added again
    $hash->{custom_annotations} = delete($vf->{_custom_annotations}) if $vf->{_custom_annotations};

    # get other data from super methods
    my $extra_hash = $self->VariationFeature_to_output_hash($vf);
    $self->add_colocated_variant_info_JSON($vf, $extra_hash);
    $hash->{lc($_)} = $extra_hash->{$_} for grep {!$SKIP_KEYS{$_}} keys %$extra_hash;

    $self->add_VariationFeatureOverlapAllele_info($vf, $hash);

    numberify($hash, \%NUMBERIFY_EXEMPT);

    # rename
    my %rename = %RENAME_KEYS;
    foreach my $key(grep {defined($hash->{$_})} keys %rename) {
      $hash->{$rename{$key}} = $hash->{$key};
      delete $hash->{$key};
    }

    push @return, $hash;
  }

  return \@return;
}


=head2 add_VariationFeatureOverlapAllele_info

  Arg 1      : Bio::EnsEMBL::Variation::VariationFeature $vf
  Arg 2      : hashref $vf_hash
  Example    : $vf_hash = $of->add_VariationFeatureOverlapAllele_info($vf, $vf_hash);
  Description: Formats and adds consequence data retrieved via
               get_all_VariationFeatureOverlapAllele_output_hashes() to the hashref
  Returntype : arrayref of hashrefs
  Exceptions : none
  Caller     : get_all_output_hashes_by_InputBuffer()
  Status     : Stable

=cut

sub add_VariationFeatureOverlapAllele_info {
  my $self = shift;
  my $vf = shift;
  my $hash = shift;

  # record all cons terms so we can get the most severe
  my @con_terms;

  # add consequence stuff
  foreach my $vfoa_hash(@{$self->get_all_VariationFeatureOverlapAllele_output_hashes($vf, {})}) {

    # lc and remove empty
    foreach my $key(keys %$vfoa_hash) {
      my $tmp = $vfoa_hash->{$key};
      delete $vfoa_hash->{$key};

      next if !defined($tmp) || ($key ne 'Allele' && $tmp eq '-');

      # convert YES to 1
      $tmp = 1 if $tmp eq 'YES';

      # fix position fields into start and end
      if($key =~ /(\w+?)\_position$/i) {
        my $coord_type = lc($1);
        my ($s, $e) = split('-', $tmp);
        $vfoa_hash->{$coord_type.'_start'} = $s;
        $vfoa_hash->{$coord_type.'_end'} = defined($e) && $e =~ /^\d+$/ ? $e : $s;

        # on rare occasions coord can be "?"; for now just don't print anything
        delete $vfoa_hash->{$coord_type.'_start'} unless looks_like_number($vfoa_hash->{$coord_type.'_start'});
        delete $vfoa_hash->{$coord_type.'_end'}   unless looks_like_number($vfoa_hash->{$coord_type.'_end'});
        next;
      }

      $vfoa_hash->{lc($key)} = $tmp;
    }

    my $ftype = lc($vfoa_hash->{feature_type} || 'intergenic');
    $ftype =~ s/feature/\_feature/;
    delete $vfoa_hash->{feature_type};

    # fix SIFT and PolyPhen
    foreach my $tool(qw(sift polyphen)) {
      if(defined($vfoa_hash->{$tool}) && $vfoa_hash->{$tool} =~ m/([a-z\_]+)?\(?([\d\.]+)?\)?/i) {
        my ($pred, $score) = ($1, $2);
        $vfoa_hash->{$tool.'_prediction'} = $pred if $pred;
        $vfoa_hash->{$tool.'_score'} = $score if defined($score);
        delete $vfoa_hash->{$tool};
      }
    }

    # fix domains
    if(defined($vfoa_hash->{domains})) {
      my @dom;

      foreach(@{$vfoa_hash->{domains}}) {
        m/(\w+)\:(\w+)/;
        push @dom, {"db" => $1, "name" => $2} if $1 && $2;
      }
      $vfoa_hash->{domains} = \@dom;
    }

    # log observed consequence terms
    push @con_terms, @{$vfoa_hash->{consequence}};

    # rename
    my %rename = %RENAME_KEYS;

    $rename{feature} = lc($ftype).'_id';
    foreach my $key(grep {defined($vfoa_hash->{$_})} keys %rename) {
      $vfoa_hash->{$rename{$key}} = $vfoa_hash->{$key};
      delete $vfoa_hash->{$key};
    }

    push @{$hash->{$ftype.'_consequences'}}, $vfoa_hash;
  }

  my %all_cons = %Bio::EnsEMBL::Variation::Utils::Constants::OVERLAP_CONSEQUENCES;
  $hash->{most_severe_consequence} = (sort {$all_cons{$a}->rank <=> $all_cons{$b}->rank} grep {$_ ne '?'} @con_terms)[0] || '?';

  return $hash;
}


=head2 add_colocated_variant_info

  Arg 1      : Bio::EnsEMBL::Variation::VariationFeature $vf
  Arg 2      : hashref $vf_hash
  Example    : $hashref = $of->add_colocated_variant_info($vf, $vf_hash);
  Description: Adds co-located variant information to hash
  Returntype : hashref
  Exceptions : none
  Caller     : VariationFeature_to_output_hash()
  Status     : Stable

=cut

sub add_colocated_variant_info_JSON {
  my $self = shift;
  my $vf = shift;
  my $hash = shift;

  foreach my $ex_orig(@{$vf->{existing} || []}) {

    # work on a copy as we're going to modify/delete things
    my $ex;
    %$ex = %$ex_orig;

    delete $ex->{$_} for qw(failed matched_alleles);

    # frequencies
    foreach my $pop(grep {defined($ex->{$_})} qw(
      AFR AMR ASN EAS SAS EUR
      AA EA
      ExAC ExAC_Adj ExAC_AFR ExAC_AMR ExAC_EAS ExAC_FIN ExAC_NFE ExAC_OTH ExAC_SAS
      gnomAD gnomAD_AFR gnomAD_AMR gnomAD_ASJ gnomAD_EAS gnomAD_FIN gnomAD_NFE gnomAD_OTH gnomAD_SAS
    )) {
      my $tmp = $ex->{$pop};
      my $lc_pop = lc($pop);

      if($tmp =~ /(\D)\:([\d\.\-e]+)/) {
        $ex->{$lc_pop.'_maf'} = $2;
        $ex->{$lc_pop.'_allele'} = $1;
      }
      else {
        $ex->{$lc_pop.'_maf'} = $tmp;
      }

      delete $ex->{$pop};
    }

    # remove empty
    foreach my $key(keys %$ex) {
      delete $ex->{$key} if !defined($ex->{$key}) || $ex->{$key} eq '' || ($key !~ /maf/ && $ex->{$key} eq 0);
    }

    # rename
    foreach my $key(grep {defined($ex->{$_})} keys %RENAME_KEYS) {
      $ex->{$RENAME_KEYS{$key}} = $ex->{$key};
      delete $ex->{$key};
    }

    # lists
    foreach my $field(grep {defined($ex->{$_})} @LIST_FIELDS) {
      $ex->{$field} = [split(',', $ex->{$field})];
    }

    push @{$hash->{colocated_variants}}, $ex;
  }

  return $hash;
}


=head2 add_colocated_variant_info

  Arg 1      : Bio::EnsEMBL::Variation::VariationFeature $vf
  Arg 2      : hashref $vf_hash
  Example    : $hashref = $of->add_colocated_variant_info($vf, $vf_hash, $ex);
  Description: Just a stub; colocated data is added by add_colocated_variant_info_JSON()
               in this class.
  Returntype : hashref
  Exceptions : none
  Caller     : VariationFeatureOverlapAllele_to_output_hash()
  Status     : Stable

=cut

sub add_colocated_variant_info {
  return $_[1];
}


=head2 add_colocated_frequency_data

  Arg 1      : Bio::EnsEMBL::Variation::VariationFeature $vf
  Arg 2      : hashref $vf_hash
  Arg 3      : hashref $existing_variant_hash
  Example    : $hashref = $of->add_colocated_frequency_data($vf, $vf_hash, $ex);
  Description: Just a stub; frequency data is added by add_colocated_variant_info()
               in this class.
  Returntype : hashref
  Exceptions : none
  Caller     : VariationFeatureOverlapAllele_to_output_hash()
  Status     : Stable

=cut

sub add_colocated_frequency_data {
  return $_[1];
}

1;

1	=head1 LICENSE
2
3	Copyright [2016-2017] EMBL-European Bioinformatics Institute
4
5	Licensed under the Apache License, Version 2.0 (the "License");
6	you may not use this file except in compliance with the License.
7	You may obtain a copy of the License at
8
9	http://www.apache.org/licenses/LICENSE-2.0
10
11	Unless required by applicable law or agreed to in writing, software
12	distributed under the License is distributed on an "AS IS" BASIS,
13	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	See the License for the specific language governing permissions and
15	limitations under the License.
16
17	=cut
18
19
20	=head1 CONTACT
21
22	Please email comments or questions to the public Ensembl
23	developers list at <http://lists.ensembl.org/mailman/listinfo/dev>.
24
25	Questions may also be sent to the Ensembl help desk at
26	<http://www.ensembl.org/Help/Contact>.
27
28	=cut
29
30	# EnsEMBL module for Bio::EnsEMBL::VEP::OutputFactory::JSON
31	#
32	#
33
34	=head1 NAME
35
36	Bio::EnsEMBL::VEP::OutputFactory::JSON - JSON format output factory
37
38	=head1 SYNOPSIS
39
40	my $of = Bio::EnsEMBL::VEP::OutputFactory::JSON->new({
41	config => $config,
42	});
43
44	# print output
45	print "$_\n" for @{$of->get_all_lines_by_InputBuffer($ib)};
46
47	=head1 DESCRIPTION
48
49	An OutputFactory class to generate JSON output. This is used
50	by the REST API to retrieve hashrefs structured ready to be
51	returned as JSON, but also can be used as an output format by
52	script users.
53
54	It differs significantly in its structure from the other output
55	formats in that each line or hashref returned contains the data
56	for all allele/feature overlaps for the variant along with any
57	locus-specific data.
58
59	This is somewhat more efficient in that data is not duplicated
60	between lines or blocks as with the other output formats, but
61	loses efficiency as each data point has a key that is repeated
62	for each variant.
63
64	It does offer significant advantages in the representation of
65	more structured data, as the JSON format allows as many layers of
66	depth as required to represent the data.
67
68	This different structure is also apparent in the structure of the
69	API calls as executed here; the way they are separated in the parent
70	OutputFactory class largely assists their reimplementation in this
71	class.
72
73	=head1 METHODS
74
75	=cut
76
77
78	use strict;	100✔
79	use warnings;	100✔
80
81	package Bio::EnsEMBL::VEP::OutputFactory::JSON;
82
83	use base qw(Bio::EnsEMBL::VEP::OutputFactory);	100✔
84
85	use Bio::EnsEMBL::Utils::Exception qw(throw warning);	100✔
86	use Bio::EnsEMBL::Variation::Utils::Constants;	100✔
87
88	use Bio::EnsEMBL::VEP::Utils qw(numberify);	100✔
89
90	use JSON;	100✔
91	use Scalar::Util qw(looks_like_number);	100✔
92
93	my %SKIP_KEYS = (
94	'Uploaded_variation' => 1,
95	'Location' => 1,
96	);
97
98	my %RENAME_KEYS = (
99	'consequence' => 'consequence_terms',
100	'gene' => 'gene_id',
101	'allele' => 'variant_allele',
102	'symbol' => 'gene_symbol',
103	'symbol_source' => 'gene_symbol_source',
104	'overlapbp' => 'bp_overlap',
105	'overlappc' => 'percentage_overlap',
106	'refseq' => 'refseq_transcript_ids',
107	'ensp' => 'protein_id',
108	'chr' => 'seq_region_name',
109	'variation_name' => 'id',
110	'sv' => 'colocated_structural_variants',
111	);
112
113	my %NUMBERIFY_EXEMPT = (
114	'seq_region_name' => 1,
115	'id' => 1,
116	'gene_symbol' => 1,
117	);
118
119	my @LIST_FIELDS = qw(
120	clin_sig
121	pubmed
122	);
123
124
125	=head2 new
126
127	Arg 1 : hashref $args
128	Example : $of = Bio::EnsEMBL::VEP::OutputFactory::JSON->new({
129	config => $config,
130	});
131	Description: Creates a new Bio::EnsEMBL::VEP::OutputFactory::JSON object.
132	Has its own constructor to add several params via
133	add_shortcuts()
134	Returntype : Bio::EnsEMBL::VEP::OutputFactory::JSON
135	Exceptions : none
136	Caller : Runner
137	Status : Stable
138
139	=cut
140
141	sub new {
142	my $caller = shift;	32✔
143	my $class = ref($caller) \|\| $caller;	32✔
144
145	my $self = $class->SUPER::new(@_);	32✔
146
147	# add shortcuts to these params
148	$self->add_shortcuts([qw(	32✔
149	assembly
150	cache_assembly
151	delimiter
152	)]);
153
154	$self->{delimiter} = " " if $self->{delimiter} =~ /\+/;	32✔
155
156	return $self;	32✔
157	}
158
159
160	=head2 output_hash_to_line
161
162	Arg 1 : hashref $vf_hash
163	Example : $line = $of->output_hash_to_line($vf_hash);
164	Description: Takes a hashref as generated by get_all_output_hashes_by_InputBuffer
165	and returns a JSON-encoded string ready for printing.
166	Returntype : string
167	Exceptions : none
168	Caller : get_all_lines_by_InputBuffer()
169	Status : Stable
170
171	=cut
172
173	sub output_hash_to_line {
174	my $self = shift;	1,592✔
175	my $hash = shift;	1,592✔
176
177	$self->{json_obj} \|\|= JSON->new;	1,592✔
178	return $self->{json_obj}->encode($hash);	1,592✔
179	}
180
181
182	=head2 get_all_output_hashes_by_InputBuffer
183
184	Arg 1 : Bio::EnsEMBL::VEP::InputBuffer $ib
185	Example : $hashes = $of->get_all_output_hashes_by_InputBuffer($ib);
186	Description: Gets all hashrefs of data given an annotated input buffer.
187	One hashref corresponds to one variant.
188	Returntype : arrayref of hashrefs
189	Exceptions : none
190	Caller : get_all_lines_by_InputBuffer(), Runner
191	Status : Stable
192
193	=cut
194
195	sub get_all_output_hashes_by_InputBuffer {
196	my $self = shift;	80✔
197	my $buffer = shift;	80✔
198
199	$self->rejoin_variants_in_InputBuffer($buffer) if $buffer->rejoin_required;	80✔
200
201	my @return;	80✔
202
203	foreach my $vf(@{$buffer->buffer}) {	80✔
204
205	my $hash = {	1,239 all except COVERALLS=true DB=mysql ✔
206	id => $vf->{variation_name},
207	seq_region_name => $vf->{chr},
208	start => $vf->{start},
209	end => $vf->{end},
210	strand => $vf->{strand},
211	allele_string => $vf->{allele_string} \|\| $vf->{class_SO_term},
212	assembly_name => $self->{assembly} \|\| $self->{cache_assembly},
213	# _order => $vf->{_order},
214	};	413 only COVERALLS=true DB=mysql ✔
215
216	# add original input for use by POST endpoints
217	$hash->{input} = join($self->{delimiter}, @{$vf->{_line}}) if defined($vf->{_line});	1,652✔
218
219	# add custom annotations here and delete so they don't get added again
220	$hash->{custom_annotations} = delete($vf->{_custom_annotations}) if $vf->{_custom_annotations};	1,652✔
221
222	# get other data from super methods
223	my $extra_hash = $self->VariationFeature_to_output_hash($vf);	1,652✔
224	$self->add_colocated_variant_info_JSON($vf, $extra_hash);	1,652✔
225	$hash->{lc($_)} = $extra_hash->{$_} for grep {!$SKIP_KEYS{$_}} keys %$extra_hash;	1,652✔
226
227	$self->add_VariationFeatureOverlapAllele_info($vf, $hash);	1,652✔
228
229	numberify($hash, \%NUMBERIFY_EXEMPT);	1,652✔
230
231	# rename
232	my %rename = %RENAME_KEYS;	1,652✔
233	foreach my $key(grep {defined($hash->{$_})} keys %rename) {	1,652✔
234	$hash->{$rename{$key}} = $hash->{$key};	×
235	delete $hash->{$key};	×
236	}
237
238	push @return, $hash;	1,652✔
239	}
240
241	return \@return;	80✔
242	}
243
244
245	=head2 add_VariationFeatureOverlapAllele_info
246
247	Arg 1 : Bio::EnsEMBL::Variation::VariationFeature $vf
248	Arg 2 : hashref $vf_hash
249	Example : $vf_hash = $of->add_VariationFeatureOverlapAllele_info($vf, $vf_hash);
250	Description: Formats and adds consequence data retrieved via
251	get_all_VariationFeatureOverlapAllele_output_hashes() to the hashref
252	Returntype : arrayref of hashrefs
253	Exceptions : none
254	Caller : get_all_output_hashes_by_InputBuffer()
255	Status : Stable
256
257	=cut
258
259	sub add_VariationFeatureOverlapAllele_info {
260	my $self = shift;	1,656✔
261	my $vf = shift;	1,656✔
262	my $hash = shift;	1,656✔
263
264	# record all cons terms so we can get the most severe
265	my @con_terms;	1,656✔
266
267	# add consequence stuff
268	foreach my $vfoa_hash(@{$self->get_all_VariationFeatureOverlapAllele_output_hashes($vf, {})}) {	1,656✔
269
270	# lc and remove empty
271	foreach my $key(keys %$vfoa_hash) {	9,532✔
272	my $tmp = $vfoa_hash->{$key};	190,676✔
273	delete $vfoa_hash->{$key};	190,676✔
274
275	next if !defined($tmp) \|\| ($key ne 'Allele' && $tmp eq '-');	190,676✔
276
277	# convert YES to 1
278	$tmp = 1 if $tmp eq 'YES';	190,676✔
279
280	# fix position fields into start and end
281	if($key =~ /(\w+?)\_position$/i) {	190,676✔
282	my $coord_type = lc($1);	22,540✔
283	my ($s, $e) = split('-', $tmp);	22,540✔
284	$vfoa_hash->{$coord_type.'_start'} = $s;	22,540✔
285	$vfoa_hash->{$coord_type.'_end'} = defined($e) && $e =~ /^\d+$/ ? $e : $s;	22,540✔
286
287	# on rare occasions coord can be "?"; for now just don't print anything
288	delete $vfoa_hash->{$coord_type.'_start'} unless looks_like_number($vfoa_hash->{$coord_type.'_start'});	22,540✔
289	delete $vfoa_hash->{$coord_type.'_end'} unless looks_like_number($vfoa_hash->{$coord_type.'_end'});	22,540✔
290	next;	22,540✔
291	}
292
293	$vfoa_hash->{lc($key)} = $tmp;	168,136✔
294	}
295
296	my $ftype = lc($vfoa_hash->{feature_type} \|\| 'intergenic');	9,532✔
297	$ftype =~ s/feature/\_feature/;	9,532✔
298	delete $vfoa_hash->{feature_type};	9,532✔
299
300	# fix SIFT and PolyPhen
301	foreach my $tool(qw(sift polyphen)) {	9,532✔
302	if(defined($vfoa_hash->{$tool}) && $vfoa_hash->{$tool} =~ m/([a-z\_]+)?\(?([\d\.]+)?\)?/i) {	19,064✔
303	my ($pred, $score) = ($1, $2);	6,064✔
304	$vfoa_hash->{$tool.'_prediction'} = $pred if $pred;	6,064✔
305	$vfoa_hash->{$tool.'_score'} = $score if defined($score);	6,064✔
306	delete $vfoa_hash->{$tool};	6,064✔
307	}
308	}
309
310	# fix domains
311	if(defined($vfoa_hash->{domains})) {	9,532✔
312	my @dom;	4,464✔
313
314	foreach(@{$vfoa_hash->{domains}}) {	4,464✔
315	m/(\w+)\:(\w+)/;	17,416✔
316	push @dom, {"db" => $1, "name" => $2} if $1 && $2;	17,416✔
317	}
318	$vfoa_hash->{domains} = \@dom;	4,464✔
319	}
320
321	# log observed consequence terms
322	push @con_terms, @{$vfoa_hash->{consequence}};	9,532✔
323
324	# rename
325	my %rename = %RENAME_KEYS;	9,532✔
326
327	$rename{feature} = lc($ftype).'_id';	9,532✔
328	foreach my $key(grep {defined($vfoa_hash->{$_})} keys %rename) {	9,532✔
329	$vfoa_hash->{$rename{$key}} = $vfoa_hash->{$key};	55,116✔
330	delete $vfoa_hash->{$key};	55,116✔
331	}
332
333	push @{$hash->{$ftype.'_consequences'}}, $vfoa_hash;	9,532✔
334	}
335
336	my %all_cons = %Bio::EnsEMBL::Variation::Utils::Constants::OVERLAP_CONSEQUENCES;	1,656✔
337	$hash->{most_severe_consequence} = (sort {$all_cons{$a}->rank <=> $all_cons{$b}->rank} grep {$_ ne '?'} @con_terms)[0] \|\| '?';	1,656✔
338
339	return $hash;	1,656✔
340	}
341
342
343	=head2 add_colocated_variant_info
344
345	Arg 1 : Bio::EnsEMBL::Variation::VariationFeature $vf
346	Arg 2 : hashref $vf_hash
347	Example : $hashref = $of->add_colocated_variant_info($vf, $vf_hash);
348	Description: Adds co-located variant information to hash
349	Returntype : hashref
350	Exceptions : none
351	Caller : VariationFeature_to_output_hash()
352	Status : Stable
353
354	=cut
355
356	sub add_colocated_variant_info_JSON {
357	my $self = shift;	1,656✔
358	my $vf = shift;	1,656✔
359	my $hash = shift;	1,656✔
360
361	foreach my $ex_orig(@{$vf->{existing} \|\| []}) {	1,656✔
362
363	# work on a copy as we're going to modify/delete things
364	my $ex;	1,220✔
365	%$ex = %$ex_orig;	1,220✔
366
367	delete $ex->{$_} for qw(failed matched_alleles);	1,220✔
368
369	# frequencies
370	foreach my $pop(grep {defined($ex->{$_})} qw(	1,220✔
371	AFR AMR ASN EAS SAS EUR
372	AA EA
373	ExAC ExAC_Adj ExAC_AFR ExAC_AMR ExAC_EAS ExAC_FIN ExAC_NFE ExAC_OTH ExAC_SAS
374	gnomAD gnomAD_AFR gnomAD_AMR gnomAD_ASJ gnomAD_EAS gnomAD_FIN gnomAD_NFE gnomAD_OTH gnomAD_SAS
375	)) {
376	my $tmp = $ex->{$pop};	16,344✔
377	my $lc_pop = lc($pop);	16,344✔
378
379	if($tmp =~ /(\D)\:([\d\.\-e]+)/) {	16,344✔
380	$ex->{$lc_pop.'_maf'} = $2;	15,272✔
381	$ex->{$lc_pop.'_allele'} = $1;	15,272✔
382	}
383	else {
384	$ex->{$lc_pop.'_maf'} = $tmp;	1,072✔
385	}
386
387	delete $ex->{$pop};	16,344✔
388	}
389
390	# remove empty
391	foreach my $key(keys %$ex) {	1,220✔
392	delete $ex->{$key} if !defined($ex->{$key}) \|\| $ex->{$key} eq '' \|\| ($key !~ /maf/ && $ex->{$key} eq 0);	44,876✔
393	}
394
395	# rename
396	foreach my $key(grep {defined($ex->{$_})} keys %RENAME_KEYS) {	1,220✔
397	$ex->{$RENAME_KEYS{$key}} = $ex->{$key};	1,220✔
398	delete $ex->{$key};	1,220✔
399	}
400
401	# lists
402	foreach my $field(grep {defined($ex->{$_})} @LIST_FIELDS) {	1,220✔
403	$ex->{$field} = [split(',', $ex->{$field})];	56✔
404	}
405
406	push @{$hash->{colocated_variants}}, $ex;	1,220✔
407	}
408
409	return $hash;	1,656✔
410	}
411
412
413	=head2 add_colocated_variant_info
414
415	Arg 1 : Bio::EnsEMBL::Variation::VariationFeature $vf
416	Arg 2 : hashref $vf_hash
417	Example : $hashref = $of->add_colocated_variant_info($vf, $vf_hash, $ex);
418	Description: Just a stub; colocated data is added by add_colocated_variant_info_JSON()
419	in this class.
420	Returntype : hashref
421	Exceptions : none
422	Caller : VariationFeatureOverlapAllele_to_output_hash()
423	Status : Stable
424
425	=cut
426
427	sub add_colocated_variant_info {
428	return $_[1];	9,548✔
429	}
430
431
432	=head2 add_colocated_frequency_data
433
434	Arg 1 : Bio::EnsEMBL::Variation::VariationFeature $vf
435	Arg 2 : hashref $vf_hash
436	Arg 3 : hashref $existing_variant_hash
437	Example : $hashref = $of->add_colocated_frequency_data($vf, $vf_hash, $ex);
438	Description: Just a stub; frequency data is added by add_colocated_variant_info()
439	in this class.
440	Returntype : hashref
441	Exceptions : none
442	Caller : VariationFeatureOverlapAllele_to_output_hash()
443	Status : Stable
444
445	=cut
446
447	sub add_colocated_frequency_data {
448	return $_[1];	7,204✔
449	}
450
451	1;

Ensembl / ensembl-vep / 765

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous