[InlineData(VariantType.run_of_homozygosity, false)] // no change
public void NeedsTranscriptVariant_NoConsequences_EvaluateByVariantType(VariantType variantType, bool expectedResult)
{
var consequences = new List <ConsequenceTag>();
bool observedResult = Consequences.NeedsTranscriptVariant(variantType, consequences);
Assert.Equal(expectedResult, observedResult);
}
public void DetermineRegularoryVariantEffects(bool isAmplification, bool isAblation)
{
var featureEffect = new Mock <IFeatureVariantEffects>();
featureEffect.Setup(x => x.Ablation()).Returns(isAblation);
featureEffect.Setup(x => x.Amplification()).Returns(isAmplification);
var consequence = new Consequences(null, featureEffect.Object);
consequence.DetermineRegulatoryVariantEffects();
var observedConsequences = consequence.GetConsequences();
Assert.Contains(ConsequenceTag.regulatory_region_variant, observedConsequences);
if (isAblation)
{
Assert.Contains(ConsequenceTag.regulatory_region_ablation, observedConsequences);
}
else
{
Assert.DoesNotContain(ConsequenceTag.regulatory_region_ablation, observedConsequences);
}
if (isAmplification)
{
Assert.Contains(ConsequenceTag.regulatory_region_amplification, observedConsequences);
}
else
{
Assert.DoesNotContain(ConsequenceTag.regulatory_region_amplification, observedConsequences);
}
}
public static IAnnotatedTranscript GetAnnotatedTranscript(int variantEnd, ITranscript transcript)
{
bool isDownStream = variantEnd < transcript.Start == transcript.Gene.OnReverseStrand;
List <ConsequenceTag> consequences = Consequences.DetermineFlankingVariantEffects(isDownStream);
return(new AnnotatedTranscript(transcript, null, null, null, null, null, null, null, null, null, consequences, false));
}
public void DetermineFlankingVariantEffects(bool isDownStreamVariant, ConsequenceTag expectedConsequence)
{
List <ConsequenceTag> observedConsequences = Consequences.DetermineFlankingVariantEffects(isDownStreamVariant);
Assert.Single(observedConsequences);
Assert.Equal(expectedConsequence, observedConsequences[0]);
}
private void AddConsequence(ConsequencesTypeConsequence consequence)
{
if (consequence != null)
{
IEnumerable <string> scopes = null;
IEnumerable <string> impacts = null;
Evaluation likelihood = Evaluation.Unknown;
var s = consequence.Scope?.ToArray();
if (s?.Any() ?? false)
{
scopes = s.Select(x => x.GetXmlEnumLabel());
}
var i = consequence.Impact?.ToArray();
if (i?.Any() ?? false)
{
impacts = i.Select(x => x.GetXmlEnumLabel());
}
if (Enum.TryParse <Evaluation>(consequence.Likelihood.ToString(), out var l))
{
likelihood = l;
}
var notes = consequence.Note?.ConvertToString();
if (Consequences == null)
{
Consequences = new List <Consequence>();
}
Consequences.Add(new Consequence(scopes, impacts, likelihood, notes));
}
}
public void Define_rule()
{
var conditions = new RuleCondition[]
{
Conditions.Equal((Order x) => x.Name, "JOE"),
Conditions.GreaterThan((Order x) => x.Amount, 10000.0m),
};
var consequences = new RuleConsequence[]
{
Consequences.Delegate <Order>((session, x) => { _result = x; }),
Consequences.Delegate <Order>((session, x) => { _resultB = x; }),
};
_rule = new OdoyuleRule("RuleA", conditions, consequences);
_rule2 = new OdoyuleRule("RuleB", conditions, consequences);
conditions = new RuleCondition[]
{
Conditions.Equal((Account a) => a.Name, "JOE"),
};
consequences = new RuleConsequence[]
{
Consequences.Delegate((Session session, Account a) => { }),
};
_rule3 = new OdoyuleRule("RuleC", conditions, consequences);
}
private void AnnotateAltAllele(VariantFeature variant, VariantAlternateAllele altAllele, Transcript transcript)
{
// handle upstream or downstream transcripts
if (!Overlap.Partial(transcript.Start, transcript.End, altAllele.Start, altAllele.End))
{
return;
}
var ta = new TranscriptAnnotation
{
AlternateAllele = altAllele,
HasValidCdnaCodingStart = false,
HasValidCdsStart = false
};
MapCdnaCoordinates(transcript, ta, altAllele);
_pianoVariant.CreateAnnotationObject(transcript, altAllele);
GetCodingAnnotations(transcript, ta, _compressedSequence);
var consequence = new Consequences(new VariantEffect(ta, transcript, variant.InternalCopyNumberType));
consequence.DetermineVariantEffects(variant.InternalCopyNumberType);
_pianoVariant.FinalizeAndAddAnnotationObject(transcript, ta, consequence.GetConsequenceStrings());
}
private void AddConsequences(JsonObject jsonObject)
{
if (Consequences.Count == 0)
{
Consequences.Add(ConsequenceTag.transcript_variant);
}
jsonObject.AddStringValues("consequence", Consequences?.Select(ConsequenceUtil.GetConsequence));
}
private static List <ConsequenceTag> GetConsequences(IInterval transcript, IVariant variant)
{
var featureEffect = new FeatureVariantEffects(transcript, variant.Type, variant, true);
var consequence = new Consequences(null, featureEffect);
consequence.DetermineStructuralVariantEffect(variant);
return(consequence.GetConsequences());
}
[InlineData(ConsequenceTag.short_tandem_repeat_contraction, true)] // parallel
public void NeedsTranscriptVariant_STR(ConsequenceTag consequence, bool expectedResult)
{
var consequences = new List <ConsequenceTag> {
consequence
};
bool observedResult = Consequences.NeedsTranscriptVariant(VariantType.unknown, consequences);
Assert.Equal(expectedResult, observedResult);
}
private static IEnumerable <ConsequenceTag> GetConsequences(IInterval transcript, ISimpleVariant variant,
bool hasGeneFusionAnnotation)
{
var featureEffect = new FeatureVariantEffects(transcript, variant.Type, variant, true);
var consequence = new Consequences(null, featureEffect);
consequence.DetermineStructuralVariantEffect(variant.Type, hasGeneFusionAnnotation);
return(consequence.GetConsequences());
}
public static IAnnotatedTranscript GetAnnotatedTranscript(int variantEnd, ITranscript transcript)
{
var isDownStream = variantEnd < transcript.Start == transcript.Gene.OnReverseStrand;
var consequence = new Consequences();
consequence.DetermineFlankingVariantEffects(isDownStream);
return(new AnnotatedTranscript(transcript, null, null, null, null, null, null, null, null, null,
consequence.GetConsequences(), false));
}
public void NeedsTranscriptVariant_Tier2_MatureMirnaVariant()
{
var consequences = new List <ConsequenceTag> {
ConsequenceTag.mature_miRNA_variant
};
bool observedResult = Consequences.NeedsTranscriptVariant(VariantType.unknown, consequences);
Assert.False(observedResult);
}
public static void Delegate <T>(this ThenConfigurator <T> configurator, Action <T> callback)
where T : class
{
DelegateConsequence <T> consequence = Consequences.Delegate <T>((session, fact) => callback(fact));
var consequenceConfigurator = new RuleConsequenceConfiguratorImpl <T>(consequence);
configurator.AddConfigurator(consequenceConfigurator);
}
public override ScriptStats GetStatistics()
{
ScriptStats s = new ScriptStats();
s.IfThen++;
s.Add(slot.GetStatistics());
s.Add(Consequences.GetStatistics());
return(s);
}
public static IAnnotatedRegulatoryRegion Annotate(IVariant variant, IRegulatoryRegion regulatoryRegion)
{
var featureEffect = new FeatureVariantEffects(regulatoryRegion, variant.Type, variant, variant.IsStructuralVariant);
var consequence = new Consequences(null, featureEffect);
consequence.DetermineRegulatoryVariantEffects();
return(new AnnotatedRegulatoryRegion(regulatoryRegion, consequence.GetConsequences()));
}
private static List <ConsequenceTag> GetConsequences(IInterval transcript, bool onReverseStrand, IVariant variant)
{
OverlapType overlapType = Intervals.Utilities.GetOverlapType(transcript.Start, transcript.End, variant.Start, variant.End);
EndpointOverlapType endpointOverlapType = Intervals.Utilities.GetEndpointOverlapType(transcript.Start, transcript.End, variant.Start, variant.End);
var featureEffect = new FeatureVariantEffects(overlapType, endpointOverlapType, onReverseStrand, variant.Type, true);
var consequence = new Consequences(variant.Type, null, featureEffect);
consequence.DetermineStructuralVariantEffect(variant);
return(consequence.GetConsequences());
}
public void DetermineFlankingVariantEffects(bool isDownStreamVariant, ConsequenceTag expectedConsequence)
{
var consequence = new Consequences();
consequence.DetermineFlankingVariantEffects(isDownStreamVariant);
var observedConsequences = consequence.GetConsequences();
Assert.Single(observedConsequences);
Assert.Equal(expectedConsequence, observedConsequences[0]);
}
private static List <ConsequenceTag> GetConsequences(ITranscript transcript, IVariant variant, VariantEffect variantEffect)
{
var featureEffect = new FeatureVariantEffects(transcript, variant.Type, variant.Start, variant.End,
variant.Behavior.StructuralVariantConsequence);
var consequence = new Consequences(variantEffect, featureEffect);
consequence.DetermineSmallVariantEffects();
return(consequence.GetConsequences());
}
public void SerializeJson(StringBuilder sb)
{
var jsonObject = new JsonObject(sb);
sb.Append(JsonObject.OpenBrace);
jsonObject.AddStringValue("transcript", Transcript.Id.WithVersion);
jsonObject.AddStringValue("bioType", GetBioType(Transcript.BioType));
jsonObject.AddStringValue("codons", GetAlleleString(ReferenceCodons, AlternateCodons));
jsonObject.AddStringValue("aminoAcids", GetAlleleString(ReferenceAminoAcids, AlternateAminoAcids));
if (MappedPosition != null)
{
jsonObject.AddStringValue("cdnaPos", GetRangeString(MappedPosition.CdnaStart, MappedPosition.CdnaEnd));
jsonObject.AddStringValue("cdsPos", GetRangeString(MappedPosition.CdsStart, MappedPosition.CdsEnd));
jsonObject.AddStringValue("exons", GetFractionString(MappedPosition.ExonStart, MappedPosition.ExonEnd, Transcript.NumExons));
jsonObject.AddStringValue("introns", GetFractionString(MappedPosition.IntronStart, MappedPosition.IntronEnd, Transcript.NumExons - 1));
jsonObject.AddStringValue("proteinPos", GetRangeString(MappedPosition.ProteinStart, MappedPosition.ProteinEnd));
}
var geneId = Transcript.Source == Source.Ensembl
? Transcript.Gene.EnsemblId.ToString()
: Transcript.Gene.EntrezGeneId.ToString();
jsonObject.AddStringValue("geneId", geneId);
jsonObject.AddStringValue("hgnc", Transcript.Gene.Symbol);
jsonObject.AddStringValues("consequence", Consequences?.Select(ConsequenceUtil.GetConsequence));
jsonObject.AddStringValue("hgvsc", HgvsCoding);
jsonObject.AddStringValue("hgvsp", HgvsProtein);
jsonObject.AddStringValue("geneFusion", GeneFusionAnnotation?.ToString(), false);
jsonObject.AddBoolValue("isCanonical", Transcript.IsCanonical);
jsonObject.AddDoubleValue("polyPhenScore", PolyPhen?.Score);
jsonObject.AddStringValue("polyPhenPrediction", PolyPhen?.Prediction);
if (Transcript.Translation != null)
{
jsonObject.AddStringValue("proteinId", Transcript.Translation.ProteinId.WithVersion);
}
jsonObject.AddDoubleValue("siftScore", Sift?.Score);
jsonObject.AddStringValue("siftPrediction", Sift?.Prediction);
if (PluginData != null)
{
foreach (var pluginData in PluginData)
{
jsonObject.AddStringValue(pluginData.Name, pluginData.GetJsonString(), false);
}
}
sb.Append(JsonObject.CloseBrace);
}
public static void Add <T, TFact>(this ThenConfigurator <T> configurator,
Func <T, TFact> factFactory)
where T : class
where TFact : class
{
AddFactConsequence <T, TFact> consequence = Consequences.Add(factFactory);
var consequenceConfigurator = new RuleConsequenceConfiguratorImpl <T>(consequence);
configurator.AddConfigurator(consequenceConfigurator);
}
public static IAnnotatedRegulatoryRegion Annotate(IVariant variant, IRegulatoryRegion regulatoryRegion)
{
OverlapType overlapType = Intervals.Utilities.GetOverlapType(regulatoryRegion.Start, regulatoryRegion.End,
variant.Start, variant.End);
EndpointOverlapType endpointOverlapType =
Intervals.Utilities.GetEndpointOverlapType(regulatoryRegion.Start, regulatoryRegion.End, variant.Start, variant.End);
var featureEffect = new FeatureVariantEffects(overlapType, endpointOverlapType, false, variant.Type, variant.IsStructuralVariant);
var consequence = new Consequences(VariantType.unknown, null, featureEffect);
consequence.DetermineRegulatoryVariantEffects();
return(new AnnotatedRegulatoryRegion(regulatoryRegion, consequence.GetConsequences()));
}
public override Moveable DeepCopy()
{
IfControl copy = new IfControl();
if (Condition != null)
{
copy.Condition = Condition.DeepCopy();
}
copy.Consequences = Consequences.DeepCopy();
return(copy);
}
public static FactDesigner <T> Add <T, TAdd>(this FactDesigner <T> designer, Func <TAdd> factFactory)
where T : class
where TAdd : class
{
designer.Then(then =>
{
AddFactConsequence <T, TAdd> consequence = Consequences.Add <T, TAdd>(x => factFactory());
var consequenceConfigurator = new RuleConsequenceConfigurator <T>(consequence);
then.AddConfigurator(consequenceConfigurator);
});
return(designer);
}
public void Define_rule()
{
var conditions = new RuleCondition[]
{
Conditions.Equal((Order x) => x.Name, "JOE"),
};
var consequences = new RuleConsequence[]
{
Consequences.Delegate <Order>((session, x) => { _result = x; }),
};
Rule rule = new OdoyuleRule("RuleA", conditions, consequences);
_engine = RulesEngineFactory.New(x => x.Add(rule));
}
public override void AssignImage(ImageProvider imageProvider)
{
if (imageProvider == null)
{
throw new ArgumentNullException("imageProvider");
}
if (Condition != null)
{
Condition.AssignImage(imageProvider);
}
if (Consequences != null)
{
Consequences.AssignImage(imageProvider);
}
}
public void Define_rule()
{
var conditions = new RuleCondition[]
{
Conditions.GreaterThan((Order x) => x.Amount, 10000.0m),
};
var consequences = new RuleConsequence[]
{
Consequences.Delegate <Order>((session, x) => { _result = x; }),
};
Rule rule = new OdoyuleRule("RuleA", conditions, consequences);
_engine = RulesEngineFactory.New(x => x.Add(rule));
}
public void Define_rule()
{
var conditions = new[]
{
Conditions.NotNull((Order x) => x.Customer),
};
var consequences = new[]
{
Consequences.Delegate((Order o) => _result = o),
};
Rule rule = new SemanticRule("RuleA", conditions, consequences);
_engine = RulesEngineFactory.New(x => x.Add(rule));
}
public void Define_rule()
{
var conditions = new[]
{
Conditions.GreaterThan((Order x) => x.Amount, 10000.0m),
};
var consequences = new[]
{
Consequences.Delegate((Order o) => _result = o),
};
Rule rule = new SemanticRule("RuleA", conditions, consequences);
_engine = RulesEngineFactory.New(x => x.Add(rule));
}
public void DetermineSmallVariantEffects_tier1()
{
var featureEffect = new Mock <IFeatureVariantEffects>();
featureEffect.Setup(x => x.Ablation()).Returns(true);
featureEffect.Setup(x => x.Amplification()).Returns(true);
var variantEffect = new Mock <IVariantEffect>();
var consequence = new Consequences(variantEffect.Object, featureEffect.Object);
consequence.DetermineSmallVariantEffects();
var observedConsequences = consequence.GetConsequences();
Assert.Equal(2, observedConsequences.Count);
Assert.Equal(ConsequenceTag.transcript_ablation, observedConsequences[0]);
Assert.Equal(ConsequenceTag.transcript_amplification, observedConsequences[1]);
}
