public async Task WaterfallPrompt() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); var convState = new ConversationState(new MemoryStorage()); var testProperty = convState.CreateProperty <Dictionary <string, object> >("test", () => new Dictionary <string, object>()); TestAdapter adapter = new TestAdapter() .Use(convState); await new TestFlow(adapter, async(turnContext) => { if (turnContext.Activity.Type == ActivityTypes.Message) { var state = await testProperty.GetAsync(turnContext); var dialogs = new DialogSet(); dialogs.Add("test-waterfall", Create_Waterfall2()); dialogs.Add("number", new NumberPrompt <int>(Culture.English)); var dc = dialogs.CreateContext(turnContext, state); await dc.ContinueAsync(); if (!turnContext.Responded) { await dc.BeginAsync("test-waterfall"); } } }) .Test(activities) .StartTestAsync(); }
public async Task WaterfallNested() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); TestAdapter adapter = new TestAdapter() .Use(new ConversationState <Dictionary <string, object> >(new MemoryStorage())); await new TestFlow(adapter, async(turnContext) => { var dialogs = new DialogSet(); dialogs.Add("test-waterfall-a", Create_Waterfall3()); dialogs.Add("test-waterfall-b", Create_Waterfall4()); dialogs.Add("test-waterfall-c", Create_Waterfall5()); var state = ConversationState <Dictionary <string, object> > .Get(turnContext); var dc = dialogs.CreateContext(turnContext, state); await dc.Continue(); if (!turnContext.Responded) { await dc.Begin("test-waterfall-a"); } }) .Test(activities) .StartTestAsync(); }
public async Task LocaleConvertToEnglish() { var botLocale = "en-us"; var activities = TranscriptUtilities.GetFromTestContext(TestContext); var userState = new UserState(new MemoryStorage()); var userLangProp = userState.CreateProperty <string>("language", () => "en-us"); TestAdapter adapter = new TestAdapter() .Use(userState) .Use(new LocaleConverterMiddleware(userLangProp, botLocale, LocaleConverter.Converter)); var flow = new TestFlow(adapter, async(context, cancellationToken) => { if (context.Activity.Type == ActivityTypes.Message) { var userMessage = context.Activity.Text.ToLowerInvariant(); if (userMessage.StartsWith("set language ")) { await userLangProp.SetAsync(context, userMessage.Substring(13, 5)); } else { await context.SendActivityAsync($"message: {context.Activity.Text}"); } } }); await flow.Test(activities, (expected, actual) => { Assert.AreEqual(expected.AsMessageActivity().Text, actual.AsMessageActivity().Text); }).StartTestAsync(); }
public async Task CustomStateTest() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); var storage = new MemoryStorage(); TestAdapter adapter = new TestAdapter() .Use(new CustomState(storage)); var flow = new TestFlow(adapter, async(context) => { var(command, value) = GetCommandValue(context); switch (command) { case "delete": CustomState.Get(context).Value = null; break; case "set": CustomState.Get(context).Value = value; break; case "read": await context.SendActivityAsync($"value:{CustomState.Get(context).Value}"); break; default: await context.SendActivityAsync("bot message"); break; } }); await flow.Test(activities).StartTestAsync(); }
public async Task TranslateToEnglish() { if (!EnvironmentVariablesDefined()) { Assert.Inconclusive("Missing Translator Environment variables - Skipping test"); return; } var nativeLanguages = new string[] { "en-us" }; var patterns = new Dictionary <string, List <string> >(); var activities = TranscriptUtilities.GetFromTestContext(TestContext); TestAdapter adapter = new TestAdapter() .Use(new UserState <LanguageState>(new MemoryStorage())) .Use(new TranslationMiddleware(nativeLanguages, translatorKey, patterns, new CustomDictionary(), GetUserLanguage, SetUserLanguage, false)); var flow = new TestFlow(adapter, async(context) => { if (!context.Responded) { await context.SendActivityAsync($"message: {context.Activity.Text}"); } }); await flow.Test(activities).StartTestAsync(); }
/// <summary> /// reads the transcript from the binary reader /// </summary> public static Transcript Read(ExtendedBinaryReader reader, Gene[] cacheGenes, SimpleInterval[] cacheIntrons, SimpleInterval[] cacheMirnas, string[] cachePeptideSeqs) { // transcript var referenceIndex = reader.ReadUInt16(); var start = reader.ReadOptInt32(); var end = reader.ReadOptInt32(); var id = CompactId.Read(reader); // gene var geneIndex = reader.ReadOptInt32(); var gene = cacheGenes[geneIndex]; // encoded data var encoded = new EncodedTranscriptData(reader.ReadUInt16(), reader.ReadByte()); // exons & introns var introns = encoded.HasIntrons ? ReadIndices(reader, cacheIntrons) : null; var cdnaMaps = encoded.HasCdnaMaps ? ReadCdnaMaps(reader) : null; // protein function predictions int siftIndex = encoded.HasSift ? reader.ReadOptInt32() : -1; int polyphenIndex = encoded.HasPolyPhen ? reader.ReadOptInt32() : -1; // translation var translation = encoded.HasTranslation ? Translation.Read(reader, cachePeptideSeqs) : null; // attributes var mirnas = encoded.HasMirnas ? ReadIndices(reader, cacheMirnas) : null; return(new Transcript(referenceIndex, start, end, id, encoded.Version, translation, encoded.BioType, gene, TranscriptUtilities.GetTotalExonLength(cdnaMaps), encoded.StartExonPhase, encoded.IsCanonical, introns, mirnas, cdnaMaps, siftIndex, polyphenIndex, encoded.TranscriptSource)); }
public async Task DateTimePrompt() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); TestAdapter adapter = new TestAdapter() .Use(new ConversationState <Dictionary <string, object> >(new MemoryStorage())); await new TestFlow(adapter, async(turnContext) => { var state = ConversationState <Dictionary <string, object> > .Get(turnContext); var prompt = new DateTimePrompt(Culture.English); var dialogCompletion = await prompt.Continue(turnContext, state); if (!dialogCompletion.IsActive && !dialogCompletion.IsCompleted) { await prompt.Begin(turnContext, state, new PromptOptions { PromptString = "What date would you like?", RetryPromptString = "Sorry, but that is not a date. What date would you like?" }); } else if (dialogCompletion.IsCompleted) { var dateTimeResult = (DateTimeResult)dialogCompletion.Result; var resolution = dateTimeResult.Resolution.First(); var reply = $"Timex:'{resolution.Timex}' Value:'{resolution.Value}'"; await turnContext.SendActivityAsync(reply); } }) .Test(activities) .StartTestAsync(); }
public async Task AttachmentPrompt() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); TestAdapter adapter = new TestAdapter() .Use(new ConversationState <Dictionary <string, object> >(new MemoryStorage())); await new TestFlow(adapter, async(turnContext) => { var state = ConversationState <Dictionary <string, object> > .Get(turnContext); var prompt = new AttachmentPrompt(); var dialogCompletion = await prompt.Continue(turnContext, state); if (!dialogCompletion.IsActive && !dialogCompletion.IsCompleted) { await prompt.Begin(turnContext, state, new PromptOptions { PromptString = "please add an attachment." }); } else if (dialogCompletion.IsCompleted) { var attachmentResult = (AttachmentResult)dialogCompletion.Result; var reply = (string)attachmentResult.Attachments.First().Content; await turnContext.SendActivityAsync(reply); } }) .Test(activities) .StartTestAsync(); }
public async Task WaterfallNested() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); var convState = new ConversationState(new MemoryStorage()); var testProperty = convState.CreateProperty <Dictionary <string, object> >("test"); var adapter = new TestAdapter() .Use(convState); await new TestFlow(adapter, async(turnContext, cancellationToken) => { if (turnContext.Activity.Type == ActivityTypes.Message) { var state = await testProperty.GetAsync(turnContext, () => new Dictionary <string, object>()); var dialogs = new DialogSet(); dialogs.Add("test-waterfall-a", Create_Waterfall3()); dialogs.Add("test-waterfall-b", Create_Waterfall4()); dialogs.Add("test-waterfall-c", Create_Waterfall5()); var dc = dialogs.CreateContext(turnContext, state); await dc.ContinueAsync(); if (!turnContext.Responded) { await dc.BeginAsync("test-waterfall-a"); } } }) .Test(activities) .StartTestAsync(); }
public void FinalizeAndAddAnnotationObject(Transcript transcript, TranscriptAnnotation ta, string[] consequences) { if (!ta.AlternateAllele.IsStructuralVariant) { _currTranscript.ComplementaryDnaPosition = GetCdnaRangeString(ta); _currTranscript.HgvsCodingSequenceName = ta.HgvsCodingSequenceName; if (ta.HasValidCdnaCodingStart) { _currTranscript.ProteinID = TranscriptUtilities.GetProteinId(transcript); } } else { _currTranscript.ProteinID = ta.HasValidCdnaCodingStart ? TranscriptUtilities.GetProteinId(transcript) : null; if (ta.GeneFusionAnnotations != null && ta.GeneFusionAnnotations.Count == 1) { var sb = new StringBuilder(); ta.GeneFusionAnnotations.First().SerializeJson(sb); _currTranscript.GeneFusion = sb.ToString(); } else if (ta.GeneFusionAnnotations != null && ta.GeneFusionAnnotations.Count > 1) { throw new Exception("has mutiple gene fusions"); } } _currTranscript.Consequence = consequences; _currJsonVariant.AddTranscript(_currTranscript, transcript.TranscriptSource); }
public async Task Waterfall() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); var convState = new ConversationState(new MemoryStorage()); var testProperty = convState.CreateProperty <Dictionary <string, object> >("test"); var adapter = new TestAdapter() .Use(convState); await new TestFlow(adapter, async(turnContext, cancellationToken) => { if (turnContext.Activity.Type == ActivityTypes.Message) { var state = await testProperty.GetAsync(turnContext, () => new Dictionary <string, object>()); var waterfall = new Waterfall(new WaterfallStep[] { async(dc, args, next) => { await dc.Context.SendActivityAsync("step1"); }, async(dc, args, next) => { await dc.Context.SendActivityAsync("step2"); }, async(dc, args, next) => { await dc.Context.SendActivityAsync("step3"); }, }); var dialogCompletion = await waterfall.ContinueAsync(turnContext, state); if (!dialogCompletion.IsActive && !dialogCompletion.IsCompleted) { await waterfall.BeginAsync(turnContext, state); } } }) .Test(activities) .StartTestAsync(); }
/// <summary> /// parses the relevant data from each mapper unit object /// </summary> public static (int Start, int End, MapperUnitType Type) Parse(ObjectValueNode objectValue) { int start = -1; int end = -1; var type = MapperUnitType.Unknown; foreach (var node in objectValue.Values) { // sanity check: make sure we know about the keys are used for if (!KnownKeys.Contains(node.Key)) { throw new InvalidDataException($"Encountered an unknown key in the mapper unit object: {node.Key}"); } switch (node.Key) { case ImportKeys.Id: type = TranscriptUtilities.GetMapperUnitType(node); break; case ImportKeys.End: end = node.GetInt32(); break; case ImportKeys.Start: start = node.GetInt32(); break; default: throw new InvalidDataException($"Unknown key found: {node.Key}"); } } return(start, end, type); }
public async Task AttachmentPrompt() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); var convState = new ConversationState(new MemoryStorage()); var testProperty = convState.CreateProperty <Dictionary <string, object> >("test"); var adapter = new TestAdapter() .Use(convState); await new TestFlow(adapter, async(turnContext, cancellationToken) => { if (turnContext.Activity.Type == ActivityTypes.Message) { var state = await testProperty.GetAsync(turnContext, () => new Dictionary <string, object>()); var prompt = new AttachmentPrompt(); var dialogCompletion = await prompt.ContinueAsync(turnContext, state); if (!dialogCompletion.IsActive && !dialogCompletion.IsCompleted) { await prompt.BeginAsync(turnContext, state, new PromptOptions { PromptString = "please add an attachment." }); } else if (dialogCompletion.IsCompleted) { var attachmentResult = (AttachmentResult)dialogCompletion.Result; var reply = (string)attachmentResult.Attachments.First().Content; await turnContext.SendActivityAsync(reply); } } }) .Test(activities) .StartTestAsync(); }
public async Task TranslateToUserLanguage() { if (!EnvironmentVariablesDefined()) { Assert.Inconclusive("Missing Translator Environment variables - Skipping test"); return; } var nativeLanguages = new string[] { }; var patterns = new Dictionary <string, List <string> >(); var activities = TranscriptUtilities.GetFromTestContext(TestContext); var userState = new UserState(new MemoryStorage()); var userLangProp = userState.CreateProperty <string>("language"); TestAdapter adapter = new TestAdapter() .Use(userState) .Use(new TranslationMiddleware(nativeLanguages, translatorKey, patterns, new CustomDictionary(), userLangProp, true)); var flow = new TestFlow(adapter, async(context, cancellationToken) => { if (!context.Responded) { await context.SendActivityAsync($"message: {context.Activity.Text}"); } }); await flow.Test(activities).StartTestAsync(); }
public async Task Waterfall() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); TestAdapter adapter = new TestAdapter() .Use(new ConversationState <Dictionary <string, object> >(new MemoryStorage())); await new TestFlow(adapter, async(turnContext) => { var waterfall = new Waterfall(new WaterfallStep[] { async(dc, args, next) => { await dc.Context.SendActivityAsync("step1"); }, async(dc, args, next) => { await dc.Context.SendActivityAsync("step2"); }, async(dc, args, next) => { await dc.Context.SendActivityAsync("step3"); }, }); var state = ConversationState <Dictionary <string, object> > .Get(turnContext); var dialogCompletion = await waterfall.Continue(turnContext, state); if (!dialogCompletion.IsActive && !dialogCompletion.IsCompleted) { await waterfall.Begin(turnContext, state); } }) .Test(activities) .StartTestAsync(); }
public SvOverlapTranscript(DataStructures.Transcript transcript, VariantAlternateAllele altAllele) { TranscriptID = TranscriptUtilities.GetTranscriptId(transcript); IsCanonical = transcript.IsCanonical ? "true" : null; Hgnc = transcript.Gene.Symbol; var isFullOverlap = altAllele.Start <= transcript.Start && altAllele.End >= transcript.End; IsPartialOverlap = isFullOverlap ? null : "true"; }
private void CreateTranscriptDictionary(List <Transcript> transcripts) { _transcriptsById.Clear(); foreach (var transcript in transcripts) { _transcriptsById[TranscriptUtilities.GetTranscriptId(transcript)] = transcript; } }
/// <summary> /// returns a new exon given an ObjectValue /// </summary> public static DataStructures.VEP.Exon Parse(ObjectValue objectValue, ushort currentReferenceIndex) { bool onReverseStrand = false; int end = -1; byte?phase = null; int start = -1; string stableId = null; // loop over all of the key/value pairs in the exon object foreach (AbstractData ad in objectValue) { // sanity check: make sure we know about the keys are used for if (!KnownKeys.Contains(ad.Key)) { throw new GeneralException($"Encountered an unknown key in the dumper mapper object: {ad.Key}"); } // handle each key switch (ad.Key) { case Transcript.EndKey: end = DumperUtilities.GetInt32(ad); break; case EndPhaseKey: break; case PhaseKey: int phaseInt = DumperUtilities.GetInt32(ad); if (phaseInt != -1) { phase = (byte)phaseInt; } break; case Transcript.StableIdKey: stableId = DumperUtilities.GetString(ad); break; case Transcript.StartKey: start = DumperUtilities.GetInt32(ad); break; case Transcript.StrandKey: onReverseStrand = TranscriptUtilities.GetStrand(ad); break; default: throw new GeneralException($"Unknown key found: {ad.Key}"); } } return(new DataStructures.VEP.Exon(currentReferenceIndex, start, end, stableId, onReverseStrand, phase)); }
public async Task NumberPrompt() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); PromptValidatorEx.PromptValidator <NumberResult <int> > validator = async(ctx, result) => { if (result.Value < 0) { result.Status = PromptStatus.TooSmall; } if (result.Value > 100) { result.Status = PromptStatus.TooBig; } await Task.CompletedTask; }; var convState = new ConversationState(new MemoryStorage()); var testProperty = convState.CreateProperty <Dictionary <string, object> >("test"); var adapter = new TestAdapter() .Use(convState); await new TestFlow(adapter, async(turnContext, cancellationToken) => { if (turnContext.Activity.Type == ActivityTypes.Message) { var state = await testProperty.GetAsync(turnContext, () => new Dictionary <string, object>()); var prompt = new NumberPrompt <int>(Culture.English, validator); var dialogCompletion = await prompt.ContinueAsync(turnContext, state); if (!dialogCompletion.IsActive && !dialogCompletion.IsCompleted) { await prompt.BeginAsync(turnContext, state, new PromptOptions { PromptString = "Enter a number.", RetryPromptString = "You must enter a valid positive number less than 100." }); } else if (dialogCompletion.IsCompleted) { var numberResult = (NumberResult <int>)dialogCompletion.Result; await turnContext.SendActivityAsync($"Bot received the number '{numberResult.Value}'."); } } }) .Test(activities) .StartTestAsync(); }
public async Task ConversationStateTest() { var testName = "ConversationStateTest"; var activities = TranscriptUtilities.GetActivitiesFromFile(ClassName, testName); var storage = new MemoryStorage(); var convoState = new ConversationState(new MemoryStorage()); var testProperty = convoState.CreateProperty <ConversationStateObject>("test"); var adapter = new TestAdapter(TestAdapter.CreateConversation(testName)) .Use(new AutoSaveStateMiddleware(convoState)); var flow = new TestFlow(adapter, async(context, cancellationToken) => { if (context.Activity.Type == ActivityTypes.Message) { var(command, value) = GetCommandValue(context); switch (command) { case "delete": await testProperty.DeleteAsync(context); break; case "set": { var data = await testProperty.GetAsync(context, () => new ConversationStateObject()); data.Value = value; await testProperty.SetAsync(context, data); } break; case "read": { var data = await testProperty.GetAsync(context, () => new ConversationStateObject()); await context.SendActivityAsync($"value:{data.Value}"); } break; default: await context.SendActivityAsync("bot message"); break; } } }); await flow.Test(activities).StartTestAsync(); }
private static string GetAlternateCds(string cacheStub, string transcriptId, string ensemblRefName, int start, int end, string allele) { var transcript = DataUtilities.GetTranscript(cacheStub, transcriptId); Assert.NotNull(transcript); var sequence = DataUtilities.GetCompressedSequence(cacheStub, ensemblRefName); Assert.NotNull(sequence); return(TranscriptUtilities.GetAlternateCds(sequence, start, end, allele, transcript.CdnaMaps, transcript.Gene.OnReverseStrand, transcript.StartExonPhase, transcript.Translation.CodingRegion.CdnaStart)); }
public static (int Start, int End, string Id, bool OnReverseStrand) Parse(IImportNode importNode) { var objectValue = importNode.GetObjectValueNode(); if (objectValue == null) { throw new InvalidDataException("Encountered a gene import node that could not be converted to an object value node."); } int start = -1; int end = -1; string stableId = null; var onReverseStrand = false; foreach (var node in objectValue.Values) { // sanity check: make sure we know about the keys are used for if (!KnownKeys.Contains(node.Key)) { throw new InvalidDataException($"Encountered an unknown key in the dumper gene object: {node.Key}"); } // handle each key switch (node.Key) { case ImportKeys.End: end = node.GetInt32(); break; case ImportKeys.StableId: stableId = node.GetString(); break; case ImportKeys.Start: start = node.GetInt32(); break; case ImportKeys.Strand: onReverseStrand = TranscriptUtilities.GetStrand(node); break; default: throw new InvalidDataException($"Unknown key found: {node.Key}"); } } return(start, end, stableId, onReverseStrand); }
public async Task TextPrompt() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); PromptValidatorEx.PromptValidator <TextResult> validator = async(ctx, result) => { if (result.Value.Length <= 3) { result.Status = PromptStatus.TooSmall; } await Task.CompletedTask; }; var convState = new ConversationState(new MemoryStorage()); var testProperty = convState.CreateProperty <Dictionary <string, object> >("test"); var adapter = new TestAdapter() .Use(convState); await new TestFlow(adapter, async(turnContext, cancellationToken) => { if (turnContext.Activity.Type == ActivityTypes.Message) { var state = await testProperty.GetAsync(turnContext, () => new Dictionary <string, object>()); var prompt = new TextPrompt(validator); var dialogCompletion = await prompt.ContinueAsync(turnContext, state); if (!dialogCompletion.IsActive && !dialogCompletion.IsCompleted) { await prompt.BeginAsync(turnContext, state, new PromptOptions { PromptString = "Enter some text.", RetryPromptString = "Make sure the text is greater than three characters." }); } else if (dialogCompletion.IsCompleted) { var textResult = (TextResult)dialogCompletion.Result; await turnContext.SendActivityAsync($"Bot received the text '{textResult.Value}'."); } } }) .Test(activities) .StartTestAsync(); }
public async Task ConfirmPrompt() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); var convState = new ConversationState(new MemoryStorage()); var testProperty = convState.CreateProperty <Dictionary <string, object> >("test"); var adapter = new TestAdapter() .Use(convState); await new TestFlow(adapter, async(turnContext, cancellationToken) => { if (turnContext.Activity.Type == ActivityTypes.Message) { var state = await testProperty.GetAsync(turnContext, () => new Dictionary <string, object>()); var prompt = new ConfirmPrompt(Culture.English) { Style = ListStyle.None }; var dialogCompletion = await prompt.ContinueAsync(turnContext, state); if (!dialogCompletion.IsActive && !dialogCompletion.IsCompleted) { await prompt.BeginAsync(turnContext, state, new PromptOptions { PromptString = "Please confirm.", RetryPromptString = "Please confirm, say 'yes' or 'no' or something like that." }); } else if (dialogCompletion.IsCompleted) { if (((ConfirmResult)dialogCompletion.Result).Confirmation) { await turnContext.SendActivityAsync("Confirmed."); } else { await turnContext.SendActivityAsync("Not confirmed."); } } } }) .Test(activities) .StartTestAsync(); }
public async Task UserStateTest() { var activities = TranscriptUtilities.GetFromTestContext(TestContext); var userState = new UserState(new MemoryStorage()); var testProperty = userState.CreateProperty <UserStateObject>("test"); var adapter = new TestAdapter() .Use(userState); var flow = new TestFlow(adapter, async(context, cancellationToken) => { if (context.Activity.Type == ActivityTypes.Message) { var(command, value) = GetCommandValue(context); switch (command) { case "delete": await testProperty.DeleteAsync(context); break; case "set": { var data = await testProperty.GetAsync(context, () => new UserStateObject()); data.Value = value; await testProperty.SetAsync(context, data); } break; case "read": { var data = await testProperty.GetAsync(context, () => new UserStateObject()); await context.SendActivityAsync($"value:{data.Value}"); } break; default: await context.SendActivityAsync("bot message"); break; } } }); await flow.Test(activities).StartTestAsync(); }
public async Task BotAdapted_Bracketing() { var testName = "BotAdapted_Bracketing"; var activities = TranscriptUtilities.GetActivitiesFromFile(ClassName, testName); TestAdapter adapter = new TestAdapter(TestAdapter.CreateConversation(testName)) .Use(new BeforeAfterMiddleware()); adapter.OnTurnError = async(context, exception) => { await context.SendActivityAsync($"Caught: {exception.Message}"); return; }; var flow = new TestFlow(adapter, async(context, cancellationToken) => { switch (context.Activity.Type) { case ActivityTypes.Message: { var userMessage = context.Activity.AsMessageActivity()?.Text; switch (userMessage) { case "use middleware": await context.SendActivityAsync("using middleware"); break; case "catch exception": await context.SendActivityAsync("generating exception"); throw new Exception("exception to catch"); } } break; default: await context.SendActivityAsync(context.Activity.Type); break; } }); await flow.Test(activities).StartTestAsync(); }
public void AddFlankingTranscript(Transcript transcript, TranscriptAnnotation ta, string[] consequences) { _currTranscript = new JsonVariant.Transcript { IsCanonical = transcript.IsCanonical ? TrueTag : null, Consequence = consequences, ProteinID = ta.HasValidCdnaCodingStart ? TranscriptUtilities.GetProteinId(transcript) : null, TranscriptID = TranscriptUtilities.GetTranscriptId(transcript), BioType = BioTypeUtilities.GetBiotypeDescription(transcript.BioType), Gene = transcript.TranscriptSource == TranscriptDataSource.Ensembl ? transcript.Gene.EnsemblId.ToString() : transcript.Gene.EntrezGeneId.ToString(), Hgnc = transcript.Gene.Symbol }; if (ta.HasValidCdnaStart && ta.HasValidCdnaEnd) { _currTranscript.ComplementaryDnaPosition = GetCdnaRangeString(ta); } _currJsonVariant.AddTranscript(_currTranscript, transcript.TranscriptSource); }
public async Task LocaleConvertToEnglish() { var botLocale = "en-us"; var activities = TranscriptUtilities.GetFromTestContext(TestContext); TestAdapter adapter = new TestAdapter() .Use(new UserState <LanguageState>(new MemoryStorage())) .Use(new LocaleConverterMiddleware(GetUserLanguage, SetUserLanguage, botLocale, LocaleConverter.Converter)); var flow = new TestFlow(adapter, async(context) => { if (!context.Responded) { await context.SendActivityAsync($"message: {context.Activity.Text}"); } }); await flow.Test(activities, (expected, actual) => { Assert.AreEqual(expected.AsMessageActivity().Text, actual.AsMessageActivity().Text); }).StartTestAsync(); }
public void CreateAnnotationObject(Transcript transcript, VariantAlternateAllele altAllele) { // while annotating alternate allele, the first output function to be called is AddExonData. // So, we set the current json variant and transcript here. // they will subsequently be used in other output functions. FindCorrespondingJsonVariant(altAllele); if (_currJsonVariant == null) { throw new GeneralException("Cannot find jsonVariant corresponding to alternate allele"); } _currTranscript = new JsonVariant.Transcript { IsCanonical = transcript.IsCanonical ? TrueTag : null, TranscriptID = TranscriptUtilities.GetTranscriptId(transcript), BioType = BioTypeUtilities.GetBiotypeDescription(transcript.BioType), Gene = transcript.TranscriptSource == TranscriptDataSource.Ensembl ? transcript.Gene.EnsemblId.ToString() : transcript.Gene.EntrezGeneId.ToString(), Hgnc = transcript.Gene.Symbol }; }
/// <summary> /// constructor /// </summary> public Transcript(ushort referenceIndex, int start, int end, CompactId id, byte version, Translation translation, BioType bioType, Gene gene, int totalExonLength, byte startExonPhase, bool isCanonical, SimpleInterval[] introns, SimpleInterval[] microRnas, CdnaCoordinateMap[] cdnaMaps, int siftIndex, int polyPhenIndex, TranscriptDataSource transcriptSource) : base(referenceIndex, start, end) { Id = id; Version = version; Translation = translation; BioType = bioType; Gene = gene; TotalExonLength = totalExonLength; StartExonPhase = startExonPhase; IsCanonical = isCanonical; Introns = introns; MicroRnas = microRnas; CdnaMaps = cdnaMaps; SiftIndex = siftIndex; PolyPhenIndex = polyPhenIndex; TranscriptSource = transcriptSource; TotalExonLength = TranscriptUtilities.GetTotalExonLength(cdnaMaps); }