Skip to content

Commit

Permalink
Merge branch 'master' into 437-optional-tx-boundaries
Browse files Browse the repository at this point in the history
  • Loading branch information
@reece
reece committed Jan 14, 2020
2 parents 3b760eb + 43085ff commit 5e2ce5c
Show file tree
Hide file tree
Showing 2 changed files with 38 additions and 32 deletions.
7 changes: 7 additions & 0 deletions hgvs/assemblymapper.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,13 @@ class AssemblyMapper(VariantMapper):
"""Provides simplified variant mapping for a single assembly and
transcript-reference alignment method.
AssemblyMapper inherits VariantMapper, which provides all
projection functionality, and adds:
* Automatic selection of genomic sequence accession
* Transcript selection from genomic coordinates
* Normalization after projection
* Special handling for PAR regions
AssemblyMapper is instantiated with an assembly name and
alt_aln_method. These enable the following conveniences over
VariantMapper:
Expand Down
63 changes: 31 additions & 32 deletions hgvs/variantmapper.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -102,9 +102,9 @@ def g_to_t(self, var_g, tx_ac, alt_aln_method=hgvs.global_config.mapping.alt_aln
if self._validator:
self._validator.validate(var_g)
var_g.fill_ref(self.hdp)
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=tx_ac, alt_ac=var_g.ac, alt_aln_method=alt_aln_method)
if tm.is_coding_transcript:
if mapper.is_coding_transcript:
var_out = VariantMapper.g_to_c(
self, var_g=var_g, tx_ac=tx_ac, alt_aln_method=alt_aln_method)
else:
Expand All @@ -118,9 +118,9 @@ def t_to_g(self, var_t, alt_ac, alt_aln_method=hgvs.global_config.mapping.alt_al
if self._validator:
self._validator.validate(var_t)
var_t.fill_ref(self.hdp)
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=var_t.ac, alt_ac=alt_ac, alt_aln_method=alt_aln_method)
if tm.is_coding_transcript:
if mapper.is_coding_transcript:
var_out = VariantMapper.c_to_g(
self, var_c=var_t, alt_ac=alt_ac, alt_aln_method=alt_aln_method)
else:
Expand Down Expand Up @@ -148,20 +148,20 @@ def g_to_n(self, var_g, tx_ac, alt_aln_method=hgvs.global_config.mapping.alt_aln
if self._validator:
self._validator.validate(var_g)
var_g.fill_ref(self.hdp)
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=tx_ac, alt_ac=var_g.ac, alt_aln_method=alt_aln_method)
pos_n = tm.g_to_n(var_g.posedit.pos)
pos_n = mapper.g_to_n(var_g.posedit.pos)
if not pos_n.uncertain:
edit_n = self._convert_edit_check_strand(tm.strand, var_g.posedit.edit)
edit_n = self._convert_edit_check_strand(mapper.strand, var_g.posedit.edit)
if edit_n.type == 'ins' and pos_n.start.offset == 0 and pos_n.end.offset == 0 and pos_n.end - pos_n.start > 1:
pos_n.start.base += 1
pos_n.end.base -= 1
edit_n.ref = ''
else:
# variant at alignment gap
pos_g = tm.n_to_g(pos_n)
pos_g = mapper.n_to_g(pos_n)
edit_n = hgvs.edit.NARefAlt(
ref='', alt=self._get_altered_sequence(tm.strand, pos_g, var_g))
ref='', alt=self._get_altered_sequence(mapper.strand, pos_g, var_g))
pos_n.uncertain = var_g.posedit.pos.uncertain
var_n = hgvs.sequencevariant.SequenceVariant(
ac=tx_ac, type="n", posedit=hgvs.posedit.PosEdit(pos_n, edit_n))
Expand Down Expand Up @@ -189,20 +189,20 @@ def n_to_g(self, var_n, alt_ac, alt_aln_method=hgvs.global_config.mapping.alt_al
if self._validator:
self._validator.validate(var_n)
var_n.fill_ref(self.hdp)
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=var_n.ac, alt_ac=alt_ac, alt_aln_method=alt_aln_method)
pos_g = tm.n_to_g(var_n.posedit.pos)
pos_g = mapper.n_to_g(var_n.posedit.pos)
if not pos_g.uncertain:
edit_g = self._convert_edit_check_strand(tm.strand, var_n.posedit.edit)
edit_g = self._convert_edit_check_strand(mapper.strand, var_n.posedit.edit)
if edit_g.type == 'ins' and pos_g.end - pos_g.start > 1:
pos_g.start.base += 1
pos_g.end.base -= 1
edit_g.ref = ''
else:
# variant at alignment gap
pos_n = tm.g_to_n(pos_g)
pos_n = mapper.g_to_n(pos_g)
edit_g = hgvs.edit.NARefAlt(
ref='', alt=self._get_altered_sequence(tm.strand, pos_n, var_n))
ref='', alt=self._get_altered_sequence(mapper.strand, pos_n, var_n))
pos_g.uncertain = var_n.posedit.pos.uncertain
var_g = hgvs.sequencevariant.SequenceVariant(
ac=alt_ac, type="g", posedit=hgvs.posedit.PosEdit(pos_g, edit_g))
Expand Down Expand Up @@ -231,20 +231,20 @@ def g_to_c(self, var_g, tx_ac, alt_aln_method=hgvs.global_config.mapping.alt_aln
if self._validator:
self._validator.validate(var_g)
var_g.fill_ref(self.hdp)
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=tx_ac, alt_ac=var_g.ac, alt_aln_method=alt_aln_method)
pos_c = tm.g_to_c(var_g.posedit.pos)
pos_c = mapper.g_to_c(var_g.posedit.pos)
if not pos_c.uncertain:
edit_c = self._convert_edit_check_strand(tm.strand, var_g.posedit.edit)
edit_c = self._convert_edit_check_strand(mapper.strand, var_g.posedit.edit)
if edit_c.type == 'ins' and pos_c.start.offset == 0 and pos_c.end.offset == 0 and pos_c.end - pos_c.start > 1:
pos_c.start.base += 1
pos_c.end.base -= 1
edit_c.ref = ''
else:
# variant at alignment gap
pos_g = tm.c_to_g(pos_c)
pos_g = mapper.c_to_g(pos_c)
edit_c = hgvs.edit.NARefAlt(
ref='', alt=self._get_altered_sequence(tm.strand, pos_g, var_g))
ref='', alt=self._get_altered_sequence(mapper.strand, pos_g, var_g))
pos_c.uncertain = var_g.posedit.pos.uncertain
var_c = hgvs.sequencevariant.SequenceVariant(
ac=tx_ac, type="c", posedit=hgvs.posedit.PosEdit(pos_c, edit_c))
Expand Down Expand Up @@ -272,29 +272,28 @@ def c_to_g(self, var_c, alt_ac, alt_aln_method=hgvs.global_config.mapping.alt_al
if self._validator:
self._validator.validate(var_c)
var_c.fill_ref(self.hdp)
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=var_c.ac, alt_ac=alt_ac, alt_aln_method=alt_aln_method)
pos_g = tm.c_to_g(var_c.posedit.pos)
pos_g = mapper.c_to_g(var_c.posedit.pos)
if not pos_g.uncertain:
edit_g = self._convert_edit_check_strand(tm.strand, var_c.posedit.edit)
edit_g = self._convert_edit_check_strand(mapper.strand, var_c.posedit.edit)
if edit_g.type == 'ins' and pos_g.end - pos_g.start > 1:
pos_g.start.base += 1
pos_g.end.base -= 1
edit_g.ref = ''
else:
# variant at alignment gap
var_n = copy.deepcopy(var_c)
var_n.posedit.pos = tm.c_to_n(var_c.posedit.pos)
var_n.posedit.pos = mapper.c_to_n(var_c.posedit.pos)
var_n.type = 'n'
pos_n = tm.g_to_n(pos_g)
pos_n = mapper.g_to_n(pos_g)
edit_g = hgvs.edit.NARefAlt(
ref='', alt=self._get_altered_sequence(tm.strand, pos_n, var_n))
ref='', alt=self._get_altered_sequence(mapper.strand, pos_n, var_n))
pos_g.uncertain = var_c.posedit.pos.uncertain
var_g = hgvs.sequencevariant.SequenceVariant(
ac=alt_ac, type="g", posedit=hgvs.posedit.PosEdit(pos_g, edit_g))
if self.replace_reference:
self._replace_reference(var_g)
# intentional: no gene symbol
return var_g

# ############################################################################
Expand All @@ -315,9 +314,9 @@ def c_to_n(self, var_c):
if self._validator:
self._validator.validate(var_c)
var_c.fill_ref(self.hdp)
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=var_c.ac, alt_ac=var_c.ac, alt_aln_method="transcript")
pos_n = tm.c_to_n(var_c.posedit.pos)
pos_n = mapper.c_to_n(var_c.posedit.pos)
if (isinstance(var_c.posedit.edit, hgvs.edit.NARefAlt)
or isinstance(var_c.posedit.edit, hgvs.edit.Dup)
or isinstance(var_c.posedit.edit, hgvs.edit.Inv)):
Expand Down Expand Up @@ -349,9 +348,9 @@ def n_to_c(self, var_n):
if self._validator:
self._validator.validate(var_n)
var_n.fill_ref(self.hdp)
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=var_n.ac, alt_ac=var_n.ac, alt_aln_method="transcript")
pos_c = tm.n_to_c(var_n.posedit.pos)
pos_c = mapper.n_to_c(var_n.posedit.pos)
if (isinstance(var_n.posedit.edit, hgvs.edit.NARefAlt)
or isinstance(var_n.posedit.edit, hgvs.edit.Dup)
or isinstance(var_n.posedit.edit, hgvs.edit.Inv)):
Expand Down Expand Up @@ -429,9 +428,9 @@ def _replace_reference(self, var):

# For c. variants, we need coords on underlying sequences
if var.type == "c":
tm = self._fetch_AlignmentMapper(
mapper = self._fetch_AlignmentMapper(
tx_ac=var.ac, alt_ac=var.ac, alt_aln_method="transcript")
pos = tm.c_to_n(var.posedit.pos)
pos = mapper.c_to_n(var.posedit.pos)
else:
pos = var.posedit.pos
seq = self.hdp.get_seq(var.ac, pos.start.base - 1, pos.end.base)
Expand Down

0 comments on commit 5e2ce5c

Please sign in to comment.