func makeVariant(chrom string, pos int, ref string, alt []string, name string, info string, h *vcfgo.Header) *parsers.Variant {
binfo := vcfgo.NewInfoByte([]byte(info), h)
v := vcfgo.Variant{Chromosome: chrom, Pos: uint64(pos), Reference: ref, Alternate: alt,
Id_: name, Info_: binfo}
return parsers.NewVariant(&v, 0, make([]interfaces.Relatable, 0))
}
// vFromB makes a variant from an interval. this helps avoid code duplication.
func vFromB(b *parsers.Interval) *parsers.Variant {
h := vcfgo.NewHeader()
h.Infos["SVLEN"] = &vcfgo.Info{Id: "SVLEN", Type: "Integer", Description: "", Number: "1"}
m := vcfgo.NewInfoByte([]byte(fmt.Sprintf("SVLEN=%d", int(b.End()-b.Start())-1)), h)
v := parsers.NewVariant(&vcfgo.Variant{Chromosome: b.Chrom(), Pos: uint64(b.Start() + 1),
Reference: "A", Alternate: []string{"<DEL>"}, Info_: m}, 0, b.Related())
return v
}
func (s *APISuite) SetUpTest(c *C) {
h.Infos["DP"] = &vcfgo.Info{Id: "DP", Description: "depth", Number: "1", Type: "Integer"}
h.Infos["SVLEN"] = &vcfgo.Info{Id: "SVLEN", Description: "SVLEN", Number: "1", Type: "Integer"}
h.Infos["CIPOS"] = &vcfgo.Info{Id: "CIPOS", Description: "CIPOS", Number: "2", Type: "Integer"}
h.Infos["CIEND"] = &vcfgo.Info{Id: "CIEND", Description: "CIEND", Number: "2", Type: "Integer"}
h.Infos["AF"] = &vcfgo.Info{Id: "AF", Description: "AF", Number: "1", Type: "Float"}
h.Infos["AC_AFR"] = &vcfgo.Info{Id: "AF_AFR", Description: "AF_AFR", Number: "1", Type: "Float"}
vv := *v1
vv.Info_ = vcfgo.NewInfoByte([]byte("DP=35"), h)
s.v1 = &parsers.Variant{IVariant: &vv}
s.v1.SetSource(0)
v2 := *v1
v2.Info_ = vcfgo.NewInfoByte([]byte("DP=44"), h)
s.v2 = &parsers.Variant{IVariant: &v2}
s.v2.Info().Set("AC_AFR", 33)
s.v2.SetSource(1)
sv1.Info_ = vcfgo.NewInfoByte([]byte("DP=35;SVLEN=15;CIPOS=-5,5;CIEND=-8,8"), h)
s.sv1 = &parsers.Variant{IVariant: sv1}
s.sv1.SetSource(0)
v3 := *v1
v3.Info_ = vcfgo.NewInfoByte([]byte("DP=88"), h)
s.v3 = &parsers.Variant{IVariant: &v3}
s.v3.SetSource(1)
v, e := v1.Info_.Get("DP")
c.Assert(e, IsNil)
c.Assert(v, Equals, 35)
v, e = v2.Info_.Get("DP")
c.Assert(e, IsNil)
c.Assert(v, Equals, 44)
v, e = v3.Info_.Get("DP")
c.Assert(e, IsNil)
c.Assert(v, Equals, 88)
s.v1.AddRelated(s.v2)
s.v1.AddRelated(s.v3)
s.sv1.AddRelated(s.v2)
s.sv1.AddRelated(s.v3)
c.Assert(2, Equals, len(s.v1.Related()))
sbed, err := parsers.IntervalFromBedLine([]byte("chr1\t224\t244\t111\t222"))
c.Assert(err, IsNil)
s.bed = sbed.(*parsers.Interval)
s.bed.SetSource(2)
s.v1.AddRelated(s.bed)
s.sv1.AddRelated(s.bed)
s.src = Source{
File: "example/fitcons.bed",
Op: "mean",
Name: "fitcons_mean",
Column: 4,
Field: "",
Index: 1,
}
s.src0 = Source{
File: "example/exac.vcf",
Op: "first",
Column: -1,
Field: "AC_AFR",
Name: "AC_AFR",
Index: 0,
}
empty := make([]PostAnnotation, 0)
code := `
function sum(t)
local sum = 0
for i=1,#t do
sum = sum + t[i]
end
return sum
end
function mean(t)
return sum(t) / #t
end
`
s.annotator = NewAnnotator([]*Source{&s.src0, &s.src}, code, false, true, empty)
}
annotator *Annotator
}
var _ = Suite(&APISuite{})
var h = vcfgo.NewHeader()
var v1 = &vcfgo.Variant{
Chromosome: "chr1",
Pos: uint64(234),
Id_: "id",
Reference: "A",
Alternate: []string{"T", "G"},
Quality: float32(555.5),
Filter: "PASS",
Info_: vcfgo.NewInfoByte([]byte("DP=35"), h),
}
var sv1 = &vcfgo.Variant{
Chromosome: "chr1",
Pos: uint64(230),
Id_: "id",
Reference: "A",
Alternate: []string{"<DEL>"},
Quality: float32(555.5),
Filter: "PASS",
Info_: vcfgo.NewInfoByte([]byte("DP=35;SVLEN=15;CIPOS=-5,5;CIEND=-8,8"), h),
}
func (s *APISuite) SetUpTest(c *C) {
h.Infos["DP"] = &vcfgo.Info{Id: "DP", Description: "depth", Number: "1", Type: "Integer"}
// AnnotateEnds makes a new 1-base interval for the left and one for the right end
// so that it can use the same machinery to annotate the ends and the entire interval.
// Output into the info field is prefixed with "left_" or "right_".
func (a *Annotator) AnnotateEnds(v interfaces.Relatable, ends string) error {
var err error
// if Both, call the interval, left, and right version to annotate.
if ends == BOTH {
if e := a.AnnotateOne(v, a.Strict); e != nil {
err = e
}
if e := a.PostAnnotate(v.Chrom(), int(v.Start()), int(v.End()), v.(interfaces.IVariant).Info(), ""); e != nil {
err = e
}
if e := a.AnnotateEnds(v, LEFT); e != nil {
err = e
}
if e := a.AnnotateEnds(v, RIGHT); e != nil {
err = e
}
}
if ends == INTERVAL {
err := a.AnnotateOne(v, a.Strict)
err2 := a.PostAnnotate(v.Chrom(), int(v.Start()), int(v.End()), v.(interfaces.IVariant).Info(), "")
if err != nil {
return err
}
return err2
}
// hack:
// modify the variant in-place to create a 1-base variant at the end of
// the interval. annotate that end and then change the position back to what it was.
if ends == LEFT || ends == RIGHT {
// the end is determined by the SVLEN, so we have to make sure it has length 1.
variant := v.(*parsers.Variant).IVariant
var l, r uint32
var ok bool
if ends == LEFT {
l, r, ok = variant.CIPos()
} else {
l, r, ok = variant.CIEnd()
}
// dont reannotate same interval
if !ok && (l == v.Start() && r == v.End()) {
return nil
}
m := vcfgo.NewInfoByte([]byte(fmt.Sprintf("SVLEN=%d;END=%d", r-l-1, r)), variant.(*vcfgo.Variant).Header)
v2 := parsers.NewVariant(&vcfgo.Variant{Chromosome: v.Chrom(), Pos: uint64(l + 1),
Reference: "A", Alternate: []string{"<DEL>"}, Info_: m}, v.Source(), v.Related())
err = a.AnnotateOne(v2, false, ends)
var val interface{}
for _, key := range v2.Info().Keys() {
if key == "SVLEN" || key == "END" {
continue
}
val, err = v2.Info().Get(key)
variant.Info().Set(key, val)
}
err2 := a.PostAnnotate(v.Chrom(), int(l), int(r), variant.Info(), ends)
if err2 != nil {
err = err2
}
}
return err
}
// AnnotatedEnds makes a new 1-base interval for the left and one for the right end
// so that it can use the same machinery to annotate the ends and the entire interval.
// Output into the info field is prefixed with "left_" or "right_".
func (a *Annotator) AnnotateEnds(r interfaces.Relatable, ends string) error {
v, ok := r.(interfaces.VarWrap)
if !ok {
return fmt.Errorf("unable to convert %v to Variant", r)
}
var err error
// if Both, call the interval, left, and right version to annotate.
if ends == BOTH {
// dont want strict for BED.
if e := a.AnnotateOne(v, a.Strict && ok); e != nil {
log.Println(e)
return e
}
if e := a.AnnotateEnds(v, LEFT); e != nil {
log.Println(e)
return e
}
if e := a.AnnotateEnds(v, RIGHT); e != nil {
log.Println(e)
return e
}
// it was a Bed, we add the info to its fields
if !ok {
b := r.(*parsers.Interval)
v.Info().Delete("SVLEN")
b.Fields = append(b.Fields, v.Info().Bytes())
}
return nil
}
if ends == INTERVAL {
return a.AnnotateOne(r, a.Strict)
}
// hack:
// modify the variant in-place to create a 1-base variant at the end of
// the interval. annotate that end and then change the position back to what it was.
if ends == LEFT || ends == RIGHT {
// the end is determined by the SVLEN, so we have to make sure it has length 1.
var l, r uint32
var ok bool
if ends == LEFT {
l, r, ok = v.IVariant.(interfaces.CIFace).CIPos()
} else {
l, r, ok = v.IVariant.(interfaces.CIFace).CIEnd()
}
// dont reannotate same interval
if !ok && (l == v.Start() && r == v.End()) {
return nil
}
m := vcfgo.NewInfoByte([]byte(fmt.Sprintf("SVLEN=%d;END=%d", r-l-1, r)), v.IVariant.(*vcfgo.Variant).Header)
v2 := parsers.NewVariant(&vcfgo.Variant{Chromosome: v.Chrom(), Pos: uint64(l + 1),
Reference: "A", Alternate: []string{"<DEL>"}, Info_: m}, v.Source(), v.Related())
err = a.AnnotateOne(v2, false, ends)
if err != nil {
log.Println(err)
}
var val interface{}
for _, key := range v2.Info().Keys() {
if key == "SVLEN" || key == "END" {
continue
}
val, err = v2.Info().Get(key)
v.Info().Set(key, val)
}
}
return err
}