public PianoAnnotator(IAnnotationProvider taProvider, ISequenceProvider sequenceProvider)
{
_taProvider = taProvider;
_sequenceProvider = sequenceProvider;
GenomeAssembly = GetGenomeAssembly();
}
public static Dictionary <string, string> GetEnstToGeneSymbols(ISequenceProvider sequenceProvider, TranscriptCacheData transcriptData)
{
var cache = transcriptData.GetCache();
var enstToGeneSymbols = new Dictionary <string, string>();
foreach (var chromIndex in sequenceProvider.RefIndexToChromosome.Keys)
{
var overlappingTranscripts =
cache.TranscriptIntervalForest.GetAllOverlappingValues(chromIndex, 1, int.MaxValue);
if (overlappingTranscripts == null)
{
continue;
}
foreach (var transcript in overlappingTranscripts)
{
if (transcript.Id.WithoutVersion.StartsWith("ENST"))
{
enstToGeneSymbols[transcript.Id.WithoutVersion] = transcript.Gene.Symbol;
}
}
}
return(enstToGeneSymbols);
}
public TranscriptAnnotationProvider(string pathPrefix, ISequenceProvider sequenceProvider, ProteinConservationProvider conservationProvider)
{
Name = "Transcript annotation provider";
_sequence = sequenceProvider.Sequence;
_refNameToChromosome = sequenceProvider.RefNameToChromosome;
_conservationProvider = conservationProvider;
using (var stream = PersistentStreamUtils.GetReadStream(CacheConstants.TranscriptPath(pathPrefix)))
{
(_transcriptCache, TranscriptIntervalArrays, VepVersion) = InitiateCache(stream, sequenceProvider.RefIndexToChromosome, sequenceProvider.Assembly);
}
Assembly = _transcriptCache.Assembly;
DataSourceVersions = _transcriptCache.DataSourceVersions;
// TODO: this is not great. We should not be using IEnumerables if we have to resort to strange stuff like this
if (conservationProvider != null)
{
DataSourceVersions = DataSourceVersions.Concat(new[] { conservationProvider.Version });
}
_siftStream = PersistentStreamUtils.GetReadStream(CacheConstants.SiftPath(pathPrefix));
_siftReader = new PredictionCacheReader(_siftStream, PredictionCacheReader.SiftDescriptions);
_polyphenStream = PersistentStreamUtils.GetReadStream(CacheConstants.PolyPhenPath(pathPrefix));
_polyphenReader = new PredictionCacheReader(_polyphenStream, PredictionCacheReader.PolyphenDescriptions);
}
// constructor
public ClinVarReader(Stream rcvStream, Stream vcvStream, ISequenceProvider sequenceProvider)
{
_rcvStream = rcvStream;
_vcvStream = vcvStream;
_sequenceProvider = sequenceProvider;
_refChromDict = sequenceProvider?.RefNameToChromosome;
}
public static IAnnotator GetAnnotator(IAnnotationProvider taProvider, ISequenceProvider sequenceProvider,
IAnnotationProvider saProviders, IAnnotationProvider conservationProvider,
IGeneAnnotationProvider geneAnnotationProviders, IEnumerable <IPlugin> plugins = null)
{
return(new Annotator(taProvider, sequenceProvider, saProviders, conservationProvider,
geneAnnotationProviders, plugins));
}
private static ExitCodes ProgramExecution()
{
const string tempLeftoverFilename = "LeftOvers.vcf.gz";
Dictionary <string, StreamWriter> writers;
ISequenceProvider srcSequenceProvider = ProviderUtilities.GetSequenceProvider(_srcRefSequence);
ISequenceProvider desSequenceProvider = ProviderUtilities.GetSequenceProvider(_desRefSequence);
using (var srcReader = GZipUtilities.GetAppropriateStreamReader(_srcMapFile))
using (var destReader = GZipUtilities.GetAppropriateStreamReader(_destMapFile))
using (var leftoverWriter = GZipUtilities.GetStreamWriter(tempLeftoverFilename))
{
var chromMapper = new ChromMapper(srcReader, destReader, leftoverWriter, srcSequenceProvider, desSequenceProvider);
writers = chromMapper.Map();
}
//now we will try to map the leftovers
using (var destReader = GZipUtilities.GetAppropriateStreamReader(_destMapFile))
using (var leftoverReader = GZipUtilities.GetAppropriateStreamReader(tempLeftoverFilename))
{
var leftOverMapper = new LeftoverMapper(leftoverReader, destReader, writers, desSequenceProvider);
var leftoverCount = leftOverMapper.Map();
Console.WriteLine($"{leftoverCount} leftovers mapped!!");
}
foreach (var writer in writers.Values)
{
writer.Dispose();
}
return(ExitCodes.Success);
}
public LinksController(IMongoDatabase db, ISequenceProvider provider, DecBase68Converter converter, IAuthTokenProvider authTokenProvider)
{
_links = db.GetCollection <ShortenedLinkModel>("ShortenedLinks");
_sequenceProvider = provider;
_converter = converter;
_authTokenProvider = authTokenProvider;
}
// constructor
public ClinVarXmlReader(FileInfo clinVarXmlFileInfo, ISequenceProvider sequenceProvider)
{
_sequenceProvider = sequenceProvider;
_aligner = new VariantAligner(_sequenceProvider.Sequence);
_clinVarXmlFileInfo = clinVarXmlFileInfo;
_refChromDict = sequenceProvider.RefNameToChromosome;
}
public RefMinorDbWriter(ExtendedBinaryWriter writer, ExtendedBinaryWriter indexWriter, DataSourceVersion version, ISequenceProvider refProvider, int schemaVersion)
{
_stream = writer.BaseStream;
_writer = writer;
_refProvider = refProvider;
_refMinorIndex = new RefMinorIndex(indexWriter, _refProvider.Assembly, version, schemaVersion);
}
public BaseMapper(ILocalizationService translationService, ISequenceProvider sequenceProvider, IMapleLog log, IValidator <T> validator)
{
_translationService = translationService ?? throw new ArgumentNullException(nameof(translationService));
_sequenceProvider = sequenceProvider ?? throw new ArgumentNullException(nameof(sequenceProvider));
_log = log ?? throw new ArgumentNullException(nameof(log));
_validator = validator ?? throw new ArgumentNullException(nameof(validator));
}
public PrimateAiParser(Stream stream, ISequenceProvider referenceProvider, Dictionary <string, string> entrezToHgnc, Dictionary <string, string> ensemblToHgnc)
{
_stream = stream;
_entrezToHgnc = entrezToHgnc;
_ensemblToHgnc = ensemblToHgnc;
_referenceProvider = referenceProvider;
}
public static IModel Create(
[NotNull] ISequenceProvider sequenceProvider,
[CanBeNull] IEnumerable <IModelRuleProvider> modelRuleProviders = null,
[CanBeNull] IEqualityComparer <object> nodePayloadEqualityComparer = null,
[CanBeNull] IEqualityComparer <object> relationshipPayloadEqualityComparer = null)
{
var payloadToModelNodeMap = ImmutableDictionary <object, IModelNode> .Empty;
if (nodePayloadEqualityComparer != null)
{
payloadToModelNodeMap = payloadToModelNodeMap.WithComparers(nodePayloadEqualityComparer);
}
var payloadToModelRelationshipMap = ImmutableDictionary <object, IModelRelationship> .Empty;
if (relationshipPayloadEqualityComparer != null)
{
payloadToModelRelationshipMap = payloadToModelRelationshipMap.WithComparers(relationshipPayloadEqualityComparer);
}
return(new Model(
ModelGraph.Empty(allowParallelEdges: false),
payloadToModelNodeMap,
payloadToModelRelationshipMap,
sequenceProvider,
modelRuleProviders,
nodePayloadEqualityComparer,
relationshipPayloadEqualityComparer));
}
public LightningLogStore(ILogObjectTypeProvider typeProvider)
{
_typeProvider = typeProvider;
_hashProvider = new LogEntryHashProvider(_typeProvider);
_keyBuilder = new SequenceKeyBuilder();
_sequence = new LogStoreSequenceProvider(this);
}
public SpliceAiParser(Stream stream, ISequenceProvider sequenceProvider, Dictionary <ushort, IntervalArray <byte> > spliceIntervals, Dictionary <string, string> spliceToNirGeneSymbols)
{
_stream = stream;
_sequenceProvider = sequenceProvider;
_spliceIntervals = spliceIntervals;
_spliceToNirvanaSymbols = spliceToNirGeneSymbols;
_unresolvedSymbols = new HashSet <string>();
}
public PianoAnnotationProvider(string pathPrefix, ISequenceProvider sequenceProvider)
{
Name = "Transcript annotation provider";
_sequence = sequenceProvider.Sequence;
_transcriptCache = InitiateCache(FileUtilities.GetReadStream(CacheConstants.TranscriptPath(pathPrefix)), sequenceProvider.GetChromosomeIndexDictionary(), sequenceProvider.GenomeAssembly, sequenceProvider.NumRefSeqs);
GenomeAssembly = _transcriptCache.GenomeAssembly;
DataSourceVersions = _transcriptCache.DataSourceVersions;
}
public MitoMapSvReader(FileInfo mitoMapFileInfo, ISequenceProvider sequenceProvider)
{
_mitoMapFileInfo = mitoMapFileInfo;
_dataType = GetDataType();
_sequenceProvider = sequenceProvider;
_chromosome = sequenceProvider?.RefNameToChromosome["chrM"];
_variantAligner = new VariantAligner(sequenceProvider?.Sequence);
}
public MergedCosmicReader(string vcfFile, string tsvFile, ISequenceProvider sequenceProvider)
{
_vcfFileReader = GZipUtilities.GetAppropriateStreamReader(vcfFile);
_tsvFileReader = GZipUtilities.GetAppropriateStreamReader(tsvFile);
_sequenceProvider = sequenceProvider;
_refChromDict = _sequenceProvider.RefNameToChromosome;
_studies = new Dictionary <string, HashSet <CosmicItem.CosmicStudy> >();
}
public LeftoverMapper(StreamReader leftoverReader, StreamReader destReader, Dictionary <string, StreamWriter> writers,
ISequenceProvider desSequenceProvider)
{
_leftoverReader = leftoverReader;
_destReader = destReader;
_writers = writers;
_desSequenceProvider = desSequenceProvider;
}
public ModelService(
[NotNull] ISequenceProvider sequenceProvider,
[CanBeNull] IEnumerable <IModelRuleProvider> modelRuleProviders = null,
[CanBeNull] IEqualityComparer <object> nodePayloadEqualityComparer = null,
[CanBeNull] IEqualityComparer <object> relationshipPayloadEqualityComparer = null)
{
LatestModel = Model.Create(sequenceProvider, modelRuleProviders, nodePayloadEqualityComparer, relationshipPayloadEqualityComparer);
_modelUpdateLockObject = new object();
}
public OrderCommandsHandler(ISequenceProvider sequenceProvider)
{
Map <CreateOrderCommand>(c => new Order(c.OrderId, sequenceProvider.GetNext(OrdersSequenceName), c.UserId));
Map <AddItemToOrderCommand>((c, a) => a.AddItem(c.SkuId, c.Quantity, c.TotalPrice));
Map <CalculateOrderTotalCommand>((c, a) => a.CalculateTotal());
Map <CompleteOrderCommand>((c, a) => a.Complete());
}
/// <summary>
/// Erstellt eine neue Instanz von ForwardSequenceProvider.
/// </summary>
/// <param name="name">String mit dem die Bezeichner erweitert werden.</param>
/// <param name="parent">ISequenceProvider an den die Befehle weitergereicht werden.</param>
public ForwardSequenceProvider(string name, ISequenceProvider parent)
{
if (parent == null)
{
throw new ArgumentNullException("parent");
}
this.name = name;
this.parent = parent;
}
public static ITranscriptAnnotationProvider GetTranscriptAnnotationProvider(string path,
ISequenceProvider sequenceProvider)
{
var benchmark = new Benchmark();
var provider = new TranscriptAnnotationProvider(path, sequenceProvider);
var wallTimeSpan = benchmark.GetElapsedTime();
Console.WriteLine("Cache Time: {0} ms", wallTimeSpan.TotalMilliseconds);
return(provider);
}
public SpliceAiParser(Stream stream, ISequenceProvider sequenceProvider, Dictionary <ushort, IntervalArray <byte> > spliceIntervals, IntervalForest <string> geneTree = null, Dictionary <string, List <string> > geneSynonyms = null)
{
_stream = stream;
_sequenceProvider = sequenceProvider;
_spliceIntervals = spliceIntervals;
_geneTree = geneTree;
_geneSynonyms = geneSynonyms;
_unresolvedSymbols = new HashSet <string>();
_currentPositionGeneSymbols = new HashSet <string>();
}
private VcfReader(StreamReader headerReader, StreamReader vcfLineReader, ISequenceProvider sequenceProvider,
IRefMinorProvider refMinorProvider, IVcfFilter vcfFilter)
{
_headerReader = headerReader;
_reader = vcfLineReader;
_variantFactory = new VariantFactory(sequenceProvider);
_refMinorProvider = refMinorProvider;
_vcfFilter = vcfFilter;
_refNameToChromosome = sequenceProvider.RefNameToChromosome;
}
public static Dictionary <ushort, IntervalArray <byte> > GetSpliceIntervals(ISequenceProvider sequenceProvider, TranscriptCacheData transcriptData)
{
var cache = transcriptData.GetCache();
var spliceIntervalDict = new Dictionary <ushort, IntervalArray <byte> >(sequenceProvider.RefIndexToChromosome.Count);
foreach (var chromIndex in sequenceProvider.RefIndexToChromosome.Keys)
{
var spliceIntervals = new List <Interval <byte> >(8 * 1024);
var overlappingTranscripts =
cache.TranscriptIntervalForest.GetAllOverlappingValues(chromIndex, 1, int.MaxValue);
if (overlappingTranscripts == null)
{
continue;
}
foreach (var transcript in overlappingTranscripts)
{
if (transcript.Id.IsPredictedTranscript())
{
continue;
}
bool isFirstExon = true;
foreach (var transcriptRegion in transcript.TranscriptRegions)
{
if (transcriptRegion.Type != TranscriptRegionType.Exon)
{
continue;
}
var firstSplicePosition = transcriptRegion.Start;
var secondSplicePosition = transcriptRegion.End;
var firstInterval = new Interval <byte>(firstSplicePosition - SpliceFlankLength, firstSplicePosition + SpliceFlankLength, 0);
var secondInterval = new Interval <byte>(secondSplicePosition - SpliceFlankLength, secondSplicePosition + SpliceFlankLength, 0);
if (!isFirstExon)
{
spliceIntervals.Add(firstInterval);
}
spliceIntervals.Add(secondInterval);
isFirstExon = false;
}
//remove the last added interval since this is the tail of the last exon- which is not a splice site
if (spliceIntervals.Count > 0)
{
spliceIntervals.RemoveAt(spliceIntervals.Count - 1);
}
}
spliceIntervalDict[chromIndex] = new IntervalArray <byte>(spliceIntervals.OrderBy(x => x.Begin).ThenBy(x => x.End).ToArray());
}
return(spliceIntervalDict);
}
public ChromMapper(StreamReader srcReader, StreamReader destReader, StreamWriter leftoverWriter,
ISequenceProvider srcSequenceProvider, ISequenceProvider desSequenceProvider)
{
_srcReader = srcReader;
_destReader = destReader;
_writers = new Dictionary <string, StreamWriter>();
_leftoverWriter = leftoverWriter;
_srcSequenceProvider = srcSequenceProvider;
_desSequenceProvider = desSequenceProvider;
_destinationVariants = new Dictionary <(long, int, string), List <int> >();
}
public IndexModule(ISequenceProvider provider)
{
_provider = provider;
Get["/"] = parameters => View["index"];
Post["/Sequence/Parse"] = _ =>
{
var data = this.Bind <SequenceModel>();
return(Response.AsJson(_provider.Provide(data?.FileName, data?.Content).Select(x => x.ToString())));
};
}
public SaMiscTsvWriter(string outputPath, DataSourceVersion dataSourceVersion, string assembly, string keyName, ISequenceProvider sequenceProvider)
{
var fileName = keyName + "_" + dataSourceVersion.Version.Replace(" ", "_") + ".misc.tsv.gz";
_bgzipTextWriter = new BgzipTextWriter(Path.Combine(outputPath, fileName));
_bgzipTextWriter.Write(GetHeader(dataSourceVersion, assembly));
_tsvIndex = new TsvIndex(Path.Combine(outputPath, fileName + ".tvi"));
_sequenceProvider = sequenceProvider;
}
private VcfReader(StreamReader headerReader, StreamReader vcfLineReader, ISequenceProvider sequenceProvider,
IRefMinorProvider refMinorProvider, IVcfFilter vcfFilter, IVariantIdCreator vidCreator, IMitoHeteroplasmyProvider mitoHeteroplasmyProvider)
{
_headerReader = headerReader;
_reader = vcfLineReader;
_variantFactory = new VariantFactory(sequenceProvider.Sequence, vidCreator);
_sequenceProvider = sequenceProvider;
_refMinorProvider = refMinorProvider;
_vcfFilter = vcfFilter;
_refNameToChromosome = sequenceProvider.RefNameToChromosome;
_mitoHeteroplasmyProvider = mitoHeteroplasmyProvider;
}
public static IRecomposer Create(ISequenceProvider sequenceProvider,
string inputCachePrefix)
{
var transcriptIntervalArrays = ReadWriteUtilities.ReadCache(FileUtilities.GetReadStream(CacheConstants.TranscriptPath(inputCachePrefix)), sequenceProvider.RefIndexToChromosome);
var(geneIntervalForest, _) = ReadWriteUtilities.GetIntervalAndTranscriptsForeachGene(transcriptIntervalArrays);
var codonInfoProvider = CodonInfoProvider.CreateCodonInfoProvider(transcriptIntervalArrays);
var variantGenerator = new VariantGenerator(sequenceProvider);
var positionBuffer = new PositionBuffer(codonInfoProvider, geneIntervalForest);
return(new Recomposer(new PositionProcessor(positionBuffer, codonInfoProvider, variantGenerator), sequenceProvider));
}
